#include <fstream>
#include <cstring>
#include <vector>
#include <queue>

#define grafSize 1001
#define edgeSize 10001
#define useSize 1001
#define TSize 1001
#define cHeight 1001
#define cWidth 1001
#define fHeight 1001
#define fWidth 1001
#define vSize 10001

#define A (*it)

#define OPT ((1<<31)-1)

#define ONE int

using namespace std;

ifstream in;
ofstream out;

vector <ONE> graf[grafSize];

int c[cHeight][cWidth];
int f[fHeight][fWidth];

int ex[edgeSize];
int ey[edgeSize];
int T[TSize];
int v[vSize];

int M,N,sol=0;
int Source,Sink;

inline void read(void);
inline void maxflow(void);
inline void critice(void);
inline void write(void);

inline int flowBFS(void);
inline int edgeBFS(int nod,int stop);

inline int ABS(int x);

int main(void)
{
    read();
    maxflow();
    critice();
    write();

    return 0;
}

inline void read(void)
{
    int x,y;

    memset(c,0,sizeof(c));
    memset(f,0,sizeof(f));
    memset(ex,0,sizeof(ex));
    memset(ey,0,sizeof(ey));
    memset(v,0,sizeof(v));

    in.open("critice.in");

    in>>N>>M;
    for(int i=1;i<=M;++i)
    {
        in>>x>>y;
        in>>c[x][y];
        c[y][x]=c[x][y];

        ex[i]=x;
        ey[i]=y;

        graf[x].push_back(y);
        graf[y].push_back(x);
    }

    in.close();

    Source=1;
    Sink=N;
}

inline void maxflow(void)
{
    for(int nod,min,drum=flowBFS();drum;drum=flowBFS())
        for(vector <ONE>::iterator it=graf[Sink].begin();it!=graf[Sink].end();++it)
            if(T[A]!=0)
            {
                T[Sink]=A;

                nod=Sink;
                while(nod!=Source&&nod!=0)
                {
                    if(min>c[T[nod]][nod]-f[T[nod]][nod])
                        min=c[T[nod]][nod]-f[T[nod]][nod];
                    nod=T[nod];
                }

                if(min<=0) continue;

                nod=Sink;
                while(nod!=Source&&nod!=0)
                {
                    f[T[nod]][nod]+=min;
                    f[nod][T[nod]]-=min;
                    nod=T[nod];
                }
            }
}

inline void critice(void)
{
    int ok;

    for(int i=1;i<=M;++i)
        if(c[ex[i]][ey[i]]==ABS(f[ex[i]][ey[i]]))
        {
            ok=0;

            ok=edgeBFS(Source,ex[i]);
            if(ok) ok=edgeBFS(Sink,ey[i]);
            else
            {
                ok=edgeBFS(Source,ey[i]);
                if(!ok) continue;
                ok=edgeBFS(Sink,ex[i]);
            }

            if(!ok) continue;
            v[++sol]=i;
        }
}

inline void write(void)
{
    out.open("critice.out");

    out<<sol<<'\n';

    for(int i=1;i<=sol;++i)
        out<<v[i]<<'\n';

    out.close();
}

inline int flowBFS(void)
{
    queue <ONE> q;
    int use[useSize];
    int ok=0;

    memset(use,0,sizeof(use));
    memset(T,0,sizeof(T));

    q.push(Source);
    use[Source]=1;

    for(int nod;!q.empty();q.pop())
    {
        nod=q.front();

        for(vector <ONE>::iterator it=graf[nod].begin();it!=graf[nod].end();++it)
            if(!use[A]&&c[nod][A]>f[nod][A])
            {
                if(A!=Sink)
                {
                    use[A]=1;
                    T[A]=nod;
                    q.push(A);
                }
                else ok=1;
            }
    }

    return ok;
}

inline int edgeBFS(int nod,int stop)
{
    if(nod==stop) return 1;

    queue <ONE> q;
    int use[useSize];

    memset(use,0,sizeof(use));

    q.push(nod);
    use[nod]=1;

    for(;!q.empty();q.pop())
    {
        nod=q.front();

        for(vector <ONE>::iterator it=graf[nod].begin();it!=graf[nod].end();++it)
            if(c[nod][A]>f[nod][A]&&!use[A])
            {
                if(A==stop) return 1;
                use[A]=1;
                q.push(A);
            }
    }

    return 0;
}

inline int ABS(int x)
{
    if(x<0) return -x;
    else return x;
}