#include <fstream>
#include <vector>
#include <queue>

#include <cstring>
using namespace std;

const int MAX_N = 1002;
const int INF = 0x3f3f3f3f;

int N, M, MaxFlow, sol;
int Capacity[MAX_N][MAX_N], Flow[MAX_N][MAX_N], F[MAX_N], A[MAX_N][2];
vector < int > v[MAX_N];
queue < int > Q;
bool G[MAX_N][2];

inline bool BFS(int st, int end) {
    memset(F, 0, sizeof(F));
    F[st] = st;
    Q.push(st);
    while(!Q.empty()) {
        int x = Q.front();
        Q.pop();
        if(x == end)
            continue;
        for(size_t i = 0; i < v[x].size(); ++i) {
            int y = v[x][i];
            if(F[y] || Flow[x][y] >= Capacity[x][y])
                continue;
            F[y] = x, Q.push(y);
        }
    }
    return (F[end] != 0);
}

int main() {
    ifstream f("critice.in");
    ofstream g("critice.out");

    f >> N >> M;
    for(int i = 1, x, y, c; i <= M; ++i) {
        f >> x >> y >> c;
        v[x].push_back(y), v[y].push_back(x);
        Capacity[x][y] += c, Capacity[y][x] += c;
        A[i] = {x, y};
    }

    while(BFS(1, N)) {
        for(size_t i = 0; i < v[N].size(); ++i) {
            int y = v[N][i];
            if(!F[y] || Capacity[y][N] <= Flow[y][N])
                continue;
            F[N] = y;
            int MinFlow = INF;
            for(int x = N; x != 1; x = F[x])
                MinFlow = min(MinFlow, Capacity[F[x]][x] - Flow[F[x]][x]);
            for(int x = N; x != 1; x = F[x])
                Flow[F[x]][x] += MinFlow, Flow[x][F[x]] = -Flow[F[x]][x];
            MaxFlow += MinFlow;
        }
    }

    memset(F, 0, sizeof(F));
    F[1] = 1, Q.push(1);
    G[1][0] = true;
    while(!Q.empty()) {
        int x = Q.front();
        Q.pop();
        for(size_t i = 0; i < v[x].size(); ++i) {
            int y = v[x][i];
            if(!F[y] && Flow[x][y] < Capacity[x][y])
                F[y] = x, Q.push(y), G[y][0] = true;
        }
    }

    memset(F, 0, sizeof(F));
    F[N] = N, Q.push(N);
    G[N][1] = true;
    while(!Q.empty()) {
        int x = Q.front();
        Q.pop();
        for(size_t i = 0; i < v[x].size(); ++i) {
            int y = v[x][i];
            if(!F[y] && Flow[x][y] < Capacity[x][y])
                F[y] = x, Q.push(y), G[y][1] = true;
        }
    }
    for(int i = 1; i <= M; ++i)
        if(Flow[A[i][0]][A[i][1]] == Capacity[A[i][0]][A[i][1]]) {
            if((G[A[i][0]][0] && G[A[i][1]][1]) || (G[A[i][1]][0] && G[A[i][0]][1]))
                ++sol;
        }
        else {
            swap(A[i][0], A[i][1]);
            if((G[A[i][0]][0] && G[A[i][1]][1]) || (G[A[i][1]][0] && G[A[i][0]][1]))
                ++sol;
        }



    g << sol << "\n";
    for(int i = 1; i <= M; ++i)
        if(Flow[A[i][0]][A[i][1]] == Capacity[A[i][0]][A[i][1]])
            if((G[A[i][0]][0] && G[A[i][1]][1]) || (G[A[i][1]][0] && G[A[i][0]][1]))
                g << i << "\n";

    f.close();
    g.close();

    return 0;
 }