#include <cstdio>
#include <cassert>
#include <algorithm>
#include <vector>
#include <list>
#include <queue>
#include <cstdlib>
#include <cstring>
using namespace std;
#define _submit
#ifdef _submit
#define InFile "critice.in"
#define OtFile "critice.out"
#else
#define InFile "fis.in"
#define OtFile "fis.out"
#endif
 
class edge {
private:
    int toNod, flow, capacity, ID;
    edge* dup;
    edge(int n1, int n2, int cap, int nr) {
        toNod = n2;
        capacity = cap;
        flow = 0;
        ID = nr;
    }
    void assignDup(edge *E) {
        dup = E;
    }
    bool isSaturated() {
        return (capacity - flow == 0) || (capacity + flow == 0);
    }
    friend class graph;
};
 
class graph {
private:
    vector< list<edge> > adiac;
    int edgeCounter;
public:
    graph(int nrNod) {
        adiac.resize(nrNod);
        edgeCounter = 0;
    }
    void newEdge(int n1, int n2, int cap) {
        adiac[n1].push_back(edge(n1, n2, cap, edgeCounter));
        adiac[n2].push_back(edge(n2, n1, cap, edgeCounter));
        adiac[n1].back().assignDup(&adiac[n2].back());
        adiac[n2].back().assignDup(&adiac[n1].back());
        edgeCounter++;
    }
    int sendFlows(vector<int>& parent, vector<int>& capToParent, vector<int*>& flowToParent, vector<int*>& flowToParentDup, queue<int>& Q) {
        while (!Q.empty())
            Q.pop();
        int endNod = adiac.size() - 1;
        int s = 0;
        memset(&parent[0], 0xFF, parent.size() * sizeof(parent[0]));
        Q.push(0);
        parent[0] = -2;
        while (!Q.empty()) {
            int t = Q.front();
            Q.pop();
            for (auto i = adiac[t].begin(); i != adiac[t].end(); ++i) {
                if (parent[i->toNod] != -1 || i->capacity - i->flow == 0)
                    continue;
                if (i->toNod == endNod) {
                    int M = i->capacity - i->flow;
                    int curNod = t;
                    while (parent[curNod] != -2) {
                        int availableFlow = capToParent[curNod] - *flowToParent[curNod];
                        if (!availableFlow)
                            break;
                        if (availableFlow < M)
                            M = availableFlow;
                        curNod = parent[curNod];
                    }
                    if (parent[curNod] != -2)
                        continue;
 
                    i->flow += M;
                    i->dup->flow -= M;
                    curNod = t;
                    while (parent[curNod] != -2) {
                        *flowToParent[curNod] += M;
                        *flowToParentDup[curNod] -= M;
                        curNod = parent[curNod];
                    }
                    s += M;
                }
                else {
                    int curNod = i->toNod;
                    parent[curNod] = t;
                    capToParent[curNod] = i->capacity;
                    flowToParent[curNod] = &i->flow;
                    flowToParentDup[curNod] = &i->dup->flow;
                    Q.push(curNod);
                }
            }
        }
        return s;
    }
    int EdmondsKarp() {
        int s = 0;
        vector<int> parent(adiac.size());
        vector<int> capToParent(adiac.size());
        vector<int*> flowToParent(adiac.size());
        vector<int*> flowToParentDup(adiac.size());
        queue<int> Q;
        while (true) {
            int res = sendFlows(parent, capToParent, flowToParent, flowToParentDup, Q);
            if (!res)
                break;
            s += res;
        }
        return s;
    }
    void DFSnesaturat(int nod, vector<char>& visited) {
        visited[nod] = 1;
        for (auto i = adiac[nod].begin(); i != adiac[nod].end(); ++i)
        if (!visited[i->toNod] && !i->isSaturated())
            DFSnesaturat(i->toNod, visited);
    }
    void getCriticalEdges(vector<int>& sol) {
        EdmondsKarp();
        vector<char> reachableFromSource(adiac.size(), 0);
        DFSnesaturat(0, reachableFromSource);
        vector<char> reachableFromSink(adiac.size(), 0);
        DFSnesaturat(adiac.size() - 1, reachableFromSink);
        int n1, n2;
        for (auto i = adiac.begin(); i != adiac.end(); ++i)
        for (auto j = i->begin(); j != i->end(); ++j) {
            n1 = distance(adiac.begin(), i);
            n2 = j->toNod;
            if (j->ID >= 0 && j->isSaturated() && ((reachableFromSink[n1] && reachableFromSource[n2]) || (reachableFromSink[n2] && reachableFromSource[n1]))) {
                sol.push_back(j->ID);
                j->dup->ID = -1;
            }
        }
    }
};
 
int main() {
    assert(freopen(InFile, "r", stdin));
    assert(freopen(OtFile, "w", stdout));
    int N, M;
    scanf("%d%d", &N, &M);
    graph G(N);
    for (int i = 0; i < M; i++) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        G.newEdge(a - 1, b - 1, c);
    }
    vector<int> sol;
    sol.reserve(M);
    G.getCriticalEdges(sol);
    printf("%d\n", sol.size());
    for (auto i = sol.begin(); i != sol.end(); ++i)
        printf("%d\n", (*i) + 1);
    return 0;
}