#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <cmath>
#define NMax 1005
#define MMax 10005
#define INFINIT 99999999
using namespace std;
int N,M,nr,flow,x,y,z;
int v[NMax],father[NMax],uz[2][NMax];
int X[MMax],Y[MMax];
int cost[NMax][NMax],flux[NMax][NMax];
vector<int> Graf[NMax],sol;

void Read()
{
    freopen("critice.in","r",stdin);
    scanf("%d%d",&N,&M);
    for(int i=1;i<=M;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        cost[x][y]=cost[y][x]=z;
        Graf[x].push_back(y);
        Graf[y].push_back(x);
        X[i]=x,Y[i]=y;
    }
}

int BFS1()
{
    queue<int> Q;
    Q.push(1);
    v[1]=nr;
    father[1]=0;
    while(Q.empty()==false)
    {
        int k=Q.front();
        Q.pop();
        if(k==N)
            continue;
        for(int i=0;i<Graf[k].size();i++)
            if(v[Graf[k][i]]!=nr && cost[k][Graf[k][i]]>flux[k][Graf[k][i]])
            {
                Q.push(Graf[k][i]);
                v[Graf[k][i]]=nr;
                father[Graf[k][i]]=k;
            }
    }
    if(v[N]==nr) return 1;
    return 0;
}

void Edmonds_Karp()
{
    int Min;
    nr=1;
    while(BFS1())
    {
        for(int i=0;i<Graf[N].size();i++)
            if(v[Graf[N][i]]==nr && flux[Graf[N][i]][N]<cost[Graf[N][i]][N])
            {
                Min=INFINIT;
                father[N]=Graf[N][i];
                for(int j=N;j!=1;j=father[j])
                    Min=min(Min,cost[father[j]][j]-flux[father[j]][j]);

                for(int j=N;j!=1;j=father[j])
                {
                    flux[father[j]][j]=flux[father[j]][j]+Min;
                    flux[j][father[j]]=flux[j][father[j]]-Min;
                }
                flow=flow+Min;
                nr++;
            }
    }
}

void BFS(int sursa,int ind)
{
    queue<int> Q;
    uz[ind][sursa]=1;
    Q.push(sursa);
    while(Q.empty()==false)
    {
        int k=Q.front();
        Q.pop();
        for(int i=0;i<Graf[k].size();i++)
            if(!uz[ind][Graf[k][i]] && cost[k][Graf[k][i]]>abs(flux[k][Graf[k][i]]))
            {
                Q.push(Graf[k][i]);
                uz[ind][Graf[k][i]]=1;
            }
    }
}

void solve()
{
    int x,y;
    for(int i=1;i<=M;i++)
    {
        x=X[i],y=Y[i];
        if((uz[0][x] && uz[1][y] && cost[x][y]==flux[x][y]) || (uz[0][y] && uz[1][x] && cost[y][x]==flux[y][x]))
            sol.push_back(i);
    }
}

void Write()
{
    freopen("critice.out","w",stdout);
    printf("%d\n",sol.size());
    for(int i=0;i<sol.size();i++)
        printf("%d\n",sol[i]);
}

int main()
{
    Read();
    Edmonds_Karp();
    BFS(1,0);
    BFS(N,1);
    solve();
    Write();
}