#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 bot[2][M][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(){
	bot[0][M-1][0]=1; // basecase
	for(int e=0;e<=G;e++){
		int my=e&1,other=my^1;
		memset(bot[other],0,sizeof bot[other]);
		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(bot[my][msk][uzeto]==0)continue;
				//cout << aa << " " << e << " " << uzeto << ": " << (int)bot[my][msk][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)bot[my][msk][uzeto]);
					if(myu>G*G)printf("%i %i\n",myu,G*G);
					assert(myu<=G*G);
					total[e][myu]+=bot[my][msk][uzeto];
					assert(cnt[msk][myu]==0);
					cnt[msk][myu]+=bot[my][msk][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);
						bot[my][msk^(1<<i)][uzeto+ad]+=bot[my][msk][uzeto];
					}
				}
				// Take some smaller 1
				int ad=sledeci+1;
				assert(ad+uzeto<=G*G);
				bot[other][msk][uzeto+ad]+=bot[my][msk][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];
int K;
vector<int> mybot;

vector<li> fact(G+1);

bool pastLim=false;
int emOffset;
vector<int> ans;
int LIMIT;

void dfs(int msk,int em,int treba){
	doneit[msk][em][treba]=1;
	int x=__builtin_popcount(msk);
	//cout << aa << " " << em << " " << treba << endl;
	if(K-x+em+emOffset==K){ // took everything, base case :)
		ordtodo[em].pb({msk,treba});
		return;
	}
	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 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++){
					value+=cnt[msk][k]*puta[em][k];
				}
			}
		}
	}
	return value;
}
void calcans(li poredu,li totalcnt){
	if(sz(ans)==n){
		assert(poredu==1);
		for(auto p:ans){
			printf("%i ",p+1);
		}
		printf("\n");
		return;
	}
	if(sz(ans)==LIMIT){
		for(auto p:havetop)havebot.insert(p);
		havetop.clear();
		LIMIT=N+1;
		pastLim=1;
		b+=dodatniTreba;
		dodatniTreba=0;
	}
	
	// Take something from bot
	// Recalc from answer
	int treba=b;
	emOffset=0;
	for(int i=0;i<sz(ans);i++){
		if(ans[i]<LIMIT){
			treba-=abs(i-ans[i]);
		}
		else{
			emOffset++;
			treba-=LIMIT-i;
		}
	}
	mybot.clear();
	for(auto d:havebot){
		mybot.pb(d-sz(ans));
	}
	if(treba<0)assert(0);
	K=sz(mybot);
	
	// Clear DFS
	memset(doneit,0,sizeof doneit);
	int MM=1<<K;
	for(int i=0;i<=G2;i++)
		ordtodo[i].clear();
	
	// DFS for case of taking bigger
	int takeEl=LIMIT-sz(ans);
	int novitreba=treba-takeEl;
	li starting=0;
	li totalTop=0;
	if(!pastLim&&novitreba>=0){ // only if there are any options
		//printf("Calculating!\n");
		for(int i=0;i<=G;i++)for(int j=0;j<=G*G;j++)puta[i][j]=0;
		memset(bot[1],0,sizeof bot[1]);
		bot[1][MM-1][novitreba]=1; // basecase when skipping first for bigger
		dfs(MM-1,1,novitreba);
		for(int em=1;em<=G;em++){
			int my=em&1,other=my^1;
			memset(bot[other],0,sizeof bot[other]);
			for(int ii=sz(ordtodo[em])-1;ii>=0;ii--){
				int msk=ordtodo[em][ii].f,t=ordtodo[em][ii].s;
				int x=__builtin_popcount(msk);
				li myv=bot[my][msk][t];
				if(myv==0)continue;
				//printf("%i %i %i!\n",em,msk,t);
				
				if(K-x+em+emOffset==K){ // took everything, base case :)
					for(int i=0;i<K;i++){
						if(msk&(1<<i)){
							t-=K-emOffset-1-mybot[i];
						}
					}
					t+=dodatniTreba;
					if(t<0||t>G*G)continue;
					//printf("Treba: %i\n",t);
					//printf("Opcija: %i\n",(int)total[em+emOffset][t]);
					
					puta[em+emOffset][t]+=fact[em-1]*fact[em+emOffset]*myv;
					starting+=total[em+emOffset][t]*fact[em-1]*fact[em+emOffset]*myv;
					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<=t){
							bot[my][msk^(1<<i)][t-ad]+=myv;
						}
					}
				}
				int ad=K-emOffset-vecUzeo;
				if(ad<=t){
					bot[other][msk][t-ad]+=myv;
				}
			}
		}
		//printf("Opcija: %i\n",(int)starting);
		for(auto p:havetop){
			li val=removeVal(p-LIMIT);
			li my=starting-val;
			totalTop+=my;
		}
		//printf("Totalno top: %i\n",(int)totalTop);
	}
	
	if(totalcnt==-1||poredu<=totalcnt-totalTop){
		// calculate full DP
		dfs(MM-1,0,treba);
		for(int em=G2;em>=0;em--){
			int my=em&1,other=my^1;
			for(auto p:ordtodo[em]){
				int msk=p.f,tr=p.s;
				int t=tr;
				int x=__builtin_popcount(msk);
				bot[my][msk][tr]=0;
					
				if(K-x+em+emOffset==K){
					if(!pastLim){
						for(int i=0;i<K;i++){
							if(msk&(1<<i)){
								tr-=K-emOffset-1-mybot[i];
							}
						}
						tr+=dodatniTreba;
						if(tr<0||tr>G*G)continue;
						
						bot[my][msk][t]=total[em+emOffset][tr]*fact[em]*fact[em+emOffset];
						continue;
					}
					else{
						assert(msk==0&&em==0);
						bot[my][msk][tr]=tr==0;
						continue;
					}
				}
				int vecUzeo=K-x+em;
				li mojval=0;
				for(int i=0;i<K;i++){
					if(msk&(1<<i)){
						int taking=mybot[i];
						int ad=abs(taking-vecUzeo);
						if(ad<=tr){
							mojval+=bot[my][msk^(1<<i)][tr-ad];
						}
					}
				}
				if(!pastLim){
					int ad=K-emOffset-vecUzeo;
					if(ad<=tr){
						mojval+=bot[other][msk][tr-ad];
					}
				}
				bot[my][msk][tr]=mojval;
			}
		}
		totalcnt=bot[0][MM-1][treba];
	}
	//printf("Total: %i\n",(int)totalcnt);
	if(!pastLim&&poredu>totalcnt-totalTop){ // val is in the top
		poredu-=totalcnt-totalTop;
		vector<int> opt;
		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("Opcija2 %i: %i\n",opt[i],(int)my);
			if(my>=poredu){
				ans.pb(p);
				remove(p-LIMIT);
				havetop.erase(p);
				calcans(poredu,my);
				return;
			}
			poredu-=my;
		}
		assert(0);
	}
	
	//value is in the bottom
	
	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<=treba){
			my=bot[0][msk^(1<<i)][treba-ad];
		}
		//printf("Opcija %i: %i\n",opt[i],(int)my);
		if(my>=poredu){
			ans.pb(opt[i]);
			havebot.erase(opt[i]);
			calcans(poredu,my);
			return;
		}
		poredu-=my;
	}
	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';
	}
	//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,-1);
	return 0;
}