#include <iostream>
#include <fstream>
#include <vector>
#include <bitset>
#include <queue>
#include <algorithm>
using namespace std;

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

bitset<1005>viz;
bitset<10005>viz_muchii;
bitset<10005>viz_pe_dfs;
queue<int>q;
int n, m, a, b, c, rezidual[1005][1005], father[1005], mini, max_flow, nr;

struct drum{
    int to, ind;
};

vector<drum>graph[1005];
vector<int>rez;

bool bfs()
{
    viz.reset();
    viz[1]=1;
    q.push(1);
    while (!q.empty())
    {
        int nod=q.front();
        q.pop();
        if (nod==n)
            continue;
        for (auto &v:graph[nod])
        {
            if (!viz[v.to] && rezidual[nod][v.to])
            {
                viz[v.to]=1;
                father[v.to]=nod;
                q.push(v.to);
            }
        }
    }
    return viz[n];
}

void dfs(int ind)
{
    viz_pe_dfs[ind]=1;
    for (auto &v:graph[ind])
    {
        if (!viz_pe_dfs[v.to])
        {
            if (rezidual[ind][v.to]==0 && !viz_muchii[v.ind])
            {
                rez.push_back(v.ind);
                viz_muchii[v.ind]=1;
            }
            else
            {
                dfs(v.to);
            }
        }
    }
}

void solve()
{
    while (bfs())
    {
        for (auto &v:graph[n])
        {
            if (viz[v.to] && rezidual[v.to][n])
            {
                father[n]=v.to;
                mini=0x3f3f3f3f;
                for (int nod=n; nod!=1; nod=father[nod])
                {
                    if (rezidual[father[nod]][nod]<mini)
                        mini=rezidual[father[nod]][nod];
                }
                if (mini)
                {
                    for (int nod=n; nod!=1; nod=father[nod])
                    {
                        rezidual[father[nod]][nod]-=mini;
                        rezidual[nod][father[nod]]+=mini;
                    }
                    max_flow+=mini;
                }
            }
        }
    }
    dfs(1);
    viz_pe_dfs.reset();
    dfs(n);
    g << rez.size() << '\n';
    sort(rez.begin(),rez.end());
    for (int &v:rez)
        g << v << '\n';
}

int main()
{
    f >> n >> m;
    for (int i=1; i<=m; ++i)
    {
        f >> a >> b >> c;
        graph[a].push_back({b,i});
        graph[b].push_back({a,i});
        rezidual[a][b]=rezidual[b][a]=c;
    }
    solve();
    return 0;
}