#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>

using namespace std;

ifstream f("critice.in");
ofstream g("critice.out");

#define nmax 1005
#define Mmax 10005

int n, m, q[nmax+Mmax], capac[nmax][nmax], flux[nmax][nmax], t[nmax];
int viz[nmax];
int alb[nmax], negru[nmax];
pair<int,int> edge[Mmax];
vector<int> gf[nmax];
int rez[Mmax];

void citeste(){
    f >> n >> m;
    int x, y;
    for(int i=1; i<=m; ++i){
        f >> x >> y;
        gf[x].push_back(y);
        gf[y].push_back(x);
        f >> capac[x][y];
        capac[y][x] = capac[x][y];
        edge[i] = make_pair(x, y);
    }
}

inline bool bfs(int S, int D, int cod){
    int st = 1; int dr = 0;
    q[++dr] = S; viz[S] = cod;

    for(; st<=dr; ){
        int nod = q[st]; ++st;
        for(int i=0; i<gf[nod].size(); ++i){
            int vc = gf[nod][i];
            if (viz[vc] != cod && capac[nod][vc] > flux[nod][vc]){
                t[vc] = nod;
                viz[vc] = cod;
                if(vc == D) return 1;
                q[++dr] = vc;
            }
        }
    }
    return 0;
}

void bagaFlux(){
    int S = 1; int D = n;
    for(int cod=1; bfs(S, D, cod); ++cod){
        int Min = (1<<30);
        for(int i=D; i!=S; i=t[i]){
            //muchia t[i] -> i
            Min = min(Min, capac[ t[i] ][i] - flux[ t[i] ][i]);
        }
        //bag fluxul
        for(int i=D; i!=S; i=t[i]){
            flux[ t[i] ][i] += Min;
            flux[i][ t[i] ] -= Min;
        }
    }
}

void coloreaza(int S, int color[], int cod){
    int st = 1; int dr = 0;
    q[++dr] = S; color[S] =1;

    for(; st<=dr; ){
        int nod = q[st]; ++st;
        for(int i=0; i<gf[nod].size(); ++i){
            int vc = gf[nod][i];
            if (cod == 0){// luate in ordinea in care vin
                if (color[vc] == 0 && flux[nod][vc] < capac[nod][vc]){
                    color[vc] = 1;
                    q[++dr] = vc;
                }
            }else {// trebe in ordine inversa ca vin din destinatie
                if (color[vc] == 0 && flux[vc][nod] < capac[vc][nod]){
                    color[vc] = 1;
                    q[++dr] = vc;
                }
            }
        }
    }
}



void rezolva(){
    // dupa ce bag flux ma intereseaza muchiile critice acestea vor fi acele care :
    // au fluxul == capac si sunt accesibile din sursa mergand dooar pe muchii nesaturate
    // la fel si pentru destinatie

    bagaFlux();
    coloreaza(1, alb, 0);
    coloreaza(n, negru, 1);

    for(int i=1; i<=m; ++i){
        int X = edge[i].first; int Y = edge[i].second;
        if (flux[X][Y] == capac[X][Y] || flux[Y][X] == capac[Y][X]){
            if ( (alb[X] == 1 && negru[Y] == 1) || (negru[X] == 1 && alb[Y] == 1) ){// e critica
                rez[++rez[0]] = i;
            }
        }
    }

    //cout << rez[0] << "\n";
    g << rez[0] << "\n";
    for(int i=1; i<=rez[0]; ++i){
        //cout << rez[i] << "\n";
        g << rez[i] << "\n";
    }
}

int main(){
    citeste();
    rezolva();

    f.close();
    g.close();

    return 0;
}