#include <bits/stdc++.h>

using namespace std;

namespace {

#ifdef AZN_LIB
#pragma once
#endif

/**
 * A class to simplify using integers modulo some number (does not have to be prime).
 * @tparam MOD number to modulo by.
 */
template <int MOD> class IntMod {
  static_assert(0 < MOD and MOD <= numeric_limits<int>::max() / 2, "MOD out of range");

  int val;

 public:

  IntMod() : val(0) {}

  IntMod(int64_t x) : val(static_cast<int>(x % MOD)) {
    if (val < 0)
      val += MOD;
  }

  IntMod& operator+=(const IntMod& x) {
    val += x.val;
    if (val >= MOD)
      val -= MOD;
    return *this;
  }

  IntMod operator+(const IntMod& x) const {
    IntMod res(*this);
    return res += x;
  }

  IntMod& operator-=(const IntMod& x) {
    val -= x.val;
    if (val < 0)
      val += MOD;
    return *this;
  }

  IntMod operator-(const IntMod& x) const {
    IntMod res(*this);
    return res -= x;
  }

  IntMod& operator*=(const IntMod& x) {
    val = static_cast<int>(static_cast<int64_t>(val) * x.val % MOD);
    return *this;
  }

  IntMod operator*(const IntMod& x) const {
    IntMod res(*this);
    return res *= x;
  }

  IntMod& operator/=(const IntMod& x) {
    return *this *= x.Inv();
  }

  IntMod operator/(const IntMod& x) const {
    IntMod res(*this);
    return res /= x;
  }

  IntMod operator-() const {
    IntMod res(*this);
    if (res.val != 0)
      res.val = MOD - res.val;
    return res;
  }

  /**
   * @return this value raised to given exponent.
   * If exponent is negative returns 1.
   * Takes O(log exponent) time.
   */
  IntMod Power(int64_t exponent) const {
    IntMod ans(1), temp(*this);
    for (; exponent > 0; exponent >>= 1) {
      if (exponent & 1)
        ans *= temp;
      temp *= temp;
    }
    return ans;
  }

  /**
   *  Undefined if this value is not co-prime with MOD.
   *  Takes O(log MOD) time.
   */
  IntMod Inv() const {
    int64_t a = MOD, b = val, nx = 1, x = 0;
    while (b != 0) {
      tie(nx, x) = make_pair(x - (a / b) * nx, nx);
      tie(a, b) = make_pair(b, a % b);
    }
    return IntMod(x);
  }

  explicit operator int() const { return val; }

  friend ostream& operator<<(ostream& out, const IntMod& x) {
    return out << x.val;
  }

  bool operator==(const IntMod& x) const {
    return val == x.val;
  }

  bool operator!=(const IntMod& x) const {
    return val != x.val;
  }
};

#define VEVE(i, a, b) for (ll i = a, __##i = b; i < __##i; ++i)
#define DYDY(i, a, b) for (ll i = a, __##i = b; i > __##i; --i)
#define RARA(x, seq) for (auto &x : seq)
#define SIZE(x) ((ll)(x.size()))
#define ALL(x) x.begin(), x.end()

typedef int64_t ll;
typedef double dd;
const ll MOD = 998244353;
typedef IntMod<MOD> Int;
const ll MAX = 2048;

// dp[i][j][h] = number of ways to choose a multiset from i types of coins such that j total
// coins are chosen and coins with the same type have the same face (heads or tails)
// and h=1 iff type i (1-indexed) is in the multiset
Int dp[MAX / 2][MAX][2];

// dp2[i][j] = number of ways to choose a multiset from i types of balls such that j total balls
// are chosen
Int dp2[MAX][MAX];

void Solve(ll) {
  ll n, k;
  cin >> k >> n;
  memset(dp, 0, sizeof(dp));
  dp[0][0][0] = 1;
  VEVE(i, 0, MAX / 2 - 1) VEVE(j, 0, MAX - 1) VEVE(have, 0, 2) {
//        Pln(i, j, have, dp[i][j][have]);
        // add coin of type i (multiply two to choose face of coin)
        if (i > 0)
          dp[i][j + 1][1] += dp[i][j][have] * (1 + (not have));
        // end coins of type i
        dp[i + 1][j][0] += dp[i][j][have];
      }
  memset(dp2, 0, sizeof(dp2));
  dp2[0][0] = 1;
  VEVE(i, 0, MAX - 1) VEVE(j, 0, MAX - 1) {
      dp2[i + 1][j] += dp2[i][j];
      if (i > 0)
        dp2[i][j + 1] += dp2[i][j];
    }
//  PlnArr(dp2, MAX, MAX);
  VEVE(sum, 2, 2 * k + 1) {
    Int res;
    VEVE(mid, 0, 1 + (sum % 2 == 0)) { // iterate sum/2 (only if sum is even) is in multiset
      const ll pairs = (sum - 1) / 2 - max(ll(0), sum - k - 1);
//      DEBUG(sum, pairs, k - 2 * pairs - (sum % 2 == 0));
      VEVE(le, 0, n - mid + 1) { // iterate number of elements < sum
        const ll gt = n - mid - le; // number of elements >= sum
        res += (dp[pairs][le][0] + dp[pairs][le][1]) * dp2[k - 2 * pairs - (sum % 2 == 0)][gt];
      }
    }
    cout << res << "\n";
  }
}

void Init() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
}
}

int32_t main() {
#ifdef AZN
  freopen("input.txt", "r", stdin);
#endif
  Init();
  ll tests = 1;
  VEVE(test, 1, tests + 1) Solve(test);
  return 0;
}


Measured memory_bytes: 33024