#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1000000000;
const long long int mod = 1000000000 + 7;
inline void IO() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
}
inline int dcmp(long double x) { return x < -1e-12 ? -1 : (x > 1e-12); }
template <class T>
inline int CHECK(T MASK, int i) {
  return (MASK >> i) & 1;
}
template <class T>
inline T ON(T MASK, int i) {
  return MASK | (T(1) << i);
}
template <class T>
inline T OFF(T MASK, int i) {
  return MASK & (~(T(1) << i));
}
template <typename T>
inline int CNT(T MASK) {
  if (numeric_limits<T>::digits <= numeric_limits<unsigned int>::digits)
    return __builtin_popcount(MASK);
  else
    return __builtin_popcountll(MASK);
}
template <class T>
inline int RIGHT(T MASK) {
  return log2(MASK & -MASK);
}
int dx4[] = {0, 0, -1, +1};
int dy4[] = {+1, -1, 0, 0};
int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1, 0};
int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1, 0};
inline void I(int& a) { scanf("%d", &a); }
inline void I(long long int& a) { scanf("%I64d", &a); }
inline void I(unsigned long long int& a) { scanf("%I64u", &a); }
inline void I(char* a) { scanf("%s", a); }
char Iarr[2000010];
inline void I(string& a) {
  scanf("%s", Iarr);
  a = Iarr;
}
template <typename T, typename... Args>
void I(T& a, Args&... args) {
  I(a);
  I(args...);
}
inline void OUT(int a) { printf("%d", a); }
inline void OUT(long long int a) { printf("%I64d", a); }
inline void OUT(const char* a) { printf("%s", a); }
inline void OUT(char* a) { printf("%s", a); }
inline void OUT(bool a) { printf("%d", a); }
inline void OUT(string a) {
  for (__typeof(a.end()) it = (a.begin()) - ((a.begin()) > (a.end()));
       it != (a.end()) - ((a.begin()) > (a.end()));
       it += 1 - 2 * ((a.begin()) > (a.end())))
    printf("%c", *it);
}
inline void OUT(unsigned long long int a) { printf("%I64u", a); }
template <typename T, typename... Args>
void OUT(T a, Args... args) {
  OUT(a);
  OUT(" ");
  OUT(args...);
}
template <typename... Args>
void O(Args... args) {
  OUT(args...);
  OUT("\n");
}
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, pair<T1, T2> p) {
  os << "{" << p.first << ", " << p.second << "}";
  return os;
}
template <typename T>
inline ostream& operator<<(ostream& os, vector<T>& a) {
  os << "[";
  for (int i = 0; i < (int)a.size(); i++) {
    if (i) os << ", ";
    os << a[i];
  }
  os << "]";
  return os;
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
  cout << *it << " = " << a << endl;
  err(++it, args...);
}
const int M = 1000010;
struct NumberTheory {
  long long int gcd(long long int a, long long int b) {
    while (b) {
      a %= b;
      swap(a, b);
    }
    return a;
  }
  long long int lcm(long long int a, long long int b) {
    return (a / gcd(a, b)) * b;
  }
  long long int bigMod(long long int p, long long int e, long long int m) {
    long long int ret = 1;
    p %= m;
    while (e > 0) {
      if (e & 1) ret = (ret * p) % m;
      p = (p * p) % m;
      e >>= 1;
    }
    return ret;
  }
  long long int modInverse(long long int a, long long int m) {
    long long int g = gcd(a, m);
    if (g != 1) {
      cout << "Inverse doesn't exist" << endl;
      return -1;
    }
    long long int m0 = m;
    long long int y = 0, x = 1;
    if (m == 1) return 0;
    while (a > 1) {
      long long int q = a / m;
      long long int t = m;
      m = a % m, a = t;
      t = y;
      y = x - q * y;
      x = t;
    }
    if (x < 0) x += m0;
    return x;
  }
  void genModInv(int n, long long int m, unsigned long long int inv[]) {
    inv[1] = 1;
    for (int i = 2; i <= n; ++i) inv[i] = (m - (m / i) * inv[m % i] % m) % m;
  }
  void genModInvFact(int n, long long int m, unsigned long long int inv[],
                     unsigned long long int invFact[]) {
    invFact[0] = invFact[1] = 1;
    for (int i = 2; i <= n; i++) invFact[i] = (invFact[i - 1] * inv[i]) % m;
  }
} num;
class nCrModPrime {
 private:
  int n;
  unsigned long long int* fact;
  unsigned long long int* inv;
  unsigned long long int* invFact;
  unsigned long long int primeMod;

 public:
  nCrModPrime(int n, unsigned long long int m) {
    this->n = n;
    primeMod = m;
    fact = new unsigned long long int[n + 1];
    inv = new unsigned long long int[n + 1];
    invFact = new unsigned long long int[n + 1];
    fact[0] = 1;
    for (int i = 1; i <= n; i++) fact[i] = (fact[i - 1] * i) % m;
    num.genModInv(n, m, inv);
    num.genModInvFact(n, m, inv, invFact);
  }
  unsigned long long int nCr(int n, int r) {
    if (n < r) return 0;
    return (((fact[n] * invFact[r]) % primeMod) * invFact[n - r]) % primeMod;
  }
};
int main() {
  int n;
  I(n);
  nCrModPrime obj(n + n - 1, mod);
  long long int ans = obj.nCr(n + n - 1, n - 1);
  O((ans * 2 - n + mod) % mod);
  return 0;
}
