#include <bits/stdc++.h>
using namespace std;
long long factorial_invertible[100001];
int factor[100001], p;
const int MAX_BAD = 17;
int idx_bad[100001];
int pow_bad[MAX_BAD][100001];
int factorial_bad[100001][MAX_BAD];
vector<int> bad_factors;
struct t {
  long long a, b;
  int g;
  t(long long a, long long b, int g) : a(a), b(b), g(g) {}
  t swap() { return t(b, a, g); }
};
t egcd(int p, int q) {
  if (q == 0) return t(1, 0, p);
  t t2 = egcd(q, p % q);
  t2.a -= t2.b * (p / q);
  return t2.swap();
}
void sieve() {
  for (int i = 1; i <= 100000; i++) factor[i] = i;
  for (int i = 2; i <= 100000; i++)
    if (factor[i] == i)
      for (int j = i + i; j <= 100000; j += i) factor[j] = i;
}
void compute_bad_factors(int p) {
  int cur = p;
  for (int f = 2; f <= 100000; f++)
    if (cur % f == 0) {
      bad_factors.push_back(f);
      while (cur % f == 0) cur /= f;
    }
  memset(idx_bad, -1, sizeof idx_bad);
  for (int i = 0; i < bad_factors.size(); i++) {
    idx_bad[bad_factors[i]] = i;
    pow_bad[i][0] = 1;
    for (int j = 1; j <= 100000; j++)
      pow_bad[i][j] = (long long)pow_bad[i][j - 1] * bad_factors[i] % p;
  }
}
void compute_factorials(int p) {
  factorial_invertible[0] = 1;
  for (int i = 1; i <= 100000; i++) {
    factorial_invertible[i] = factorial_invertible[i - 1];
    memcpy(factorial_bad[i], factorial_bad[i - 1], sizeof factorial_bad[i]);
    int full = i;
    {
      int cur = i;
      while (cur > 1) {
        int f = factor[cur];
        int power = 0;
        while (cur % f == 0) {
          cur /= f;
          if (idx_bad[f] != -1) {
            factorial_bad[i][idx_bad[f]]++;
            full /= f;
          }
        }
      }
    }
    factorial_invertible[i] = (long long)full * factorial_invertible[i] % p;
  }
}
long long binom(int a, int b) {
  if (b < 0 || b > a) return 0;
  long long ans = factorial_invertible[a];
  ans = ans * egcd(p, factorial_invertible[b]).b % p;
  ans = ans * egcd(p, factorial_invertible[a - b]).b % p;
  for (int i = 0; i < bad_factors.size(); i++) {
    int power = factorial_bad[a][i];
    power -= factorial_bad[b][i] + factorial_bad[a - b][i];
    assert(power >= 0);
    ans = ans * pow_bad[i][power] % p;
  }
  return ans;
}
int main() {
  int n, l, r;
  cin >> n >> p >> l >> r;
  sieve();
  compute_bad_factors(p);
  compute_factorials(p);
  long long ans = 0;
  for (int c = 0; c <= n; c++) {
    long long paths =
        (binom(c, (c + l + 1) / 2) - binom(c, (c + r) / 2 + 1)) % p;
    ans = (ans + (long long)binom(n, c) * paths) % p;
  }
  ans = (ans + p) % p;
  cout << ans << endl;
}
