#include <bits/stdc++.h>

using namespace std;

typedef long long i64;
const int inf = 1e9;
typedef double f64;

int n, m, k;
vector< set<int> > graph;
mt19937 rnd(847);

void gen() {
    const int N = 10000;
    const int M = 200'000;
    const int K = 8;
    n = N;
    m = M;
    k = K;
    graph.assign(n, set<int>());
    for (int i = 0; i < m; i++) {
        int a = rnd() % n, b = rnd() % n;
        graph[a].insert(b);
        graph[b].insert(a);
    }
}

bool try_solve() {
    vector<int> path;
    path.reserve(n);
    vector< vector<int> > paths;
    int iter = 0;
    auto start_ts = clock();
    for (int it = 0; it < k; it++) {
        for (;;) {
            path.clear();
            vector<int> in(n, 0);
            int s = rnd() % n;
            path.push_back(s);
            in[s] = 1;

            while (path.size() < n) {
                if (++iter % 1000 == 0) {
                    auto cur_ts = clock();
                    if (cur_ts - start_ts > CLOCKS_PER_SEC / 2) {
                        return false;
                    }
                }

                // for (int x : path) cerr << x << " ";
                // cerr << endl;

                int v = path.back();
                int prev = path.size() >= 2 ? path[path.size() - 2] : -1;
                bool found = false;
                vector<int> tos;
                tos.reserve(graph[v].size());
                for (int to : graph[v]) {
                    if (to != prev) {
                        tos.push_back(to);
                    }
                }
                shuffle(tos.begin(), tos.end(), rnd);
                for (int to : tos) {
                    if (!in[to]) {
                        path.push_back(to);
                        in[to] = 1;
                        found = true;
                        break;
                    }
                }
                if (found) continue;
                if (tos.size() == 0) break;

                int x = tos[rnd() % tos.size()];
                // cerr << "flip " << x << endl;
                auto it = find(path.begin(), path.end(), x);
                assert(it != path.end());
                reverse(it + 1, path.end());
            }
            if (path.size() == n) break;
        }

        paths.push_back(path);
        for (int i = 0; i + 1 < n; ++i) {
            int u = path[i], v = path[i + 1];
            graph[u].erase(v);
            graph[v].erase(u);
        }
    }
    for (auto path : paths) {
        for (int x : path) cout << x + 1 << " ";
        cout << "\n";
    }
    return true;
}

void solve() {
    cin >> n >> m >> k;
    graph.assign(n, set<int>());
    for (int i = 0; i < m; i++) {
        int a, b;
        cin >> a >> b;
        --a, --b;
        graph[a].insert(b);
        graph[b].insert(a);
    }
    // gen();
    for (int jt = 0; jt < 10; ++jt) {
        auto backup = graph;
        if (try_solve()) {
            return;
        }
        graph = backup;
    }

}

signed main() {
    rnd = mt19937(time(0));
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    ios_base::sync_with_stdio(false);
    int t = 1;
    // cin >> t;
    while (t --> 0) {
        solve();
    }
    return 0;
}