#include <bits/stdc++.h>
//#define int long long
#define FOR(i,a,b) for(int i = (a); i <= (b); i++)
#define RE(i,n) FOR(i,1,n)
#define REP(i,n) FOR(i,0,(n)-1)
#define MP make_pair
#define PB push_back
#define st first
#define nd second
#define SZ(x) ((int)(x).size())
#ifndef LOCAL
#define cerr if(0)cout
#endif
using namespace std;
const int N = 2e2 + 5;

int dp[N][N][N];
int newt[N][N];
int inv[N];
int spow(int a, int b, int P) {
  int r = 1;
  while (b) {
    if (b % 2) {
      r = 1ll * r * a % P;
    }
    a = 1ll * a * a % P;
    b /= 2;
  }
  return r;
}
int Inv(int a, int P) {
  return spow(a, P - 2, P);
}
int P;
#undef int
int main() {
#define int long long
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  
  int n, max_d;
  cin>>n>>max_d>>P;
  if (n == 1) {
    cout<<(max_d == 0)<<endl;
    return 0;
  }
  if (n == 2) {
    cout<<(max_d == 1)<<endl;
    return 0;
  }
  if (max_d <= 1) {
    cout<<"0\n";
    return 0;
  }
  int npar = max_d % 2;
  max_d /= 2;
  RE (i, n) {
    inv[i] = Inv(i, P);
  }
  dp[1][0][0] = 1;
  RE (dep, max_d) {
    dp[1][dep][0] = 1;
    FOR (sz, 2, n) {
      RE (max_son, sz - 1) {
        // Wkladamy synow wielkosci max_son
        // aby sumarycznie miec sz wierzcholkow
        // Albo nie dokladamy nikogo (dp[max_son][dep - 1][max_son - 1])
        // albo dokladamy l synow wielkosci max_son
        // i wtedy bierzemy wynik z dp[prev][dep][prev - 1]
        // l synow takiej wielkosci wybieramy ilestam sposobow
        int cur = dp[max_son][dep - 1][max_son - 1];
        dp[sz][dep][max_son] = dp[sz][dep][max_son - 1];
        for (int l = 1; l * max_son < sz; l++) {
          int prev = sz - l * max_son;
          dp[sz][dep][max_son] = (dp[sz][dep][max_son] + 1ll * dp[prev][dep][min(prev, max_son) - 1] * cur) % P;
          cur = 1ll * cur * inv[l + 1] % P * (dp[max_son][dep - 1][max_son - 1] + l) % P;
          //cerr<<cur<<endl;
        }
        cerr<<"dp["<<sz<<"]["<<dep<<"]["<<max_son<<"]="<<dp[sz][dep][max_son]<<endl;
      }
    }
  }
  long long res = 0;
  if (npar) {
    for (int l = 1; 2 * l < n; l++) {
      int r = n - l;
      res += 1ll * (dp[l][max_d][l - 1] - dp[l][max_d - 1][l - 1] + P) * (dp[r][max_d][r - 1] - dp[r][max_d - 1][r - 1] + P);
      res %= P;
    }
    if (n % 2 == 0) {
      long long K = dp[n / 2][max_d][n / 2 - 1] - dp[n / 2][max_d - 1][n / 2 - 1] + P;
      res += 1ll * K * (K + 1) / 2;
    }
    cout<<res % P<<endl;
  } else {
    res = (dp[n][max_d][n - 1] - dp[n][max_d - 1][n - 1] + P) % P;
    RE (big_son, n - 1) {
      long long BIG_DEEP = dp[big_son][max_d - 1][big_son - 1];
      if (max_d >= 2) {
        BIG_DEEP = (BIG_DEEP - dp[big_son][max_d - 2][big_son - 1] + P) % P;
      }
      res = (res - (BIG_DEEP * dp[n - big_son][max_d - 1][n - big_son - 1]) % P + P) % P;
    }
    cout<<res<<endl;
  }

  return 0;
}