# include <algorithm>
# include <cstdio>
# include <cstring>
# include <queue>
# include <vector>
using namespace std;

# define x first
# define y second

const char *FIN = "critice.in", *FOU = "critice.out";
const int MAX = 1005;

vector <int> sol;
vector < pair <int, int> > G[MAX];
int N, M, C[MAX][MAX], F[MAX][MAX], T[MAX], VIZ[MAX];

inline void getmin (int &a, int b) {
    a = a < b ? a : b;
}

void solve (int nod) {
    int viz[MAX]; queue <int> Q;
    memset (viz, 0, sizeof (viz)), viz[nod] = 1;
    for (Q.push (1); ! Q.empty (); Q.pop ()) {
        int X = Q.front ();
        for (typeof (G[0].end ()) i = G[X].begin (); i != G[X].end (); ++i) {
            if (viz[i -> x] == 0) {
                if (F[X][i -> x] == C[X][i -> x] || VIZ[i -> y] && F[i -> x][X] == C[i -> x][X]) {
                    if (VIZ[i -> y] == 0) VIZ[i -> y] = 1;
                    else                  sol.push_back (i -> y);
                } else {
                    viz[i -> x] = 1, Q.push (i -> x);
                }
            }
        }
    }
}

inline int bfs (void) {
    memset (T, -1, sizeof (T)), T[1] = 0;
    queue <int> Q;
    for (Q.push (1); ! Q.empty (); Q.pop ()) {
        int X = Q.front ();
        for (typeof (G[0].end ()) i = G[X].begin (); i != G[X].end (); ++i)
            if (T[i -> x] == -1 && F[X][i -> x] < C[X][i -> x])
                Q.push (i -> x), T[i -> x] = X;
    }
    return T[N] != -1;
}

int main (void) {
    freopen (FIN, "r", stdin);

    scanf ("%d %d", &N, &M);
    for (int i = 1, x, y, z; i <= M; ++i) {
        scanf ("%d %d %d", &x, &y, &z);
        C[x][y] = C[y][x] = z, G[x].push_back (make_pair (y, i)), G[y].push_back (make_pair (x, i));
    }
    for (; bfs ();) {
        for (typeof (G[0].end ()) i = G[N].begin (); i != G[N].end (); ++i)
            if (F[i -> x][N] < C[i -> x][N]) {
                int fmin = C[i -> x][N] - F[i -> x][N];
                for (int j = i -> x; T[j]; j = T[j])
                    getmin (fmin, C[T[j]][j] - F[T[j]][j]);
                F[i -> x][N] += fmin, F[N][i -> x] -= fmin;
                for (int j = i -> x; T[j]; j = T[j])
                    F[T[j]][j] += fmin, F[j][T[j]] -= fmin;
            }
    }
    solve (1), solve (N);
    sort (sol.begin (), sol.end ());

    freopen (FOU, "w", stdout);
    printf ("%d\n", sol.size ());
    for (size_t i = 0; i < sol.size (); ++i)
        printf ("%d\n", sol[i]);
}