#include <bits/stdc++.h>
#include <fstream>
 
using namespace std;
 
const int MAXN = 1000;
const int MAXM = 10001;
 
vector<int> G[MAXN + 1];
unordered_map<int, unordered_map<int, int>> capacity, flow; // O(E)
vector<vector<int>> muchii;
vector<int> in; // will initialize after reading N
vector<int> sol;
int N, M;
 
void readInput() {
    ifstream f("critice.in");
    f >> N >> M;
    // initialize 'in' to size N+1 (1-based nodes)
    in.assign(N+1, 0);
    for (int i = 0; i < M; i++) {
        int x, y, c;
        f >> x >> y >> c;
        G[x].push_back(y);
        G[y].push_back(x);
        muchii.push_back({x,y,c});
        capacity[x][y] += c; 
    }
    f.close();
}

 
bool bfs(int source, int sink, vector<int>& parent, vector<bool>& visited) {
    fill(visited.begin(), visited.end(), false);
    fill(parent.begin(), parent.end(), -1);
 
    queue<int> q;
    q.push(source);
    visited[source] = true;
 
    while (!q.empty()) {
        int u = q.front(); q.pop();
        if (u == sink) continue;   
 
        for (int v : G[u]) {
            if (!visited[v] && capacity[u][v] - flow[u][v] > 0) {
                visited[v] = true;
                parent[v] = u;
                q.push(v);
            }
        }
    }
    return visited[sink];
}
void sourcebf(int source, int sink)
{
    queue<int> q;
    q.push(source);
    in[source] = 1;
    while(!q.empty())
    {
        int curr = q.front();
        q.pop();
        for(int v: G[curr]){
            if(in[v] == 0 && capacity[curr][v] - flow[curr][v]>0)
                {
                    in[v] = 1;
                    q.push(v);
                }



        }
    }
}
 
void EdmondsKarpOptimizat(int source, int sink) {
    int maxFlow = 0;
    vector<int> parent(N + 1);
    vector<bool> visited(N + 1);
 
    while (bfs(source, sink, parent, visited)) {
 
        for (int v : G[sink]) {
            if (!visited[v]) continue;
            if (capacity[v][sink] - flow[v][sink] <= 0) continue;
 
            parent[sink] = v;
 
            int add = INT_MAX;
            for (int u = sink; u != source; u = parent[u]) {
                int p = parent[u];
                add = min(add, capacity[p][u] - flow[p][u]);
            }
 
            if (add == 0) continue;
 
            for (int u = sink; u != source; u = parent[u]) {
                int p = parent[u];
                flow[p][u] += add;
                flow[u][p] -= add;
            }
 
            maxFlow += add;
        }
    }
    sourcebf(1,N);
    for(int i =0;i<muchii.size();i++)
    {
        auto c = muchii[i];
        if(in[c[0]] == 1 && flow[c[0]][c[1]] == capacity[c[0]][c[1]] && !in[c[1]])
            sol.push_back(i+1);
        if(in[c[1]] == 1 && flow[c[1]][c[0]] == capacity[c[1]][c[0]] && !in[c[0]])
            sol.push_back(i+1);
    }




    
}
 
int main() {
    readInput();
 
    ofstream g("critice.out");
    EdmondsKarpOptimizat(1,N);
    g<<sol.size()<<'\n';
    for(auto idx : sol)
        g<<idx<<'\n';
 
    return 0;
}