#include <bits/stdc++.h>

using namespace std;
ifstream fin("critice.in");
ofstream fout("critice.out");
vector <int> G[1002];
int t[1002];
int n;
struct edge{
    int u,v,cap,f = 0;
    edge(int _u, int _v, int _cap){
        u = _u;
        v = _v;
        cap = _cap;
    }
};
vector <edge> edges;
vector <int> level;
vector <int> ptr;
queue <int> q;
bool uz[1002], v2[1002];
int bfs2(){
    q.push(1);
    uz[1] = 1;
    while(!q.empty()){
        for(auto x : G[q.front()]){
            if(!uz[edges[x].v] && edges[x].cap > edges[x].f){
                uz[edges[x].v] = 1;
                q.push(edges[x].v);
            }
        }
        q.pop();
    }
    return uz[n];
}
void bfs3(int start, bool v[]){
    q.push(start);
    v[start] = 1;
    while(!q.empty()){
        for(auto x : G[q.front()]){
            if(!v[edges[x].v] && edges[x ^ 1].cap > edges[x ^ 1].f){
                v[edges[x].v] = 1;
                q.push(edges[x].v);
            }
        }
        q.pop();
    }
}
bool bfs(){
    q.push(1);
    while(!q.empty()){
        int u = q.front();
        for(auto x : G[u]){
            if(edges[x].cap - edges[x].f < 1) continue;
            if(level[edges[x].v] != -1) continue;
            level[edges[x].v] = level[u] + 1;
            q.push(edges[x].v);
        }
        q.pop();
    }
    return level[n] != -1;
}
int dfs(int nod, int ftemp){
    if(!ftemp) return 0;
    if(nod == n) return ftemp;
    for(int &p = ptr[nod]; p < G[nod].size(); p++){
        int id = G[nod][p];
        int x = edges[id].v;
        if(level[nod] + 1 != level[x] || edges[id].cap - edges[id].f < 1) continue;
        int t = dfs(x, min(ftemp, edges[id].cap - edges[id].f));
        if(!t) continue;
        edges[id].f += t;
        edges[id ^ 1].f -= t;
        return t;
    }
    return 0;
}
int dinic(){
    int rez = 0;
    while(1){
        fill(level.begin(), level.end(), -1);
        level[1] = 0;
        if(!bfs()) break;
        fill(ptr.begin(), ptr.end(), 0);
        while(int t = dfs(1, 1e9)) rez += t;
    }
    return rez;
}
vector < pair <int, int> > e2;
vector <int> sol;
int main()
{
    int i,m,u,v,c,t = 0,k = 0;
    fin >> n >> m;
    for(i = 1; i <= m; i++){
        fin >> u >> v >> c;
        G[u].push_back(k);
        G[v].push_back(k + 1);
        edges.push_back(edge(u,v,c));
        edges.push_back(edge(v,u,c));
        k += 2;
        e2.push_back({u,v});
    }
    level.resize(n + 1);
    ptr.resize(n + 1);
    dinic();
    bfs2();
    bfs3(n, v2);
    for(i = 0; i < e2.size(); i++){
        auto x = e2[i];
        if((uz[x.first] & v2[x.second]) || (v2[x.first] & uz[x.second])){
            sol.push_back(i + 1);
            t++;
        }
    }
    fout << t << "\n";
    for(auto x : sol) fout << x << "\n";
    return 0;
}
/*
6 8
2 1 2
2 3 3
3 5 4
1 4 7
4 3 2
4 5 6
3 6 5
5 6 3
*/