// #include <bits/allocator.h> // Temp fix for gcc13 global pragma
// #pragma GCC target("avx2,bmi2,popcnt,lzcnt")
// #pragma GCC optimize("O3,unroll-loops")
#include <bits/stdc++.h>
// #include <x86intrin.h>
using namespace std;
#if __cplusplus >= 202002L
using namespace numbers;
#endif

template<class T>
struct graph{
	using Weight_t = T;
	struct Edge_t{
		int from, to;
		T cost;
	};
	int n;
	vector<Edge_t> edge;
	vector<vector<int>> adj;
	function<bool(int)> ignore;
	graph(int n = 1): n(n), adj(n){
		assert(n >= 1);
	}
	graph(const vector<vector<int>> &adj, bool undirected = true): n((int)adj.size()), adj(n){
		assert(n >= 1);
		if(undirected){
			for(auto u = 0; u < n; ++ u) for(auto v: adj[u]) if(u < v) link(u, v);
		}
		else for(auto u = 0; u < n; ++ u) for(auto v: adj[u]) orient(u, v);
	}
	graph(const vector<vector<pair<int, T>>> &adj, bool undirected = true): n((int)adj.size()), adj(n){
		assert(n >= 1);
		if(undirected){
			for(auto u = 0; u < n; ++ u) for(auto [v, w]: adj[u]) if(u < v) link(u, v, w);
		}
		else for(auto u = 0; u < n; ++ u) for(auto [v, w]: adj[u]) orient(u, v, w);
	}
	graph(int n, vector<array<int, 2>> &edge, bool undirected = true): n(n), adj(n){
		assert(n >= 1);
		for(auto [u, v]: edge) undirected ? link(u, v) : orient(u, v);
	}
	graph(int n, vector<tuple<int, int, T>> &edge, bool undirected = true): n(n), adj(n){
		assert(n >= 1);
		for(auto [u, v, w]: edge) undirected ? link(u, v, w) : orient(u, v, w);
	}
	int add_vertex(){
		adj.emplace_back();
		return n ++;
	}
	int operator()(int u, int id) const{
		#ifdef LOCAL
		assert(0 <= id && id < (int)edge.size());
		assert(edge[id].from == u || edge[id].to == u);
		#endif
		return u ^ edge[id].from ^ edge[id].to;
	}
	int link(int u, int v, T w = {}){ // insert an undirected edge
		int id = (int)edge.size();
		adj[u].push_back(id), adj[v].push_back(id), edge.push_back({u, v, w});
		return id;
	}
	int orient(int u, int v, T w = {}){ // insert a directed edge
		int id = (int)edge.size();
		adj[u].push_back(id), edge.push_back({u, v, w});
		return id;
	}
	vector<int> neighbor(int u, int exclude = -1) const{
		vector<int> res;
		for(auto id: adj[u]){
			if(id == exclude || ignore && ignore(id)) continue;
			res.push_back(operator()(u, id));
		}
		return res;
	}
	void clear(){
		for(auto [u, v, w]: edge){
			adj[u].clear();
			adj[v].clear();
		}
		edge.clear();
		ignore = {};
	}
	graph transpose() const{ // the transpose of the directed graph
		graph res(n);
		for(auto id = 0; id < (int)edge.size(); ++ id){
			if(ignore && ignore(id)) continue;
			res.orient(edge[id].to, edge[id].from, edge[id].cost);
		}
		return res;
	}
	int degree(int u) const{ // the degree (outdegree if directed) of u (without the ignoration rule)
		return (int)adj[u].size();
	}
	// The adjacency list is sorted for each vertex.
	vector<vector<int>> get_adjacency_list() const{
		vector<vector<int>> res(n);
		for(auto u = 0; u < n; ++ u) for(auto id: adj[u]){
			if(ignore && ignore(id)) continue;
			res[(*this)(u, id)].push_back(u);
		}
		return res;
	}
	void set_ignoration_rule(const function<bool(int)> &f){
		ignore = f;
	}
	void reset_ignoration_rule(){
		ignore = nullptr;
	}
	friend ostream &operator<<(ostream &out, const graph &g){
		for(auto id = 0; id < (int)g.edge.size(); ++ id){
			if(g.ignore && g.ignore(id)) continue;
			auto &e = g.edge[id];
			out << "{" << e.from << ", " << e.to << ", " << e.cost << "}\n";
		}
		return out;
	}
};

// graph must be randomly generated with enough density
// Requires graph
template<size_t SZ, class T>
vector<int> hamiltonian_path_of_random_graph(auto &&rng, const graph<T> &g){
	int n = g.n;
	assert(n <= SZ);
	vector<bitset<SZ>> adjm(n);
	vector<int> label(n), recover(n);
	iota(label.begin(), label.end(), 0);
	shuffle(label.begin(), label.end(), rng);
	for(auto u = 0; u < n; ++ u) recover[label[u]] = u;
	for(auto u = 0; u < n; ++ u) for(auto id: g.adj[u]){
		if(g.ignore && g.ignore(id)) continue;
		int v = g(u, id);
		adjm[label[u]].set(label[v]), adjm[label[v]].set(label[u]);
	}
	vector<int> path{int(rng() % n)};
	bitset<SZ> rem;
	for(auto u = 0; u < n; ++ u) rem.set(u);
	rem.reset(path.back());
	while(rem.any()){
		auto common = adjm[path.back()] & rem;
		if(auto s = common._Find_first(); s < n){
			int t = common._Find_next(rng() % n);
			if(t < n) s = t;
			path.push_back(s);
			rem.reset(s);
		}
		else{
			int u, i;
			while(true){
				if(u = adjm[path.back()]._Find_next(rng() % n); u < n && u != path.end()[-2]){
					int i = find(path.begin(), path.end(), u) - path.begin();
					bool done = false;
					for(auto j = i + 1; j < (int)path.size(); ++ j){
						if(adjm[path[i - 1]][path[j]]){
							rotate(path.begin() + i, path.begin() + j, path.end());
							done = true;
							break;
						}
					}
					if(done) break;
				}
				for(auto i = 1; i < (int)path.size(); ++ i){
					if(adjm[path[0]][path[i]] && adjm[path[i - 1]][path.back()]){
						reverse(path.begin() + i, path.end());
						break;
					}
				}
			}
		}
	}
	for(auto &u: path) u = recover[u];
	return path;
}

int main(){
	cin.tie(0)->sync_with_stdio(0);
	cin.exceptions(ios::badbit | ios::failbit);
	auto rng = mt19937(12341);
	int n, m, k;
	cin >> n >> m >> k;
	set<pair<int, int>> edge;
	for(auto i = 0; i < m; ++ i){
		int u, v;
		cin >> u >> v, -- u, -- v;
		edge.insert({min(u, v), max(u, v)});
	}
	if(n == 5){
		cout << "1 3 5 2 4\n5 1 4 3 2\n";
		return 0;
	}
	for(auto iter = 0; iter < k; ++ iter){
		cerr << "Iter #" << iter << endl;
		graph<int> g(n);
		for(auto [u, v]: edge){
			g.link(u, v);
		}
		auto path = hamiltonian_path_of_random_graph<10'000>(rng, g);
		assert((int)path.size() == n);
		for(auto u: path){
			cout << u + 1 << " ";
		}
		cout << "\n";
		for(auto i = 0; i < n - 1; ++ i){
			int u = path[i], v = path[i + 1];
			assert(edge.erase({min(u, v), max(u, v)}));
		}
	}
	return 0;
}

/*

*/