#include <iostream>
#include <vector>
using namespace std;
const int N = 1000 ;
vector<vector<pair<int,int>>> edges, oedges;
int adj[N][N], oadj[N][N];
char aspec[N][N] ;
vector<char> visited, ndel, ondel;
vector<int> tin, low, live, olive, isspec;
int n, m, k;
int timer;

void rmedge(int a, int b) {
   if(adj[a][b] == 0)
      return ;
   adj[a][b] = adj[b][a] = 0 ;
}

void rmnode(int a) {
   if(ndel[a])
      return;
   ndel[a] = 1;
   for (auto b : edges[a]) {
      rmedge(a, b.first);
      if (b.second)
         rmnode(b.first);
   }
}
void dfs(int v, int p = -1) {
   visited[v] = true ;
   if (ndel[v])
      return;
   tin[v] = low[v] = timer ++;
   for (auto b: edges[v]) {
      int to = b.first ;
      if (ndel[to] || adj[v][to] == 0 || to == p) continue;
      if (visited[to]) {
         low[v] = min(low[v], tin[to]);
      } else {
         dfs(to, v) ;
         low[v] = min(low[v], low[to]);
         if (low[to] > tin[v])
            adj[v][to] = adj[to][v] = -1;
      }
   }
}
void find_bridges() {
   timer = 0;
   visited.assign(n, false);
   tin.assign(n, -1);
   low.assign(n, -1);
   for (int i = 0; i < n; ++ i)
      if (!visited[i])
         dfs(i);
}
void restore() {
   edges = oedges;
   ndel = ondel;
   live = olive;
   for (int i = 0; i < n; ++ i)
      for (int j = 0; j < n; ++ j)
         adj[i][j] = oadj[i][j];
}
void save() {
   oedges = edges;
   ondel = ndel;
   olive = live;
   for (int i = 0; i < n; ++ i)
      for (int j = 0; j < n; ++ j)
         oadj[i][j] = adj[i][j];
}
void rmedge2(int a, int b) {
   rmedge(a, b);
   if (aspec[a][b]) {
      rmnode(a);
      rmnode(b);
   }
}
int clean() {
   while (1) {
      int changed = 0 ;
      find_bridges() ;
      for(int a = 0; a < n; ++ a)
         for(auto b : edges[a])
            if(adj[a][b.first] < 0) {
               rmedge2(a, b.first) ;
               changed = 1 ;
            }
      if(!changed)
         break ;
   }
   for(int a=0; a<n; a++) {
      vector<pair<int, int>> ne ;
      for(auto b: edges[a])
         if (adj[a][b.first])
            ne.push_back(b) ;
      swap(edges[a], ne) ;
   }
   live.clear() ;
   for(int a=0; a<n; a++)
      if(!ndel[a] && edges[a].size() > 1)
         live.push_back(a) ;
   return live.size() ;
}
int main() {
   cin >> n >> m >> k;
   isspec.resize(n);
   edges.resize(n);
   visited.resize(n);
   tin.resize(n);
   low.resize(n);
   for(int i = 0; i < m; i ++) {
      int a, b;
      cin >> a >> b;
      int s = (i < k);
      a --;
      b --;
      edges[a].push_back({b,s});
      edges[b].push_back({a,s});
      adj[a][b] = adj[b][a] = 1;
      if(s) {
         isspec[a]++;
         isspec[b]++;
         aspec[a][b] = aspec[b][a] = 1;
      }
   }
   ndel.resize(n);
   for(int a = 0; a < n; a ++)
      if (isspec[a] > 2)
         rmnode(a);
   for(int a = 0; a < n; a ++)
      if(isspec[a] == 2)
         for(auto b: edges[a])
            if(b.second == 0)
               rmedge(a, b.first);
   if(clean() == 0) {
      cout << -1 << endl;
      exit(0);
   }
   while (1) {
      int changed = 0;
      for(int i = 0; i < n; i++)
         for(int j = i + 1; j < n; j ++)
            if(adj[i][j] == 1) {
               save();
               rmedge2(i, j);
               if(clean() == 0) {
                  restore();
               } else {
                  changed ++;
               }
            }
      if (changed == 0)
         break;
   }
   cout << live.size() << endl ;
   int a = live[0];
   int b = edges[a][0].first;
   visited[a] = 2;
   visited[b] = 2;
   vector <int> sol;
   sol.push_back(a);
   sol.push_back(b);
   while (1) {
      int c = -1;
      for(int i = 0; i < (int)edges[b].size(); i ++)
         if(visited[edges[b][i].first] != 2)
            c = edges[b][i].first;
      if(c < 0)
         break;
      sol.push_back(c);
      visited[c] = 2;
      a = b;
      b = c;
   }
   for(auto a : sol)
      cout << " " <<  1 + a;
   cout << endl ;
}