#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MAXN = 10'100;

vector<int> G[MAXN];

mt19937_64 rnd(228);

double prev_time = 0;

double get_time() {
  return clock() * 1.0 / CLOCKS_PER_SEC;
}

const double MAXTIME = 0.3;

bool is_tl() {
  static int kek = 0;
  ++kek;
  if (kek != 100)
    return false;
  kek = 0;
  double time = get_time();
  if (time - prev_time > MAXTIME)
    return true;
  return false;
}

//#define RANDOM

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);


  int n, m, k;
  cin >> n >> m >> k;

#ifdef RANDOM
for (int _ = 0; _ < 100; ++_) {
  double kek = get_time();
#endif


  vector<pair<int, int>> edges(m);
  for (int i = 0; i < m; ++i) {
    int a, b;
#ifdef RANDOM
    a = rand() % n;
    b = rand() % n;
#else
    cin >> a >> b;
    --a;
    --b;
#endif

    edges[i] = make_pair(a, b);
  }

  while (true) {

    prev_time = get_time();

    for (auto [a, b] : edges) {
      G[a].emplace_back(b);
      G[b].emplace_back(a);
    }
    auto rem_edge = [&](int u, int v) {
      for (int _ = 0; _ < 2; ++_) {
        int j = 0;
        while (G[u][j] != v)
          ++j;
        swap(G[u][j], G[u].back());
        G[u].pop_back();
        swap(u, v);
      }
    };

    vector<vector<int>> paths;
    bool ok = true;

    for (int i = 0; i < k; ++i) {
      vector<int> cur_order;
      int cur = rnd() % n;
      cur_order.emplace_back(cur);
      vector<bool> in_path(n, false);
      in_path[cur] = true;
      while (!is_tl() && cur_order.size() < n) {
        cur = cur_order.back();
        vector<int> opts;
        for (int v : G[cur]) {
          if (!in_path[v])
            opts.emplace_back(v);
        }
        if (opts.empty()) {
          int prev = G[cur][rnd() % G[cur].size()];
          int j = cur_order.size() - 1;
          while (j >= 0 && cur_order[j] != prev)
            --j;
          reverse(cur_order.begin() + j + 1, cur_order.end());
        } else {
          int nxt = opts[rnd() % opts.size()];
          cur_order.emplace_back(nxt);
          in_path[nxt] = true;
        }
      }
      if (cur_order.size() != n) {
        ok = false;
        break;
      }
      for (int i = 0; i + 1 < cur_order.size(); ++i) {
        int v = cur_order[i], u = cur_order[i + 1];
        rem_edge(v, u);
      }
      paths.emplace_back(cur_order);
    }
    if (ok) {
#ifdef RANDOM
      cerr << _ << " ok " << get_time() - kek << '\n';
#else
      for (int i = 0; i < k; ++i) {
        for (int v : paths[i])
          cout << v + 1 << ' ';
        cout << '\n';
      }
#endif
      break;
    }

    for (int i = 0; i < n; ++i)
      G[i].clear();
  }


  for (int i = 0; i < n; ++i)
    G[i].clear();

#ifdef RANDOM
}
#endif
  return 0;
}