#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

// Hàm cộng hai số lớn dạng string
string add(string a, string b) {
    string res = "";
    int carry = 0;
    int i = a.length() - 1, j = b.length() - 1;
    while (i >= 0 || j >= 0 || carry) {
        int sum = carry;
        if (i >= 0) sum += a[i--] - '0';
        if (j >= 0) sum += b[j--] - '0';
        res += (sum % 10) + '0';
        carry = sum / 10;
    }
    reverse(res.begin(), res.end());
    return res;
}

int main() {
    int n;
    cin >> n;
    vector<string> dp(n + 1);
    dp[0] = "1";
    for (int i = 1; i <= n; i++) {
        dp[i] = "0";
        for (int j = 0; j < i; j++) {
            dp[i] = add(dp[i], multiply(dp[j], dp[i - 1 - j])); // Need multiply function
        }
    }
    cout << dp[n] << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

const int MAX = 2500; // Đủ để chứa các số từ 2n (2000)
int prime[MAX];
int exponent[MAX];

void sieve() {
    for (int i = 2; i < MAX; i++) prime[i] = i;
    for (int i = 2; i * i < MAX; i++) {
        if (prime[i] == i) {
            for (int j = i * i; j < MAX; j += i)
                if (prime[j] == j) prime[j] = i;
        }
    }
}

void add_exponent(int n, int factor) {
    while (n > 1) {
        int p = prime[n];
        while (n % p == 0) {
            exponent[p] += factor;
            n /= p;
        }
    }
}

void multiply(vector<int> &res, int x) {
    int carry = 0;
    for (int i = 0; i < res.size(); i++) {
        long long cur = 1LL * res[i] * x + carry;
        res[i] = cur % 10;
        carry = cur / 10;
    }
    while (carry) {
        res.push_back(carry % 10);
        carry /= 10;
    }
}

int main() {
    int n;
    cin >> n;
    if (n == 0) {
        cout << 1 << endl;
        return 0;
    }
    sieve();

    // Tính số mũ cho (2n)! / ((n+1)! * n!)
    // C_n = (2n)! / ((n+1)! * n!)
    // Ta có thể viết lại: C_n = (2n)! / (n! * (n+1)!) = (2n)! / (n! * n! * (n+1))
    // Hay dùng Suy biến: C_n = Prod_{k=2}^{2n} k / (Prod_{k=2}^{n} k * Prod_{k=2}^{n} k * (n+1))
    // Thêm/Sớt số mũ nguyên tố

    // Tăng mũ cho (2n)!
    for (int i = 2; i <= 2 * n; i++) add_exponent(i, 1);
    // Giảm mũ cho n!
    for (int i = 2; i <= n; i++) add_exponent(i, -1);
    // Giảm mũ cho (n+1)!
    for (int i = 2; i <= n + 1; i++) add_exponent(i, -1);

    vector<int> result;
    result.push_back(1);

    // Tích tất cả các số nguyên tố với số mũ tương ứng
    // Tối ưu: nhân từ nhỏ đến lớn
    for (int i = 2; i < MAX; i++) {
        if (exponent[i] > 0) {
            for (int j = 0; j < exponent[i]; j++) {
                multiply(result, i);
            }
        }
    }

    for (int i = result.size() - 1; i >= 0; i--) cout << result[i];
    cout << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void multiply(vector<int> &a, int x) {
    int carry = 0;
    for (int i = 0; i < a.size(); i++) {
        long long cur = 1LL * a[i] * x + carry;
        a[i] = cur % 10;
        carry = cur / 10;
    }
    while (carry) {
        a.push_back(carry % 10);
        carry /= 10;
    }
}

void divide(vector<int> &a, int x) {
    long long rem = 0;
    for (int i = a.size() - 1; i >= 0; i--) {
        long long cur = rem * 10 + a[i];
        a[i] = cur / x;
        rem = cur % x;
    }
    while (a.size() > 1 && a.back() == 0) a.pop_back();
}

int main() {
    int n;
    cin >> n;
    vector<int> res;
    res.push_back(1);

    // Dựa trên C_n = C_{n-1} * (4n - 2) / (n + 1)
    for (int i = 1; i <= n; i++) {
        multiply(res, 4 * i - 2);
        divide(res, i + 1);
    }

    for (int i = res.size() - 1; i >= 0; i--) cout << res[i];
    cout << endl;
    return 0;
}