#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[10*DIM];
queue <int> Q;
vector <int> Sol;

int BFS(){

    U.reset();
    while(!Q.empty())
        Q.pop();
    U[1]=1;
    Q.push(1);
    while(!Q.empty()){
        int node = Q.front();
        Q.pop();
        if(node==N)
            return 1;
        for(int i=0;i<v[node].size();i++){
            int it=v[node][i];
            if(C[node][it] > F[node][it] && U[it]==0){
                T[it]=node;
                U[it]=1;
                Q.push(it);
            }
        }
    }
    return 0;
}
void minibfs1(){
    U1[1]=1;
    Q.push(1);
    while(!Q.empty()){
        int node = Q.front();
        Q.pop();
        for(int i=0;i<v[node].size();i++){
            int it=v[node][i];
            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(int i=0;i<v[node].size();i++){
            int it=v[node][i];
            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(int i=0;i<Sol.size();i++)
        fout << Sol[i] << "\n";

    return 0;
}