#include <bits/stdc++.h>
using namespace std;
ifstream f("critice.in");
ofstream g("critice.out");
int m,n,i,j,a,b,c;
struct edge{
    int u;
    int v;
    int cap;
};
struct Dinic {
    int m=0,n,s,t;
    vector<edge>e;
    vector<vector<int>>v;
    vector<int>last,level,from_s,from_t;
    Dinic(int a,int c,int d){
        n=a;
        s=c;
        t=d;
        v.resize(n+1);
        last.resize(n+1);
        level.resize(n+1);
        from_s.resize(n+1);
        from_t.resize(n+1);
        //from_s[s]=1;
        //from_t[t]=1;
    }
    void add_edge(int a,int b,int c){
        v[a].push_back(m++);
        e.push_back({a,b,c});
        v[b].push_back(m++);
        e.push_back({b,a,c});
    }
    bool bfs(){
        queue<int>Q;
        Q.push(s);
        for (int i=1;i<=n;i++){
            level[i]=-1;
            last[i]=0;
        }
        level[s]=0;
        while (!Q.empty()){
            int now=Q.front();
            Q.pop();
            for (int i=0;i<v[now].size();i++){
                edge it=e[v[now][i]];
                if (level[it.v]==-1&&it.cap){
                    level[it.v]=level[it.u]+1;
                    Q.push(it.v);
                }
            }
        }
        return (level[t]!=-1);
    }
    int dfs(int node,int flow){
        if (flow==0){
            return 0;
        }
        if (node==t){
            return flow;
        }
        for (;last[node]<v[node].size();last[node]++){
            auto it=e[v[node][last[node]]];
            if (level[node]!=level[it.v]-1||it.cap==0)continue;
            int f=dfs(it.v,min(flow,it.cap));
            if (f){
                e[v[node][last[node]]].cap-=f;
                e[v[node][last[node]]^1].cap+=f;
                return f;
            }
        }
        return 0;
    }
    void solve(){
        int sol=0;
        vector<int>ans;
        while(bfs()){
            while(int f=dfs(s,1e9))sol+=f;
        }
        reachable(1,0);
        reachable(n,1);
        for (int i=0;i<=m;i+=2){
            if((from_s[e[i].u]&&from_t[e[i].v])||
               (from_t[e[i].u]&&from_s[e[i].v])
            )ans.push_back(i);
        }
        g<<ans.size()<<'\n';
        for (int it : ans)g<<(it+1)/2+1<<'\n';
        //return sol;
    }
    void reachable(int node,int type){
        if (!type){
            from_s[node]=1;
        }
        else from_t[node]=1;
        for (auto it : v[node]){
            if (!type){
                if (!from_s[e[it].v]&&e[it].cap){
                    reachable(e[it].v,type);
                }
            }
            if (type){
                if (!from_t[e[it].v]&&e[it].cap){
                    reachable(e[it].v,type);
                }
            }
        }
    }
};
int main()
{
    f>>n>>m;
    Dinic dinic(n,1,n);
    for (i=1;i<=m;i++){
        f>>a>>b>>c;
        dinic.add_edge(a,b,c);
    }
    dinic.solve();
    //dinic.reachable(1,0);
    //dinic.reachable(n,1);
    //cout<<dinic.solve();
    /*
    2
    1
    4
    */
    return 0;
}