#include<fstream>
#include<cstring>
#include<algorithm>

using namespace std;

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

const int maxn=1002;
const int INF=0x3f3f3f3f;
const int maxm=10002;

struct nod
{
    int v;
    int who;
    nod *next;
}*a[maxn];

int F[maxn][maxn],C[maxn][maxn];

int i,j,n,m,x,y,z,par[maxn],ans[5*maxm],k,r;

bool been[maxn],been_source[maxn],been_dest[maxn];

int coada[maxn];

bool bfs()
{
    int x,elem=1,i;
    coada[1]=1;
    memset(been,false,sizeof(been));
    for(i=1;i<=elem;++i)
    {
        x=coada[i];
        if(x==n)
            continue;
        for(nod *it=a[x];it;it=it->next)
        {
            if(F[x][it->v]==C[x][it->v]||been[it->v])
                continue;
            been[it->v]=true;
            coada[++elem]=it->v;
            par[it->v]=x;
        }
    }

    return been[n];
}

int main()
{
    f>>n>>m;
    for(i=1;i<=m;++i)
    {
        f>>x>>y>>z;
        nod *key=new nod;
        key->next=a[x];
        key->v=y;
        key->who=i;
        a[x]=key;
        key=new nod;
        key->next=a[y];
        key->v=x;
        key->who=i;
        a[y]=key;
        C[x][y]=C[y][x]+=z;
    }

    int flow,fmin;
    for(flow=0;bfs();)
        for(nod *it=a[n];it;it=it->next)
        {
            if(F[it->v][n]==C[it->v][n]||been[it->v]==false)
                continue;
            fmin=INF;
            par[n]=it->v;
            for(i=n;i!=1;i=par[i])
                fmin=min(fmin,C[par[i]][i]-F[par[i]][i]);
            if(fmin==0)
                continue;
            for(i=n;i!=1;i=par[i])
                F[par[i]][i]+=fmin,F[i][par[i]]-=fmin;
            flow+=fmin;
        }

    int elem=1;
    coada[1]=1;
    been_source[1]=true;
    for(i=1;i<=elem;++i)
    {
        x=coada[i];
        for(nod *it=a[x];it;it=it->next)
        {
            if(F[x][it->v]==C[x][it->v]||been_source[it->v])
                continue;
            coada[++elem]=it->v;
            been_source[it->v]=true;
        }
    }
    elem=1;
    coada[1]=n;
    been_dest[n]=true;
    for(i=1;i<=elem;++i)
    {
        x=coada[i];
        for(nod *it=a[x];it;it=it->next)
        {
            if(F[it->v][x]==C[it->v][x]||been_dest[it->v])
                continue;
            coada[++elem]=it->v;
            been_dest[it->v]=true;
        }
    }

    for(i=1;i<=n;++i)
        if(been_source[i]||been_dest[i])
            for(nod *it=a[i];it;it=it->next)
                if((been_source[i]&&been_dest[it->v])||(been_dest[i]&&been_source[it->v]))
                    ans[++k]=it->who;

    sort(ans+1,ans+k+1);
    for(i=1;i<=k;++i)
        if(ans[i]!=ans[i-1])
            ++r;
    g<<r<<"\n";
    for(i=1;i<=k;++i)
        if(ans[i]!=ans[i-1])
            g<<ans[i]<<"\n";
    g<<"\n";
    f.close();
    g.close();

    return 0;
}