#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")

#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;

#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 ALL(u) (u).begin(),(u).end()

#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

typedef pair<int, int> PII;

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

const int MR = 1010;

int C[MR][MR];

bool done[MR][MR], doneMagic[MR][MR], doneMagic2[MR][MR];
int dp[MR][MR], dpMagic[MR][MR], dpMagic2[MR][MR], P, maxTime[2*MR];


// funkcja go(N,K) oznaczaja, ze chcemy wybrac zwyciezce po K pojedynkach
// funkcje goMagic oznaczaja, ze chcemy skasowac przedzial po K rundach
// przedzial jest ograniczony z jednej lub z 2 stron czyms wiekszym niz cala reszta

int goMagic2(int N, int K)
{
	// na 2 baty - cos zre z 2 stron
	if (K >= maxTime[N])
		return 0;

	// pusty przedzial mozemy skonczyc jedynie po 0 rundach
	if (N == 0)
		return !K;

	// jesli mamy cos niepustego skonczyc w 0, to sie nie da
	if (!K)
		return 0;

	if (N == 1)
	{
		// jednoelementowy przedzial jedynie po 1 rundzie
		if (K == 1)
			return 1;

		return 0;
	}

	if (N == 2)
	{
		// dwuelementowy takze po 1 rundzie
		if (K == 1)
			return 2;

		return 0;
	}

	if (doneMagic2[N][K])
		return dpMagic2[N][K];
	doneMagic2[N][K] = 1;

	// dawaj maxa na kazdej pozycji
	FORQ(i, 1, N)
	{
		// konczymy lewy i prawy przedzial dowolnie az do K-1
		int sl = 0;
		FOR(j, 0, K)
			sl = (sl + goMagic2(i - 1, j)) % P;

		int sr = 0;
		FOR(j, 0, K)
			sr = (sr + goMagic2(N - i, j)) % P;

		//dpMagic2[N][K] = (dpMagic2[N][K] + ((sl * (LL)sr)) % P * C[N - 1][i - 1]) % P;

		// skoncz lewy jak wczesniej, a prawy w K
		dpMagic2[N][K] = (dpMagic2[N][K] + (sl * (LL)goMagic2(N - i, K)) % P * C[N - 1][i - 1]) % P;
		// skoncz prawy jak wczesniej, a lewy w K
		dpMagic2[N][K] = (dpMagic2[N][K] + (sr * (LL)goMagic2(i - 1, K)) % P * C[N - 1][i - 1]) % P;

		// tylko ta opcja jest ok
		dpMagic2[N][K] = (dpMagic2[N][K] + (goMagic2(i - 1, K - 1) * (LL)goMagic2(N - i, K - 1)) % P * C[N - 1][i - 1]) % P;
	}

	return dpMagic2[N][K];
}

int goMagic(int N, int K)
{
	// cos zre tylko z jednej strony
	if (K >= maxTime[N])
		return 0;

	// pusty przedzial mozemy skonczyc jedynie po 0 rundach
	if (N == 0)
		return !K;

	// jesli mamy cos niepustego skonczyc w 0, to sie nie da
	if (!K)
		return 0;

	if (N == 1)
	{
		// jednoelementowy przedzial jedynie po 1 rundzie
		if (K == 1)
			return 1;

		return 0;
	}

	if (N == 2)
	{
		// dwuelementowy
		if (K == 1)
			// 2,1 -> ta permutacja sie skonczy po 1 rundzie, zakladamy, ze jest ograniczona z lewej
			return 1;

		if (K == 2)
			// 1,2 -> ta skonczy sie po 2, zakladajac ograniczenie z lewej
			return 1;

		return 0;
	}

	if (doneMagic[N][K])
		return dpMagic[N][K];
	doneMagic[N][K] = 1;

	// dawaj maxa na kazdej pozycji
	FORQ(i, 1, N)
	{
		// wybierz czas zakonczenia lewego przedzialu - od 0 do K-2
		FOR(j, 0, K - 1)
			dpMagic[N][K] = (dpMagic[N][K] + (goMagic2(i - 1, j) * (LL)goMagic(N - i, K)) % P *C[N - 1][i - 1]) % P;
		// konczymy lewy przedzial dowolnie az do K-2, prawy dowolnie az do K
		// lewy ograniczony jest z 2 stron, prawy tylko z jednej
		//int sl = 0;
		//FOR(j, 0, K)
		//	sl = (sl + goMagic2(i - 1, j)) % P;

		int sr = 0;
		FORQ(j, 0, K)
			sr = (sr + goMagic(N - i, j)) % P;

		// jesi lewy w K-1, to prawy w K-1 lub K
		dpMagic[N][K] = (dpMagic[N][K] + (goMagic2(i - 1, K - 1) * (LL)(/*goMagic(N - i, K - 1) + goMagic(N - i, K)*/sr)) % P *C[N - 1][i - 1]) % P;

		// jesli lewy ma sie skonczyc dowolnie do K-2

		// nie mozesz skonczyc prawego w K, bo calosc skonczy sie za pozno - lewy moze sie skonczyc w K
		//dpMagic[N][K] = (dpMagic[N][K] + (sl * (LL)goMagic(N - i, K)) % P * C[N - 1][i - 1]) % P;
		// skoncz prawy jak wczesniej, a lewy w K
		//dpMagic[N][K] = (dpMagic[N][K] + (sr * (LL)goMagic2(i - 1, K)) % P * C[N - 1][i - 1]) % P;
	}

	return dpMagic[N][K];
}

int go(int N, int K)
{
	if (K >= maxTime[N])
		return 0;

	if (N == 1)
	{
		if (K == 0)
			return 1;

		return 0;
	}

	if (N == 2)
	{
		if (K == 1)
			return 2;

		return 0;
	}

	if (done[N][K])
		return dp[N][K];
	done[N][K] = 1;

	// ustawiaj na wszystkich pozycjach
	FORQ(i, 1, N)
	{
		// konczymy lewy i prawy przedzial dowolnie az do K-1 - ograniczone jednostronnie
		int sl = 0;
		FOR(j, 0, K)
			sl = (sl + goMagic(i - 1, j)) % P;

		int sr = 0;
		FOR(j, 0, K)
			sr = (sr + goMagic(N - i, j)) % P;

		// nie mozemy z obu stron zakonczyc przed K, bo inaczej zwyciezca bedzie wybrany za szybko
		// dp[N][K] = (dp[N][K] + (sl * (LL)sr) % P * C[N - 1][i - 1]) % P;

		// skoncz lewy jak wczesniej, a prawy w K
		dp[N][K] = (dp[N][K] + (sl * (LL)goMagic(N - i, K)) % P * C[N - 1][i - 1]) % P;
		// skoncz prawy jak wczesniej, a lewy w K
		dp[N][K] = (dp[N][K] + (sr * (LL)goMagic(i - 1, K)) % P * C[N - 1][i - 1]) % P;

		// skoncz oba w K - na koncu zostanie jeden zwyciezca
		dp[N][K] = (dp[N][K] + (goMagic(i - 1, K)*(LL)goMagic(N - i, K)) % P * C[N - 1][i - 1]) % P;
	}

	return dp[N][K];
}

int main()
{
	FORQ(w, 0, 10)
	{
		int pt = 1 << w;
		while (pt >= 0 && !maxTime[pt])
		{
			maxTime[pt] = w + 3;
			pt--;
		}
	}

	//P = 1e9 + 7;

	REP(i, MR)
	{
		C[i][0] = C[i][i] = 1;
		FOR(j, 1, i)
			C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
	}

	/*FORQ(i, 1, 10)
	{
		FORQ(j, 1, i)
			printf("%d ", go(i, j));
		printf("\n");
	}*/

	int N, K;
	scanf("%d%d%d", &N, &K, &P);

	printf("%d\n", go(N, K));

	return 0;
}