using System;
using System.Collections.Generic;


namespace átszállás
{
    internal class Program
    {



        static int[] be()
        {
            string[] sts = Console.ReadLine().Split(' ');
            int[] st = new int[3];
            st[1] = int.Parse(sts[1]);
            st[0] = int.Parse(sts[0]);
            return st;
        }
        static void Main(string[] args)
        {
            int[] st = be();//alapadatok beolvasása
            int N = st[1];
            int M = st[0];
            st = be();//első vonat beolvasása
            List<int[]> v = new List<int[]>();
            st[2] = 1;

            if (st[0] != 1) Console.WriteLine(-1);//nem a kezdőállomásról indul az első vonat
            else
            {
                int indulas = st[0], erkezes = st[1], vonat = 1;
                for (int i = 1; i <= M; i++)//=, hogy az utolső elemet is 
                {
                    if (indulas == st[0])//ha azonos induló állomáson vagyunk
                    {
                        if (erkezes < st[1])
                        {
                            erkezes = st[1];//az adott állomásról a legtávolabb menő vonat
                            vonat = i;
                        }
                    }
                    else//másik indulló állomáson vagyunk
                    {
                        int[] t = new int[3];//az előző leghosszabb adatait rögzítjük
                        t[0] = indulas;
                        t[1] = erkezes;
                        t[2] = vonat;
                        v.Add(t);//beteszük egy listába
                        indulas = st[0];//a következő indulásnál keressük a legtávolabbi érkezést
                        erkezes = st[1];
                        vonat = i;

                    }
                    if (i < M) st = be();//az utolső elem után ne olvasson be
                }
                //az utolső intervallumot betesz a lsitába
                int[] t1 = new int[3];
                t1[0] = indulas;
                t1[1] = erkezes;
                t1[2] = vonat;
                v.Add(t1);
                //belső intervallumok kizárása pl. 1 7, 2 5 a 2 5 felesleges
                List<int[]> v2 = new List<int[]>();//átmásoljuk egy új listába a jó elemeket
                v2.Add(v[0]);//betesszük az elős elemet, ez biztos
                erkezes = v[0][1];//rögzítjük mikor érezik meg
                foreach (var item in v)
                {
                    if (item[1] > erkezes)//ha adott elem később fejeződik be, mint ahogy az aktuális pl 1 7, 5 8
                    {
                        v2.Add(item);
                        erkezes = item[1];//ez lesz az aktuális
                    }
                }
                //a legkedvezőbb intevallumok kiválasztása
                //kiválasztjuk kér egymást követő intervallumból a legnagyobbat
                List<int[]> v3 = new List<int[]>();
                if (v2.Count == 1)//ha csak 1 intervallum van nem kell vizsgálni, ez a legjobb
                {
                    v3.Add(v2[0]);
                }
                else//ha több van
                {
                    v3.Add(v2[0]);//betesszük az elsőt, ez az induló járat biztos benne van
                    erkezes = v2[0][1];//az elős vonat ekkor fog megérkezni
                    int maxi = 1;//ez a maximumkereésé kezdőeleme
                    for (int i = 1; i < v2.Count; i++)//végig a listán
                    {
                        if (v2[i][0] <= erkezes)//ha az adott lemnek és az eddigi legjobbnak van közös eleme 
                            //pl 1 7, 6 10
                        {
                            if (v2[i][1] > v2[maxi][1])//megnézzük, hogy ez nagyobb-e mint az eddigi legtávolabbi pont
                            {
                                maxi = i;//ha igen ez a legtávolabbi, ez egy maximum keresés
                            }
                        }
                        else//ha nincs közös pontjuk, akkor az eddigi legnagyobbhoz képest kell keresni a legtávolabbi pontot
                        {
                            v3.Add(v2[maxi]);//betesszük maximális elemet a listába
                            erkezes = v2[maxi][1];//beállítjuk az ő érkezését, aminél nagyobbat kell keresnünk
                            maxi = i;//az aktuális elem, amely az eddigi intervallumon kívül van, az lezs a maximum
                        }
                    }
                    v3.Add(v2[maxi]);//az utolsó elemet nem vizsgálja, ezért hozzáadjuk.
                }
                //van e átfedés az intervallumok között mert az 1 2, 3 10 esetet az előző nem vizsgálta
                //eldöntés tétele
                int cv = 1;//ciklusváltozó 1 mert az előző elemhez hasonlitjuk az aktuálisa elemet.
                while (cv < v3.Count && //a tömbön belül vagyunk-e
                    v3[cv][0] <= v3[cv - 1][1])//az aktuális lemenek, és az előzőnek van közös pontja
                {
                    cv++;//ekkor megyünk a következőre
                }
                if (cv < v3.Count||//ha a ciklus előbb leállt a végénél, akkor talált egy olyan esetet, ahol nincs közös pont
                    v3[v3.Count-1][1]!=N)//nem bztos, hogy a végállomásig elé tudunk menni, megvizsgáljuk az utolsó elemet, hogy az a végállomás-e
                {
                    Console.WriteLine(-1);//ha nincs átfedés, vagy nem ér el a végállomásig, akkor nem lehetséges
                }
                else
                {
                    Console.WriteLine(v3.Count - 1);//kiírjuk az vonatok számát -t mert az átszállást kérdezi
                    foreach (var item in v3)
                    {
                        Console.Write(item[2] + " ");//kiíratjuk a vonat számát
                    }
                    Console.WriteLine();//miután Write-ot használtunk le kell zárni a sort, különben hibás megoldást fog adni a program
                }
            }
            Console.ReadKey();
        }
    }
}