#include <bits/stdc++.h>

using namespace std;

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

const int nmax = 1005;
int n, m, c[nmax][nmax], f[nmax][nmax], t[nmax];
bool viz[nmax], pot[nmax][2];
vector <int> G[nmax];

bool bfs(){
    memset(viz, 0, sizeof viz);
    queue <int> coada;
    coada.push(1);
    viz[1] = true;
    while (!coada.empty()){
        int nod = coada.front();
        coada.pop();
        if (nod == n) continue;
        for (auto it : G[nod]){
            if (viz[it] == true || f[nod][it] == c[nod][it]) continue;
            coada.push(it);
            viz[it] = true;
            t[it] = nod;
        }
    }
    return viz[n];
}

void idk(int nod, int tip){
    queue <int> coada;
    pot[nod][tip] = true;
    coada.push(nod);
    while (!coada.empty()){
        int nodulet = coada.front();
        coada.pop();
        for (auto it : G[nodulet]){
            if (pot[it][tip] == true || f[nodulet][it] == c[nodulet][it]) continue;
            coada.push(it);
            pot[it][tip] = true;
        }
    }
}

int main(){
    fin >> n >> m;
    vector <pair <int, int> > muchii;
    for (int i = 1; i <= m; ++i){
        int x, y, z;
        fin >> x >> y >> z;
        G[x].push_back(y);
        G[y].push_back(x);
        c[x][y] += z;
        c[y][x] += z;
        muchii.push_back({x, y});
    }
    int flow, fmin;
    for (flow = 0; bfs();){
        for (auto it : G[n]){
            if (!viz[it] || f[it][n] == c[it][n]) continue;
            fmin = 1e9;
            t[n] = it;
            for (int nod = n; nod != 1; nod = t[nod]){
                fmin = min(fmin, c[t[nod]][nod] - f[t[nod]][nod]);
            }
            if (fmin == 0) continue;
            for (int nod = n; nod != 1; nod = t[nod]){
                f[t[nod]][nod] += fmin;
                f[nod][t[nod]] -= fmin;
            }
            flow += fmin;
        }
    }
    idk(1, 0);
    idk(n, 1);
    vector <int> ans;
    for (int i = 0; i < m; ++i){
        int x = muchii[i].first, y = muchii[i].second;
        if (f[x][y] > 0){
            if (f[x][y] == c[x][y]){
                if (pot[x][0] && pot[y][1]){
                    ans.push_back(i + 1);
                }
            }
        }
        else{
            if (f[y][x] == c[y][x]){
                if (pot[y][0] && pot[x][1]){
                    ans.push_back(i + 1);
                }
            }
        }
    }
    fout << ans.size() << "\n";
    for (auto it : ans){
        fout << it << "\n";
    }
    fin.close();
    fout.close();
    return 0;
}