#include<bits/stdc++.h>
using namespace std;
ifstream f("critice.in");
ofstream g("critice.out");

int n,m,a[1005][1005],sol,viz[1005],tata[1005],s,d,ind[1005][1005],viz1[1005],k,val;
vector<int>v[1005],w;
queue<int>q;

int bfs()
{
    int i;
    for(i=1;i<=n;i++)
        viz[i]=0,tata[i]=0;
    q.push(s);
    viz[s]=1;
    while(!q.empty())
    {
        int nod=q.front();
        q.pop();
        for(auto it:v[nod])
        {
            if(a[nod][it]>0 && viz[it]==0)
            {
                viz[it]=1;
                q.push(it);
                tata[it]=nod;
            }
        }
    }
    return viz[d];
}

void flux_maxim()
{
    int flux,nr;
    while(bfs()==1)
    {
        for(auto it:v[d])
        {
            if(a[it][d]>0)
            {
                flux=a[it][d];
                nr=it;
                while(nr!=s)
                {
                    flux=min(flux,a[tata[nr]][nr]);
                    nr=tata[nr];
                }
                nr=it;
                a[nr][d]-=flux;
                a[d][nr]-=flux;
                while(nr!=s)
                {
                    a[tata[nr]][nr]-=flux;
                    a[nr][tata[nr]]-=flux;
                    nr=tata[nr];
                }
                sol+=flux;
            }
        }
    }
}

void reconstituire(int nod, int tata)
{
    viz1[nod]=1;
    if(nod==d)
    {
        if(k==1)
            w.push_back(val);
        if(a[tata][d]==0)
            k--;
        viz1[nod]=0;
    }
    else
    {
        for(auto it:v[nod])
        {
            if(it!=tata && viz1[it]==0)
            {
                if(a[nod][it]==0)
                    k++,val=ind[nod][it];
                reconstituire(it,nod);
            }
        }
        if(a[tata][nod]==0)
            k--;
        viz1[nod]=0;
    }
}

signed main()
{
    int i,j,x,y,z;
    f>>n>>m;
    for(i=1;i<=m;i++)
    {
        f>>x>>y>>z;
        v[x].push_back(y);
        v[y].push_back(x);
        a[x][y]+=z;
        a[y][x]+=z;
        ind[x][y]=i;
        ind[y][x]=i;
    }
    s=1;
    d=n;
    flux_maxim();
    reconstituire(s,0);
    g<<w.size()<<'\n';
    for(auto it:w)
        g<<it<<'\n';
    return 0;
}