// Not afraid to dark.

#include <bits/stdc++.h>
using namespace std;

clock_t start_time, end_time;
#define GET_START start_time = clock ();
#define GET_END end_time = clock (); fprintf (stderr, "TIME COSSEMED : %0.3lf\n", 1.0 * (end_time - start_time) / CLOCKS_PER_SEC);
#define inline __inline__ __attribute__ ((always_inline))

#define int long long

namespace io {
    int read_pos, read_dt; char read_char;
    inline int read (int &p = read_pos){
        p = 0, read_dt = 1; read_char = getchar ();
        while (! isdigit (read_char)){
            if (read_char == '-')
                read_dt = - 1;
            read_char = getchar ();
        }
        while (isdigit (read_char)){
            p = (p << 1) + (p << 3) + read_char - 48;
            read_char = getchar ();
        }
        return p = p * read_dt;
    }
    int write_sta[65], write_top;
    inline void write (int x){
        if (x < 0)
            putchar ('-'), x = - x;
        write_top = 0;
        do
            write_sta[write_top ++] = x % 10, x /= 10;
        while (x);
        while (write_top)
            putchar (write_sta[-- write_top] + 48);
    }
}

const int P = 1e6;
int p, g, gp[P + 5];
int f[P + 5]; // f[i]=f(g^i)
int jc[P + 5], inv[P + 5], inj[P + 5];

#define vic(x) (((x) & 1) ? (p - 1) : 1)

inline int power (int a, int t){
    int res = 1;
    while (t > 0){
        if (t & 1)
            res = res * a % p;
        a = a * a % p;
        t >>= 1;
    }
    return res;
}

inline void Init (int n){
    vector < int > fac;
    jc[0] = jc[1] = inv[1] = inj[0] = inj[1] = 1;
    for (int i = 2, rs = p - 1;i < p;++ i){
        inv[i] = inv[i - p % i] * (p / i + 1) % p;
        jc[i] = jc[i - 1] * i % p;
        inj[i] = inj[i - 1] * inv[i] % p;
        if (rs % i == 0){
            while (rs % i == 0)
                rs /= i;
            fac.push_back (i);
        }
        if (i == p - 1 && rs > 1)
            fac.push_back (rs);
    }
    for (int i = 2;i < p;++ i){
        for (int x : fac)
            if (power (i, (p - 1) / x) == 1)
                goto out_case;
        g = i;
        break;
        out_case : ;
    }
    gp[0] = 1;
    for (int i = 1;i < p;++ i)
        gp[i] = gp[i - 1] * g % p;
    for (int i = 0;i < p;++ i)
        f[i] = ((gp[i] + n - 1 < p) ? (jc[gp[i] + n - 1] * inj[gp[i] - 1] % p) : 0);
}

inline int Sum (int n, int m){
    if (n == 0)
        return 1;
    m = min (n, m);
    int res = (m + 1) * f[0] % p;
    for (int i = 1;i < p - 1;++ i)
        res = (res + f[i] * (gp[p - 1 - i * (m + 1) % (p - 1)] - 1) % p * inv[gp[p - 1 - i] - 1] % p) % p;
    return (p - res) % p;
}

int C (int a, int b){
    if (a < 0 || b < 0)
        return 0;
    if (a < b)
        return 0;
    if (a >= p)
        return C (a / p, b / p) * C (a % p, b % p) % p;
    return jc[a] * inj[a - b] % p * inj[b] % p;
}

inline int Calc (int n, int m){
    if (m < 1)
        return 0;
    if (n == m){
        if (n >= p)
            return 0;
        return jc[n];
    }
    int q = n / p, r = n % p;
    if (m < q)
        return 0;
    m -= q;
    int k = m / (p - 1), t = m % (p - 1);
    return vic (q - k) * (C (q, k) * Sum (r, t) % p - C (q - 1, k - 1) * jc[r] % p + p) % p;
}

inline void ARKNIGHTS (){
    int n = io::read (), l = io::read (), r = io::read (); io::read (p);
    Init (n % p);
    io::write ((Calc (n, r) - Calc (n, l - 1) + p) % p), puts ("");
}

signed main (){
    GET_START

    ARKNIGHTS ();

    GET_END
    return 0;
}