#include <bits/stdc++.h>

using namespace std;

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

const int MAXN = 1002;
const int INF  = 10002;


int N,M,nr,x,y,i,j;

int c[MAXN][MAXN],f[MAXN][MAXN],parent[MAXN],visited[MAXN],visited1[MAXN],visitedN[MAXN],critice[MAXN];
vector <int>G[MAXN],ANS;
vector <pair<int,int>> edges;

int BFS1()
{
    memset(parent,0,sizeof(parent));
    memset(visited,0,sizeof(visited));
    memset(critice,0,sizeof(critice));
    parent[1] = 1;
    critice[++critice[0]] = 1;

    for (i = 1; i <= critice[0]; i++)
    {
        int x = critice[i];
        for (auto elem : G[x])
            if (!visited[elem]&& c[x][elem] > f[x][elem])
                {
                    visited[elem] = 1;
                    parent[elem] = x;
                    critice[++critice[0]] = elem;

                }

    }

    return visited[N];

}

void DFS1(int node)
{
    visited1[node] = 1;
    for(auto x : G[node])
    {
        if(!visited1[x] && f[node][x]<c[node][x] && f[x][node]<c[x][node])
        {
            DFS1(x);
        }
    }
}
void DFSN(int node)
{
    visitedN[node] = 1;
    for(auto x : G[node])
    {
        if(!visitedN[x] && f[node][x]<c[node][x] && f[x][node]<c[x][node])
        {
            DFSN(x);
        }
    }
}


void maxflow()
{
    int fmin = 0;
    while (BFS1())
    {
        fmin=INF;
        for(auto x : G[N])
        if(visited[x])
        {
            fmin=c[x][N]-f[x][N];
            for(i=x;i>1;i=parent[i])
            {
                if(fmin > c[parent[i]][i]-f[parent[i]][i])
                    fmin=c[parent[i]][i]-f[parent[i]][i];
            }
            f[x][N]+=fmin;
            f[N][x]-=fmin;
            for(i=x;i>1;i=parent[i])
            {
                f[parent[i]][i]+=fmin;
                f[i][parent[i]]-=fmin;
            }
        }
    }
}
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();

    DFS1(1);
    DFSN(N);

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

}