// Dinic O(V^2 * E)
#include <bits/stdc++.h>
#define ll long long

using namespace std;

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

struct Edge {
    int from;
    int to;
    ll cap;
    ll flow;
    int id;

    Edge(int x, int y, ll c, int i) : from(x), to(y), cap(c), flow(0), id(i) {}

    ll resCap() {
        return cap - flow; // residual capacity
    }
};

struct DinicMaxFlow {
    const ll inf = 1e18;
    int source;
    int sink;
    vector<Edge> edges;
    vector<vector<int> > v;
    vector<int> seen;
    vector<int> level;
    vector<int> lst;
    int N;
    int M;

    DinicMaxFlow(int s, int d, int n) : source(s), sink(d), v(n), seen(n), level(n), lst(n), N(n), M(0) {}

    void addEdge(int from, int to, ll cap, int id) {
        edges.push_back(Edge(from, to, cap, id));
        edges.push_back(Edge(to, from, 0, id));
        v[from].push_back(M++);
        v[to].push_back(M++);
    }

    // the layered network has no cycles obv
    bool canPush() {
        queue<int> q;
        fill(level.begin(), level.end(), -1);
        
        level[source] = 0;
        q.push(source);

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

            if (node == sink) {
                return true;
            }

            for (auto edgeId : v[node]) {
                int nxt = edges[edgeId].to;

                if (level[nxt] == -1) {
                    if (edges[edgeId].resCap() > 0) {
                        level[nxt] = level[node] + 1;
                        q.push(nxt);
                    }
                }
            }
        }
        
        return false;
    }

    ll push(int node, ll pushedFlow) {
        if (pushedFlow == 0) {
            return 0;
        }

        if (node == sink) {
            return pushedFlow;
        }

        for (; lst[node] < (int) v[node].size(); lst[node]++) { // nu trecem printr-o muchie de mai multe ori
            int edgeId = v[node][lst[node]];
            int nxt = edges[edgeId].to;
            auto resCap = edges[edgeId].resCap();

            if (level[node] + 1 != level[nxt] || resCap <= 0) {
                continue;
            }

            auto flow = push(nxt, min(pushedFlow, resCap));
            if (flow == 0) {
                continue;
            }

            edges[edgeId].flow += flow;
            edges[edgeId ^ 1].flow -= flow;
            
            return flow;
        }

        return 0;
    }   

    ll maxFlow() {
        ll flow = 0;
        while (canPush()) {
            fill(lst.begin(), lst.end(), 0);

            while (auto pushedFlow = push(source, inf)) {
                flow += pushedFlow;
            }
        }

        return flow;
    }

    void solve() {
        maxFlow();
        vector<int> sol;

        for (int i = 0; i < M; i += 4) {
            edges[i].cap++;
            edges[i + 2].cap++;

            if (canPush()) {
                sol.push_back(edges[i].id);
            }

            edges[i].cap--;
            edges[i + 2].cap--;
        }

        out << sol.size() << '\n';
        for (auto i : sol) {
            out << i << '\n';
        }
    }
};

int main() {
    int n, m;
    in >> n >> m;
    DinicMaxFlow graph(0, n - 1, n);

    for (int i = 1, x, y, c; i <= m; i++) {
        in >> x >> y >> c;
        x--;
        y--;
        graph.addEdge(x, y, c, i);
        graph.addEdge(y, x, c, i);
    }

    graph.solve();
 
    return 0;
}