#include <fstream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <iomanip>

#define NMax 1005
#define INF 0x3f3f3f3f
using namespace std;

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

struct muchie{
    int x,y;
}M[NMax * 10];

int n,m,x,y,w,F,nr;

int VIZ[NMax],tata[NMax],viz[NMax],vizu[NMax],vizd[NMax];

int c[NMax][NMax],f[NMax][NMax];

vector<int> G[NMax];

vector<int> sol;

queue<int> q;

int bfs(){
    memset(viz,0,sizeof(viz));
    while(!q.empty())
        q.pop();
    q.push(1);
    viz[1] = 1;
    tata[1] = 0;

    while(!q.empty()){
        int nod = q.front();
        q.pop();
        if(nod == n)
            continue;
        for(int i = 0; i < G[nod].size(); ++i){
            int V = G[nod][i];
            if(!viz[V] && c[nod][V] != f[nod][V]){
                viz[V] = 1;
                q.push(V);
                tata[V] = nod;
            }
        }
    }
    return viz[n];
   /* while(!q.empty())
        q.pop();    */

}
void bfs(int k,int viz[NMax]){
    q.push(k);
    viz[k] = 1;

    while(!q.empty()){
        int nod = q.front();
        q.pop();
        for(int i = 0; i < G[nod].size(); ++i){
            int V = G[nod][i];
            if(!viz[V] && c[nod][V] != f[nod][V] && c[V][nod] != f[V][nod]){
                viz[V] = 1;
                q.push(V);
            }
        }
    }
}
int main()
{
    t >> n >> m;
    for(int i = 1; i <= m; ++i){
        t >> x >> y >> w;
        c[x][y] = w;
        c[y][x] = w;
        G[x].push_back(y);
        G[y].push_back(x);
        M[++nr].x = x;
        M[nr].y = y;
    }

    while(bfs()){
        for(int i = 0; i < G[n].size(); ++i){
            int V = G[n][i];
            if(!viz[V] || c[G[n][i]][n] == f[G[n][i]][n])
                continue;
            int fm = INF;
            for(int nod = V; nod != 1; nod = tata[nod]){
                fm = min(fm, c[tata[nod]][nod] - f[tata[nod]][nod]);
            }
            for(int nod = V; nod != 1; nod = tata[nod]){
                f[tata[nod]][nod] += fm;
                f[nod][tata[nod]] -= fm;
            }
            F += fm;
        }
    }
    bfs(1,vizu);
    bfs(n,vizd);
    for(int i = 1; i <= nr; ++i){
        if((vizu[M[i].x] && vizd[M[i].y]) || (vizu[M[i].y] && vizd[M[i].x])){
            sol.push_back(i);
        }
    }
    g << sol.size() << '\n';
    for(int i = 0; i < sol.size(); ++i){
        g << sol[i] << '\n';
    }
  //  g << F;
    return 0;
}