#include <iostream>
#include <vector>
#include <queue>
#include <limits>

using namespace std;

const int INF = numeric_limits<int>::max();

struct Edge {
    int dest;
    int train;
};

typedef vector<vector<Edge>> Graph;

vector<int> dijkstra(const Graph& G, int start) {
    int N = G.size();
    vector<int> dist(N, INF);
    vector<int> prev(N, -1);
    priority_queue<pair<int,int>, vector<pair<int,int>>, greater<>> pq;
    dist[start] = 0;
    pq.emplace(0, start);
    while (!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();
        if (d > dist[u]) continue;
        for (const auto& e : G[u]) {
            int v = e.dest;
            int w = 1;
            if (dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                prev[v] = e.train;
                pq.emplace(dist[v], v);
            }
        }
    }
    return prev;
}

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

    Graph G(M);
    for (int i = 0; i < N; i++) {
        int a, b;
        cin >> a >> b;
        a--; b--;
        for (int j = a; j < b; j++) {
            G[j].push_back({j+1, i+1});
            G[j+1].push_back({j, i+1});
        }
    }

    auto prev = dijkstra(G, 0);
    if (prev[M-1] == -1) {
        cout << "-1\n";
    } else {
        vector<int> trains;
        int u = M-1;
        while (u != 0) {
            int t = prev[u];
            trains.push_back(t);
            int v = -1;
            for (const auto& e : G[u]) {
                if (e.train == t) {
                    v = e.dest;
                    break;
                }
            }
            u = v;
        }
        int K = trains.size();
        cout << K-1 << endl;
        for (int i = K-1; i >= 0; i--) {
            cout << trains[i] << " ";
        }
        cout << endl;
    }
    return 0;
}