from sys import stdin

def main():
    elements = stdin.read().strip().split()
    n = len(elements)
    bell_triangle = [[0] * (n + 1) for _ in range(n + 1)]
    bell_triangle[0][0] = 1

    for i in range(1, n + 1):
        bell_triangle[i][0] = bell_triangle[i - 1][i - 1]
        for j in range(1, i + 1):
            bell_triangle[i][j] = bell_triangle[i - 1][j - 1] + bell_triangle[i][j - 1]

    print(bell_triangle[n][0] - 1)

if __name__ == "__main__":
    main()

#include <bits/stdc++.h>

using namespace std;

string ltrim(const string &);
string rtrim(const string &);



/*
 * Complete the 'minTimeForRobots' function below.
 *
 * The function is expected to return a LONG_INTEGER.
 * The function accepts following parameters:
 *  1. INTEGER the_number_of_robots
 *  2. INTEGER_ARRAY rack_capacities
 */


#include<bits/stdc++.h>
using ll = long long;
using namespace std;
bool canAllocate(const vector<int>& capacities, ll k, ll maxLoad) {
    ll robotCount = 1; 
    ll currentLoad = 0; 

    for (int cap : capacities) {
        if (cap > maxLoad) return false; 
        if (currentLoad + cap > maxLoad) {
            robotCount++;
            currentLoad = cap;
            if (robotCount > k) return false;
        } else {
            currentLoad += cap;
        }
    }

    return true;
}


long long minTimeForRobots(int the_number_of_robots, std::vector<int> rack_capacities) {
    ll n = rack_capacities.size();
    if (the_number_of_robots == 0) return -1; 
    if(the_number_of_robots>n)return *max_element(rack_capacities.begin(), rack_capacities.end());
    ll low = *max_element(rack_capacities.begin(), rack_capacities.end());
    ll high = accumulate(rack_capacities.begin(), rack_capacities.end(), 0l);
    ll result = high;

    while (low <= high) {
        ll mid = low + (high - low) / 2;

        if (canAllocate(rack_capacities, the_number_of_robots, mid)) {
            result = mid;
            high = mid - 1; 
        } else {
            low = mid + 1;
        }
    }

    return result;

}