#include <fstream>
#include <vector>
#include <bitset>
#include <queue>
#include <cmath>

#define oo 0x3f3f3f3f
#define NMAX 1005
using namespace std;

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

struct muchie{
    int x, y, i;
};
int n, m, x, y, c;
int cap[NMAX][NMAX], flow[NMAX][NMAX];
int tati[NMAX];
int viz1[NMAX], viz2[NMAX];

vector<int>graph[NMAX];
vector<muchie>edges;
vector<int>sol;
queue<int>Q;
bitset<NMAX>viz;

void citire(){
    f>>n>>m;
    for(int i=1; i<=m; i++){
        f>>x>>y>>c;
        graph[x].push_back(y);
        graph[y].push_back(x);
        edges.push_back({x, y, i});
        cap[x][y] = cap[y][x] = c;
    }
}
bool bfs(){
    viz.reset();

    Q.push(1);
    viz[1] = true;
    while(!Q.empty()){
        int el = Q.front();
        Q.pop();

        if(el == n)
            continue;
        for(auto &v:graph[el])
            if(viz[v] == false && cap[el][v] > flow[el][v]){
                viz[v] = true;
                tati[v] = el;
                Q.push(v);
            }
    }
    return viz[n];
}
void Edmond_Karp(){
    while(bfs()){
        for(auto v:graph[n]){
            if(!viz[v] || cap[v][n] == abs(flow[v][n]))
                continue;
            int maxFlow = oo;
            tati[n] = v;
            for(int i=n; i>1; i=tati[i])
                maxFlow = min(maxFlow, cap[tati[i]][i] - flow[tati[i]][i]);

            if(maxFlow == 0)
                continue;

            for(int i=n; i>1; i=tati[i]){
                flow[tati[i]][i] += maxFlow;
                flow[i][tati[i]] -= maxFlow;
            }
        }
    }
}


void BFS1(){
    queue<int> Q;
    Q.push(1);
    viz1[1] = 1;

    while(!Q.empty()){
        int nod = Q.front();
        Q.pop();

        for(auto v:graph[nod]){
            if(!viz1[v] && flow[v][nod] < cap[v][nod]){
                viz1[v] = 1;
                Q.push(v);
            }
        }
    }
}


void BFS2(){
    queue<int> Q;
    Q.push(1);
    viz2[1] = 1;

    while(!Q.empty()){
        int nod = Q.front();
        Q.pop();

        for(auto v:graph[nod]){
            if(!viz2[v] && -flow[nod][v] < cap[nod][v]){
                viz2[v] = 1;
                Q.push(v);
            }
        }
    }
}

void solve(){

    for(auto v:edges)
    {
        x = v.x;
        y = v.y;

        if(abs(flow[x][y]) == cap[x][y] && (viz1[x] && viz2[y]) || (viz2[x] && viz1[y])){
            sol.push_back(v.i);
        }
    }
}

void afisare(){
    g<<sol.size()<<'\n';
    for(auto v:sol){
        g<<v<<'\n';
    }
}
int main()
{
    citire();
    Edmond_Karp();
    BFS1();
    BFS2();
    solve();
    afisare();

    return 0;
}