#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;

bool ok1[10005], ok2[10005];

struct drum
{
    int to, ind;
};

struct d{
    int a, b;
}drumuri[10005];

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, bool ok[])
{
    viz_pe_dfs[ind]=1;
    ok[ind]=1;
    for (auto &v:graph[ind])
    {
        if (!viz_pe_dfs[v.to])
        {
            if (rezidual[ind][v.to]==0)
            {
                if (!viz_muchii[v.ind])
                {
                    rez.push_back(v.ind);
                    viz_muchii[v.ind]=1;
                }
            }
            else
            {
                dfs(v.to, ok);
            }
        }
    }
}

void alt_bfs(int ind, bool ok[])
{
    viz_pe_dfs[ind]=1;
    q.push(ind);
    ok[ind]=1;
    while (!q.empty())
    {
        int nod=q.front();
        q.pop();
        for (auto &v:graph[nod])
        {
            if (!viz_pe_dfs[v.to] && rezidual[nod][v.to])
            {
                q.push(v.to);
                viz_pe_dfs[v.to]=1;
                ok[v.to]=1;
            }
        }
    }
}

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;
                }
            }
        }
    }
    alt_bfs(1,ok1);
    viz_pe_dfs.reset();
    alt_bfs(n,ok2);
    for (int i=1; i<=n; ++i)
    {
        if (ok1[drumuri[i].a] && ok2[drumuri[i].b] || ok1[drumuri[i].b] && ok2[drumuri[i].a])
        {
            rez.push_back(i);
            ++nr;
        }
    }
    g << nr << '\n';
    for (auto &v:rez)
        g << v << '\n';
}

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