#include<cstdio>
    #include<vector>
    #include<iostream>
    #include<cstring>
    using namespace std;
    #define MAX 1001
    #define MMAX 10001
    #define pb push_back
    int N , M  , C[MAX][MAX] , F[MAX][MAX] , t[MAX] , fmin, L[MAX] , sol , viz[MAX];
    int m[MMAX][3] , ind = 1 , u[MAX];
    bool c[MAX];
    vector<int> G[MAX];

    void read();
    bool BFS(int ind);
    void solve();
    void write();
    int abs(int x)
    {
        if(x < 0)return -x;
        return x;
    }
    bool DFS1(int nod,int ind);
    bool DFS2(int nod,int ind);

    int main()
    {
        read();
        solve();
        write();
        return 0;
    }

    void read()
    {
        int x , y , c;
        freopen("critice.in" , "r" , stdin );
        scanf("%d%d" , &N , &M );
        for(int i = 1 ; i<= M ; ++i )
            {
                scanf("%d%d%d" , &x , &y , &c );
                G[x].pb(y);
                G[y].pb(x);
                C[x][y] = c;
                C[y][x] = c;
                m[i][1] = x ; m[i][2] = y;
            }
    }

    void solve()
    {
        int nod;
        while(BFS(ind))
        {
            for(int i = 0 ; i <(int)G[N].size() ; ++i )
            {
                nod = G[N][i];
                if(C[nod][N] > F[nod][N])
                {
                    t[N] = nod;
                    fmin = C[nod][N]-F[nod][N];
                    if(fmin == 0)continue;
                    for(;nod != 1 ; nod = t[nod])
                        fmin = min(fmin,C[t[nod]][nod]- F[t[nod]][nod]);
                    for(nod = N ; nod != 1 ; nod = t[nod])
                    {
                        F[t[nod]][nod] += fmin;
                        F[nod][t[nod]] -=fmin;
                    }
                }
            }
            ind++;
        }
        ind = 0;
        int u,v;
        for(int i = 1 ; i<= M ; ++i )
        {
            u = m[i][1] ; v = m[i][2];
            if(abs(F[u][v]) == abs(C[u][v]))
            {
                ind+=2;
                if(F[u][v] > 0 && DFS1(u,ind) && DFS2(v,ind+1))
                    sol++,c[i] = 1;
                if(F[u][v] < 0 && DFS1(v,ind) && DFS2(u,ind+1))
                    sol++,c[i] = 1;
            }
        }
    }

    bool BFS(int ind)
    {
        L[1] = 1;
        u[1] = ind;
        int r = 1;
        for(int i = 1 ; i <= r ; ++i )
        {
            if(L[i] == N)continue;
            for(int j = 0 ; j < (int)G[L[i]].size() ; ++j )
            {
                int w = G[L[i]][j];
                if(u[w] != ind && C[L[i]][w] > F[L[i]][w])
                {
                    u[w] = ind;
                    L[++r] = w;
                    t[w] = L[i];
                }
            }
        }
        return u[N] == ind;
    }

    void write()
    {
        freopen("critice.out" , "w" , stdout );
        printf("%d\n" , sol);
        for(int i = 1 ; i<= M ; ++i )
            if(c[i])
                printf("%d\n" , i);
    }

    bool DFS1(int nod , int ind)
    {
        if(nod == 1)return 1;
        viz[nod] = ind;
        bool sw = 0;
        for(int i = 0 ; i< (int)G[nod].size() ; ++i )
            if(viz[G[nod][i]] != ind && abs(F[G[nod][i]][nod]) < C[nod][G[nod][i]])
                    sw = (sw || DFS1(G[nod][i],ind));
        return sw;
    }

    bool DFS2(int nod , int ind)
    {
        if(nod == N)return 1;
        viz[nod] = ind;
        bool sw = 0;
        for(int i = 0 ; i< (int)G[nod].size() ; ++i )
            if(viz[G[nod][i]] != ind && abs(F[nod][G[nod][i]]) < C[nod][G[nod][i]])
                    sw = (sw || DFS2(G[nod][i],ind));
        return sw;
    }