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

using namespace std;
typedef int var;

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

#define MAXN 1001

var C[MAXN][MAXN], F[MAXN][MAXN];
bool VIZ[MAXN];
var PARENT[MAXN];
vector<var> G[MAXN];
vector<var> SOL;
vector<var*> T1, T2;

var src, sink;
var n, m;

bool bfs() {
    queue<var> Q;
    memset(VIZ, 0, sizeof(VIZ));
    memset(PARENT, 0, sizeof(PARENT));
    Q.push(src);
    VIZ[src] = 1;
    while(!Q.empty()) {
        var node = Q.front();
        Q.pop();
        for(auto vec : G[node]) {
            if(!VIZ[vec] && F[node][vec] < C[node][vec]) {
                PARENT[vec] = node;
                VIZ[vec] = 1;
                Q.push(vec);
            }
        }
    }
    return VIZ[sink];
}

void maxflow() {
    while(bfs()) {
        for(auto t : G[sink]) {
            if(!PARENT[t]) continue;

            var MIN = C[t][sink] - F[t][sink];

            for(var node = t; node != src; node = PARENT[node]) {
                MIN = min(MIN, C[PARENT[node]][node] - F[PARENT[node]][node]);
            }

            F[t][sink] += MIN;
            F[sink][t] -= MIN;

            for(var node = t; node != src; node = PARENT[node]) {
                F[PARENT[node]][node] += MIN;
                F[node][PARENT[node]] -= MIN;
            }
        }
    }
}

int main() {
    fin>>n>>m;
    var a, b, c;
    src = 1;
    sink = n;
    for(var i=1; i<=m; i++) {
        fin>>a>>b>>c;
        C[b][a] = C[a][b] = c;
        G[a].push_back(b);
        G[b].push_back(a);
        T1.push_back(&C[a][b]);
        T2.push_back(&C[b][a]);
    }

    maxflow();

    for(var i=0; i<m; i++) {
        T1[i][0] ++;
        T2[i][0] ++;
        if(bfs()) {
            SOL.push_back(i+1);
        }
        T1[i][0] --;
        T2[i][0] --;
    }

    fout<<SOL.size()<<'\n';
    for(auto sol : SOL) {
        fout<<sol<<'\n';
    }

    return 0;
}