#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[2][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;
    }
    void DFS1(int nod);
    void DFS2(int nod);

    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;
        DFS1(1);
        DFS2(N);
        for(int i = 1 ; i<= M ; ++i )
        {
            u = m[i][1] ; v = m[i][2];
            if(abs(F[u][v]) == abs(C[u][v]))
                if((viz[1][u] && viz[2][v]) || (viz[1][v] && viz[2][u]))
                    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);
    }

    void DFS1(int nod)
    {
        viz[1][nod] = 1;
        for(int i = 0 ; i< (int)G[nod].size() ; ++i )
            if(!viz[1][G[nod][i]] && abs(F[G[nod][i]][nod]) < C[nod][G[nod][i]])
                    DFS1(G[nod][i]);
    }

    void DFS2(int nod)
    {
        viz[2][nod] = 1;
        for(int i = 0 ; i< (int)G[nod].size() ; ++i )
            if(!viz[2][G[nod][i]]&& abs(F[nod][G[nod][i]]) < C[nod][G[nod][i]])
                    DFS2(G[nod][i]);
    }