#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i = a; i < b; i++)
using ll = long long;
#define all(p) p.begin(),p.end()

template<class T> bool chmin(T &a,T b){
    if(a>b){
        a=b;
        return true;
    }
    return false;
}

template<class T> bool chmax(T &a,T b){
    if(a<b){
        a=b;
        return true;
    }
    return false;
}

const int N = 10000;
const int M = 200000;
const int K = 8;

unsigned int X = 167167;

unsigned int rd(){
    X ^= X << 13;
    X ^= X >> 17;
    X ^= X << 5;
    return X;
}

vector<vector<int>> make_test(){
    vector<vector<int>> G(N);
    set<pair<int, int>> s;
    rep(rp, 0, M){
        while (true){
            int a = rd() % N;
            int b = rd() % N;
            if (a == b) continue;
            if (a > b) swap(a, b);
            if (s.count({a, b})) continue;
            G[a].push_back(b);
            G[b].push_back(a);
            s.insert({a, b});
            break;
        }
    }
    return G;
}

vector<vector<int>> solve(vector<vector<int>> G){
    rep(i, 0, N){
        rep(j, 0, G[i].size()){
            swap(G[i][j], G[i][j + rd() % (G[i].size() - j)]);
        }
    }
    vector<vector<int>> ans;
    auto g = G;
    rep(rp, 0, K){
        // cout << rp << endl;
        int st = 0;
        rep(i, 0, N) if (g[i].size() < g[st].size()){
            st = i;
        }
        vector<int> seen(N, -1);

        int V = 1;
        seen[st] = 0;
        vector<int> order = {st};
        while (V != N){
            int n_st = -1;
            for (auto x : g[st]){
                if (seen[x] != -1) continue;
                n_st = x;
                break;
            }
            if (n_st != -1){
                seen[n_st] = V++;
                order.push_back(n_st);
                st = n_st;/*
                if (V % 100 == 0){
                    cout << V << endl;
                }*/
            }
            else {
                int a = -1;
                for (auto x : g[st]){
                    if (seen[x] >= seen[st] - 2) continue;
                    int d = 0;
                    for (auto y : g[order[seen[x] + 1]]){
                        if (seen[y] == -1) d++;
                    }
                    if (d != 0){
                        a = x;
                        break;
                    }
                }
                if (a == -1){
                    a = g[st][rd() % g[st].size()];
                }
                int tmp = seen[a] + 1;
                reverse(order.begin() + tmp, order.begin() + V);
                rep(i, tmp, V){
                    seen[order[i]] = i;
                }
                st = order.back();
                // cout << "# " << V << " " << seen[st] << "" << tmp << endl;
            }
        }

        ans.push_back(order);
        // delete
        vector<vector<int>> n_g(N);
        vector<int> L(N, -1), R(N, -1);
        rep(i, 0, N - 1){
            L[order[i]] = order[i + 1];
            R[order[i + 1]] = order[i];
        }
        rep(i, 0, N) for (auto x : g[i]){
            if (x != L[i] && x != R[i]) n_g[i].push_back(x);
        }
        swap(n_g, g);
    }
    return ans;
}

void test(){
    cout << "hash : " << X << endl;
    auto G = make_test();
    auto ans = solve(G);
    set<pair<int,int>> s;
    rep(i, 0, K){
        vector<int> seen(N);
        rep(j, 0, N){
            int a = ans[i][j];
            if (seen[a]){
                cout << "mult" << endl;
                assert(false);
            }
            if (j){
                int b = ans[i][j - 1];
                bool ok = 0;
                for (auto x : G[a]) if (x == b) ok = 1;
                if (!ok){
                    cout << "not path" << endl;
                    assert(false);
                }
                if (a > b) swap(a, b);
                if (s.count({a, b})){
                    cout << "double" << endl;
                    assert(false);
                }
                s.insert({a, b});
            }
        }
    }
    cout << "ok" << endl;
}

int main(){
    const int local = 0;
    if (local){
        test();
        return 0;
    }
    int n, m, k;
    cin >> n >> m >> k;
    if (n != N){
        cout << "1 3 5 2 4\n5 1 4 3 2\n";
        return 0;
    }
    vector<vector<int>> G(N);
    rep(i, 0, M){
        int a, b;
        cin >> a >> b;
        a--, b--;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    auto ans = solve(G);
    rep(i, 0, K){
        rep(j, 0, N){
            if (j) cout << " ";
            cout << ans[i][j] + 1;
        }
        cout << "\n";
    }
}