#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
ifstream f("critice.in");
ofstream g("critice.out");
const int NMAX = 1002;
vector<int> G[NMAX],T;
int F[NMAX][NMAX],C[NMAX][NMAX];
int m,n;
bool BF()
{
    T=vector<int>(n+1,0);
    queue<int> q;
    q.push(1);
    T[1]=-1;
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        for(auto x:G[u])
            if(!T[x] && C[u][x]>F[u][x])
            {
                T[x]=u;
                q.push(x);
                if(x==n)
                    return true;
            }
    }
    return false;
}
void BF(int start,vector<bool> &viz)
{
    queue <int> q;
    q.push(start);
    viz[start]=1;
    while(!q.empty())
    {
      int u =q.front();
            q.pop();
        for(auto x:G[u])
            if(!viz[x] && (C[u][x]!=F[u][x] && C[x][u]!=F[x][u]))
            {
                q.push(x);
                viz[x]=1;
            }
    }
}
int main()
{
    f>>n>>m;
    int flux = 0;
    vector<pair<int,int>>edges;
    vector<int> rez;
    while(m--)
    {
        int a,b;
        f>>a>>b;
        f>>C[a][b];
        C[b][a]=C[a][b];
        edges.push_back({a,b});
        G[a].push_back(b);
        G[b].push_back(a);
    }
    while(BF())
        for(auto x:G[n])
        {
            if(T[x]==-1 || C[x][n]<=F[x][n])
                continue;
            int r = C[x][n]-F[x][n];
            for(int j = x; j>1; j=T[j])
                r=min(r,C[T[j]][j]-F[T[j]][j]);
            if(!r)
                continue;
            F[x][n]+=r;
            F[n][x]-=r;
            for(int j=x; j>1; j=T[j])
                F[T[j]][j]+=r,F[j][T[j]]-=r;
            flux+=r;
        }
    vector<bool> viz1(n+1),viz2(n+1);
    BF(1,viz1);
    BF(n,viz2);
    for(int i=0;i<edges.size();i++)
        if((viz1[edges[i].first] && viz2[edges[i].second]) || (viz2[edges[i].first] && viz1[edges[i].second]))
        rez.push_back(i+1);
    g<<rez.size()<<"\n";
    for(int x:rez)
        g<<x<<"\n";
}