#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using PII = pair<ll, ll>;

#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
 
template<typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template<typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }

const ll LLINF = 1LL<<60;

template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
    out<<'('<<a.first<<','<<a.second<<')'; return out;
}
template<class T>
ostream &operator <<(ostream& out,const vector<T>& a){
    out<<'['; for(T i: a) {out<<i<<',';} out<<']'; return out;
}
template<class T, class S>
ostream &operator <<(ostream& out,const map<T,S>& a){
    out<<'['; for(auto i: a) {out<<i<<',';} out<<']'; return out;
}
template<class T>
ostream &operator <<(ostream& out,const set<T>& a){
    out<<'['; for(auto i: a) {out<<i<<',';} out<<']'; return out;
}
template<class T, class S>
ostream &operator <<(ostream& out,const unordered_map<T,S>& a){
    out<<'['; for(auto i: a) {out<<i<<',';} out<<']'; return out;
}
template<class T>
ostream &operator <<(ostream& out,const unordered_set<T>& a){
    out<<'['; for(auto i: a) {out<<i<<',';} out<<']'; return out;
}

struct SCC {
    int V, K;
    vector<vector<int>> G;
    vector<vector<int>> rG;
    vector<int> vs;
    vector<int> used;
    vector<int> cmp;

    void dfs(int v) {
        used[v]=true;
        for(int nx: G[v]) if(!used[nx]) dfs(nx);
        vs.push_back(v);
    }
    void rdfs(int v,int k) {
        used[v]=true; cmp[v]=k;
        for(int nx: rG[v]) if(!used[nx]) rdfs(nx,k);
    }

    SCC() { V=K=-1; }
    SCC(int V_): V(V_), G(V_), rG(V_), used(V_), cmp(V_) {}

    void add_edge(int from,int to) {
        G[from].push_back(to);
        rG[to].push_back(from);
    }
    int scc() {
        used.assign(V,0); vs.clear();
        for(int v=0;v<V;v++) if(!used[v]) dfs(v);
        used.assign(V,0);
        int k=0;
        for(int i=(int)vs.size()-1;i>=0;i--) if(!used[vs[i]]) {
            rdfs(vs[i],k++);
        }
        return K=k;
    }
    // O(ElogE)
    // SCCしたあとのグラフはトポロジカル順になってる
    vector<vector<int>> getDAG() {
        vector<vector<int>> res(K);
        for(int from=0;from<V;from++) {
            for(int to:G[from]) if(cmp[from]!=cmp[to]) {
                res[cmp[from]].push_back(cmp[to]);
            }
        }
        for(int i=0;i<K;i++){
            sort(ALL(res[i]));
            res[i].erase(unique(ALL(res[i])),res[i].end());
        }
        return res;
    }
};

bool graph[1005][1005];
int main(void) {
    cin.tie(0);
    ios::sync_with_stdio(false);

    ll n, m;
    cin >> n >> m;
    vector<vector<ll>> g(n);
    REP(i, m) {
        ll a, b;
        cin >> a >> b;
        a--, b--;
        g[a].push_back(b);
        graph[a][b] = true;
    }

    vector<vector<ll>> dist(n, vector<ll>(n, LLINF)), prev(n, vector<ll>(n, -1));
    REP(i, n) {
        queue<ll> que;
        que.push(i);
        dist[i][i] = 0;
        while(que.size()) {
            ll v = que.front(); que.pop();
            for(auto to: g[v]) {
                if(dist[i][to] == LLINF) {
                    dist[i][to] = dist[i][v] + 1;
                    prev[i][to] = v;
                    que.push(to);
                }
            }
        }
    }

    vector<ll> ans(n+5);
    REP(i, n) {
        ll mi = LLINF, idx = -1;
        REP(j, n) {
            if(!graph[j][i]) continue;
            if(mi > dist[i][j]) {
                mi = dist[i][j];
                idx = j;
            }
        }
        if(idx == -1) continue;

        vector<ll> ret;
        ll v = idx;
        while(v != -1) {
            ret.push_back(v);
            v = prev[i][v];
        }
        // cerr << "i:" << i << " idx:" << idx << " ret:" << ret << endl;
        if(ret.size() < ans.size()) {
            swap(ans, ret);
        }
    }

    if(ans.size() == n+5) cout << -1 << endl;
    else {
        cout << ans.size() << endl;
        for(auto i: ans) cout << i+1 << endl;
    }

    // ll n, m;
    // cin >> n >> m;
    // vector<vector<ll>> g(n);
    // vector<vector<ll>> graph(n, vector<ll>(n, LLINF));
    // REP(i, m) {
    //     ll a, b;
    //     cin >> a >> b;
    //     a--, b--;
    //     g[a].push_back(b);
    //     graph[a][b] = 1;
    // }

    // vector<vector<ll>> tree(n);
    // vector<bool> used(n);
    // vector<ll> ans;
    // function<void(ll)> dfs = [&](ll v) {
    //     used[v] = true;
    //     for(auto to: g[v]) {
    //         if(used[to]) continue;
    //         tree[to].push_back(v);
    //         dfs(to);
    //     }
    // };
    // REP(i, n) if(!used[i]) dfs(i);

    // // REP(i, n) cerr << i << " " << tree[i] << endl;

    // vector<vector<ll>> path(n);
    // vector<vector<ll>> visit(n, vector<ll>(n));
    // REP(i, n) {
    //     function<void(ll)> dfs2 = [&](ll v) {
    //         path[i].push_back(v);
    //         for(auto to: tree[v]) {
    //             visit[i][to] = true;
    //             dfs2(to);
    //         }
    //     };
    //     dfs2(i);
    // }

    // vector<ll> ret(n+5);
    // REP(i, n) {
    //     vector<ll> ans;
    //     for(auto j: path[i]) {
    //         ans.push_back(j);
    //         if(graph[i][j]==1) {
    //             if(ans.size() < ret.size()) {
    //                 ret = ans;
    //                 break;
    //             }
    //         }
    //     }
    // }
    
    // if(ret.size() == n+5) cout << -1 << endl;
    // else {
    //     cout << ret.size() << endl;
    //     for(auto i: ret) cout << i+1 << endl;
    // }

    return 0;
}

Measured memory_bytes: 17024