#include <fstream>
#include <vector>
#include <queue>
#include <climits>

#define Nmax 1002

using namespace std;

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

int n, m, s, d;
vector<int> G[Nmax];
int r[Nmax][Nmax], dad[Nmax], mat[Nmax][Nmax];
vector<int> sol;
bool visited[2][Nmax];
queue<int> q;

bool bfs() {
    for(int i = 1; i <= n; ++i)
        dad[i] = 0;
    dad[s] = s;
    q.push(s);
    while(!q.empty()) {
        int node = q.front();
        q.pop();
        for(int son : G[node]) {
            if(!r[node][son] || dad[son]) continue;
            dad[son] = node;
            if(son != d) q.push(son);
        }
    }
    return dad[d] != 0;
}

void dfs(int node, int dir) {
    for(int son : G[node])
        if(r[node][son] > 0 && r[son][node] > 0 && !visited[dir][son]) {
            visited[dir][son] = true;
            dfs(son, dir);
        }
}

void flow() {
    while(bfs()) {
        for(auto node : G[d])
            if(dad[node]) {
                dad[d] = node;
                int pathFlow = INT_MAX;
                node = d;
                while(node != s) {
                    pathFlow = min(pathFlow, r[dad[node]][node]);
                    node = dad[node];
                }
                node = d;
                while(node != s) {
                    r[dad[node]][node] -= pathFlow;
                    r[node][dad[node]] += pathFlow;
                    node = dad[node];
                }
            }
    }
}

void solve() {
    visited[0][1] = true;
    dfs(1, 0);
    visited[1][n] = true;
    dfs(n, 1);
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= n; ++j)
            if(!r[i][j] && mat[i][j] && ((visited[0][i] && visited[1][j]) || (visited[1][i] && visited[0][j])))
                sol.push_back(mat[i][j]);
    fout << sol.size() << '\n';
    for(auto edge : sol)
        fout << edge << '\n';
}

int main() {
    int x, y, c;
    fin >> n >> m;

    for(int i = 1; i <= m; ++i) {
        fin >> x >> y >> c;
        r[x][y] = r[y][x] = c;
        mat[x][y] = mat[y][x] = i;
        G[x].push_back(y), G[y].push_back(x);
    }
    s = 1, d = n;

    flow();
    solve();
}