Given are integers N and K, and a prime number P. Find the number, modulo P, of directed graphs G with N vertices that satisfy below. Here, the vertices are distinguishable from each other.

* G is a tournament, that is, G contains no duplicated edges or self-loops, and exactly one of the edges u\to v and v\to u exists for any two vertices u and v.
* The in-degree of every vertex in G is at most K.
* For any four distinct vertices a, b, c, and d in G, it is not the case that all of the six edges a\to b, b\to c, c\to a, a\to d, b\to d, and c\to d exist simultaneously.

Constraints

* 4 \leq N \leq 200
* \frac{N-1}{2} \leq K \leq N-1
* 10^8<P<10^9
* N and K are integers.
* P is a prime number.

Input

Input is given from Standard Input in the following format:


N K P


Output

Print the number of directed graphs that satisfy the conditions, modulo P.

Examples

Input

4 3 998244353


Output

56


Input

7 3 998244353


Output

720


Input

50 37 998244353


Output

495799508
#include <bits/stdc++.h>

namespace IO
{
char gc()
{
#ifdef FREAD
	static char buf[1<<21], *P1 = buf, *P2 = buf;
	if(P1 == P2)
	{
		P1 = buf;
		P2 = buf + fread(buf, 1, 1<<21, stdin);
		if(P1 == P2) return EOF;
	}
	return *(P1++);
#else
	return getchar();
#endif
}
template<typename Tp> bool get1(Tp &x)
{
	bool neg = 0;
	char c = gc();
	while( c != EOF && (c < '0' || c > '9') && c != '-' ) c = gc();
	if(c == '-') c = gc(), neg = 1;
	if(c == EOF) return false;
	x = 0;
	for(; c>='0' && c<='9'; c = gc()) x = x*10 + c - '0';
	if(neg) x = -x;
	return true;
}
template<typename Tp> void printendl(Tp x)
{
	if(x<0)putchar('-'),x=-x;
	static short a[40], sz;
	sz = 0;
	while(x>0)a[sz++]=x%10,x/=10;
	if(sz==0)putchar('0');
	for(int i=sz-1; i>=0; i--)putchar('0'+a[i]);
	puts("");
}
} // namespace IO
using IO::get1;
using IO::printendl;
#define get2(x,y) get1(x) && get1(y)
#define get3(x,y,z) get2(x,y) && get1(z)
#define get4(x,y,z,w) get3(x,y,z) && get1(w)
#define pb push_back
#define mp std::make_pair
#define ff first
#define ss second
typedef long long LL;
typedef unsigned long long uLL;
typedef std::pair<int,int> pii;
const int inf = 0x3f3f3f3f;
const LL Linf = 1ll<<61;

const int maxn = 211;
int n, k, mod;

int fac[maxn], invf[maxn], c[maxn][maxn];
int qpow(int x, int y)
{
	int ret = 1;
	while(y)
	{
		if(y & 1) ret = 1ll * ret * x % mod;
		x = 1ll * x * x % mod;
		y >>= 1;
	}
	return ret;
}

int calc(int n, int k)
{
	if(k < 0) return 0;
	if(n == 0) return 1;
	if(n < 3) return 0;
	
	int ret = 0;
	for(int L=2; L<n; L++)
	{
		int R = n - L;
		static int dp[maxn][maxn];
		memset(dp, 0, sizeof(dp));
		
		dp[0][0] = 1;
		for(int i=0; i<=L; i++) for(int j=0; j<=R; j++)
		{
			if(j+1 <= R)
			{
				int ind = L - i + j;
				if(ind > 0 && ind <= k)
				{
					dp[i][j+1] += dp[i][j];
					if(dp[i][j+1] >= mod) dp[i][j+1] -= mod;
				}
			}
			if(i+1 <= L)
			{
				int ind = R - j + i;
				if(ind > 0 && ind <= k && (i < L - 1 || j == R))
				{
					dp[i+1][j] += dp[i][j];
					if(dp[i+1][j] >= mod) dp[i+1][j] -= mod;
				}
			}
		}
		ret += dp[L][R];
		if(ret >= mod) ret -= mod;
	}
	ret = 1ll * ret * fac[n-1] % mod;
	return ret;
}

int main()
{
	get3(n, k, mod);
	
	fac[0] = invf[0] = 1;
	for(int i=1; i<maxn; i++)
	{
		fac[i] = 1ll * i * fac[i-1] % mod;
		invf[i] = qpow(fac[i], mod - 2);
	}
	for(int i=0; i<maxn; i++)
	{
		c[i][0] = 1;
		for(int j=1; j<=i; j++)
		{
			c[i][j] = c[i-1][j] + c[i-1][j-1];
			if(c[i][j] >= mod) c[i][j] -= mod;
		}
	}
	
	if(k == n - 1) k = n;
	
	int ans = 0;
	for(int i=0; i<=n; i++) ans = (ans + 1ll * fac[n] * invf[n-i] % mod * calc(n - i, k - i)) % mod;
	printendl(ans);
	return 0;
}