#include <bits/stdc++.h>
using namespace std;

using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
template <typename T> constexpr T inf = numeric_limits<T>::has_infinity ? numeric_limits<T>::infinity() : numeric_limits<T>::max() / 4;

#define REP(i, stop) FOR(i, 0, stop)
#define FOR(i, start, stop) for (int i = start, i##_len = stop; i < i##_len; ++i)
#define RREP(i, n) for (int i = n; i-- > 0;)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define COMP(key) [](const auto& a, const auto& b) { return a.key < b.key; }

template<typename T, typename U> istream& operator>>(istream& is, pair<T, U>& a) { return is >> a.first >> a.second; }
template<typename T> istream& operator>>(istream& is, vector<T>& a) { for (T& x : a) is >> x; return is; }

void LOG(const int& x) { cerr << x << "\n"; }
template<typename T> void LOG(const vector<T>& a) { for (const T& x : a) cerr << x << " "; cerr << "\n"; }
template<typename T, std::size_t S> void LOG(const T (&a)[S]) { REP(i, S) cerr << a[i] << " "; cerr << "\n"; }
template<typename T, std::size_t S, std::size_t R> void LOG(const T (&a)[S][R]) { REP(i, S) { REP(j, R) cerr << a[i][j] << " "; cerr << "\n"; } }

i64 ceil(i64 a, i64 b) { return (a - 1) / b + 1; }
i64 gcd(i64 a, i64 b) { while (b != 0) { i64 t = b; b = a % b; a = t; } return a; }
i64 lcm(i64 a, i64 b) { return a / gcd(a, b) * b; }
i64 gcd(const vector<i64>& v) { return accumulate(ALL(v), 1LL, static_cast<i64(*)(i64, i64)>(gcd)); }
i64 lcm(const vector<i64>& v) { return v.empty() ? 0LL : accumulate(v.begin() + 1, v.end(), v[0], static_cast<i64(*)(i64, i64)>(lcm)); }
i64 pow(i64 x, i64 y, i64 z) { i64 a = 1; while (y > 0) { if (y & 1) a = a * x % z; x = x * x % z; y /= 2; } return a; }
i64 inv(i64 x, i64 m) { return pow(x, m - 2, m); }

struct InitCpp { InitCpp() { cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(10); } } initCpp;

signed main() {
  i64 N, M;
  cin >> N >> M;
  vector<vector<i64>> G(N);
  REP(i, M) {
    i64 a, b;
    cin >> a >> b;
    G[a - 1].push_back(b - 1);
  }
  vector<i64> ans;
  vector<i64> d(N);
  vector<i64> prev(N);
  bool found = false;
  REP(i, N) {
    using P = pair<i64, i64>;
    fill(d.begin(), d.end(), inf<i64>);
    d[i] = 0;
    fill(prev.begin(), prev.end(), -1);
    prev[i] = -1;
    priority_queue<P, vector<P>, greater<P>> que;
    que.push({0, i});
    while (que.size()) {
      P p = que.top();
      que.pop();
      i64 from = p.second;
      if (d[from] < p.first) continue;
      for (i64 to : G[from]) {
        if (d[to] > d[from] + 1) {
          d[to] = d[from] + 1;
          prev[to] = from;
          que.push({d[to], to});
        }
      }
    }
    REP(j, N) {
      for (i64 to : G[j]) {
        if (to == i) {
          vector<i64> acc;
          for (i64 v = j; ~v; v = prev[v]) {
            acc.push_back(v);
          }
          if (acc.size() != 1 && (!found || acc.size() < ans.size())) {
            found = true;
            reverse(acc.begin(), acc.end());
            ans = acc;
          }
          // LOG(acc);
        }
      }
    }
  }
  if (found) {
    cout << ans.size() << endl;
    for (i64 v : ans) {
      cout << (v + 1) << endl;
    }
  } else {
    cout << -1 << endl;
  }
}


Measured memory_bytes: 384