#include <bits/stdc++.h>

using namespace std;

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

const int MAXN = 1001;
const int INF  = 10001;

int N,M,x,y,i,j;
int c[MAXN][MAXN],f[MAXN][MAXN],parent[MAXN],visited1[MAXN],visited2[MAXN],critice[MAXN];

vector <int>G[MAXN],ANS;
vector <pair<int,int>> edges;

inline int abs(int a)
{
    if(a<0)
        return -a;
    return a;
}

int BFS1()
{
    memset(parent,0,sizeof(parent));

    parent[1] = 1;
    critice[0] = 1;
    critice[1] = 1;

    for (j = 1; j <= critice[0]; j++)
    {
        int x = critice[j];
        for (int i = 0; i < G[x].size(); i++)
            if (parent[G[x][i]] == 0 && c[x][G[x][i]] > f[x][G[x][i]])
                {
                    parent[G[x][i]] = x;
                    critice[++critice[0]] = G[x][i];
                }
        if (parent[N])
        return 1;
    }

    return 0;
}

void BFS2(int start,int visited[])
{
    memset(visited,0,sizeof(visited));
    critice[0] = 1;
    critice[1] = start;
    visited[start] = 1;

    for (j = 1; j <= critice[0]; j++ )
    {
        int x = critice[j];
        for (i = 0; i < G[x].size(); i++)
            if (!visited[G[x][i]] && abs(f[x][G[x][i]]) < c[x][G[x][i]])
            {
                visited[G[x][i]] = 1;
                critice[++critice[0]] = G[x][i];
            }
    }
}

void maxflow()
{
    int fmin = 0;
    while (BFS1())
    {
        fmin = INF;
        x = N;
        while (x != 1)
        {
            if(fmin > c[parent[x]][x]-f[parent[x]][x])
                fmin = c[parent[x]][x]-f[parent[x]][x];
            x = parent[x];
        }
        x = N;
        while (x != 1)
        {
            f[parent[x]][x] += fmin;
            f[x][parent[x]] -= fmin;
            x = parent[x];
        }

    }
}

int main()
{

    in>>N>>M;
    for (i = 1; i <= M; i++)
    {
        int x,y,cost;
        in>>x>>y>>cost;
        G[x].push_back(y);
        G[y].push_back(x);

        c[x][y] = cost;
        c[y][x] = cost;
        edges.push_back(make_pair(x,y));
    }

    maxflow();

    BFS2(1,visited1);
    BFS2(N,visited2);

    for (i = 0; i < M; i++)
        {
            x = edges[i].first;
            y = edges[i].second;
            if ( visited1[x] && visited2[y] || visited1[y] && visited2[x])
                ANS.push_back(i+1);
        }
    out<<ANS.size()<<"\n";
    for (i = 0; i <ANS.size(); i++)
        {
            out<<ANS[i]<<"\n";
        }
    return 0;
}