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

#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;
bool VIZ[MAXN];

bool bfs() {
    queue<var> Q;
    memset(PARENT, 0, sizeof(PARENT));
    memset(VIZ, 0, sizeof(VIZ));

    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];
                if(MAX == 0) break;
            }
            if(MAX == 0) continue;
            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];
            }
        }
    }
}

bool VIZ1[2][MAXN];
void dfs(var node, bool val) {
    VIZ1[val][node] = 1;
    for(vector<Elem>::iterator it = G[node].begin(); it!=G[node].end(); ++it) {
        if(!VIZ1[val][(*it).n] && F[node][(*it).n] < C[node][(*it).n]) {
            dfs((*it).n, val);
        }
    }
}

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();

    dfs(s, 0);
    dfs(e, 1);

    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] && (VIZ1[0][i] &&VIZ1[1][vec])) {
                SOL.push_back((*it).ind);
            }
        }
    }

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