#include <iostream>
#include <fstream>


std::ofstream fout("planeta.out");
std::ifstream fin("planeta.in");

long long arbore_binar[100], x;
int n;

// aleg nod 1 ca root, am 0 elem pe stanga si n-1 elem pe dreapta
// aleg nod 2 ca root am 1 elem pe stanga si n-2 elem pe dreapta
// aleg nod 3 ca root, am 2 elem pe stanga si n-3 elem pe dreapta
// aleg nod i ca root, am i-1 elem pe stanga  si n-i pe dreapta

// at nr de subarobori ar fi:
//: f(n) (nr de arbori cu n root node) = f(0) * f(n-1) + f(1) * f(n-2) + .......... + f(n-1) * f(0)--> nr catalan

// dr estte in esenta n in cazul meu (sfarsitul pentru permuutarile luate in vedere)
// st e de fapt inceputul, 1

void search_tree(int st, int dr, long long k)
{
    int current_root;
    for(current_root = st; current_root < dr; current_root++)
    {
        //parte din formula nr de arbori care ma ajuta sa vad si a cata permutare am
        long long nr_subarbori = arbore_binar[current_root - st] * arbore_binar[dr-current_root];

// caut arborele atat timp cat nr de arbori parcursi <=k si scad pe masura ce ma duc catre permutarea dorita
        if (nr_subarbori <= k)
            k -= nr_subarbori;
        else
            break;
    }

    // afisare pentru fiecare nod
    fout<<current_root<<' ';

    // apelare recursiva pentru fiecare nod (e ca si cum as vedea la un moment acel nod ca un root node)
    // in functie de cum am pozitionez nodul curent in preordine (in raport cu regula de BST)
    if(current_root > st)
        search_tree(st, current_root - 1, k / arbore_binar[dr-current_root]);
    if(current_root < dr)
        search_tree(current_root + 1, dr, k % arbore_binar[dr-current_root]);

}

int main()
{
    fin>>n>>x;
    // pornesc cu 1 ca root node
    arbore_binar[0] = 1;

    //// pt fiecare i vad nr de arbori binari de cautare care se pot forma cu nr 1...i
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= i; j++)
            // nr de arbori binari poate fi calculat folosind nr catalan
            // in functie de fiecare root node considerat
            arbore_binar[i] +=  arbore_binar[i - j] * arbore_binar[j - 1];

    x--;
    search_tree(1, n, x);
    return 0;
}