#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }

#ifndef LIBRA_OTHER_INT128_H_
#define LIBRA_OTHER_INT128_H_

#include <stdio.h>
#include <iostream>

constexpr unsigned __int128 toUInt128(const char *s) {
  unsigned __int128 x = 0;
  for (; *s; ++s) x = x * 10 + (*s - '0');
  return x;
}
constexpr __int128 toInt128(const char *s) {
  if (*s == '-') return -toInt128(s + 1);
  __int128 x = 0;
  for (; *s; ++s) x = x * 10 + (*s - '0');
  return x;
}
unsigned __int128 inUInt128() {
  static char buf[41];
  scanf("%s", buf);
  return toUInt128(buf);
}
__int128 inInt128() {
  static char buf[41];
  scanf("%s", buf);
  return toInt128(buf);
}

void out(unsigned __int128 x) {
  static char buf[41];
  int len = 0;
  do { buf[len++] = '0' + static_cast<int>(x % 10); } while (x /= 10);
  for (int i = len; --i >= 0; ) putchar(buf[i]);
}
void out(__int128 x) {
  if (x < 0) {
    putchar('-');
    out(-static_cast<unsigned __int128>(x));
  } else {
    out(static_cast<unsigned __int128>(x));
  }
}
std::ostream &operator<<(std::ostream &os, unsigned __int128 x) {
  static char buf[41];
  int len = 0;
  do { buf[len++] = '0' + static_cast<int>(x % 10); } while (x /= 10);
  for (int i = len; --i >= 0; ) os << buf[i];
  return os;
}
std::ostream &operator<<(std::ostream &os, __int128 x) {
  if (x < 0) {
    os << '-' << -static_cast<unsigned __int128>(x);
  } else {
    os << static_cast<unsigned __int128>(x);
  }
  return os;
}

#endif  // LIBRA_OTHER_INT128_H_


using INT = __int128;

INT P, A;
INT X, Y;
INT ans;

// above
inline bool inside(INT x, INT y) {
  return (P * y > x*x + A);
}

// next slope: (a/b, c/d]
void dfs(INT a, INT b, INT c, INT d) {
// cerr<<"dfs "<<a<<" "<<b<<" "<<c<<" "<<d<<endl;
  {
    /*
      \exists? k s.t. -(a + k c, b + k d): in
      P (Y - (b + k d)) > (X - (a + k c))^2 + A
      c^2 k^2 - (2 (X - a) c - P d) k + * < 0
    */
    const INT numer = 2 * (X - a) * c - P * d;
    const INT denom = 2 * c * c;
    INT q = numer / denom, r = numer % denom;
    if (r < 0) {
      --q;
      r += denom;
    }
    if (2 * r > denom) {
      ++q;
      r -= denom;
    }
    const INT k = q;
    if (!inside(X - (a + k * c), Y - (b + k * d))) {
      return;
    }
  }
  const INT e = a + c;
  const INT f = b + d;
  if (inside(X - e, Y - f)) {
    dfs(a, b, e, f);
  }
  if (inside(X - e, Y - f)) {
    /*
      max k s.t. -(k e, k f): in
    */
    auto check = [&](INT k) -> bool {
      return inside(X - k * e, Y - k * f);
    };
    INT lo = 1, hi = 2;
    for (; check(hi); ) {
      lo = hi;
      hi <<= 1;
    }
    for (; lo + 1 < hi; ) {
      const INT mid = (lo + hi) / 2;
      (check(mid) ? lo : hi) = mid;
    }
    const INT k = lo;
    const INT XX = X - k * e;
    const INT YY = Y - k * f;
// cerr<<"  "<<k<<" ("<<e<<", "<<f<<"); ("<<X<<", "<<Y<<") -> ("<<XX<<", "<<YY<<")"<<endl;
    ans += ((X - XX + 1) * (Y + YY + 1) - (k + 1)) / 2 - (X - XX + 1) - (YY - 1);
    X = XX;
    Y = YY;
  }
  if (inside(X - c, X - d)) {
    dfs(e, f, c, d);
  }
}

// \sum[0<x<=(P-1)/2] floor((x^2 + A) / P)
INT solve(INT P_, INT A_) {
  P = P_;
  A = A_;
// cerr<<"solve "<<P<<" "<<A<<endl;
  X = (P - 1) / 2;
  Y = (X*X + A) / P + 1;
  ans = 0;
  dfs(0, 1, 1, 0);
  ans += X * (Y - 1);
  return ans;
}


void stress() {
  for (INT P = 3; P < 1000; P += 2) {
    for (INT A = 0; A <= P; ++A) {
      INT brt = 0;
      for (INT x = 1; x <= (P - 1) / 2; ++x) {
        brt += (x*x + A) / P;
      }
      const INT res = solve(P, A);
      if (brt != res) {
        cerr << P << " " << A << ": " << brt << " " << res << endl;
        assert(false);
      }
    }
  }
}

int main() {
  // stress();
  
  Int P, L, R;
  for (; ~scanf("%lld%lld%lld", &P, &L, &R); ) {
    INT ans = 0;
    ans += solve(P, P - L);
    ans -= solve(P, P - R - 1);
    cout << ans << endl;
  }
  return 0;
}