#include <iostream>
#include <fstream>
#include <cstring>
#define DMAX 1001
#define FMAX 10001

using namespace std;

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

struct nod{
    int val;
    nod * urm;
}*v[DMAX];

struct muchii{
    int x, y;
}lat[10003];

int n, m;//date de intrare
int rezistenta[DMAX][DMAX];
int flux[DMAX][DMAX];
int tata[DMAX], S, D;
int fluxMaxim;
bool da[DMAX];


void citire(){
    in >> n >> m;
    S = 1;
    D = n;
    for(int i = 1; i <= m; i++){
        int x, y, c;
        in >> x >> y >> c;
        lat[i].x = x;
        lat[i].y = y;
        rezistenta[x][y] = rezistenta[y][x] = c;

        nod * deAdaugat1 = new nod;
        deAdaugat1 -> val = y;
        deAdaugat1 -> urm = v[x];
        v[x] = deAdaugat1;

        nod * deAdaugat2 = new nod;
        deAdaugat2 -> val = x;
        deAdaugat2 -> urm = v[y];
        v[y] = deAdaugat2;
    }
}

bool bfs(){
    memset(tata, 0, sizeof(tata));
    memset(da, false, sizeof(da));
    da[S] = true;
    int coada[DMAX], primul = 1, ultimul = 1;
    coada[primul] = S;
    tata[S] = -1;
    while (primul <= ultimul){
        nod * parcurg = v[coada[primul]];
        while (parcurg != NULL){
            if(tata[parcurg -> val] == 0 && rezistenta[coada[primul]][parcurg -> val] > flux[coada[primul]][parcurg -> val]){
                if(parcurg -> val == D){
                    return true;
                }else{
                    coada[++ultimul] = parcurg -> val;
                    tata[parcurg -> val] = coada[primul];
                    da[parcurg -> val] = true;
                }
            }
            parcurg = parcurg -> urm;
        }
        primul ++;
    }
    return false;
}

void dinic(){
    bool existaDrum;
    for(existaDrum = bfs(); existaDrum; existaDrum = bfs()){
        nod * parcurg = v[D];
        while(parcurg != NULL){
            if(tata[parcurg -> val] != 0 && rezistenta[parcurg -> val][D] > flux[parcurg -> val][D]){
                tata[D] = parcurg -> val;
                int fluxActual = FMAX;
                for(int intoarcere = D; intoarcere != S; intoarcere = tata[intoarcere]){
                    int aux = tata[intoarcere];
                    fluxActual = min(fluxActual, rezistenta[aux][intoarcere] - flux[aux][intoarcere]);
                }
                if(fluxActual > 0){//am gasit o posibilitate de drum
                    fluxMaxim += fluxActual;
                    for(int intoarcere = D; intoarcere != S; intoarcere = tata[intoarcere]){
                        int aux = tata[intoarcere];
                        flux[aux][intoarcere] += fluxActual;
                        flux[intoarcere][aux] -= fluxActual;
                    }
                }
            }
            parcurg = parcurg -> urm;
        }
    }
}

void parcurgereGrafBFS(){

}


int main() {
    citire();
    dinic();
    bfs();
    int rez[DMAX];
    for(int i = 1; i <= m; i++){
        if((da[lat[i].x] && !da[lat[i].y]) || (!da[lat[i].x] && da[lat[i].y])){
            rez[++rez[0]] = i;
        }
    }
    out<< rez[0] <<'\n';
    for(int i = 1; i <= rez[0]; i++){
        out<<rez[i]<<'\n';
    }
    return 0;
}