#include <bits/stdc++.h>
#define nmax 1005
#define inf 1000000009
using namespace std;
ifstream in("critice.in");
ofstream out("critice.out");

vector<int> lista[nmax];
int flow[nmax][nmax], capacity[nmax][nmax], pater[nmax];
int n,m;
pair<int,int> muchii[10*nmax];

bool bfs(int start, int fin){
    queue<int> q;
    for(int i=1; i<=n; i++){
        pater[i] = -1;
    }
    pater[start] = 0;
    q.push(start);
    while(!q.empty()){
        int nod = q.front();
        q.pop();
        for(auto neigh: lista[nod]){
            if(pater[neigh] == -1 && capacity[nod][neigh] > flow[nod][neigh]){
                pater[neigh] = nod;
                q.push(neigh);
            }
        }
    }
    return pater[fin] != -1;
}

int max_flow(int s, int t){
    int ma_flow = 0;
    while(bfs(s, t)){
        for(auto v: lista[t]){
            if(pater[v] == -1) continue;
            int neck = capacity[v][t] - flow[v][t];
            if(neck == 0) continue;
            for(int u = v; pater[u]!=0; u = pater[u]){
                neck = min(neck, capacity[pater[u]][u] - flow[pater[u]][u]);
            }
            if(neck == 0) continue;
            flow[v][t] += neck;
            flow[t][v] -= neck;
            for(int u = v; pater[u]!=0; u = pater[u]){
                flow[pater[u]][u] += neck;
                flow[u][pater[u]] -= neck;
            }
            ma_flow += neck;
        }
    }
    return ma_flow;
}
void dfs(int nod, int ap[]){
    ap[nod] = 1;
    for(auto neigh: lista[nod]){
        if(!ap[neigh] && capacity[nod][neigh] > flow[nod][neigh]){
            dfs(neigh, ap);
        }
    }
}
void dfs2(int nod, int ap[]){
    ap[nod] = 1;
    for(auto neigh: lista[nod]){
        if(!ap[neigh] && capacity[neigh][nod] > flow[neigh][nod]){
            dfs2(neigh, ap);
        }
    }
}
int ap[nmax],ap2[nmax];
int main(){
    in >> n;
    in >> m;
    for(int i=0; i<m; i++){
        int x, y;
        in >> x >> y;
        if(!capacity[x][y] && !capacity[y][x]){
            lista[x].push_back(y);
            lista[y].push_back(x);
        }
        muchii[i].first = x;
        muchii[i].second = y;
        in >> capacity[x][y];
        capacity[y][x] = capacity[x][y];
    }
    max_flow(1,n);
    dfs(1, ap);
    dfs2(n, ap2);
    vector<int> sol;
    for(int i=0; i<m; i++){
        int u = muchii[i].first;
        int v = muchii[i].second;
        if((ap[u] && ap2[v]) || (ap[v] && ap2[u])){
            sol.push_back(i+1);
        }
    }
    out << sol.size() << '\n';
    for(auto elem: sol){
        out << elem << '\n';
    }
    return 0;
}