#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

struct Train {
    int start, end, index;
};

int main() {
    int N, M;
    cin >> N >> M;

    vector<Train> trains(N);
    for (int i = 0; i < N; i++) {
        cin >> trains[i].start >> trains[i].end;
        trains[i].index = i + 1; // Store the train index (1-based)
    }

    // Create a graph where each station points to the trains that can be taken from it
    vector<vector<int>> graph(M + 1);
    for (const auto& train : trains) {
        graph[train.start].push_back(train.index);
    }

    // BFS to find the shortest path from station 1 to station M
    vector<int> transfers(M + 1, -1); // -1 means not reachable
    vector<int> previousTrain(N + 1, -1); // To track the previous train used
    queue<int> q;

    // Start from station 1
    transfers[1] = 0; // 0 transfers to start
    q.push(1);

    while (!q.empty()) {
        int currentStation = q.front();
        q.pop();

        for (int trainIndex : graph[currentStation]) {
            const Train& train = trains[trainIndex - 1]; // Get the train

            // If we can reach the end of this train
            if (transfers[train.end] == -1) { // If not visited
                transfers[train.end] = transfers[currentStation] + 1; // Increment transfers
                previousTrain[train.end] = trainIndex; // Track the train used
                q.push(train.end);
            }
        }
    }

    // Check if we reached station M
    if (transfers[M] == -1) {
        cout << -1 << endl; // Not reachable
    } else {
        // Output the number of transfers
        cout << transfers[M] << endl;

        // Backtrack to find the trains used
        vector<int> trainPath;
        int currentStation = M;
        while (currentStation != 1) {
            int trainIndex = previousTrain[currentStation];
            trainPath.push_back(trainIndex);
            const Train& train = trains[trainIndex - 1];
            currentStation = train.start; // Move to the starting station of the train
        }

        // Reverse the trainPath to get the correct order
        reverse(trainPath.begin(), trainPath.end());

        // Output the train indices
        for (int trainIndex : trainPath) {
            cout << trainIndex << " ";
        }
        cout << endl;
    }

    return 0;
}