#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
using namespace std;

#include "message.h"

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

// change the include here!!!
#include "futbol.h"

const int SKLADSZ = 7;

inline LL modPow(int a, int x, int p) {
	// return a^x mod p
	int res = 1;
	while (x > 0) {
		if (x & 1) res = (res*(LL)a) % p;
		a = (a*(LL)a) % p;
		x >>= 1;
	}

	return res;
}

inline LL modInverse(int a, int p) {
	// return modular multiplicative of: a mod p, assuming p is prime
	return modPow(a, p - 2, p);
}

int main()
{
	int id = MyNodeId();
	int ileI = NumberOfNodes();

	// Get number of elements
	int N = GetN();
	int K = GetK();
	int P = GetP();

	// ponizsze local testing
	/*if (id)
		N = 0;*/

	bool bad = 0;
	if (!N)
		bad = 1;

	int ileSkladow = ileI/SKLADSZ;

	if (K < ileSkladow)
		ileSkladow = max(K, 1);

	if (id == ileI - 1)
	{
		// jestes ostatnim kompem - dostaniesz wszystkie sumy i wypiszesz wynik

		// bo 0 nikt nie obsluguje
		int res = 1;

		REP(i, ileSkladow)
		{
			int skad = Receive(-1);

			int tmp = GetInt(skad);

			if (tmp)
				N = tmp;

			int s = GetInt(skad);

			if (!bad)
				res = (res + s) % P;
		}

		//if (bad)
		//	printf("Sam licze wszystko N:%d\n", N);

		if (bad)
		{
			// wylicz wszystko sam
			int silN = 1, silNK = 1, silK = 1;

			FOR(i, 2, N)
				silN = (silN*(LL)i) % P;

			silNK = silN;
			silN = (silN*(LL)N) % P;

			int NK = N - 1;
			FORQ(i, 1, K)
			{
				int tmp = (silK*(LL)silNK) % P;
				tmp = modInverse(tmp, P);

				res = (res + silN * (LL)tmp) % P;

				silK = (silK*(LL)(i + 1)) % P;
				silNK = (silNK*modInverse(NK, P)) % P;

				NK--;
			}
		}

		printf("%d\n", res);

		return 0;
	}

	int ids = id / SKLADSZ;

	// zobacz, czy jakis komp bedzie bezproduktywny
	if (ids >= ileSkladow)
		return 0;

	// wylicz ile elementow sklad bedzie przetwarzal
	int iles = K / ileSkladow;

	int K_start = ids * iles + 1;

	//printf("Zaczynam K w %d\n", K_start);

	if (ids == ileSkladow - 1)
	{
		iles += K % ileSkladow;
	}

	int idwsklad = id % SKLADSZ;

	// wylicz ile elementow ma przetworzyc maszyna - jesli jest robocza
	if (idwsklad != SKLADSZ - 1)
	{
		// do kogo wysylasz
		int target = ids * SKLADSZ + (SKLADSZ - 1);

		// wylicz swoje wartosci
		// podczas wyliczania N! natrafimy na K_start i N-K_start, ktore jest stale dla calego skladu

		int NK = N - K_start;

		int silN = 1, silK = 1, silNK = 1;
		int ile = N / (SKLADSZ-1);

		int beg = idwsklad * ile + 1;

		if (idwsklad == SKLADSZ - 2)
			ile += N % (SKLADSZ - 1);

		REP(i, ile)
		{
			silN = (silN * (LL)beg) % P;

			if (beg <= K_start)
				silK = silN;
			if (beg <= NK)
				silNK = silN;

			beg++;
		}

		PutInt(target, N);
		PutInt(target, silN);
		PutInt(target, silK);
		PutInt(target, silNK);

		// wyslij 4 liczby do targetu
		Send(target);
	}
	else
	{
		// nie jestes w grupie roboczej, czekasz na policzone wyniki od poprzednikow
		// musza przekazac 3 wartosci N!, K_start! i (N-K_start)!
		int silN = 1, silK = 1, silNK = 1;
		REP(i, SKLADSZ - 1)
		{
			int skad = Receive(-1);

			// odbierz N
			int tmp = GetInt(skad);
			if (tmp)
				N = tmp;

			silN = (silN*(LL)GetInt(skad)) % P;
			silK = (silK*(LL)GetInt(skad)) % P;
			silNK = (silNK*(LL)GetInt(skad)) % P;
		}

		// wylicz wartosci jeszcze raz, zeby sprawdzic
		/*{
			int tmpN = 1, tmpK = 1, tmpNK = 1;

			FORQ(i, 1, N)
			{
				tmpN = (tmpN*(LL)i) % P;
				if (i <= K_start)
					tmpK = (tmpK*(LL)i) % P;
				if (i <= N - K_start)
					tmpNK = (tmpNK*(LL)i) % P;
			}

			assert(tmpN == silN);
			assert(tmpK == silK);
			assert(tmpNK == silNK);
		}*/

		// jedz po calym przedziale i sumuj wartosci N po K
		int res = 0;
		int NK = N - K_start;

		REP(i, iles)
		{
			int tmp = (silK*(LL)silNK) % P;
			tmp = modInverse(tmp, P);

			res = (res + silN * (LL)tmp) % P;

			K_start++;

			silK = (silK*(LL)K_start) % P;
			silNK = (silNK*modInverse(NK, P)) % P;

			NK--;
		}

		// wyslij do ostatniego kompa wiadomosc - on zawsze dziala, nawet jak niektore sklady nie pracuja
		PutInt(ileI - 1, N);
		PutInt(ileI - 1, res);

		Send(ileI - 1);
	}

	return 0;
}