#include<iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <fstream>
#include <string>
#include <set>
#include <deque>
#include <queue>
#include <map>
#include <bitset>
#include <random>
#include <cassert>
#include <unordered_map>
#include <unordered_set>
using namespace std;
typedef long long            ll;
typedef unsigned long long   ull;
typedef long double          ld;
#define sqrt              sqrtl
#define endl              "\n"
#define all(a)            a.begin(), a.end()
#define pb                push_back
#define F               first
#define S                second

const ll inf = 1e18;
long double eps = 1e-18;
ll mod = 1e9 + 7;

template<typename T>
T add(T x) {
    return x;
}

template<typename T, typename... Ts>
T add(T x, Ts... y) {
    T res = x + add(y...);
    if (res >= mod)
        res -= mod;
    return res;
}

template<typename T, typename... Ts>
T sub(T x, Ts... y) {
    return add(x, mod - add(y...));
}

template<typename T, typename... Ts>
void udd(T& x, Ts... y) {
    x = add(x, y...);
}

template<typename T>
T mul(T x) {
    return x;
}

template<typename T, typename... Ts>
T mul(T x, Ts... y) {
    return (x * 1ll * mul(y...)) % mod;
}

template<typename T, typename... Ts>
void uul(T& x, Ts... y) {
    x = mul(x, y...);
}
// segment_tree
const ll N = 100000;
ll  tree[N * 4], a[N];
void build(ll v, ll l, ll r) {
    if (l == r) {
        tree[v] = a[l];
        return;
    }
    else {
        ll m = (r + l) / 2;
        build(v * 2 + 1, l, m);
        build(v * 2 + 2, m + 1, r);
        tree[v] = tree[2 * v] + tree[2 * v + 1];
    }
}
void update(ll v, ll tl, ll tr, ll pos, ll new_val) {
    if (tl == tr)
        tree[v] = new_val;
    else {
        ll tm = (tl + tr) / 2;
        if (pos <= tm)
            update(v * 2, tl, tm, pos, new_val);
        else
            update(v * 2 + 1, tm + 1, tr, pos, new_val);
        tree[v] = tree[v * 2] + tree[v * 2 + 1];
    }
}
ll sum(ll v, ll tl, ll tr, ll l, ll r) {
    if (l > r)
        return 0;
    if (l == tl && r == tr)
        return tree[v];
    ll tm = (tl + tr) / 2;
    return sum(v * 2, tl, tm, l, min(r, tm)) + sum(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
//const int Lg = 63;
//int cnt[2][Lg], a[N];
//ll ans = 0;
//
//struct trie {
//    struct node {
//        int go[2] = { -1, -1 }, count = 0;
//        ll sum = 0;
//    };
//    vector<node> t = { {} };
//    void add(ll x) {
//        int v = 0;
//        for (int i = Lg - 1; i > -1; --i) {
//            t[v].count++;
//            int b = (int)((x >> i) & 1LL);
//            if (t[v].go[b] == -1) {
//                t[v].go[b] = (int)size(t);
//                t.emplace_back();
//            }
//            int to = t[v].go[b ^ 1];
//            if (to != -1) {
//                ans += cnt[b ^ 1][i] * 1LL * t[to].count + t[to].sum;
//            }
//            to = t[v].go[b];
//            t[to].sum -= cnt[b][i];
//            v = to;
//        }
//        ++t[v].count;
//    }
//};
void solve() {
    //dp[i][j] i - число кубиков j число кубиков в основании
    ll n;
    cin >> n;
    vector<vector<ll>>dp(n + 1, vector<ll>(n + 1, 0));
    dp[0][0] = 1;
    for (ll i = 1; i <= n; i++) {
        for (ll f = 0; f <= i; f++)
            for (ll j = 0; j < f; j++) {
                dp[i][f] += dp[i - f][j];
            }
    }
    ll sum = 0;
    for (ll i = 0; i <= n; i++)sum += dp[n][i];
    cout << sum;
}
signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    ll t = 1;
    //cin >> t;
    while (t--) {
       solve();
    }
    /*int n;
    cin >> n;
    trie bor;
    for (int i = 0; i < n; ++i) {
        ll x;
        cin >> x;
        for (int j = Lg - 1; j > -1; --j) {
            cnt[(x >> j) & 1][j]++;
        }
        bor.add(x);
    }
    cout << ans;*/

}