#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <typename T>
void DBG(const char* name, T&& H) {
  cerr << name << " = " << H << ')' << '\n';
}
template <typename T, typename... Args>
void DBG(const char* names, T&& H, Args&&... args) {
  const char* NEXT = strchr(names + 1, ',');
  cerr.write(names, NEXT - names) << " = " << H << " |";
  DBG(NEXT + 1, args...);
}
using ll = long long;
using ld = long double;
const ll mod = 1e9 + 7;
const ld PI = acos(-1.0);
const ll maxN = 1e6 + 1;
const ll INF = 1e18;
struct modint {
  static constexpr int MOD = 1e9 + 7;
  using lli = long long;
  int vv;
  static int minv(int a, int m) {
    a %= m;
    assert(a);
    return a == 1 ? 1 : int(m - lli(minv(m, a)) * lli(m) / a);
  }
  modint() : vv(0) {}
  modint(lli v_) : vv(int(v_ % MOD)) {
    if (vv < 0) vv += MOD;
  }
  explicit operator int() const { return vv; }
  friend std::ostream& operator<<(std::ostream& out, const modint& n) {
    return out << int(n);
  }
  friend std::istream& operator>>(std::istream& in, modint& n) {
    lli v_;
    in >> v_;
    n = modint(v_);
    return in;
  }
  friend bool operator==(const modint& a, const modint& b) {
    return a.vv == b.vv;
  }
  friend bool operator!=(const modint& a, const modint& b) {
    return a.vv != b.vv;
  }
  modint inv() const {
    modint res;
    res.vv = minv(vv, MOD);
    return res;
  }
  friend modint inv(const modint& m) { return m.inv(); }
  modint neg() const {
    modint res;
    res.vv = vv ? MOD - vv : 0;
    return res;
  }
  friend modint neg(const modint& m) { return m.neg(); }
  modint operator-() const { return neg(); }
  modint operator+() const { return modint(*this); }
  modint& operator++() {
    vv++;
    if (vv == MOD) vv = 0;
    return *this;
  }
  modint& operator--() {
    if (vv == 0) vv = MOD;
    vv--;
    return *this;
  }
  modint& operator+=(const modint& o) {
    vv += o.vv;
    if (vv >= MOD) vv -= MOD;
    return *this;
  }
  modint& operator-=(const modint& o) {
    vv -= o.vv;
    if (vv < 0) vv += MOD;
    return *this;
  }
  modint& operator*=(const modint& o) {
    vv = int(lli(vv) * lli(o.vv) % MOD);
    return *this;
  }
  modint& operator/=(const modint& o) { return *this *= o.inv(); }
  friend modint operator++(modint& a, int) {
    modint r = a;
    ++a;
    return r;
  }
  friend modint operator--(modint& a, int) {
    modint r = a;
    --a;
    return r;
  }
  friend modint operator+(const modint& a, const modint& b) {
    return modint(a) += b;
  }
  friend modint operator-(const modint& a, const modint& b) {
    return modint(a) -= b;
  }
  friend modint operator*(const modint& a, const modint& b) {
    return modint(a) *= b;
  }
  friend modint operator/(const modint& a, const modint& b) {
    return modint(a) /= b;
  }
};
modint match[2001][2001];
bool vis[2001][2001];
void rec(int length, int req) {
  if ((length == 0) && (req == 0)) {
    return;
  }
  if (req > length) return;
  if (vis[length][req]) return;
  if (req) {
    rec(length - 1, req + 1);
    rec(length - 1, req - 1);
    match[length][req] += match[length - 1][req + 1];
    match[length][req] += match[length - 1][req - 1];
    if ((length % 2) == 1) match[length][req]++;
  } else {
    rec(length - 1, req + 1);
    match[length][req] += match[length - 1][req + 1];
    if ((length % 2) == 1) match[length][req]++;
  }
  vis[length][req] = 1;
}
void Solve() {
  int n;
  cin >> n;
  rec(2 * n, 0);
  cout << match[2 * n][0] << '\n';
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int tt = 1;
  while (tt--) {
    Solve();
  }
  return 0;
}
