#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>

#define ll long long
#define pb push_back
#define f first
#define s second
#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define ios ios_base::sync_with_stdio(false);cin.tie(NULL)
#define ld long double
#define li __int128

using namespace __gnu_pbds;
using namespace std;

mt19937 rng(time(NULL));
const int N=30,G=15,M=1<<G;
li top[M][2][G*G+1];
int n,b;
li total[G+1][G*G+1];
li puta[G+1][G*G+1];
li cnt[M][G*G+1];
bool done[M];
void calctop(){
	top[M-1][0][0]=1; // basecase
	for(int e=0;e<=G;e++){
		int my=e&1,other=my^1;
		for(int i=0;i<M;i++)for(int j=0;j<=G*G;j++)top[i][other][j]=0;
		for(int msk=M-1;msk>=0;msk--){
			int x=__builtin_popcount(msk);
			int nema=G-x + e;
			int sledeci=G-nema-1;
			for(int uzeto=0;uzeto<=G*G;uzeto++){
				if(top[msk][my][uzeto]==0)continue;
				bitset<G> aa=msk;
				//cout << aa << " " << e << " " << uzeto << ": " << (int)top[msk][my][uzeto] << endl;
				if(nema==G){
					int myu=uzeto;
					for(int i=0;i<G;i++){
						if(msk&(1<<i)){
							myu+=i;
						}
					}
					//cout << aa << " ";
					//printf("%i %i += %i\n",e,myu,(int)top[msk][my][uzeto]);
					if(myu>G*G)printf("%i %i\n",myu,G*G);
					assert(myu<=G*G);
					total[e][myu]+=top[msk][my][uzeto];
					assert(cnt[msk][myu]==0);
					cnt[msk][myu]+=top[msk][my][uzeto];
					continue;
				}
				// Take it
				for(int i=0;i<G;i++){
					int ad=abs(i-sledeci);
					if(msk&(1<<i)){
						assert(ad+uzeto<=G*G);
						top[msk^(1<<i)][my][uzeto+ad]+=top[msk][my][uzeto];
					}
				}
				// Take some smaller 1
				int ad=sledeci+1;
				assert(ad+uzeto<=G*G);
				top[msk][other][uzeto+ad]+=top[msk][my][uzeto];
			}
		}
	}
}
vector<int> tk;
void remove(int i){
	tk.clear();
	for(int msk=0;msk<M;msk++){
		if(!(msk&(1<<i))){
			if(!done[msk]){
				done[msk]=1;
				tk.pb(msk);
				int em=__builtin_popcount(msk);
				for(int k=0;k<=G*G;k++){
					//printf("%i %i -= %i\n",em,k,(int)cnt[msk][k]);
					total[em][k]-=cnt[msk][k];
				}
			}
		}
	}
}
void undo(){
	for(auto msk:tk){
		done[msk]=0;
		int em=__builtin_popcount(msk);
		for(int k=0;k<=G*G;k++){
			total[em][k]+=cnt[msk][k];
		}
	}
}
set<int> havebot,havetop;
const int G2=N-G,M2=(1<<G2),D=G2*G2;
int dodatniTreba;
bool doneit[M2][G2+1][D+1];
vector<pair<int,int>> ordtodo[G2+1];
li bot[M2][2][D+1];
int K;
vector<int> mybot;
void reset(){
	K=sz(mybot);
}
vector<li> fact(G+1);
bool pastLim=false;
int emOffset;
int lastTr;
vector<int> ans;
int LIMIT;
void dfs(int msk,int em,int treba){
	doneit[msk][em][treba]=1;
	int x=__builtin_popcount(msk);
	bitset<M2> aa=msk;
	//cout << aa << " " << em << " " << treba << endl;
	if(K-x+em+emOffset==K){ // took everything, base case :)
		ordtodo[em].pb({msk,treba});
		return;
	}
	li val=0;
	int vecUzeo=K-x+em;
	for(int i=0;i<K;i++){
		if(msk&(1<<i)){
			int taking=mybot[i];
			int ad=abs(taking-vecUzeo);
			if(ad<=treba){
				if(!doneit[msk^(1<<i)][em][treba-ad]){
					dfs(msk^(1<<i),em,treba-ad);
				}
			}
		}
	}
	if(sz(havetop)){
		int ad=K-emOffset-vecUzeo;
		if(ad<=treba){
			if(!doneit[msk][em+1][treba-ad]){
				dfs(msk,em+1,treba-ad);
			}
		}
	}
	ordtodo[em].pb({msk,treba});
}
li calc(){
	lastTr=b;
	emOffset=0;
	for(int i=0;i<sz(ans);i++){
		if(ans[i]<LIMIT){
			// small
			lastTr-=abs(i-ans[i]);
		}
		else{
			emOffset++;
			lastTr-=LIMIT-i;
		}
	}
	mybot.clear();
	for(auto d:havebot){
		mybot.pb(d-sz(ans));
	}
	if(lastTr<0)return 0;
	reset();
	
	memset(doneit,0,sizeof doneit);
	int MM=1<<K;
	for(int i=0;i<=G2;i++)
		ordtodo[i].clear();
	dfs(MM-1,0,lastTr);
	for(int em=G2;em>=0;em--){
		int my=em&1,other=my^1;
		for(auto p:ordtodo[em]){
			int msk=p.f,treba=p.s;
			int t=treba;
			int x=__builtin_popcount(msk);
			bot[msk][my][treba]=0;
				
			if(K-x+em+emOffset==K){ // took everything, base case :)
				if(!pastLim){
					for(int i=0;i<K;i++){
						if(msk&(1<<i)){
							treba-=K-emOffset-1-mybot[i];
						}
					}
					treba+=dodatniTreba;
					if(treba<0||treba>G*G)continue;
					//printf("Treba: %i\n",treba);
					//printf("Opcija: %i\n",(int)total[em+emOffset][treba]);
					
					bot[msk][my][t]=total[em+emOffset][treba]*fact[em]*fact[em+emOffset];
					continue;
				}
				else{
					assert(msk==0&&em==0);
					bot[msk][my][treba]=treba==0;
					continue;
				}
			}
			int vecUzeo=K-x+em;
			for(int i=0;i<K;i++){
				if(msk&(1<<i)){
					int taking=mybot[i];
					int ad=abs(taking-vecUzeo);
					if(ad<=treba){
						bot[msk][my][treba]+=bot[msk^(1<<i)][my][treba-ad];
					}
				}
			}
			if(sz(havetop)){
				int ad=K-emOffset-vecUzeo;
				if(ad<=treba){
					bot[msk][my][treba]+=bot[msk][other][treba-ad];
				}
			}
		}
	}
	return bot[MM-1][0][lastTr];
}
queue<pair<pair<int,int>,int>> q;
li processBot(){
	lastTr=b;
	emOffset=0;
	for(int i=0;i<sz(ans);i++){
		if(ans[i]<LIMIT){
			// small
			lastTr-=abs(i-ans[i]);
		}
		else{
			emOffset++;
			lastTr-=LIMIT-i;
		}
	}
	mybot.clear();
	for(auto d:havebot){
		mybot.pb(d-sz(ans));
	}
	if(lastTr<0)return 0;
	reset();
	int MM=1<<K;
	for(int i=0;i<=G;i++)for(int j=0;j<=G*G;j++)puta[i][j]=0;
	for(int i=0;i<MM;i++)for(int j=0;j<=D;j++)bot[i][0][j]=0;
	li anss=0;
	
	bot[MM-1][0][lastTr]=1; // basecase
	for(int em=0;em<=G;em++){
		int my=em&1,other=my^1;
		for(int i=0;i<MM;i++)for(int j=0;j<=D;j++)bot[i][other][j]=0;
		for(int msk=MM-1;msk>=0;msk--){
			int x=__builtin_popcount(msk);
			for(int t=0;t<=D;t++){
				int treba=t;
				li myv=bot[msk][my][treba];
				if(myv==0)continue;
				
				if(K-x+em+emOffset==K){ // took everything, base case :)
					if(!pastLim){
						for(int i=0;i<K;i++){
							if(msk&(1<<i)){
								treba-=K-emOffset-1-mybot[i];
							}
						}
						treba+=dodatniTreba;
						if(treba<0||treba>G*G)continue;
						//printf("Treba: %i\n",treba);
						//printf("Opcija: %i\n",(int)total[em+emOffset][treba]);
						
						puta[em+emOffset][treba]+=fact[em]*fact[em+emOffset]*myv;
						anss+=total[em+emOffset][treba]*fact[em]*fact[em+emOffset]*myv;
						continue;
					}
					else{
						assert(0);
					}
				}
				int vecUzeo=K-x+em;
				for(int i=0;i<K;i++){
					if(msk&(1<<i)){
						int taking=mybot[i];
						int ad=abs(taking-vecUzeo);
						if(ad<=treba){
							bot[msk^(1<<i)][my][treba-ad]+=myv;
						}
					}
				}
				if(sz(havetop)){
					int ad=K-emOffset-vecUzeo;
					if(ad<=treba){
						bot[msk][other][treba-ad]+=myv;
					}
				}
			}
		}
	}
	return anss;
}
li removeVal(int i){
	li value=0;
	for(int msk=0;msk<M;msk++){
		if(!(msk&(1<<i))){
			if(!done[msk]){
				int em=__builtin_popcount(msk);
				for(int k=0;k<=G*G;k++){
					//printf("%i %i -= %i\n",em,k,(int)cnt[msk][k]);
					value+=cnt[msk][k]*puta[em][k];
					//total[em][k]-=cnt[msk][k];
				}
			}
		}
	}
	return value;
}
ll starttim;
ll tima,timb;
void calcans(li treba){
	if(sz(ans)==n){
		assert(treba==1);
		for(auto p:ans){
			printf("%i ",p+1);
		}
		printf("\n");
		return;
	}
	//printf("%i: %lld\n",sz(ans),clock()-starttim);
	/*printf("%i!\n",sz(ans));
	for(auto p:ans)printf("%i ",p);
	printf("\n");
	for(auto p:havebot)printf("%i ",p);
	printf("\n");
	for(auto p:havetop)printf("%i ",p);
	printf("\n");*/
	if(sz(ans)==LIMIT){
		// Convert all the top to bot case
		// TODO
		for(auto p:havetop)havebot.insert(p);
		havetop.clear();
		LIMIT=N+1;
		pastLim=1;
		b+=dodatniTreba;
		dodatniTreba=0;
	}
	// Take something from bot
	ll startt=clock();
	li totalCnt=calc();
	tima+=clock()-startt;
	//printf("Total: %i\n",(int)totalCnt);
	
	vector<int> opt;
	for(auto p:havebot)opt.pb(p);

	int msk=(1<<K)-1;
	for(int i=0;i<sz(mybot);i++){
		int taking=mybot[i];
		int ad=abs(taking);
		li my=0;
		if(ad<=lastTr){
			my=bot[msk^(1<<i)][0][lastTr-ad];
		}
		//printf("Pokusavam %i: %i\n",opt[i],(int)my);
		if(my>=treba){
			ans.pb(opt[i]);
			havebot.erase(opt[i]);
			calcans(treba);
			return;
		}
		treba-=my;
	}
	
	/*for(auto p:opt){
		havebot.erase(p);
		ans.pb(p);

		li my=calctr();
		printf("Pokusavam %i: %i\n",p,(int)my);
		if(my>=treba){
			calcans(treba);
			return;
		}
		treba-=my;
		
		ans.pop_back();
		havebot.insert(p);
	}*/
	
	if(sz(havetop)){
		// calculate
		startt=clock();
		ans.pb(LIMIT);
		li starting=processBot();
		ans.pop_back();
		timb+=clock()-startt;
		// Take something from top
		opt.clear();
		for(auto p:havetop)opt.pb(p);
		
		for(int i=0;i<sz(opt);i++){
			int p=opt[i];
			li val=removeVal(p-LIMIT);
			li my=starting-val;
			//printf("Pokusavam 2 %i: %i\n",p,(int)my);
			if(my>=treba){
				ans.pb(p);
				remove(p-LIMIT);
				havetop.erase(p);
				calcans(treba);
				return;
			}
			treba-=my;
		}
		
		/*for(auto p:opt){
			havetop.erase(p);
			ans.pb(p);
			remove(p-LIMIT);
	
			li my=calctr();
			//printf("Pokusavam 2 %i: %i\n",p,(int)my);
			if(my>=treba){
				calcans(treba);
				return;
			}
			treba-=my;
			
			ans.pop_back();
			havetop.insert(p);
			undo();
		}*/
	}
	assert(0);
}
int main()
{
	fact[0]=1;
	for(int i=1;i<=G;i++)fact[i]=i*fact[i-1];
	scanf("%i %i",&n,&b);
	if(b>G2*G2){
		dodatniTreba=b-G2*G2;
		b=G2*G2;
	}
	int mx=0;
	for(int i=0;i<n;i++){
		mx+=abs(i-(n-1-i));
	}
	//printf("%i!\n",mx);
	string s;
	cin >> s;
	li k=0;
	for(auto p:s){
		k*=10;
		k+=p-'0';
	}
	starttim=clock();
	//n=b=k=6;
	if(n>G){
		calctop();
		//printf("Done calctop!\n");
		for(int i=0;i<n-G;i++){
			havebot.insert(i);
		}
		for(int i=n-G;i<n;i++)havetop.insert(i);
		LIMIT=n-G;
	}
	else{
		for(int i=0;i<n;i++)havebot.insert(i);
		LIMIT=n;pastLim=1;
	}
	calcans(k);
	//printf("%lld %lld\n",tima,timb);
	return 0;
}