#include <bits/stdc++.h>

using namespace std;

namespace IO {
    const int BUFFER_SIZE = 1 << 15;

    char input_buffer[BUFFER_SIZE];
    int input_pos = 0, input_len = 0;

    void _update_input_buffer() {
        input_len = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
        input_pos = 0;

        if (input_len == 0)
            input_buffer[0] = EOF;
    }

    inline char next_char(bool advance = true) {
        if (input_pos >= input_len)
            _update_input_buffer();

        return input_buffer[advance ? input_pos++ : input_pos];
    }

    template<typename T>
    inline void read_int(T &number) {
        bool negative = false;
        number = 0;

        while (!isdigit(next_char(false)))
            if (next_char() == '-')
                negative = true;

        do {
            number = 10 * number + (next_char() - '0');
        } while (isdigit(next_char(false)));

        if (negative)
            number = -number;
    }

    template<typename T, typename... Args>
    inline void read_int(T &number, Args &... args) {
        read_int(number);
        read_int(args...);
    }
}

const int N = 31;

unsigned long long dp[N];
bitset < N > used;

vector < int > ans;

void solve(int n, long long k) {
    if (n == 0)
        return;
    ///gasim ce e pe poz k
    int first;
    for (first = 1; first <= n; ++first) {
        if ((dp[first - 1] <= ULLONG_MAX / dp[n - first]) && k >= dp[first - 1] * dp[n - first])
            k -= dp[first - 1] * dp[n - first];
        else
            break;
    }
    ans.push_back(first);
    solve(first - 1, k / dp[n - first]);
    int poz = ans.size();
    solve(n - first, k % dp[n - first]);
    for (; poz < ans.size(); ++poz)
        ans[poz] += first;
}

int main()
{
//    ios_base::sync_with_stdio(NULL);
//    cin.tie(0);
//    cout.tie(0);
    ifstream fin("planeta.in");
    ofstream fout("planeta.out");
    int n;
    long long k;
    fin >> n >> k;
    k--;
    dp[0] = 1;
    dp[1] = 1;
    for (int i = 2; i <= n; ++i)
        for (int j = 0; j < i; ++j)
            dp[i] += dp[j] * dp[i - 1 - j];

    solve(n, k);
    for (int i : ans)
        fout << i << ' ';
    return 0;
}