#include <fstream>
#include <vector>
#include <queue>
using namespace std;

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

const int N = 1000;
const int M = 10000;
const int INF = 2e9;

int adj[N + 1][N + 1];
pair <int, int> edge[M + 1];
int n, m;
vector<int> par(N + 1, 0), ans;
vector<int> v[N + 1];
bool vis[N + 1];

bool bfs()
{
    queue<int> q;

    for(int i = 1; i <= n; ++i)
        par[i] = 0;

    q.push(1);
    par[1] = -1;

    //coada este goala si nu a fost gasit drum catre destinatie
    while(!q.empty())
    {
        int curr = q.front();
        q.pop();
        if (curr != n)
        {
            for(auto nbh: v[curr])
            {
                // mai poate fi pompat flux si nodul nu a fost vizitat
                if(adj[curr][nbh] && !par[nbh])
                {
                    par[nbh] = curr;
                    q.push(nbh);
                }
            }
        }
    }
    return par[n] != 0;
}

void ford_fulkerson()
{
    while(bfs())
    {
        for(auto nbh: v[n])
        {
            if(par[nbh] > 0 && adj[nbh][n])
            {
                int curr = n;
                par[n] = nbh;
                int flow = INF;
                //bottleneck
                while(curr != 1)
                {
                    flow = min(flow, adj[par[curr]][curr]);
                    curr = par[curr];
                }
                curr = n;
                //update flux
                if (flow)
                {
                    while(curr != 1)
                    {
                        adj[par[curr]][curr] -= flow;
                        adj[curr][par[curr]] += flow;
                        curr = par[curr];
                    }
                }
            }
        }
    }
}

void dfs(int node)
{
    vis[node] = true;
    for (auto nbh : v[node])
        if(!vis[nbh] && adj[node][nbh])
            dfs(node);

}
int main()
{
    in >> n >> m;
    for(int i = 1; i <= m ; ++i)
    {
        int a, b, c;
        in >> a >> b >> c;
        adj[a][b] = c;
        adj[b][a] = c;
        v[a].push_back(b);
        v[b].push_back(a);
        edge[i] = {a, b};
    }

    ford_fulkerson();
    dfs(1);

    for (int i = 1; i <= m; ++i)
        if (vis[edge[i].first] != vis[edge[i].second])
            ans.push_back(i);

    out << ans.size() << '\n';
    for(auto i:ans)
        out << i << '\n';
    return 0;
}