#include <cstdio>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <queue>
#define NMAX 1001
using namespace std;

int vizitat[NMAX];
int father[NMAX];
int A[NMAX],B[NMAX];
int Sol[NMAX];
int sursa[NMAX];
int dest[NMAX];
vector < vector < int > > Graf;
queue < int > q;
int n,m,flow,Capacitate[NMAX][NMAX],Flow[NMAX][NMAX],capacitate_reziduala;

inline void citesc(){

    int cap;
    freopen("critice.in","r",stdin);
    freopen("critice.out","w",stdout);
    scanf("%d%d",&n,&m);
    Graf.resize(n+1);
    for(register int i=1;i<=m;++i){

        scanf("%d%d%d",&A[i],&B[i],&cap);
        Graf[A[i]].push_back(B[i]);
        Graf[B[i]].push_back(A[i]);
        Capacitate[A[i]][B[i]] = Capacitate[B[i]][A[i]] = cap;
    }
}

void DFS(int nod, int V[]){

    V[nod] = 1;
    for(vector < int >::iterator it = Graf[nod].begin();it!=Graf[nod].end();++it)
        if(!V[*it] && Capacitate[nod][*it] > Flow[nod][*it] && Capacitate[*it][nod] > Flow[*it][nod])
           DFS(*it,V);
}

int BFS(){

    memset(vizitat,0,sizeof(vizitat));
    vizitat[1] = 1;
    q.push(1);
    int nod;
    while(!q.empty()){

            nod = q.front();
            q.pop();
            if(nod == n) continue;
            for(vector < int >::iterator it = Graf[nod].begin();it!=Graf[nod].end();++it)
            if(!vizitat[*it] && Capacitate[nod][*it] > Flow[nod][*it]){
                vizitat[*it] = 1;
                q.push(*it);
                father[*it] = nod;
            }
    }
return vizitat[n];
}

inline void Max_Flow(){

    int nod;
    while(BFS())
        for(vector < int >::iterator it = Graf[n].begin();it!=Graf[n].end();++it)

            if(vizitat[*it] && Capacitate[*it][n] > Flow[*it][n]){
            father[n] = *it;

            capacitate_reziduala = 0x3f3f3f3f;
            for(nod = n;nod!=1;nod=father[nod])
            capacitate_reziduala = min(capacitate_reziduala,Capacitate[father[nod]][nod] - Flow[father[nod]][nod]);

            for(nod = n;nod!=1;nod=father[nod]){
                Flow[father[nod]][nod]+=capacitate_reziduala;
                Flow[nod][father[nod]]-=capacitate_reziduala;
        }
    }
}

inline void solve(){

    DFS(1,sursa);
    DFS(n,dest);
    for(register int i=1;i<=m;++i)
        if((sursa[A[i]] && dest[B[i]]) || (sursa[B[i]] && dest[A[i]]))
            Sol[++Sol[0]] = i;

    printf("%d\n",Sol[0]);
    for(register int i=1;i<=Sol[0];++i)
        printf("%d\n",Sol[i]);
}

int main(){

    citesc();
    Max_Flow();
    solve();

return 0;
}