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

variant<bool, vector<int>> find_journey(int N, int M,
    vector<int> U, vector<int> V) {

    // Build adjacency list
    vector<vector<pair<int,int>>> adj(N); // adj[u] = {(v, edge_id)}
    for (int i = 0; i < M; i++)
        adj[U[i]].push_back({V[i], i});

    // Check if node 0 has out-degree >= 2 or can reach a cycle

    // Case 1: Node 0 has >= 2 outgoing edges to the same node
    // or has a self-loop
    for (auto [v, id] : adj[0]) {
        if (v == 0) {
            // Self-loop: use it twice
            return vector<int>{id, id};
        }
    }

    // Case 2: Find a cycle reachable from 0
    // DFS from 0
    vector<int> color(N, 0); // 0=white, 1=gray, 2=black
    vector<int> parent_edge(N, -1);
    vector<int> parent_node(N, -1);
    vector<int> path; // current DFS path

    bool found_cycle = false;
    int cycle_start = -1, cycle_edge = -1;

    function<void(int)> dfs = [&](int u) {
        if (found_cycle) return;
        color[u] = 1;
        path.push_back(u);

        for (auto [v, id] : adj[u]) {
            if (found_cycle) return;
            if (color[v] == 1) {
                // Back edge: cycle found
                cycle_start = v;
                cycle_edge = id;
                found_cycle = true;
                return;
            }
            if (color[v] == 0) {
                parent_edge[v] = id;
                parent_node[v] = u;
                dfs(v);
                if (found_cycle) return;
            }
        }

        path.pop_back();
        color[u] = 2;
    };

    dfs(0);

    if (!found_cycle) return false;

    // Construct the journey
    // Path from 0 to cycle_start, then around the cycle, then back

    // Extract path from 0 to cycle_start
    vector<int> path_to_cycle;
    int node = cycle_start;
    vector<int> rev_path;
    // Trace back from cycle_start to 0 using parent_edge
    // Wait, cycle_start is already on the DFS path from 0
    // The path from 0 to cycle_start is the DFS path

    // Actually, the current DFS path (stack) contains the path from 0 to u
    // where u is the node that found the back edge.
    // cycle_start is on this path.

    // Reconstruct: path from 0 to cycle_start via parent edges
    vector<int> to_cycle_edges;
    node = cycle_start;
    // But cycle_start might be 0 itself
    if (node != 0) {
        vector<int> tmp;
        int cur = cycle_start;
        // Need path from 0 to cycle_start
        // Use parent_edge/parent_node to trace back
        // But cycle_start was reached during DFS from 0
        // Trace: cycle_start -> parent -> ... -> 0
        while (cur != 0) {
            tmp.push_back(parent_edge[cur]);
            cur = parent_node[cur];
            if (cur == -1) return false; // shouldn't happen
        }
        reverse(tmp.begin(), tmp.end());
        to_cycle_edges = tmp;
    }

    // Extract cycle edges: from cycle_start, follow the DFS tree path back to cycle_start
    // via the back edge
    // The cycle is: cycle_start -> ... -> u -> cycle_start (via back edge cycle_edge)
    // where u is the node that has the back edge

    // Find u: the node whose DFS found the back edge
    int u_node = U[cycle_edge]; // the source of the back edge

    vector<int> cycle_edges;
    {
        int cur = u_node;
        while (cur != cycle_start) {
            // This traces backwards, we need forward direction
            cycle_edges.push_back(parent_edge[cur]);
            cur = parent_node[cur];
        }
        reverse(cycle_edges.begin(), cycle_edges.end());
        cycle_edges.push_back(cycle_edge); // the back edge
    }

    // Journey: go to cycle_start, traverse cycle twice, come back
    // For the "each edge even times" and "no consecutive same edge" constraint:
    // If cycle length >= 2: go around twice. Edges: e1,e2,...,ek,e1,e2,...,ek
    // No consecutive duplicates as long as ek != e1 (which holds if cycle length >= 2)

    // If cycle has self-loop (length 1): special handling needed

    vector<int> journey;
    // Go to cycle_start
    for (int e : to_cycle_edges) journey.push_back(e);
    // Traverse cycle
    if (cycle_edges.size() == 1) {
        // Single edge cycle (self-loop): use it twice
        journey.push_back(cycle_edges[0]);
        journey.push_back(cycle_edges[0]);
    } else {
        // Traverse twice
        for (int e : cycle_edges) journey.push_back(e);
        for (int e : cycle_edges) journey.push_back(e);
    }
    // Come back: reverse the path edges
    for (int i = to_cycle_edges.size() - 1; i >= 0; i--) {
        // Need the reverse edge... but edges are directed!
        // We need to find a way back from cycle_start to 0.
        // This is not guaranteed in a directed graph!
        // If the graph is not strongly connected, we might not be able to return.
    }

    // Actually, we need to be more careful. The problem guarantees each node
    // has at least one outgoing edge, but there may not be a path back.
    // We need to find a cycle through node 0 specifically.

    // Revised approach: only report success if the cycle includes node 0
    if (cycle_start == 0) {
        vector<int> result;
        if (cycle_edges.size() >= 2) {
            for (int e : cycle_edges) result.push_back(e);
            for (int e : cycle_edges) result.push_back(e);
        } else {
            result.push_back(cycle_edges[0]);
            result.push_back(cycle_edges[0]);
        }
        return result;
    }

    // cycle doesn't include 0: need different approach
    // Check if node 0 has >= 2 outgoing edges
    if (adj[0].size() >= 2) {
        // Use two different first edges from 0, follow each to a cycle, and combine
        auto [v1, e1] = adj[0][0];
        auto [v2, e2] = adj[0][1];

        // Follow e1 until we return to 0 or find a cycle
        // This is complex; for now, return false if cycle doesn't include 0
    }

    return false;
}

int main() {
    int N, M;
    scanf("%d %d", &N, &M);
    vector<int> U(M), V(M);
    for (int i = 0; i < M; i++)
        scanf("%d %d", &U[i], &V[i]);
    auto result = find_journey(N, M, U, V);
    if (holds_alternative<bool>(result)) {
        printf("IMPOSSIBLE\n");
    } else {
        auto& journey = get<vector<int>>(result);
        printf("%d\n", (int)journey.size());
        for (int e : journey)
            printf("%d ", e);
        printf("\n");
    }
    return 0;
}