#define DIM 1010
#include <fstream>
#include <queue>
#include <vector>
#include <bitset>

using namespace std;

ifstream fin("critice.in");
ofstream fout("critice.out");

int N, M, minim, flux;

int F[DIM][DIM];
int C[DIM][DIM];
vector <int> v[DIM];
int T[DIM];
bitset <DIM> U,U1,U2;
pair <int,int> p[DIM];
queue <int> Q;
vector <int> Sol;

int BFS(){

    U.reset();
    U[1]=1;
    Q.push(1);
    while(!Q.empty()){
        int node = Q.front();
        Q.pop();
        for(vector<int>::iterator it=v[node].begin();it!=v[node].end();it++){
            if(C[node][*it] > F[node][*it] && U[*it]==0){
                T[*it]=node;
                U[*it]=1;
                Q.push(*it);
            }
        }
    }
    return U[N];
}
void minibfs1(){
    U1[1]=1;
    Q.push(1);
    while(!Q.empty()){
        int node = Q.front();
        Q.pop();
        for(vector<int>::iterator it=v[node].begin();it!=v[node].end();it++){
            if(U1[*it]==0 && C[node][*it] > F[node][*it] && C[node][*it] > F[*it][node]){
                U1[*it]=1;
                Q.push(*it);
            }
        }
    }
}
void minibfsn(){
    U2[N]=1;
    Q.push(N);
    while(!Q.empty()){
        int node = Q.front();
        Q.pop();
        for(vector<int>::iterator it=v[node].begin();it!=v[node].end();it++){
            if(U2[*it]==0 && C[node][*it] > F[node][*it] && C[node][*it] > F[*it][node]){
                U2[*it]=1;
                Q.push(*it);
            }
        }
    }
}
int main(){

    fin >> N >> M;

    for(int i=1;i<=M;i++){
        int x,y,c;
        fin >> x >> y >> c;
        v[x].push_back(y);
        v[y].push_back(x);
        C[x][y] = c;
        C[y][x] = c;
        p[i] = make_pair(x,y);
    }

    while(BFS()){
        int minim = 0x3f3f3f3f;
        int u = N;
        while(u!=1){
            if(minim > C[T[u]][u] - F[T[u]][u])
                minim = C[T[u]][u] - F[T[u]][u];
            u = T[u];
        }
        u = N;
        while(u!=1){
            F[T[u]][u] += minim;
            F[u][T[u]] -= minim;
            u = T[u];
        }
    }
    minibfs1();
    minibfsn();
    for(int i=1;i<=M;i++){
        if(C[p[i].first][p[i].second]==F[p[i].first][p[i].second] || C[p[i].second][p[i].first]==F[p[i].second][p[i].first]){
            if((U1[p[i].first] && U2[p[i].second]) || (U1[p[i].second] && U2[p[i].first]))
                Sol.push_back(i);
        }
    }
    fout << Sol.size() << "\n";
    for(vector<int>::iterator it=Sol.begin();it!=Sol.end();it++)
        fout << *it << "\n";

    return 0;
}