Problem p02990 (C++)

Buggy submission (status: Runtime Error):
#include <bits/stdc++.h>
using namespace std;

#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for (int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for (int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second

using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;

const double eps = 1e-10;

template <typename A, typename B> inline void chmin(A &a, B b) {
  if (a > b)
    a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
  if (a < b)
    a = b;
}

template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }

template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
  return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}

template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_v(U &u, const V... v) {
  u = U(v...);
}

template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_v(U &u, const V... v) {
  for (auto &e : u)
    fill_v<T>(e, v...);
}

template <typename Data, typename T> struct ReRooting {

  struct Node {
    int to, rev;
    Data data;
  };

  using F1 = function<T(T, T)>;
  using F2 = function<T(T, Data)>;

  vector<vector<Node>> g;
  vector<vector<T>> ldp, rdp;
  vector<int> lptr, rptr;
  const F1 f1;
  const F2 f2;
  const T ident;

  ReRooting(int n, const F1 &f1, const F2 &f2, const T &ident)
      : g(n), ldp(n), rdp(n), lptr(n), rptr(n), f1(f1), f2(f2), ident(ident) {}

  void add_edge(int u, int v, const Data &d) {
    g[u].emplace_back((Node){v, (int)g[v].size(), d});
    g[v].emplace_back((Node){u, (int)g[u].size() - 1, d});
  }

  void add_edge_bi(int u, int v, const Data &d, const Data &e) {
    g[u].emplace_back((Node){v, (int)g[v].size(), d});
    g[v].emplace_back((Node){u, (int)g[u].size() - 1, e});
  }

  T dfs(int idx, int par) {

    while (lptr[idx] != par && lptr[idx] < g[idx].size()) {
      auto &e = g[idx][lptr[idx]];
      ldp[idx][lptr[idx] + 1] =
          f1(ldp[idx][lptr[idx]], f2(dfs(e.to, e.rev), e.data));
      ++lptr[idx];
    }
    while (rptr[idx] != par && rptr[idx] >= 0) {
      auto &e = g[idx][rptr[idx]];
      rdp[idx][rptr[idx]] =
          f1(rdp[idx][rptr[idx] + 1], f2(dfs(e.to, e.rev), e.data));
      --rptr[idx];
    }
    if (par < 0)
      return rdp[idx][0];
    return f1(ldp[idx][par], rdp[idx][par + 1]);
  }

  vector<T> solve() {
    for (int i = 0; i < g.size(); i++) {
      ldp[i].assign(g[i].size() + 1, ident);
      rdp[i].assign(g[i].size() + 1, ident);
      lptr[i] = 0;
      rptr[i] = (int)g[i].size() - 1;
    }
    vector<T> ret;
    for (int i = 0; i < g.size(); i++) {
      ret.push_back(dfs(i, -1));
    }
    return ret;
  }
};

template <::std::uint_fast64_t mod> class ModInt {
private:
  using value_type = ::std::uint_fast64_t;
  value_type n;

public:
  ModInt() : n(0) {}
  ModInt(value_type n_) : n(n_ % mod) {}
  ModInt(const ModInt &m) : n(m.n) {}

  template <typename T> explicit operator T() const {
    return static_cast<T>(n);
  }
  value_type get() const { return n; }

  friend ::std::ostream &operator<<(::std::ostream &os, const ModInt<mod> &a) {
    return os << a.n;
  }

  friend ::std::istream &operator>>(::std::istream &is, ModInt<mod> &a) {
    value_type x;
    is >> x;
    a = ModInt<mod>(x);
    return is;
  }

  bool operator==(const ModInt &m) const { return n == m.n; }
  bool operator!=(const ModInt &m) const { return n != m.n; }
  ModInt &operator*=(const ModInt &m) {
    n = n * m.n % mod;
    return *this;
  }

  ModInt pow(value_type b) const {
    ModInt ans = 1, m = ModInt(*this);
    while (b) {
      if (b & 1)
        ans *= m;
      m *= m;
      b >>= 1;
    }
    return ans;
  }

  ModInt inv() const { return (*this).pow(mod - 2); }
  ModInt &operator+=(const ModInt &m) {
    n += m.n;
    n = (n < mod ? n : n - mod);
    return *this;
  }
  ModInt &operator-=(const ModInt &m) {
    n += mod - m.n;
    n = (n < mod ? n : n - mod);
    return *this;
  }
  ModInt &operator/=(const ModInt &m) {
    *this *= m.inv();
    return *this;
  }
  ModInt operator+(const ModInt &m) const { return ModInt(*this) += m; }
  ModInt operator-(const ModInt &m) const { return ModInt(*this) -= m; }
  ModInt operator*(const ModInt &m) const { return ModInt(*this) *= m; }
  ModInt operator/(const ModInt &m) const { return ModInt(*this) /= m; }
  ModInt &operator++() {
    n += 1;
    return *this;
  }
  ModInt &operator--() {
    n -= 1;
    return *this;
  }
  ModInt operator++(int) {
    ModInt old(n);
    n += 1;
    return old;
  }
  ModInt operator--(int) {
    ModInt old(n);
    n -= 1;
    return old;
  }
  ModInt operator-() const { return ModInt(mod - n); }
};

template <::std::size_t size, ::std::uint_fast64_t mod = 1000000007>
class Factorial {
private:
  using value_type = ModInt<mod>;
  ::std::vector<value_type> fact, inv;

public:
  Factorial() : fact(size + 1, 1), inv(size + 1, 1) {
    for (::std::size_t i = 1; i <= size; ++i) {
      fact[i] = fact[i - 1] * value_type(i);
      inv[i] = fact[i].inv();
    }
  }

  value_type comb(::std::int64_t a, ::std::int64_t b) {
    assert(a >= b);
    assert(b >= 0);
    return fact[a] * inv[b] * inv[a - b];
  }

  value_type &operator[](::std::size_t k) { return fact[k]; }
};

const int64 mod = 1e9 + 7;
using Mint = ModInt<mod>;
Factorial<10000> f;

int main(void) {
  int64 N, K;
  cin >> N >> K;
  int64 R = N - K;
  REP(i, K) {
    Mint res = 0;
    // if (R-1 >= 0 && i-1 >= 0)
    //   res += f.comb(K-1, i) * f.comb(R-1, i-1);
    // cout << res << " ";
    // if (R >= i+1)
    //   res += f.comb(K-1, i) * f.comb(R, i+1);
    // cout << res << " ";
    // if (R >= i+2)
    //   res += f.comb(K-1, i) * f.comb(R, i+2);
    res += f.comb(K - 1, i) * f.comb(R + 1, i + 1);
    cout << res << endl;
  }
}

Fixed submission:
#include <bits/stdc++.h>
using namespace std;

#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for (int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for (int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second

using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;

const double eps = 1e-10;

template <typename A, typename B> inline void chmin(A &a, B b) {
  if (a > b)
    a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
  if (a < b)
    a = b;
}

template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }

template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
  return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}

template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_v(U &u, const V... v) {
  u = U(v...);
}

template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_v(U &u, const V... v) {
  for (auto &e : u)
    fill_v<T>(e, v...);
}

template <typename Data, typename T> struct ReRooting {

  struct Node {
    int to, rev;
    Data data;
  };

  using F1 = function<T(T, T)>;
  using F2 = function<T(T, Data)>;

  vector<vector<Node>> g;
  vector<vector<T>> ldp, rdp;
  vector<int> lptr, rptr;
  const F1 f1;
  const F2 f2;
  const T ident;

  ReRooting(int n, const F1 &f1, const F2 &f2, const T &ident)
      : g(n), ldp(n), rdp(n), lptr(n), rptr(n), f1(f1), f2(f2), ident(ident) {}

  void add_edge(int u, int v, const Data &d) {
    g[u].emplace_back((Node){v, (int)g[v].size(), d});
    g[v].emplace_back((Node){u, (int)g[u].size() - 1, d});
  }

  void add_edge_bi(int u, int v, const Data &d, const Data &e) {
    g[u].emplace_back((Node){v, (int)g[v].size(), d});
    g[v].emplace_back((Node){u, (int)g[u].size() - 1, e});
  }

  T dfs(int idx, int par) {

    while (lptr[idx] != par && lptr[idx] < g[idx].size()) {
      auto &e = g[idx][lptr[idx]];
      ldp[idx][lptr[idx] + 1] =
          f1(ldp[idx][lptr[idx]], f2(dfs(e.to, e.rev), e.data));
      ++lptr[idx];
    }
    while (rptr[idx] != par && rptr[idx] >= 0) {
      auto &e = g[idx][rptr[idx]];
      rdp[idx][rptr[idx]] =
          f1(rdp[idx][rptr[idx] + 1], f2(dfs(e.to, e.rev), e.data));
      --rptr[idx];
    }
    if (par < 0)
      return rdp[idx][0];
    return f1(ldp[idx][par], rdp[idx][par + 1]);
  }

  vector<T> solve() {
    for (int i = 0; i < g.size(); i++) {
      ldp[i].assign(g[i].size() + 1, ident);
      rdp[i].assign(g[i].size() + 1, ident);
      lptr[i] = 0;
      rptr[i] = (int)g[i].size() - 1;
    }
    vector<T> ret;
    for (int i = 0; i < g.size(); i++) {
      ret.push_back(dfs(i, -1));
    }
    return ret;
  }
};

template <::std::uint_fast64_t mod> class ModInt {
private:
  using value_type = ::std::uint_fast64_t;
  value_type n;

public:
  ModInt() : n(0) {}
  ModInt(value_type n_) : n(n_ % mod) {}
  ModInt(const ModInt &m) : n(m.n) {}

  template <typename T> explicit operator T() const {
    return static_cast<T>(n);
  }
  value_type get() const { return n; }

  friend ::std::ostream &operator<<(::std::ostream &os, const ModInt<mod> &a) {
    return os << a.n;
  }

  friend ::std::istream &operator>>(::std::istream &is, ModInt<mod> &a) {
    value_type x;
    is >> x;
    a = ModInt<mod>(x);
    return is;
  }

  bool operator==(const ModInt &m) const { return n == m.n; }
  bool operator!=(const ModInt &m) const { return n != m.n; }
  ModInt &operator*=(const ModInt &m) {
    n = n * m.n % mod;
    return *this;
  }

  ModInt pow(value_type b) const {
    ModInt ans = 1, m = ModInt(*this);
    while (b) {
      if (b & 1)
        ans *= m;
      m *= m;
      b >>= 1;
    }
    return ans;
  }

  ModInt inv() const { return (*this).pow(mod - 2); }
  ModInt &operator+=(const ModInt &m) {
    n += m.n;
    n = (n < mod ? n : n - mod);
    return *this;
  }
  ModInt &operator-=(const ModInt &m) {
    n += mod - m.n;
    n = (n < mod ? n : n - mod);
    return *this;
  }
  ModInt &operator/=(const ModInt &m) {
    *this *= m.inv();
    return *this;
  }
  ModInt operator+(const ModInt &m) const { return ModInt(*this) += m; }
  ModInt operator-(const ModInt &m) const { return ModInt(*this) -= m; }
  ModInt operator*(const ModInt &m) const { return ModInt(*this) *= m; }
  ModInt operator/(const ModInt &m) const { return ModInt(*this) /= m; }
  ModInt &operator++() {
    n += 1;
    return *this;
  }
  ModInt &operator--() {
    n -= 1;
    return *this;
  }
  ModInt operator++(int) {
    ModInt old(n);
    n += 1;
    return old;
  }
  ModInt operator--(int) {
    ModInt old(n);
    n -= 1;
    return old;
  }
  ModInt operator-() const { return ModInt(mod - n); }
};

template <::std::size_t size, ::std::uint_fast64_t mod = 1000000007>
class Factorial {
private:
  using value_type = ModInt<mod>;
  ::std::vector<value_type> fact, inv;

public:
  Factorial() : fact(size + 1, 1), inv(size + 1, 1) {
    for (::std::size_t i = 1; i <= size; ++i) {
      fact[i] = fact[i - 1] * value_type(i);
      inv[i] = fact[i].inv();
    }
  }

  value_type comb(::std::int64_t a, ::std::int64_t b) {
    assert(a >= b);
    assert(b >= 0);
    return fact[a] * inv[b] * inv[a - b];
  }

  value_type &operator[](::std::size_t k) { return fact[k]; }
};

const int64 mod = 1e9 + 7;
using Mint = ModInt<mod>;
Factorial<10000> f;

int main(void) {
  int64 N, K;
  cin >> N >> K;
  int64 R = N - K;
  REP(i, K) {
    Mint res = 0;
    // if (R-1 >= 0 && i-1 >= 0)
    //   res += f.comb(K-1, i) * f.comb(R-1, i-1);
    // cout << res << " ";
    // if (R >= i+1)
    //   res += f.comb(K-1, i) * f.comb(R, i+1);
    // cout << res << " ";
    // if (R >= i+2)
    //   res += f.comb(K-1, i) * f.comb(R, i+2);
    if (K - 1 >= i && R + 1 >= i + 1)
      res += f.comb(K - 1, i) * f.comb(R + 1, i + 1);
    cout << res << endl;
  }
}