#include <bits/stdc++.h>

using namespace std;

using ull = unsigned long long;
using L = __uint128_t;

int mod;

struct FastMod {
  ull b, m;
  FastMod(ull b) : b(b), m(ull((L(1) << 64) / b)) {}
  ull operator()(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;
  }
} R(2);
int norm(int x) { return x >= mod ? x - mod : x; }
int reduce(int x) { return x < 0 ? x + mod : x; }
int neg(int x) { return x ? mod - x : 0; }
int quo2(int x) { return (x + (x & 1 ? mod : 0)) >> 1; }
void add(int &x, int y) { x += y, x = x >= mod ? x - mod : x; }
void sub(int &x, int y) { x -= y, x = x < 0 ? x + mod : x; }
void fam(int &x, int y, int z) { x = R(x + (ull)y * z); }
int mpow(int a, int b) {
  int ret = 1;
  for (; b; b >>= 1) {
    if (b & 1) ret = R((ull)ret * a);
    a = R((ull)a * a);
  }
  return ret;
}

const int N = 2e4;

int n;
int fac[N * 4 + 5], ifac[N * 4 + 5];
int f[N + 5][2], ans = 1;

int main() {
  scanf("%d%d", &n, &mod), R = FastMod(mod), fac[0] = 1;
  for (int i = 1; i <= n * 2; ++i) fac[i] = R((ull)fac[i - 1] * i);
  ifac[n * 2] = mpow(fac[n * 2], mod - 2);
  for (int i = n * 2; i; --i) ifac[i - 1] = R((ull)ifac[i] * i);
  f[1][0] = f[2][1] = 1;
  for (int i = 1; i <= n; ++i)
    for (int u = 0; u < 2; ++u)
      if (f[i][u])
        for (int j = 0; i + j <= n; ++j)
          for (int v = 0; v < 2 && i + j + v <= n; ++v) {
            ull t = f[i][u];
            if (v) t *= j + 1 + u;
            if (u) t *= j + 1;
            f[i + j + v + 1][v] = R(f[i + j + v + 1][v] + R(R(t) * fac[i * 2 - 2 - u + j]) * ifac[i * 2 - 2 - u]);
          }
  for (int i = 3; i <= n * 2; i += 2) ans = R((ull)ans * i);
  sub(ans, f[n + 1][0]), printf("%d\n", ans);
}