#include <bits/stdc++.h> // Tomasz Nowak
using namespace std;     // XIII LO Szczecin

#define FOR(i,a,n) for (auto i = (a), i##__ = (n); i <= i##__; ++i)
#define REP(i,n) FOR(i,0,(n)-1)
#define FORD(i,a,n) for (auto i = (a), i##__ = (n); i >= i##__; --i)
#define REPD(i,n) FORD(i,(n)-1,0)
#define ALL(x) x.begin(), x.end()
#define SZ(x) ((int) x.size())
#define X first
#define Y second
#define V vector
#define A array
constexpr char nl = '\n';

template<class A, class B> A&& mini(A &&a, B &&b) { if (b < a) a = b; return a; }
template<class A, class B> A&& maxi(A &&a, B &&b) { if (b > a) a = b; return a; }
int first_bit(int x) { return x == 0 ? 0 : sizeof(x) * 8 - __builtin_clz(x); }
int ceil2(int x) { return x < 2 ? x : 1 << first_bit(x - 1); }
constexpr int inf = 0x3f3f3f3f; 
constexpr long long inf_l = 0x3f3f3f3f3f3f3f3f;

#define _eif(a...) typename enable_if<a, int>::type()
#define _func(func, a...) template<class T> auto func(T &&x) -> decltype(a)
#define _rref(a...) typename remove_reference<a>::type
#define _create_trait(name, a...) \
    _func(_##name, a, true_type{}); \
    false_type _##name(...); \
    template<class T> struct name : decltype(_##name(declval<T>())) {};
struct Debug;
_create_trait(is_debug_func, x(declval<add_lvalue_reference<Debug>::type>()));
_create_trait(is_func, x())
_create_trait(is_string, string(x))
_create_trait(is_ptr, *x, _eif(is_string<T>() == false));
_create_trait(is_container, x.begin(), _eif(is_string<T>() == false))

template<class Iter> struct Off { Iter _a, _b; };
_func(O, _eif(is_container<T>() == true), Off<decltype(x.begin())>()) { return { ALL(x) }; }
_func(O, _eif(is_container<T>() == false), x) { return x; }

#define _operator(a...) _func(operator<<, a, *this)
struct Debug {
    Debug() {  cerr << boolalpha << fixed << setprecision(0); }
    ~Debug() { cerr << nl; }
    Debug& operator()(int x = 1) { REP(_, x) *this << "  "; return *this; }
    _operator(cerr << x, _eif(is_func<T>() == false && is_ptr<T>() == false && is_integral<_rref(T)>() == true)) { 
        using L = long long;
        if(abs(int(x)) == inf || abs(L(x)) == inf_l)
            cerr << ((int(x) == inf || L(x) == inf_l) ? "+∞" : (int(x) == -inf || L(x) == -inf_l) ? "-∞" : "?");
        else
            cerr << x;
        return *this; 
    }
    _operator(cerr << x, _eif(is_func<T>() == false && is_ptr<T>() == false && is_integral<_rref(T)>() == false)) {
        cerr << x;
        return *this;
    }
    _operator(x.first) { 
        return *this << "(" << O(x.first) << ", " << O(x.second) << ")"; }
    _operator(_eif(is_container<T>() == true)) {
        *this << "{\n";
        for (auto a = x.begin(); a != x.end(); ++a)
            *this << "  " << distance(x.begin(), a) << ": " << O(*a) << '\n';
        return *this << "}";
    }
    _operator(x._a) {
        *this << "{";
        for (auto a = x._a, b = x._b; a != b; ++a)
            *this << O(*a) << (next(a) == b ? "" : ", ");
        return *this << "}";
    }
    _operator(_eif(is_func<T>() == true)) { x(); return *this; }
    _operator(_eif(is_debug_func<T>() == true)) { x(*this); return *this; }
    _operator(_eif(is_ptr<T>() == true && is_func<T>() == false && is_debug_func<T>() == false)) {
        return *this << *x;
    }
};
struct DebugOff { 
    template<class T> DebugOff& operator<<(T&&) { return *this; }
    DebugOff& operator()(int = 0) { return *this; }
};
//#define DEBUG
#ifdef DEBUG
# define D Debug()
#else
# define D DebugOff()
#endif
#define I(a...) #a ": " << a << "   "

using VI    = V<int>;
using VVI   = V<VI>;
using L     = long long;
using VL    = V<L>;
using VB    = V<bool>;
using II    = pair<int, int>;
using VII   = V<II>;
using VVII  = V<VII>;

// end of templates v8 by Tomasz Nowak

#include "message.h"
#include "futbol.h"

struct Dummy {
	Dummy() {
		D << I(MyNodeId());
		PutInt(0, GetN());
		Send(0);
	}
};

struct Brute {
	int pot(int a, int b, int p) {
		if(b == 0)
			return 1;
		int x = pot(a, b / 2, p);
		x = x * L(x) % p;
		if(b & 1)
			x = x * L(a) % p;
		return x;
	}

	int fast_add(int a, int b, int p) {
		if((a += b) >= p)
			return a - p;
		return a;
	}

	int mnoz(int a, int b, int p) {
		return a * L(b) % p;
	}

	Brute() {
		D << "starting brute";
		int n = GetN(), k = GetK(), p = GetP();

		VI silnia(n + 1, 1), rev(n + 1);
		FOR(i, 2, n)
			silnia[i] = mnoz(silnia[i - 1], i, p);
		rev.back() = pot(silnia.back(), p - 2, p);
		FORD(i, n - 1, 0)
			rev[i] = mnoz(rev[i + 1], i + 1, p);

		int ans = 0;
		FOR(i, 0, k)
			ans = fast_add(ans, mnoz(rev[i], rev[n - i], p), p);
		cout << mnoz(ans, silnia[n], p);
	}
};

struct Worker {
	int slave_id, slave_no;
	int range_l, range_r;
	int n, k, p;

	int fast_add(int a, int b) {
		if((a += b) >= p)
			return a - p;
		return a;
	}

	int mnoz(int a, int b) {
		return a * L(b) % p;
	}

	int pot(int a, int b) {
		if(b == 0)
			return 1;
		int x = pot(a, b / 2);
		x = mnoz(x, x);
		if(b & 1)
			x = mnoz(x, a);
		return x;
	}

	int inverse(int x) {
		return pot(x, p - 2);
	}

	Worker() {
		// getting worker info

		slave_id = MyNodeId();
		slave_no = min(GetK() + 1, NumberOfNodes() - 1);

		if(slave_id >= GetK() + 1)
			return;

		if(slave_id == 0) {
			D << "receiving";
			Receive(NumberOfNodes() - 1);
			int n = GetInt(NumberOfNodes() - 1);
			D << I(n);
			if(n == 0) {
				Brute();
				return;
			}
		} else if(GetN() == 0)
			return;

		D << I(slave_id);

		n = GetN();
		k = GetK();
		p = GetP();
		if(slave_id == 0)
			D << I(n) << I(k) << I(p);

		range_l = (L(slave_id) * (k + 1)) / slave_no;
		range_r = (L(slave_id + 1) * (k + 1)) / slave_no - 1;
		int range = range_r - range_l + 1;
		D << I(range_l) << I(range_r);

		// creating necessary tables

		int pref = 1;
		FOR(i, range_l, range_r)
			pref = mnoz(pref, max(1, i));
		VI suff(range, n - range_r);
		FORD(i, range_r - 1, range_l)
			suff[i - range_l] = mnoz(suff[i + 1 - range_l], n - i);
		D << I(pref) << I(suff);

		// inverses

		VI pref_inv(range);
		pref_inv.back() = inverse(pref);
		FORD(i, range_r - 1, range_l)
			pref_inv[i - range_l] = mnoz(pref_inv[i + 1 - range_l], i + 1);
		D << I(pref_inv);

		// sum
		
		int sum = 0, fragment = 1;
		FOR(i, range_l, range_r) {
			int curr = mnoz(pref_inv[i - range_l], fragment);
			sum = fast_add(sum, curr);
			fragment = mnoz(fragment, n - i);
		}
		D << I(sum);

		// sending / receiving info

		int got_inv_pref = 1, got_suff = 1, new_sum = 0;
		if(slave_id != 0) {
			Receive(slave_id - 1);
			got_inv_pref = GetInt(slave_id - 1);
			got_suff = GetInt(slave_id - 1);
			new_sum = GetInt(slave_id - 1);
		}

		sum = mnoz(sum, got_inv_pref);
		sum = mnoz(sum, got_suff);
		sum = fast_add(sum, new_sum);

		D << "ending";
		if(slave_id != slave_no - 1) {
			PutInt(slave_id + 1, mnoz(pref_inv.back(), got_inv_pref));
			PutInt(slave_id + 1, mnoz(suff.front(), got_suff));
			PutInt(slave_id + 1, sum);
			Send(slave_id + 1);
		} else {
			cout << sum << nl;
			PutInt(0, -1);
			Send(0);
		}

		// to delete

		if(slave_id == 0) {
			Receive(slave_no - 1);
			void(GetInt());
		}

	}
};

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

	if(MyNodeId() == NumberOfNodes() - 1)
		Dummy();
	else
		Worker();

}