#include <fstream>
#include <vector>
#include <queue>
#define MAXN 1005
using namespace std;
ifstream f("critice.in");
ofstream g("critice.out");

int n,m,x,y,c[MAXN][MAXN],flux[MAXN][MAXN],tata[MAXN],mn;
bool uz1[MAXN],uzn[MAXN];
vector<int> G[MAXN],sol;
vector< pair<int,int> > muchii;
pair<int,int> a;
queue<int> q;

bool BFS();
void DFS1(int p);
void DFSn(int p);

int main()
{
    int i;
    f>>n>>m;
    for(i=1;i<=m;i++){
        f>>x>>y;
        f>>c[x][y];
        c[y][x]=c[x][y];
        G[x].push_back(y);
        G[y].push_back(x);
        muchii.push_back(make_pair(x,y));}
    tata[1]=-1;
    while(BFS());
    DFS1(1);
    DFSn(n);
    for(i=0;i<muchii.size();i++){
        a=muchii[i];
        if((flux[a.first][a.second]==c[a.first][a.second]&&uz1[a.first]&&uzn[a.second])||(flux[a.second][a.first]==c[a.second][a.first]&&uz1[a.second]&&uzn[a.first]))
            sol.push_back(i+1);}
    g<<sol.size()<<'\n';
    for(i=0;i<sol.size();i++)
        g<<sol[i]<<'\n';
    f.close();
    g.close();
    return 0;
}

bool BFS(){
    int i;
    for(i=2;i<=n;i++)
        tata[i]=0;
    q.push(1);
    while(!q.empty()){
        x=q.front();
        q.pop();
        for(i=0;i<G[x].size();i++){
            y=G[x][i];
            if(!tata[y]&&flux[x][y]<c[x][y]){
                q.push(y);
                tata[y]=x;}}}
    if(!tata[n])
        return 0;
    for(i=0;i<G[n].size();i++){
        x=G[n][i];
        if(!tata[x])
            continue;
        mn=c[x][n]-flux[x][n];
        while(x>1&&mn){
            if(c[tata[x]][x]-flux[tata[x]][x]<mn)
                mn=c[tata[x]][x]-flux[tata[x]][x];
            x=tata[x];}
        if(!mn)
            continue;
        x=G[n][i];
        flux[x][n]+=mn; flux[n][x]-=mn;
        while(x>1){
            flux[tata[x]][x]+=mn;
            flux[x][tata[x]]-=mn;
            x=tata[x];}}
    return 1;}

void DFS1(int p){
    int i;
    uz1[p]=1;
    for(i=0;i<G[p].size();i++){
        x=G[p][i];
        if(!uz1[x]&&flux[p][x]<c[p][x])
            DFS1(x);}}

void DFSn(int p){
    int i;
    uzn[p]=1;
    for(i=0;i<G[p].size();i++){
        x=G[p][i];
        if(!uzn[x]&&flux[x][p]<c[x][p])
            DFSn(x);}}