#include <bits/stdc++.h>
#define node1 first
#define node2 second

using namespace std;

class Graph{
    int source, dest, n;
    vector < vector <int> > capacity;
    vector < vector <int> > adj;
    vector <int> parent;
    vector <bool> vis1;
    vector <bool> vis2;
    vector <pair <int, int>> edges;

    bool bfs(int src, int dst, vector <bool>& vis) {
        fill(vis.begin(), vis.end(), false);

        int node = src;
        vis[node] = true;
        queue <int> q;
        q.push(node);

        while (!q.empty()) {
            node = q.front();
            q.pop();

            if (node == dst) continue;

            for (auto& it : adj[node])
                if (!vis[it] and capacity[node][it]) {
                    vis[it] = true;
                    parent[it] = node;
                    q.push(it);
                }
        }

        return vis[dst];
    }

    int max_flow() {
        int maxflow = 0;

        while (bfs(source, dest, vis1)) {
            for (auto& it : adj[dest]) 
                if (vis1[it] and capacity[it][dest]) {
                    parent[dest] = it;
                    int flow = INT_MAX;

                    for (int node = dest; node != source; node = parent[node]) 
                        flow = min(flow, capacity[parent[node]][node]);

                    for (int node = dest; node != source; node = parent[node]) {
                        capacity[parent[node]][node] -= flow;
                        capacity[node][parent[node]] += flow;
                    }

                    maxflow += flow;
                }
        }

        return maxflow;
    }

public:
    Graph(int _n, int _source, int _dest) : n(_n), source(_source), dest(_dest) {
        adj.resize(n + 1);
        capacity.resize(n + 1);
        for (auto& line : capacity)
            line.resize(n + 1);
        parent.resize(n + 1);
        vis1.resize(n + 1);
        vis2.resize(n + 1);
    }

    void add_edge(int node1, int node2, int cap) {
        adj[node1].push_back(node2);
        adj[node2].push_back(node1);
        capacity[node1][node2] = capacity[node2][node1] = cap;
        edges.push_back({node1, node2});
    }

    vector <int> critice() {
        max_flow();
        bfs(source, dest, vis1);
        bfs(dest, source, vis2);
        
        vector <int> ans;

        for (int i = 0; i < edges.size(); ++i) {
            auto edge = edges[i];
            if (capacity[edge.node1][edge.node2] == 0 or capacity[edge.node2][edge.node1] == 0) {
                if (vis1[edge.node1] and vis2[edge.node2])
                    ans.push_back(i + 1);
                else if (vis2[edge.node1] and vis1[edge.node2])
                    ans.push_back(i + 1);
            }
        }

        return ans;
    }
};

int main() {
    ifstream cin("critice.in");
    ofstream cout("critice.out");
    // ifstream cin("input.txt");
    // ofstream cout("output.txt");

    int n, m;
    cin >> n >> m;
    Graph G(n, 1, n);

    for (int i = 1; i <= m; ++i) {
        int x, y, z;
        cin >> x >> y >> z;
        G.add_edge(x, y, z);
    }

    auto ans = G.critice();   
    cout << ans.size() << '\n';
    for (auto& it : ans)
        cout << it << '\n';

    return 0;
}