#include <iostream>
#include <map>
#include <set>
#include <algorithm>
#include <vector>
#include <sstream>
#include <string>
#include <functional>
#include <queue>
#include <deque>
#include <stack>
#include <limits>
#include <unordered_map>
#include <unordered_set>
#include <math.h>
#include <fstream>
#include <iterator>
#include <random>
#include <chrono>
 
 
#define forr(i,start,count) for (int i = (start); i < (start)+(count); ++i)
#define set_map_includes(set, elt) (set.find((elt)) != set.end())
#define readint(i) int i; cin >> i
#define readll(i) ll i; cin >> i
#define readdouble(i) double i; cin >> i
#define readstring(s) string s; cin >> s
 
typedef long long ll;
 
using namespace std;

ll modd = 1000*1000*1000+7;

template<class T>
class depth_first_search_iterator {
  public:
    stack<pair<T,T>> todo;
    function<bool(T)> notvisited;
    function<void(T)> mark_visited;
    function<set<T>(T)> neighbors;

    depth_first_search_iterator() {}

    depth_first_search_iterator(T start, function<bool(T)> notv, function<void(T)> mark_v, function<set<T>(T)> neigh) :
      notvisited(notv), mark_visited(mark_v), neighbors(neigh), end_(false), current(start), prev(start) {
          todo.push(make_pair(start, start)); operator++();
    }

    void operator++() {
        end_ = true;
        while (!todo.empty()) {
            current = todo.top().first; prev = todo.top().second; todo.pop();
            if (notvisited(current)) {
                mark_visited(current);
                for (const T x : neighbors(current)) {  todo.push(make_pair(x, current));   }
                end_ = false;
                break;
            }
        }
    }

    T operator*() {     return current;    }

    T previous() {  return prev;  }

    bool end() {  return end_;  }

  private:
    T current; // contains current node
    T prev;    // contains previous node
    bool end_;
};

template<class T>
class breadth_first_search_iterator {
  public:
    queue<pair<T,T>> todo;
    function<bool(T)> notvisited;
    function<void(T)> mark_visited;
    function<set<T>(T)> neighbors;

    breadth_first_search_iterator() {}

    breadth_first_search_iterator(T start, function<bool(T)> notv, function<void(T)> mark_v, function<set<T>(T)> neigh) :
      notvisited(notv), mark_visited(mark_v), neighbors(neigh), end_(false), current(start), prev(start) {
          todo.push(make_pair(start, start)); operator++();
    }

    void operator++() {
        end_ = true;
        while (!todo.empty()) {
            current = todo.front().first; prev = todo.front().second; todo.pop();
            if (notvisited(current)) {
                mark_visited(current);
                for (const T x : neighbors(current)) {  todo.push(make_pair(x, current));   }
                end_ = false;
                break;
            }
        }
    }

    T operator*() {     return current;    }

    T previous() {  return prev;  }

    bool end() {  return end_;  }

  private:
    T current;   // current node
    T prev;      // previous node
    bool end_;
};

template<class T>
class Graph {
    // allows only single connection between two vertices
    public:
      vector<T> vertices;
      vector<set<int>> neighbors;
      depth_first_search_iterator<int> dfs_iterator;
      breadth_first_search_iterator<int> bfs_iterator;
      vector<bool> visited;

      Graph() {}

      Graph(int n) {  for (int i = 0; i < n; ++i) {  AddVertex(0);  }   }

      void AddVertex(T val) {
          vertices.push_back(val);
          neighbors.push_back(set<int>());      }

      bool EdgeExists(int i, int j) {
          return (neighbors[i].find(j) != neighbors[i].end());
     }

      void AddEdge(int i, int j) {
          if (!EdgeExists(i,j)) {
            neighbors[i].insert(j);
            if (i != j) {         neighbors[j].insert(i);         } 
          }
      }

      T& operator[](int i) {      return vertices[i];      }

      void RemoveEdge(int i, int j) {
          if (EdgeExists(i,j)) {
            neighbors[i].erase(find(neighbors[i].begin(), neighbors[i].end(), j));
            neighbors[j].erase(find(neighbors[j].begin(), neighbors[j].end(), i));
          }
      }

      void dfs_init(int start) {
          visited = vector<bool>(vertices.size(), false);
          dfs_iterator = depth_first_search_iterator<int>(start, [this](int x){ return !visited[x]; }, [this](int x) { visited[x] = true;  },
            [this](int x) {  return neighbors[x];  } );
      }

      void bfs_init(int start) {
          visited = vector<bool>(vertices.size(), false);
          bfs_iterator = breadth_first_search_iterator<int>(start, [this](int x){ return !visited[x]; }, [this](int x) { visited[x] = true;  },
            [this](int x) {  return neighbors[x];  } );
      }

      void print_() {
          forr(i, 0, vertices.size()) {
              for (auto x : neighbors[i]) {
                  if (i <= x) {  cout << i << "-" << x << endl;  }                  
              }
          }
      }
};


template<class T>
class DirectedGraph {
    // allows only single connection between two vertices
    public:
      vector<T> vertices;
      vector<set<int>> neighbors;
      depth_first_search_iterator<int> dfs_iterator;
      breadth_first_search_iterator<int> bfs_iterator;
      vector<bool> visited;

      DirectedGraph() {}

      DirectedGraph(int n) {  for (int i = 0; i < n; ++i) {  AddVertex(0);  }   }

      bool EdgeExists(int i_from, int j_to) {
          return (neighbors[i_from].find(j_to) != neighbors[i_from].end());
      }

      void AddVertex(T val) {
          vertices.push_back(val);
          neighbors.push_back(set<int>());      }

      void AddEdge(int i_from, int j_to) {
          if (!EdgeExists(i_from, j_to)) {     neighbors[i_from].insert(j_to);      }
      }

      T& operator[](int i) {      return vertices[i];      }

      void RemoveEdge(int i_from, int j_to) {
          if (EdgeExists(i_from, j_to)) {
          neighbors[i_from].erase(find(neighbors[i_from].begin(), neighbors[i_from].end(), j_to));      } }

      DirectedGraph<T> Transpose() {
          DirectedGraph<T> ret;
          for (auto x : vertices) {  ret.AddVertex(x);   }
          for (int i_from = 0; i_from < vertices.size(); ++i_from) {
              for (int j_to : neighbors[i_from]) {
                  ret.AddEdge(j_to, i_from);
              }
          }
          return ret;      }

      int vertices_count() {   return vertices.size();  }

      void dfs_init(int start) {
          visited = vector<bool>(vertices.size(), false);
          dfs_iterator = depth_first_search_iterator<int>(start, [this](int x){ return !visited[x]; }, [this](int x) { visited[x] = true;  },
            [this](int x) {  return neighbors[x];  } );
      }

      void bfs_init(int start) {
          visited = vector<bool>(vertices.size(), false);
          bfs_iterator = breadth_first_search_iterator<int>(start, [this](int x){ return !visited[x]; }, [this](int x) { visited[x] = true;  },
            [this](int x) {  return neighbors[x];  } );
      }

      void print_() {
          forr(i, 0, vertices.size()) {
              for (auto x : neighbors[i]) {
                  cout << i << "->" << x << endl;
              }
          }
      }
};

class UnionFind {
    // can be slow !!!! -- if you need components only, consider bfs/dfs
    public:
      set<int> roots;
      int total_n;
      DirectedGraph<int> gr;     // value stores rank

      UnionFind(int n) : total_n(n)  { 
          for (int i = 0; i < n; ++i) {  roots.insert(i); gr.AddVertex(1); }
      }

      int Find(int i)   {
          gr.dfs_init(i);
          int root = i;
          while (!gr.dfs_iterator.end()) {  root = *gr.dfs_iterator;  ++gr.dfs_iterator;  }
          if (root != i) {
              if (*gr.neighbors[i].begin() != root) {
                gr.RemoveEdge(i, *gr.neighbors[i].begin());
                gr.AddEdge(i, root);
              }
          }
          return root;
      }

      void Union(int i, int j) {
          int root_i = Find(i), root_j = Find(j);
          if (root_i == root_j) {  return;  }

          if (gr[root_i] < gr[root_j])  {
              gr.AddEdge(root_i, root_j); roots.erase(root_i);
          } else if ( gr[root_i] > gr[root_j] ) {
              gr.AddEdge(root_j, root_i); roots.erase(root_j);
          }  else  {
              gr.AddEdge(root_i, root_j); roots.erase(root_i); ++gr[root_j];
          } 
      }

      void print_() {
          for (auto x : roots) {
          cout << x << " : ";
          for (int i = 0; i < total_n; ++i) {
            if (Find(i) == x) {   cout << i << " ";  }
          }
          cout << endl;
        }
      }


};

long long time__;

template<class T>
void SCCUtil(int u, vector<int>& disc, vector<int>& low, stack<int>& st, vector<bool>& stackMember, UnionFind& ret, DirectedGraph<T>& gr)   { 
  
        disc[u] = low[u] = ++time__;
        st.push(u);
        stackMember[u] = true; 

        for (auto v : gr.neighbors[u])    {
          if (disc[v] == -1)   { 
              SCCUtil<T>(v, disc, low, st, stackMember, ret, gr);
              low[u]  = min(low[u], low[v]); 
          }
          else if (stackMember[v])    { low[u]  = min(low[u], disc[v]); }   }
  
        int w = 0;
        if (low[u] == disc[u])   {
          stack<int> component;
          while (st.top() != u)    { 
              w = (int) st.top();
              component.push(w);
              stackMember[w] = false; 
              st.pop(); 
          } 
          w = (int) st.top();
          while (!component.empty())   {  ret.Union(w, component.top()); component.pop();   }

          stackMember[w] = false;
          st.pop(); 
        }
};



template<class T>
UnionFind SCC(DirectedGraph<T>& gr)  {
        vector<int> disc(gr.vertices.size(), -1);
        vector<int> low(gr.vertices.size(), -1); 
        vector<bool> stackMember(gr.vertices.size(), false);
        stack<int> st;
        UnionFind ret(gr.vertices.size());

        time__ = 0;
        for (int i = 0; i < gr.vertices.size(); i++)  {    if (disc[i] == -1) {     SCCUtil<T>(i, disc, low, st, stackMember, ret, gr); }        }
        return ret;
};


int main()   {

    ios_base::sync_with_stdio(false);

    cout.precision(17);
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    uniform_int_distribution<int> rand_gen(0, modd);   // rand_gen(rng) gets the rand no
 
//    auto start = chrono::steady_clock::now();
  
//    readint(test_cases);
    int test_cases = 1;
    forr(t, 1, test_cases) {
        readll(n); readll(m);
        DirectedGraph<int> g(n);
        forr(i,0,m)  {
            readint(a); readint(b);
            g.AddEdge(a-1,b-1);
        }

        auto scc = SCC<int>(g);
        map<int,int> comps;
        forr(i,0,n) {
            comps[scc.Find(i)]++;
        }
        int root = -1;
        for(auto x : comps) {   if (x.second>1) {  root = x.first; break;  }  }

        if (root==-1) {
            cout << -1 << endl; continue;
        }

        vector<int> path;
        int curr = root, last;
        while (true) {
            int nn;
            for(auto x : g.neighbors[curr]) {
                if (scc.Find(x)==scc.Find(root)) {
                    nn = x; break;
                }
            }
            path.push_back(curr);
            last = find(path.begin(), path.end(), nn) - path.begin();
            if (last<path.size()) {  break;  }
            curr = nn;
        }
        vector<int> new_path;
          for(int i = last; i < path.size(); ++i) {
               new_path.push_back(path[i]); 
        }
        path = move(new_path);
        while(true)  {
          int er1 = -1, er2 = -1;
          forr(i,0,path.size()) {
            forr(j,0,path.size()) {
                if (g.EdgeExists(path[i],path[j]) && (j % path.size() != (i+1) % path.size()))  {  er1 = i; er2 = j; break;  }
            }
            if (er1>=0) {  break;  }
          }
          if (er1<0) {break;}
          new_path.clear();
          new_path.push_back(path[er1]); new_path.push_back(path[er2]);
          int curr = er2;
          while (true) {
              curr++; curr = curr % path.size();
              if (path[curr]==path[er1]) {break;}
              new_path.push_back(path[curr]);
          }
          path = move(new_path);
        }

        cout << path.size() << endl;
        for(auto x : path) {
            cout << x+1 << endl;
        }

    }
 
//    auto end = chrono::steady_clock::now();
//    cout << chrono::duration_cast<chrono::milliseconds>(end - start).count() << endl;
 
    return 0;
}

Measured memory_bytes: 4188