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>
using namespace std;

#ifdef local
#define _assert(expr) assert(expr)
#else
#define _assert(expr)
#endif

int Mod = 998244353;

typedef long long ll;

void exgcd(int a, int b, int& x, int& y) {
  if (!b) {
    x = 1, y = 0;
  } else {
    exgcd(b, a % b, y, x);
    y -= (a / b) * x;
  }
}
int inv(int a, int Mod = ::Mod) {
  int x, y;
  exgcd(a, Mod, x, y);
  return (x < 0) ? (x + Mod) : x;
}

class Z {
  public:
    int v;

    Z() {	}
    Z(int v) : v(v) {
      _assert(v >= 0 && v < Mod);
    }
    Z(ll x) : v(x % Mod) {	}

    friend Z operator + (Z a, Z b) {
      int x;
      return Z((x = a.v + b.v) >= Mod ? x - Mod : x); 
    }
    friend Z operator - (Z a, Z b) {
      int x;
      return Z((x = a.v - b.v) < 0 ? x + Mod : x);
    }
    friend Z operator * (Z a, Z b) {
      return 1ll * a.v * b.v;
    }
    friend Z operator ~ (Z a) {
      _assert(a.v);
      return inv(a.v);
    }
    friend Z operator - (Z a) {
      return Z(0) - a;
    }
    Z& operator += (Z b) {
      return *this = *this + b;
    }
    Z& operator -= (Z b) {
      return *this = *this - b;
    }
    Z& operator *= (Z b) {
      return *this = *this * b;
    }
};

typedef Z Zi;

Zi qpow(Zi a, int p) {
  if (p < 0)
    p += Mod - 1;
  Zi rt = 1;
  for ( ; p; p >>= 1, a *= a) {
    if (p & 1) {
      rt *= a;
    }
  }
  return rt;
}
Zi qpow(Zi a, ll p) {
  return qpow(a, (int) (p % (Mod - 1)));
}

const int N = 405;

int n, K;

vector<Zi> fac, _fac;

void init_fac(int n) {
  fac.resize(n + 1);
  _fac.resize(n + 1);
  fac[0] = 1;
  for (int i = 1; i <= n; i++) {
    fac[i] = fac[i - 1] * i;
  }
  _fac[n] = ~fac[n];
  for (int i = n; i; i--) {
    _fac[i - 1] = _fac[i] * i;
  }
}
Zi comb(int n, int m) {
  return n < m ? 0 : fac[n] * _fac[m] * _fac[n - m];
}

Zi f[205][205];

Zi calc(int n, int m, int bu, int bd) {
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      f[i][j] = 0;
    }
  }
  for (int j = 0; j < m; j++) {
    f[0][j] = (j <= bu && j >= bd);
  }
  for (int i = 1; i < n; i++) {
    Zi sum = 0;
    for (int j = 0; j < m && j <= bu + i; j++) {
      sum += f[i - 1][j];
      if (j >= bd + i) {
        f[i][j] = sum;
      }
    }
  }
  Zi sum = 0;
  for (int j = max(bd + n - 1, 0); j < m && j < bu + n; j++) {
    sum += f[n - 1][j];
  }
  for (int i = 1; i < n; i++) {
    if (i + bu >= m) {
      sum += f[i][m - 1];
    }
  }
  return sum;
}

int main() {
  scanf("%d%d%d", &n, &K, &Mod);
  init_fac(405);
  K = n - 1 - K;
  Zi ans = !K;
  for (int sl = max(K, 1); sl < n; sl++) {
    for (int sr = max(K, 1); sl + sr < n; sr++) {
      Zi tmp = calc(sr, sl, sl - K, K - sr); 
//      cerr << tmp.v << " ";
      tmp = tmp * ~Zi(sl + sr + 1);
      ans += tmp;
    }
  }
  ans *= fac[n];
  printf("%d\n", ans.v);
  return 0;
}