#include<fstream>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
vector<int> L[1005];
queue<int> q, sol;
pair<int, int> M[10005];
bool u[1005], acces[2][1005];
int T[1005], C[1005][1005], F[1005][1005], n, m, i, minim, flux, nrm, nod, vecin, x, y, z, ok;
int bfs()
{
    while(!q.empty())
        q.pop();
    memset(u, 0, sizeof(u));
    q.push(1);
    u[1]=1;
    ok=0;
    while(!q.empty())
    {
        nod=q.front();
        if(nod==n)
        {
            ok=1;
            break;
        }
        for(i=0; i<L[nod].size(); i++)
        {
            vecin=L[nod][i];
            if(u[vecin]==0 && C[nod][vecin]>F[nod][vecin])
            {
                q.push(vecin);
                u[vecin]=1;
                T[vecin]=nod;
            }
        }
        q.pop();
    }
    return ok;
}
void dfs(int side, int nod)
{
    for(int i=0; i<L[nod].size(); i++)
    {
        int vecin=L[nod][i];
        if(acces[side][vecin]==0 && C[nod][vecin]-F[nod][vecin]>0)
        {
            acces[side][vecin]=1;
            dfs(side, vecin);
        }
    }
}
ifstream in("critice.in");
ofstream out("critice.out");
int main()
{
    in>>n>>m;
    for(i=1; i<=m; i++)
    {
        in>>x>>y>>z;
        L[x].push_back(y);
        L[y].push_back(x);
        C[x][y]=z;
        C[y][x]=z;
        M[++nrm].first=x;
        M[nrm].second=y;
    }
    while(bfs())
    {
        for(i=0; i<L[n].size(); i++)
        {
            nod=L[n][i];
            if(u[nod]==1)
            {
                minim=C[nod][n]-F[nod][n];
                for(; T[nod]!=0 && minim!=0; nod=T[nod])
                {
                    minim=min(minim, C[T[nod]][nod]-F[T[nod]][nod]);
                }
                if(minim!=0)
                {
                    flux+=minim;
                    nod=L[n][i];
                    F[nod][n]+=minim;
                    F[n][nod]-=minim;
                    for(; T[nod]!=0; nod=T[nod])
                    {
                        F[T[nod]][nod]+=minim;
                        F[nod][T[nod]]-=minim;
                    }
                }
            }
        }
    }
    acces[0][1]=1;
    dfs(0, 1);
    acces[1][n]=1;
    dfs(1, n);
    for(i=1; i<=nrm; i++)
    {
        if((acces[0][M[i].first] && acces[1][M[i].second]) || (acces[1][M[i].first] && acces[0][M[i].second]))
            sol.push(i);
    }
    out<<sol.size()<<"\n";
    while(!sol.empty())
    {
        out<<sol.front()<<"\n";
        sol.pop();
    }
    return 0;
}