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

#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second

using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;

const double eps = 1e-10;

template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}

template<typename T>
vector<T> make_v(size_t a){return vector<T>(a);}

template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
    return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value!=0>::type
fill_v(U &u,const V... v){u=U(v...);}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value==0>::type
fill_v(U &u,const V... v){
    for(auto &e:u) fill_v<T>(e,v...);
}

::std::vector<::std::pair<::std::int64_t, ::std::int32_t>> primeFactors(::std::int64_t x) {
    ::std::vector<::std::pair<::std::int64_t, ::std::int32_t>> res;
    for (::std::int64_t i = 2; i*i <= x; ++i) {
        if (x % i == 0) {
            res.emplace_back(i, 1);
            x /= i;
            while (x % i == 0) x /= i, res.back().second++;
        }
    }
    if (x != 1) res.emplace_back(x, 1);
    return res;
}

int64 N, M;
vector<int64> G[1123];
vector<int64> cy;
vector<int64> used;
vector<vector<int>> edge;

bool cycle(int64 v) {
    if (used[v]) return true;
    used[v] = 1;
    bool ok = 0;
    REP(i, G[v].size()) {
        cy.push_back(G[v][i]);
        ok |= cycle(G[v][i]);
        if (ok) break;
        cy.pop_back();
    }
    return ok;
}

vector<int64> make_ok(const vector<int64>& cyc) {
    vector<int64> res;
    REP(i, cyc.size()) {
        FOR(j, i+2, cyc.size()-(i==0)) {
           if (edge[cyc[i]][cyc[j]]) {
               REP(k, i+1) res.push_back(cyc[k]);
               FOR(k, j, cyc.size()) res.push_back(cyc[k]);
               res = make_ok(res);
               return res;
           } else if (edge[cyc[j]][cyc[i]]) {
               FOR(k, i, j+1) res.push_back(cyc[k]);
               res = make_ok(res);
               return res;
           }
        }
    }
    return cyc;
}

int main(void) {
    cin >> N >> M;
    edge.resize(N, vector<int>(N, 0));
    REP(i, M) {
        int64 a, b;
        cin >> a >> b; a--; b--;
        G[a].push_back(b);
        edge[a][b] = 1;
    }
    REP(i, N) {
        used = vector<int64>(N, 0);
        cy = vector<int64>();
        cy.push_back(i);
        bool ok = cycle(i);
        if (ok) {
            vector<int64> cyok;
            REP(j, cy.size()) {
                if (cy[j] == cy.back() || cyok.size()) cyok.push_back(cy[j]);
            }
            cyok.pop_back();
            cy = make_ok(cyok);
            if (cy.size() <= 1) continue;
            cout << cy.size() << endl;
            REP(k, cy.size()) {
                cout << cy[k]+1 << endl;
            }
            cout << endl;
            return 0;
        }
    }
    cout << -1 << endl;
}


Measured memory_bytes: 4352