#include<fstream>
#include<algorithm>
#include<vector>
#include<queue>

#define MAXN 1002

using namespace std;

typedef int var;

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

struct Elem {
    var ind, n;
    Elem(var a, var b) {
        n = a; ind = b;
    }
};

vector<Elem> G[MAXN];
var C[MAXN][MAXN], F[MAXN][MAXN];
var PARENT[MAXN];
var s, e, n;
vector<var> SOL;
queue<var> Q;
bool VIZ[MAXN];

bool bfs() {
    while(!Q.empty()) Q.pop();
    for(var i=1; i<=n; i++) {
        PARENT[i] = 0;
        VIZ[i] = 0;
    }

    Q.push(s);
    VIZ[s] = 1;

    while(!Q.empty()) {
        var node = Q.front();
        Q.pop();
        for(vector<Elem>::iterator it = G[node].begin(); it!=G[node].end(); ++it) {
            var vec = (*it).n;
            if(!VIZ[vec] && F[node][vec] < C[node][vec]) {
                PARENT[vec] = node;
                Q.push(vec);
                VIZ[vec] = 1;
            }
        }
    }
    return VIZ[e];
}

void fluxmaxim() {
    while(bfs()) {
        for(vector<Elem>::iterator it = G[e].begin(); it!=G[e].end(); ++it) {
            var node = (*it).n;
            if(!PARENT[node]) continue;
            var MAX = C[node][e] - F[node][e];
            while(PARENT[node]) {
                MAX = min(MAX, C[PARENT[node]][node] - F[PARENT[node]][node]);
                node = PARENT[node];
            }
            node = (*it).n;
            F[node][e] += MAX;
            F[e][node] -= MAX;
            while(PARENT[node]) {
                F[PARENT[node]][node] += MAX;
                F[node][PARENT[node]] -= MAX;
                node = PARENT[node];
            }
        }
    }
}

int main() {
    var m, a, b, c;


    fin>>n>>m;
    s = 1; e = n;
    for(var e=1; e<=m; e++) {
        fin>>a>>b>>c;
        G[a].push_back(Elem(b, e));
        G[b].push_back(Elem(a, e));
        C[a][b] = C[b][a] = c;
    }
    fluxmaxim();

    for(var i=1; i<=n; i++) {
        for(vector<Elem>::iterator it = G[i].begin(); it != G[i].end(); ++it) {
            var vec = (*it).n;
            if(F[i][vec] == C[i][vec]) {
                C[i][vec] ++;
                if(bfs()) {
                    SOL.push_back((*it).ind);
                }
                C[i][vec] --;
            }
        }
    }

    fout<<SOL.size();
    for(vector<var>::iterator it = SOL.begin(); it!=SOL.end(); ++it) {
        fout<<'\n'<<*it;
    }
}