#include <bits/stdc++.h>
#define all(a) begin(a), end(a)
#define int long long

using namespace std;

const int N = 1e4 + 11;
const int K = 8;
set<int> G[N];

struct edge{
	int u, v;
};

vector<edge> E;
vector<int> ans[K];
int n, m, k; 

random_device rd;
mt19937 rng(rd());

void reset(){
	for (auto [u, v] : E) {
		G[u].insert(v);
		G[v].insert(u);
	}
	for (int i = 0; i < K; i++) {
		ans[i].clear();
	}
}

void remove_path(vector<int> ans){
	for (int i = 0; i + 1 < ans.size(); i++) {
		int u = ans[i], v = ans[i + 1];
		G[u].erase(v); G[v].erase(u);
	}
}

int kth(set<int>& S, int id){
	return *next(S.begin(), id);
}

bool find_hamilton_path(vector<int>& ans) {
	int st = rng() % n + 1;
	for (int i = 1; i <= n; i++) {
		if (G[i].size() < G[st].size()) st = i;
	}
	vector<int> path {st};
	vector<bool> ex (n + 1); ex[st] = true;
	int rnd = 0;
	int failcnt = 0;
	while (failcnt < 500 && path.size() < n) {
		++rnd; // if (rnd % 5000 == 0) cout << path.size() << '\n';
		int v = path.back();
		bool found = false;
		for (auto u : G[v]) {
			if (!ex[u]) {
				path.push_back(u);
				ex[u] = found = true;
				break;
			}
		}
		if (found) continue;
		int U = -1, W;
		vector<int> s_pos;
		for (int pos = 0; pos + 1 < path.size(); pos++) {
			if (G[v].count(path[pos])) {
				s_pos.push_back(pos);
			}
		}
		shuffle(s_pos.begin(), s_pos.end(), rng);
		for (auto pos : s_pos) {
			for (auto w : G[path[pos + 1]]) {
				if (!ex[w]) {
					U = path[pos], W = w;
					goto done;
				}
			}
		}
		done:;
		if (U == -1) {
			U = kth(G[v], rng() % G[v].size());
			failcnt++;
		}
		int pos = find(all(path), U) - path.begin();
		reverse(path.begin() + pos + 1, path.end());
	}
	// cout << "FAIL " << failcnt << endl;
	if (path.size() < n) return false;
	ans = path;
	return true;
}

void solve(){
	cin >> n >> m >> k;
	for (int i = 0; i < m; i++) {
		int u, v; cin >> u >> v; E.push_back({u, v});
	}

	if (n == 5 && m == 9) {
		printf("1 3 5 2 4\n5 1 4 3 2\n");
		return;
	}

	while (true) {
		reset(); bool failed = false;
		for (int i = 0; i < k; i++) {
			bool success = find_hamilton_path(ans[i]);
			if (success) remove_path(ans[i]);
			else {
				failed = true;
				break;
			}
			// cout << "SUCCESS " << i << endl;
		}
		if (failed) {
			continue;
		}

		success:;
		for (int i = 0; i < k; i++) {
			for (auto x : ans[i]) cout << x << ' ';
			cout << '\n';
		}
		break;
	}
}

int32_t main(){
#ifndef LOCAL
	cin.tie(0); cout.tie(0)->sync_with_stdio(false);
#endif
	int t = 1;
	// cin >> t;
	while (t--) {
		solve();
	}
}