#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define all(a) a.begin(), a.end()
ll ceildiv(ll a, ll b) { return a / b + (a % b && (a ^ b) >= 0); }

struct mint {
  inline static int m = 0;
  int x;
  mint() : x(0) {}
  mint(ll x_) : x(x_% m) {
    if (x < 0)
      x += m;
  }
  mint& operator+=(mint b) {
    if ((x += b.x) >= m)
      x -= m;
    return *this;
  }
  mint& operator-=(mint b) {
    if ((x -= b.x) < 0)
      x += m;
    return *this;
  }
  mint& operator*=(mint b) {
    x = (ll)(x)*b.x % m;
    return *this;
  }
  mint pow(ll e) const {
    mint r = 1, b = *this;
    while (e) {
      if (e & 1)
        r *= b;
      b *= b;
      e /= 2;
    }
    return r;
  }
  mint inv() const { return pow(m - 2); }
  mint& operator/=(mint b) { return *this *= b.inv(); }
  friend mint operator+(mint a, mint b) { return a += b; }
  friend mint operator-(mint a, mint b) { return a -= b; }
  friend mint operator*(mint a, mint b) { return a *= b; }
  friend mint operator/(mint a, mint b) { return a /= b; }
};

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

  int N, p;
  cin >> N >> p;
  mint::m = p;

  const int lim = 2 * N + 1;
  vector<mint> fact(lim, 1), ifact(lim);
  rep(i, 1, lim) fact[i] = fact[i - 1] * i;
  ifact.back() = 1 / fact.back();
  for (int i = lim - 1; i >= 1; i--)
    ifact[i - 1] = ifact[i] * i;
  const auto binom2 = [&](int a, int b) {
    return fact[a + b] * ifact[a] * ifact[b];
  };
  const auto paren = [&](int n) -> mint {
    if (n == 0)
      return 1;
    else
      return binom2(n, n) - binom2(n + 1, n - 1);
  };

  using poly = vector<mint>;
  vector<poly> acol(2 * N + 1, poly(N + 1, 0));
  acol[0][0] = 1;
  rep(i, 0, N + 1) {
    rep(j, 0, i + 1) {
      acol[1][i] += paren(j) * paren(i - j) * binom2(2 * (i - j), 2 * j);
    }
  }
  rep(l, 2, 2 * N + 1) {
    rep(i, 0, N + 1) {
      rep(j, 0, i + 1) { acol[l][i] += acol[l - 1][j] * acol[1][i - j]; }
    }
  }

  vector<mint> ccol(N + 1, 0);
  rep(l, 1, N + 1) {
    mint temp = acol[1][l];
    rep(k, 1, l) temp -= ccol[k] * acol[2 * k][l - k];
    ccol[l] = temp / acol[2 * l][0];
  }

  vector<mint> cbip(N + 1, 0);
  rep(i, 0, N + 1) cbip[i] = ccol[i] / 2;

  vector<poly> abip(2 * N + 1, poly(N + 1, 0));
  rep(i, 0, 2 * N + 1) abip[i][0] = 1;
  rep(l, 1, N + 1) {
    rep(k, 1, l + 1) abip[1][l] += cbip[k] * abip[2 * k][l - k];
    rep(k, 2, 2 * N + 1) {
      rep(i, 0, l + 1) { abip[k][l] += abip[k - 1][i] * abip[1][l - i]; }
    }
  }

  rep(i, 1, N + 1) cout << abip[1][i].x << "\n";

  return 0;
}