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

using namespace std;
ifstream in("critice.in");
ofstream out("critice.out");

#define pb push_back
const int NMax = 1e3 + 5;
const int MMax = 1e4 + 5;
const int inf = 2e9 + 5;

int N,M;
int cap[NMax][NMax],dad[NMax];
bool viz[NMax],canReachfromSource[NMax],canReachfromSink[NMax];
vector<int> v[NMax];

struct elem {
    int x,y,id;
    elem(int _x = 0,int _y = 0,int _id = 0) {
        x = _x; y = _y; id = _id;
    }
};
vector<elem> muchii;
vector<int> sol;

bool bfs();
void afterBfs(int,bool*);

int main() {
    in>>N>>M;
    for (int i=1;i<=M;++i) {
        int x,y,c;
        in>>x>>y>>c;

        cap[x][y] = cap[y][x] = c;
        muchii.pb(elem(x,y,i));
        v[x].pb(y);
        v[y].pb(x);
    }

    int maxFl = 0;
    while (bfs()) {

        for (int k=0;k < (int)v[N].size();++k) {
            int pre = v[N][k];
            if (!viz[pre] || !cap[pre][N]) {
                continue;
            }

            dad[N] = pre;
            int nod = N,mnCap = inf;
            while (nod != 1) {
                mnCap = min(mnCap,cap[dad[nod]][nod]);
                nod = dad[nod];
            }

            if (!mnCap) {
                continue;
            }

            nod = N;
            while (nod != 1) {
                cap[dad[nod]][nod] -= mnCap;
                cap[nod][dad[nod]] += mnCap;
                nod = dad[nod];
            }

            maxFl += mnCap;
        }
    }
    //cout<<maxFl<<'\n';

    //*
    //afterBfs(1,canReachfromSource);
    afterBfs(N,canReachfromSink);

    for (int k=0;k < (int)muchii.size();++k) {
        int x = muchii[k].x;
        int y = muchii[k].y;
        if ( (cap[x][y] == 0 && viz[x] && canReachfromSink[y]) ||
             (cap[y][x] == 0 && viz[y] && canReachfromSink[x])    ) {

            sol.pb(muchii[k].id);
            //cout<<muchii[k].id<<'\n';
        }
    }

    out<<sol.size()<<'\n';
    sort(sol.begin(),sol.end());
    for (int k=0;k <(int)sol.size();++k) {
        out<<sol[k]<<'\n';
    }
    //*/

    in.close();out.close();
    return 0;
}

bool bfs() {
    for (int i=2;i<=N;++i) {
        viz[i] = false;
    }
    viz[1] = true;
    queue<int> Q;
    Q.push(1);
    bool reachedN = false;
    while (Q.size()) {
        int nod = Q.front();
        Q.pop();
        if (nod == N) {
            reachedN = true;
            continue;
        }

        for (int k=0;k < (int)v[nod].size();++k) {
            int next = v[nod][k];
            if (viz[next] || !cap[nod][next]) {
                continue;
            }

            viz[next] = true;
            dad[next] = nod;
            Q.push(next);
        }
    }
    return reachedN;
}

void afterBfs(int source,bool* canReach) {

    canReach[source] = true;
    queue<int> Q;
    Q.push(source);
    while (Q.size()) {
        int nod = Q.front();
        Q.pop();

        for (int k=0;k < (int)v[nod].size();++k) {
            int next = v[nod][k];
            if (canReach[next] || !cap[nod][next]) {
                continue;
            }

            canReach[next] = true;
            Q.push(next);
        }
    }
}