#include <fstream>
#include <vector>
#include <string.h>
#include <limits.h>
#include <algorithm>

#define NDIM 1003
#define MDIM 10003
#define INF INT_MAX
#define pb push_back
using namespace std;
ifstream fin("critice.in");
ofstream fout("critice.out");
int n,m,i,nod,flow,a,b,cost,c[NDIM][NDIM],q[NDIM*NDIM],x1,nflow,nrm,x2,f[NDIM][NDIM],much[MDIM][2],par[NDIM],fiu,poz[NDIM][NDIM],sol[MDIM],nr;
bool viz[NDIM],viz1[NDIM];
vector <int> G[NDIM];
int BFS()
{
    memset(viz,0,sizeof(viz));
    q[0]=q[1]=viz[1]=1;
    for(int i=1;i<=q[0];i++)
    {
        nod=q[i];
        if(nod==n) continue;
        for(size_t j=0;j<G[nod].size();j++)
        {
            fiu=G[nod][j];
            if(c[nod][fiu]==f[nod][fiu]||viz[fiu])
            {
                continue;
            }
            viz[fiu]=1;
            par[fiu]=nod;
            q[++q[0]]=fiu;
        }
    }
    return viz[n];
}
int maxflow(int ap)
{
    memset(f,0,sizeof(f));
    for(flow=0;BFS();)
    {
        for(size_t i=0;i<G[n].size();i++)
        {
            int fmin=INF;
            nod=G[n][i];
            if(c[nod][n]==f[nod][n]||!viz[nod]) continue;
            par[n]=nod;
            for(nod=n;nod!=1;nod=par[nod])
            {
                if(fmin>c[par[nod]][nod]-f[par[nod]][nod])
                {
                    fmin=c[par[nod]][nod]-f[par[nod]][nod];
                    x1=par[nod];
                    x2=nod;
                }
            }
            if(fmin==0) continue;
            if(ap==1)
            {
                much[++nr][0]=x1;
                much[nr][1]=x2;
            }
            for(nod=n;nod!=1;nod=par[nod])
            {
                f[par[nod]][nod]+=fmin;
                f[nod][par[nod]]-=fmin;
            }
            flow+=fmin;
        }
    }
    return flow;
}
int main()
{
    fin>>n>>m;
    for(i=1;i<=m;i++)
    {
        fin>>a>>b>>cost;
        poz[a][b]=poz[b][a]=i;
        c[a][b]=cost;
        c[b][a]=cost;
        G[a].pb(b);
        G[b].pb(a);
    }
    nflow=maxflow(1);
    int apel=2;
    for(i=1;i<=nr;i++)
    {
        c[much[i][0]][much[i][1]]++;
        c[much[i][1]][much[i][0]]++;
        if(nflow<maxflow(++apel))
        {
            sol[++nrm]=poz[much[i][0]][much[i][1]];
        }
        c[much[i][0]][much[i][1]]--;
        c[much[i][1]][much[i][0]]--;
    }
    fout<<nrm<<'\n';
    sort(sol+1,sol+nrm+1);
    for(i=1;i<=nrm;i++)
        fout<<sol[i]<<'\n';

    return 0;
}