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

using namespace std;

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

const int NMAX = 1005;

struct Edge {
    int u, v, id;
};

int n, m;
int capacity[NMAX][NMAX];
vector<int> adj[NMAX];
vector<Edge> edges;
int parent[NMAX];
bool visited[NMAX];

void readInput() {
    fin >> n >> m;
    for (int i = 1; i <= m; ++i) {
        int u, v, c;
        fin >> u >> v >> c;
        adj[u].push_back(v);
        adj[v].push_back(u);
        capacity[u][v] += c;
        capacity[v][u] += c;
        edges.push_back({u, v, i});
    }
}

int bfs_flow(int s, int d) {
    fill(parent, parent + n + 1, -1);
    parent[s] = -2;
    queue<pair<int, int>> q;
    q.push({s, 2000000000});

    while (!q.empty()) {
        int u = q.front().first;
        int flow = q.front().second;
        q.pop();

        for (int v : adj[u]) {
            if (parent[v] == -1 && capacity[u][v] > 0) {
                parent[v] = u;
                int new_flow = min(flow, capacity[u][v]);
                if (v == d) return new_flow;
                q.push({v, new_flow});
            }
        }
    }
    return 0;
}

void edmonds_karp(int s, int d) {
    int flow;
    while (flow = bfs_flow(s, d)) {
        int curr = d;
        while (curr != s) {
            int prev = parent[curr];
            capacity[prev][curr] -= flow;
            capacity[curr][prev] += flow;
            curr = prev;
        }
    }
}

void bfs_min_cut(int s) {
    fill(visited, visited + n + 1, false);
    queue<int> q;
    q.push(s);
    visited[s] = true;

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int v : adj[u]) {
            if (!visited[v] && capacity[u][v] > 0) {
                visited[v] = true;
                q.push(v);
            }
        }
    }
}

int main() {
    readInput();
    edmonds_karp(1, n);
    bfs_min_cut(1);

    vector<int> result;
    for (const auto& e : edges) {
        if (visited[e.u] != visited[e.v]) {
            result.push_back(e.id);
        }
    }

    sort(result.begin(), result.end());

    gout << result.size() << '\n';
    for (int id : result) {
        gout << id << '\n';
    }

    return 0;
}