#include <fstream>
#include <bitset>
#include <algorithm>
#include <cmath>
#include <stack>
#include <cstring>
#include <queue>
#define Nmax 1001
using namespace std;

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

typedef vector < int > VI;

int n, m, x, y, c;
bool E[Nmax], Fr1[Nmax], Fr2[Nmax];
int C[Nmax][Nmax], F[Nmax][Nmax], Dad[Nmax];
VI V[Nmax];
const int oo = 1 << 28;
queue < int > Q;

struct chestie{
    int x, y, c;
}M[Nmax * Nmax];

VI Ans;

bool BFS(int vertex){
    while(Q.size()) Q.pop();
    Q.push(vertex);
    memset(E, 0, sizeof(E));
    E[vertex] = 1;

    while(Q.size()){
        vertex = Q.front();
        Q.pop();

        if(vertex == n)
            break;

        for(int new_vertex : V[vertex])
            if(!E[new_vertex] && C[vertex][new_vertex] != F[vertex][new_vertex]){
                Dad[new_vertex] = vertex;
                E[new_vertex] = 1;
                Q.push(new_vertex);
            }
    }
    return E[n];
}

void DFS(int vertex, bool Fr[]){
    Fr[vertex] = 1;

    for(int new_vertex : V[vertex])
        if(!Fr[new_vertex] && C[vertex][new_vertex] > F[vertex][new_vertex] && C[new_vertex][vertex] > F[new_vertex][vertex])
            DFS(new_vertex, Fr);
}

int main() {
    fin >> n >> m;

    for(int i = 1; i <= m; ++i){
        fin >> x >> y >> c;

        V[x].push_back(y);
        V[y].push_back(x);

        C[x][y] += c;
        C[y][x] += c;

        M[i] = { x, y, c };
    }

    int flow = 0;

    while( BFS(1) )
        for(int vertex : V[n])
            if(E[vertex] && C[vertex][n] != F[vertex][n]) {
               Dad[n] = vertex;

               int fmin = oo;

               for(int i = n; i != 1; i = Dad[i])
                    fmin = min(fmin, C[Dad[i]][i] - F[Dad[i]][i]);

                for(int i = n; i != 1; i = Dad[i]){
                    F[Dad[i]][i] += fmin;
                    F[i][Dad[i]] -= fmin;
                }

                flow += fmin;
        }

    DFS(1, Fr1);
    DFS(n, Fr2);

    for(int i = 1; i <= m; ++i){
        int x = M[i].x;
        int y = M[i].y;

        if( ( Fr1[x] && Fr2[y] ) || ( Fr1[y] && Fr2[x] ) )
            Ans.push_back(i);
    }

    fout << Ans.size() << '\n';

    for(auto x : Ans)
        fout << x << '\n';

    return 0;
}