//#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;
#define MAXN 256
#define RADIX 1000000000


bool use_fft = false;


class lint {
	int d;
	int a[63];
public:
	lint(){d=-1;}
	lint(int x)
	{
		d = 0;
		do {
			a[d++] = x % RADIX;
			x/=RADIX;
		} while (x);
	}
	lint(char *s)
	{
		int l = (int) strlen(s);
		d = (l-1)/9+1;
		for (int i = 0; i < l; i++) {
			int x = s[l-1-i]-'0';
			if (i % 9 == 0)
				a[i/9] = 0;
			for (int j = 0; j < (i%9); j++)
				x *= 10;
			a[i/9] += x;
		}
		while (d > 1 && a[d-1] == 0) d--;
	}
	void print(void)
	{
		for (int i = d-1; i >= 0; i--) {
			if (i == d - 1)
				printf("%d", a[i]);
			else
				printf("%09d", a[i]);
		}
	}
	friend lint operator + (const lint &a, const lint &b);
	friend lint operator * (const lint &a, const lint &b);
	friend ostream& operator<<(ostream&, const lint &);
	friend istream& operator>>(istream&, lint &);
	friend void _mul_fft(const lint &a, const lint &b, lint &d);
	void muldig(int digit)
	{
		if (!digit) {
			d = 1;
			a[0] = 0;
			return;
		}
		int carry = 0;
		for (int i = 0; i < d; i++) {
			long long temp = a[i];
			temp *= (long long) digit;
			temp += carry;
			carry = (int) (temp / RADIX);
			a[i] = (int) (temp % RADIX);
		}
		if (carry) {
			a[d++] = carry;
		}
	}
	void shift(int amount)
	{
		for (int i = d+amount-1; i >= 0; i--) {
			a[i] = i - amount >= 0 ? a[i-amount] : 0;
		}
		d += amount;
	}
	bool operator <= (const lint &rhs) const
	{
		if (d > rhs.d) return false;
		if (d < rhs.d) return true;
		for (int i = d-1; i >= 0; i--) {
			if (a[i] != rhs.a[i])
				return a[i] < rhs.a[i];
		}
		return true;
	}
	void operator -= (const lint &rhs)
	{
		int borrow = 0;
		int i;
		for (i = 0; i < rhs.d; i++) {
			a[i] = a[i] - rhs.a[i] - borrow;
			borrow = 0;
			if (a[i] < 0) {
				a[i] += RADIX;
				borrow = 1;
			}
		}
		while (borrow && i < d) {
			a[i] --;
			borrow = 0;
			if (a[i] < 0) {
				a[i] += RADIX;
				borrow = 1;
			}
			i++;
		}
		while (d > 1 && a[d-1] == 0) d--;
	}
};


lint operator + (const lint& a, const lint &b)
{
	lint c;
	int fa, fb, fc = 0;
	int m = max(a.d, b.d);
	c.d = m;
	for (int i = 0; i < m; i++) {
		fa = i < a.d ? a.a[i] : 0;
		fb = i < b.d ? b.a[i] : 0;
		c.a[i] = fa + fb + fc;
		fc = 0;
		if (c.a[i] >= RADIX) {
			fc = 1;
			c.a[i] -= RADIX;
		}
	}
	if (fc) {
		c.d++;
		c.a[m] = fc;
	}
	return c;
}

lint operator * (const lint &a, const lint &b)
{
/*
	if (use_fft && a.d > 10 && b.d > 10) {
		lint c;
		_mul_fft(a, b, c);
		return c;
	}
*/
	lint sum=0;
	for (int i = 0; i < b.d; i++) {
		lint c = a;
		c.shift(i);
		c.muldig(b.a[i]);
		sum = sum + c;
	}
	return sum;
}
/*
ostream& operator << (ostream &os, const lint &l)
{
	char s[12];
	for (int i = l.d-1; i >= 0; i--) {
		if (i == l.d - 1)
			sprintf(s, "%d", l.a[i]);
		else
			sprintf(s, "%09d", l.a[i]);
		os << s;
	}
	return os;
}
istream& operator >> (istream &os, lint &l)
{
	char x[2000] = {0};
	os >> x;
	l = x;
	return os;
}*/

lint R[MAXN][MAXN];
lint P[MAXN];
lint K;

int N,From;
vector <int> Sol;

void static_init();
bool init();
void nextStep();
bool cmp(const pair < pair <int,int> , pair <lint, int> > a,
		 const pair < pair <int,int> , pair <lint, int> > b)
{
	pair <int,int> x = a.first;
	pair <int,int> y = b.first;
	int minpoz = min(x.first, y.first);
	int first = x.first == minpoz ? x.second : Sol[minpoz];
	int second = y.first == minpoz ? y.second : Sol[minpoz];
	return first < second;
}

void static_init()
{
	P[0] = 1;
	for (int i = 1 ; i < MAXN ; i++)
		P[i] = P[i - 1] * i;
	for (int i = 0 ; i < MAXN ; i++)
		for (int j = 0 ; j < MAXN ; j++)
			R[i][j] = i && j ? R[i - 1][j] + R[i][j - 1] : 1;
}

bool init()
{
	int m;
	char sK[2000] = {0};
	if (3 != scanf("%d%d%s", &N, &m, sK))
		return false;
	K = sK;
	Sol.clear();
	for (int i = 0 ; i < m ; i++)
	{
		int x;
		scanf("%d", &x);
		Sol.push_back(x);
	}
	From = 0;
	return true;
}

void nextStep()
{
	bool used[MAXN];
	int sz = (int)Sol.size();
	memset(used, false, sizeof used);
	for (int i = 0 ; i < sz; i++)
		used[Sol[i]] = true;
	vector <int> free;
	for (int i = 1 ; i <= N ; i++)
		if (!used[i])
			free.push_back(i);
	vector < pair < pair <int,int> , pair <lint, int> > > F;
	for (int i = From ; i <= sz; i++)
		for (int j = 0 ; j < (int)free.size() ; j++)
		{
			lint val = P[N - sz - 1] * R[N - sz - 1][sz - i];
			F.push_back(
				make_pair(
					make_pair(i,free[j]),
					make_pair(val,i + 1)));
		}
	sort(F.begin(), F.end(), cmp);
	for (int i = 0 ; true; i++)
		if (K <= F[i].second.first)
		{
			Sol.insert(Sol.begin() + F[i].first.first,F[i].first.second);
			From = F[i].second.second;
			return;
		}
		else
			K -= F[i].second.first;
}

int main()
{
	//freopen("input", "rt", stdin);
	static_init();
	while (init())
	{
		while (N > (int)Sol.size())
			nextStep();
		for (int i = 0 ; i < N ; i++)
		{
			printf("%d", Sol[i]);
			if (i < N - 1)
				printf(" ");
			else
				printf("\n");
		}
	}
	return 0;
}