#include <bits/stdc++.h>

typedef unsigned long long ull;
typedef __uint128_t L;

struct FastMod {
    ull b, m;
    FastMod(ull b) : b(b), m(ull((L(1) << 64) / b)) {}
    ull reduce(ull a) {
        ull q = (ull)((L(m) * a) >> 64);
        ull r = a - q * b; // can be proven that 0 <= r < 2 * b
        return r >= b ? r - b : r;
    }
} Fastmod(2);

template<unsigned id>
class dynamic_modint {
  using mint = dynamic_modint<id>;

protected:
  static unsigned P;

  unsigned v;

public:
  dynamic_modint() : v() {}

  template<typename T,
           typename std::enable_if<std::is_integral<T>::value &&
                                       std::is_signed<T>::value,
                                   bool>::type = true>
  dynamic_modint(T t_v) : v() {
    long long tmp = t_v % static_cast<long long>(P);
    if (tmp < 0) {
      tmp += P;
    }
    v = tmp;
  }

  template<typename T,
           typename std::enable_if<std::is_integral<T>::value &&
                                       std::is_unsigned<T>::value,
                                   bool>::type = true>
  dynamic_modint(T t_v) : v() {
    v = t_v % P;
  }

  unsigned val() const {
    return v;
  }

  static unsigned mod() {
    return P;
  }

  static void set_mod(unsigned nP) {
    Fastmod = FastMod(nP);
    P = nP;
  }

  static mint raw(unsigned v) {
    mint res;
    res.v = v;
    return res;
  }

  mint &operator+=(const mint &rhs) {
    v < P - rhs.v ? v += rhs.v : v -= P - rhs.v;
    return *this;
  }

  mint &operator++() {
    v + 1 < P ? ++v : v = 0;
    return *this;
  }

  mint operator++(int) {
    mint tmp = *this;
    v + 1 < P ? ++v : v = 0;
    return tmp;
  }

  mint &operator-=(const mint &rhs) {
    v < rhs.v ? v += P - rhs.v : v -= rhs.v;
    return *this;
  }

  mint &operator--() {
    v ? --v : v = P - 1;
    return *this;
  }
  
  mint operator--(int) {
    mint tmp = *this;
    v ? --v : v = P - 1;
    return tmp;
  }

  mint operator-() const {
    mint res;
    res.v = v ? P - v : 0;
    return res;
  }

  mint &operator*=(const mint &rhs) {
    v = Fastmod.reduce(static_cast<unsigned long long>(v) * rhs.v);
    return *this;
  }

  mint pow(unsigned long long b) const {
    mint a(*this), s(1);
    for (; b; b >>= 1) {
      if (b & 1) {
        s *= a;
      }
      a *= a;
    }
    return s;
  }

  mint inv() const {
    return pow(P - 2);
  }

  friend mint operator+(const mint &lhs, const mint &rhs) {
    return mint(lhs) += rhs;
  }

  friend mint operator-(const mint &lhs, const mint &rhs) {
    return mint(lhs) -= rhs;
  }

  friend mint operator*(const mint &lhs, const mint &rhs) {
    return mint(lhs) *= rhs;
  }

  friend bool operator==(const mint &lhs, const mint &rhs) {
    return lhs.v == rhs.v;
  }

  friend bool operator!=(const mint &lhs, const mint &rhs) {
    return lhs.v != rhs.v;
  }

  friend std::istream &operator>>(std::istream &in, mint &x) {
    return in >> x.v;
  }

  friend std::ostream &operator<<(std::ostream &out, const mint &x) {
    return out << x.v;
  }
};

template<unsigned id>
unsigned dynamic_modint<id>::P;

using mint = dynamic_modint<0>;

class Binom {
private:
  std::vector<mint> Fac, Inv;

public:
  Binom(int n) : Fac(n + 1), Inv(n + 1) {
    Fac[0] = 1;
    for (int i = 1; i <= n; ++i) {
      Fac[i] = Fac[i - 1] * i;
    }
    Inv[n] = Fac[n].inv();
    for (int i = n; i; --i) {
      Inv[i - 1] = Inv[i] * i;
    }
  }

  mint fac(int x) {
    return Fac[x];
  }

  mint invfac(int x) {
    return Inv[x];
  }

  mint binom(int n, int m) {
    if (n < m) {
      return mint();
    }
    return Fac[n] * Inv[m] * Inv[n - m];
  }
};

signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);

  int n, P;
  std::cin >> n >> P;
  mint::set_mod(P);

  Binom comb(n);
  std::vector<std::vector<mint>> dp(n + 1, std::vector<mint>(n + 1));
  dp[1][0] = 1;

  for (int i = 2; i <= n; ++i) {
    for (int j = 0; i + j <= n; ++j) {
      dp[i][j] += dp[i - 1][0];

      for (int k = 2; i - k > 1; ++k) {
        dp[i][j] += (dp[k][0] - dp[k][i - k - 1 + j]) * dp[i - k][j];
      }

      dp[i][j] *= mint(i + j - 1).inv();
    }
  }

  std::cout << dp[n][0] * comb.fac(n - 1) << '\n';
}