#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <cmath>
 #include <algorithm>
using namespace std;

int oo = 1 << 30, n;
vector<int> V[1105];
int c[1105][1105];
int f[1105][1105];
int prec[1105];

vector<int> aux;
queue<int> Q;

void bfs() {
    prec[1] = -1; Q.push(1);
    while(!Q.empty()) {
        int top = Q.front(); Q.pop();
        for(int i = 0; i < V[top].size(); i ++) {
            int cur = V[top][i];
            if(c[top][cur] > f[top][cur] && !prec[cur]) {
                prec[cur] = top;
                if(c[cur][n] > f[cur][n]) aux.push_back(cur);
                else Q.push(cur);
            }
        }
    }
}

vector< pair<int, int> > M;
void verif();
bool viz[1105];
bool viz2[1105];

int main()
{
    M.push_back(make_pair(0, 0));
    ifstream d("critice.in");
    ofstream g("critice.out");
    int m, x, y, z; d >> n >> m;
    for(int i = 1; i <= m; i ++) {
        d >> x >> y >> z;
        M.push_back(make_pair(x, y));
        V[x].push_back(y);
        V[y].push_back(x);
        c[x][y] = c[y][x] = z;
    }

    while(true) {
        bfs();
        if(!aux.size()) break;
        for(int i = 0; i < aux.size(); i ++) {
            int j = aux[i];
            int mn = c[j][n] - f[j][n];
            for(int l = j; prec[l] != -1; l = prec[l])
                mn = min(mn, c[prec[l]][l] - f[prec[l]][l]);

            f[j][n] += mn; f[n][j] -= mn;
            for(int l = j; prec[l] != -1; l = prec[l])
                f[prec[l]][l] += mn, f[l][prec[l]] -= mn;
        }
        for(int i = 1; i <= n; i ++) prec[i] = 0;
        while(!aux.empty()) aux.pop_back();
    }

    while(!aux.empty()) aux.pop_back();
    verif();
    for(int i = 1; i <= m; i ++)
        if(c[ M[i].first ][ M[i].second ] == abs(f[ M[i].first ][ M[i].second ]) &&
           ((viz[M[i].first] && viz2[M[i].second]) || (viz[M[i].second] && viz2[M[i].first]))) aux.push_back(i);
    g << aux.size() << "\n";
    for(int i = 0; i < aux.size(); i ++) g << aux[i] << "\n";
    return 0;
}

void DFS(int node);
void DFS2(int node);
void verif() {
    DFS(1);
    DFS2(n);
}

void DFS(int node) {
    viz[node] = true;
    for(int i = 0; i < V[node].size(); i ++) {
        int now = V[node][i];
        if(!viz[now] && c[node][now] > f[node][now]) DFS(now);
    }
}

void DFS2(int node) {
    viz2[node] = true;
    for(int i = 0; i < V[node].size(); i ++) {
        int now = V[node][i];
        if(!viz2[now] && c[now][node] > f[now][node]) DFS2(now);
    }
}