#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


// sz: size of the matching
// mate[u]: matching mate of u or -1
// need[u]: every max matching contains u? (call run(true))
struct MaxMatch {
  int n, sz;
  vector<vector<int>> graph;
  vector<int> mate, need;
  MaxMatch() {}
  MaxMatch(int n_) : n(n_), graph(n_) {}
  void ae(int u, int v) {
    assert(0 <= u); assert(u < n);
    assert(0 <= v); assert(v < n);
    if (u != v) {
      graph[u].push_back(v);
      graph[v].push_back(u);
    }
  }

  vector<int> ts, ps;
  vector<pair<int, int>> fs;
  int root(int u) {
    return (ts[u] != sz || !~ps[u]) ? u : (ps[u] = root(ps[u]));
  }
  void rematch(int u, int v) {
    const int w = mate[u];
    mate[u] = v;
    if (~w && mate[w] == u) {
      if (~fs[u].second) {
        rematch(fs[u].first, fs[u].second);
        rematch(fs[u].second, fs[u].first);
      } else {
        mate[w] = fs[u].first;
        rematch(fs[u].first, w);
      }
    }
  }
  int augment(int src) {
    std::queue<int> que;
    ts[src] = sz;
    ps[src] = -1;
    fs[src] = make_pair(-1, -1);
    que.push(src);
    for (; !que.empty();) {
      int u = que.front();
      que.pop();
      for (const int v : graph[u]) if (v != src) {
        if (mate[v] == -1) {
          mate[v] = u;
          rematch(u, v);
          return 1;
        }
        if (ts[v] == sz) {
          int x = root(u), y = root(v), z = src;
          if (x == y) continue;
          for (; x != src || y != src; x = root(fs[mate[x]].first)) {
            if (y != src) swap(x, y);
            if (fs[x].first == u && fs[x].second == v) {
              z = x;
              break;
            }
            fs[x] = make_pair(u, v);
          }
          for (const int r : {root(u), root(v)}) {
            for (int w = r; w != z; w = root(fs[mate[w]].first)) {
              ts[w] = sz;
              ps[w] = z;
              que.push(w);
            }
          }
        } else if (ts[mate[v]] != sz) {
          fs[v] = make_pair(-1, -1);
          ts[mate[v]] = sz;
          ps[mate[v]] = v;
          fs[mate[v]] = make_pair(u, -1);
          que.push(mate[v]);
        }
      }
    }
    return 0;
  }
  void run(bool buildNeed = false) {
    sz = 0;
    mate.assign(n, -1);
    ts.assign(n, -1);
    ps.assign(n, -1);
    fs.assign(n, make_pair(-1, -1));
    for (int u = 0; u < n; ++u) if (!~mate[u]) sz += augment(u);
    if (buildNeed) {
      for (int u = 0; u < n; ++u) if (!~mate[u]) augment(u);
      need.resize(n);
      for (int u = 0; u < n; ++u) need[u] = (~mate[u] && ts[u] != sz) ? 1 : 0;
    }
  }
};


int N, M, K;
vector<int> A, B;

vector<int> solve() {
  int id = 0;
  vector<vector<int>> idss(N);
  vector<pair<int, int>> edges(K);
  for (int i = 0; i < K; ++i) {
    const int x = id++;
    const int y = id++;
    idss[A[i]].push_back(x);
    idss[B[i]].push_back(y);
    edges[i] = make_pair(x, y);
  }
  vector<int> spe(N, 0);
  for (int u = 0; u < N; ++u) {
    spe[u] = idss[u].size();
    // not used
    if (spe[u] == 0) {
      idss[u].push_back(id++);
      idss[u].push_back(id++);
    }
  }
  vector<int> tr(id, -1);
  for (int u = 0; u < N; ++u) {
    for (const int x : idss[u]) {
      tr[x] = u;
    }
  }
// cerr<<"idss = "<<idss<<endl;
  
  for (int ban = 0; ban < K; ++ban) {
    MaxMatch mxm(id);
    for (int i = 0; i < K; ++i) if (i != ban) {
      mxm.ae(edges[i].first, edges[i].second);
    }
    for (int i = K; i < M; ++i) if (spe[A[i]] < 2 && spe[B[i]] < 2) {
      for (const int x : idss[A[i]]) for (const int y : idss[B[i]]) {
        mxm.ae(x, y);
      }
    }
    for (int u = 0; u < N; ++u) if (idss[u].size() == 2) {
      mxm.ae(idss[u][0], idss[u][1]);
    }
    mxm.run();
    if (2 * mxm.sz == id) {
      vector<int> mate(id, -1);
      for (int u = 0; u < N; ++u) if (idss[u].size() == 2) {
        mate[idss[u][0]] = idss[u][1];
        mate[idss[u][1]] = idss[u][0];
      }
      // overwrite vertex with two special edges
      for (int i = 0; i < K; ++i) {
        mate[edges[i].first] = edges[i].second;
        mate[edges[i].second] = edges[i].first;
      }
// cerr<<"mate = "<<mate<<endl;
// cerr<<"mxm.mate = "<<mxm.mate<<endl;
      vector<int> cyc;
      for (int x = edges[ban].first; ; ) {
        cyc.push_back(tr[x]);
        // new matching
        x = mxm.mate[x];
        assert(~x);
        
        cyc.push_back(tr[x]);
        // original matching
        x = mate[x];
        assert(~x);
        
        if (x == edges[ban].first) {
          break;
        }
      }
// cerr<<"cyc = "<<cyc<<endl;
      vector<int> ans;
      for (const int u : cyc) {
        for (int j = 0; j < (int)ans.size(); ++j) {
          if (ans[j] == u) {
            ans.erase(ans.begin() + j, ans.end());
            break;
          }
        }
        ans.push_back(u);
      }
      return ans;
    }
  }
  return {};
}

int main() {
  for (; ~scanf("%d%d%d", &N, &M, &K); ) {
    A.resize(M);
    B.resize(M);
    for (int i = 0; i < M; ++i) {
      scanf("%d%d", &A[i], &B[i]);
      --A[i];
      --B[i];
    }
    
    const auto ans = solve();
    if (!ans.empty()) {
      printf("%d\n", (int)ans.size());
      for (const int u : ans) {
        printf("%d\n", u + 1);
      }
    } else {
      puts("-1");
    }
#ifdef LOCAL
cerr<<"========"<<endl;
#endif
  }
  return 0;
}