#include <fstream>
#include <cstdio>
#include <vector>
#include <memory.h>
#include <queue>

#define NMAX 1002
#define INF 0x3f3f3f3f
using namespace std;

ofstream fout("critice.out");

int ANT[NMAX],F[NMAX][NMAX];
bool viz[NMAX] , sol[10003];
int n,m,nrNod;
struct drum{int nod1,nod2,limit;} muchie[10003];
struct mystruct{int flux,muchie;} C[NMAX][NMAX];
vector<int> G[NMAX];

void read()
{
    freopen("critice.in","r",stdin);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&muchie[i].nod1,&muchie[i].nod2,&muchie[i].limit);

        G[muchie[i].nod1].push_back(muchie[i].nod2);
        G[muchie[i].nod2].push_back(muchie[i].nod1);

        C[muchie[i].nod1][muchie[i].nod2].flux = muchie[i].limit;
        C[muchie[i].nod2][muchie[i].nod1].flux = muchie[i].limit;
        C[muchie[i].nod1][muchie[i].nod2].muchie = C[muchie[i].nod2][muchie[i].nod1].muchie = i;
    }
}

bool BFS()
{
    queue<int> co;
    int nod;
    co.push(1);
    memset(viz,0,sizeof(viz));
    viz[1]=1;

    while(!co.empty())
    {
        nod = co.front();
        co.pop();
        if(nod == n)
            return 1;

        for(int i=0;i<G[nod].size();i++)
        {
            if(viz[G[nod][i]] || C[nod][G[nod][i]].flux == F[nod][G[nod][i]]) continue;

            viz[G[nod][i]] = 1;
            ANT[G[nod][i]] = nod;
            co.push(G[nod][i]);
        }
    }
    return 0;

}

void createFlux()
{
    int nod, flux;
    while(BFS())
        for(int i=0;i<G[n].size();i++)
        {
            nod = G[n][i];
            if(!viz[nod] || C[nod][n].flux == F[nod][n]) continue;
            ANT[n]= nod;

            flux = INF;
            for(int i=n;i>1;i = ANT[i])
                flux = min(flux, C[ANT[i]][i].flux - F[ANT[i]][i]);
            if(flux == 0) continue;

            for(int i=n;i>1;i=ANT[i])
                F[ANT[i]][i] = F[i][ANT[i]] = F[ANT[i]][i] + flux;
        }
}

void DFS(int nod,int k)
{
    if(nod == n)
        sol[k] = 1,nrNod++;
    else
    {
        viz[nod] = 1;
        for(int i=0;i<G[nod].size();i++)
            if(!viz[G[nod][i]])
            {
                if(C[G[nod][i]][nod].flux > F[G[nod][i]][nod])
                    DFS(G[nod][i],k);
                else
                    if(k==0)
                        DFS(G[nod][i],C[G[nod][i]][nod].muchie);
            }
        viz[nod] = 0;
    }
}

void afis()
{
    fout<<nrNod<<'\n';
    for(int i=1;i<=m;i++)
        if(sol[i]==1)
            fout<<i<<'\n';
}

int main()
{
    read();
    createFlux();
    memset(viz,0,sizeof(viz));
    DFS(1,0);
    afis();

    return 0;
}