#include<bits/stdc++.h>
#define file(F) freopen(#F".in","r",stdin),freopen(#F".out","w",stdout)
#define lowbit(x) ((x)&-(x))
#define ALL(x) (x).begin(),(x).end()
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define popc(x) (__builtin_popcountll((x)))
#define abs(x) ((x)>=0?(x):-(x))
using namespace std;
using ll=long long;
using uint=uint32_t;
template<typename T>
inline bool Max(T &x,T y) { return std::less<T>()(x,y)&&(x=y,true); }
template<typename T>
inline bool Min(T &x,T y) { return std::less<T>()(y,x)&&(x=y,true); }
void Solve();
namespace asnown {
using i32=int32_t;
using u32=uint32_t;
using i64=int64_t;
using u64=uint64_t;
using i128=__int128_t;
using u128=__uint128_t;
struct barrett {
   u32 _m; u64 im;
   explicit barrett(u32 m) : _m(m),im((u64)(-1)/m+1) {}
   u32 umod() const { return _m; }
   u32 mul(u32 a,u32 b) const {
      u64 z=a; z*=b;
      u64 v=((u128(z)*im)>>64);
      u64 y=v*_m;
      return z-y+(z<y?_m:0);
   }
};
constexpr i32 inverse(i32 a,i32 m) {
   i64 r=1;
   while(a>1) { r=r*(m-m/a)%m,a=m%a; }
   return r;
}
template<i32 _m>
struct dynamic_modint {
   using mint=dynamic_modint;
public:
   constexpr dynamic_modint() : v(0) {}
   constexpr dynamic_modint(i32 v) : v(normal(v%mod())) {}
   constexpr dynamic_modint(u32 v) : v(v%mod()) {}
   constexpr dynamic_modint(i64 v) : v(normal(v%mod())) {}
   constexpr dynamic_modint(u64 v) : v(v%mod()) {}
   constexpr dynamic_modint(i128 v) : v(normal(v%mod())) {}
   constexpr dynamic_modint(u128 v) : v(v%mod()) {}
   constexpr static u32 normal(i32 v) { i32 m=mod(); if(v>=m) v-=m; return v+((v>>31)&m); }
   constexpr u32 val() const { return v; }
   constexpr static void set_mod(i32 m) { assert(m>=1); bt=barrett((u32)m); }
   constexpr static u32 mod() { return bt.umod(); }
   constexpr explicit operator bool() const { return v; }
   constexpr mint inv() const { assert(v!=0); return mint(inverse(v,mod())); }
   constexpr mint pow(i64 b) const { assert(b>=0); mint a=*this,res=1;
      for(;b;b>>=1,a*=a) if(b&1) res*=a; return res; }
   constexpr mint operator+() const { return *this; }
   constexpr mint operator-() const { return mint()-*this; }
   constexpr mint& operator+=(const mint &p) { return v=normal(v+p.v),*this; }
   constexpr mint& operator-=(const mint &p) { return v=normal(v-p.v),*this; }
   constexpr mint& operator++() { return (*this)+=1; }
   constexpr mint& operator--() { return (*this)-=1; }
   constexpr mint& operator++(i32) { auto tmp=*this; return ++*this,tmp; }
   constexpr mint& operator--(i32) { auto tmp=*this; return --*this,tmp; }
   constexpr mint& operator*=(const mint &p) { v=i64(v)*p.v%mod(); return *this; }
   constexpr mint& operator/=(const mint &p) { return *this *= p.inv(); }
   constexpr friend mint operator+(const mint &p,const mint &q) { return mint(p)+=q; }
   constexpr friend mint operator-(const mint &p,const mint &q) { return mint(p)-=q; }
   constexpr friend mint operator*(const mint &p,const mint &q) { return mint(p)*=q; }
   constexpr friend mint operator/(const mint &p,const mint &q) { return mint(p)/=q; }
   constexpr friend std::istream& operator>>(std::istream &is,mint &a) { i64 v; is>>v; a=v; return is; }
   constexpr friend std::ostream& operator<<(std::ostream &os,const mint &a) { os<<a.val(); return os; }
   constexpr bool operator==(const mint& p) const { return val()==p.val(); }
   constexpr bool operator!=(const mint& p) const { return val()!=p.val(); }
private:
   i32 v; 
   static barrett bt;
};
template<i32 m> barrett dynamic_modint<m>::bt(998244353);
using mint=dynamic_modint<-1>;
};
using asnown::mint;
const int N = 805;
int n,P;
mint f[N][N];
signed main() {
#ifndef ONLINE_JUDGE
#endif
   cin.tie(nullptr)->sync_with_stdio(false);
   Solve();
}
void Solve() {
   cin>>n>>P; mint::set_mod(P);
   f[1][0]=1;
   for(int i=2;i<=n;i++) for(int j=0;i+j<=n;j++) {
      f[i][j]=f[i-1][0];
      for(int k=2;k<=i-1;k++) f[i][j]+=f[i-k][j]*(f[k][0]-f[k][i-k-1+j]);
      f[i][j]/=i+j-1;
   }
   auto ans=f[n][0];
   for(int i=1;i<n;i++) ans*=i;
   printf("%d\n",ans.val());
}