#include <cstdio>
#include <vector>
#include <queue>
#include <bitset>
using namespace std;

const int NMAX = 1002, INFI = 32000;

vector <short> G[NMAX], ans;
vector <pair <short, short> > edges;
queue <short> Q;
bitset <NMAX> check, _check;
short flow[NMAX][NMAX], cap[NMAX][NMAX], T[NMAX], N;

inline bool BFS () {

    vector <short> :: iterator i;
    short node;
    check.reset ();
    check[1] = 1;
    for (Q.push (1); !Q.empty (); Q.pop ()) {
        node = Q.front ();
        if (node == N)
            continue;
        for (i = G[node].begin (); i != G[node].end (); ++i)
            if (!check[*i] && flow[node][*i] != cap[node][*i]) {
                check[*i] = 1;
                Q.push (*i);
                T[*i] = node;
            }
    }
    return check[N];

}

inline void max_flow () {

    vector <short> :: iterator i;
    short node, _min;
    while (BFS ())
        for (i = G[N].begin (); i != G[N].end (); ++i) {
            T[N] = *i;
            _min = INFI;
            for (node = N; node != 1; node = T[node])
                _min = min ((int)_min, cap[T[node]][node] - flow[T[node]][node]);
            for (node = N; node != 1; node = T[node]) {
                flow[T[node]][node] += _min;
                flow[node][T[node]] -= _min;
            }
        }
}

void DFS (const short &node) {

    check[node] = 1;
    for (vector <short> :: iterator i = G[node].begin (); i != G[node].end (); ++i)
        if (!check[*i] && max (flow[node][*i], flow[*i][node]) != cap[node][*i])
            DFS (*i);

}

void _DFS (const short &node) {

    _check[node] = 1;
    for (vector <short> :: iterator i = G[node].begin (); i != G[node].end (); ++i)
        if (!_check[*i] && max (flow[node][*i], flow[*i][node]) != cap[node][*i])
            _DFS (*i);

}

int main () {

    freopen ("critice.in", "r", stdin);
    freopen ("critice.out", "w", stdout);
    short M, a, b, c, s = 1;
    vector <pair <short, short> > :: iterator i;
    scanf ("%hd%hd", &N, &M);
    while (M--) {
        scanf ("%hd%hd%hd", &a, &b, &c);
        cap[a][b] = cap[b][a] = c;
        G[a].push_back (b);
        G[b].push_back (a);
        edges.push_back (make_pair (a, b));
    }
    max_flow ();
    check.reset ();
    DFS (1);
    _DFS (N);
    for (i = edges.begin (); i != edges.end (); ++i, ++s)
        if (check[i->first] && _check[i->second] || check[i->second] && _check[i->first])
            ans.push_back (s);
    printf ("%d", ans.size ());
    for (vector <short> :: iterator j = ans.begin (); j != ans.end (); ++j)
        printf ("\n%d", *j);

}