#include<bits/stdc++.h>
using namespace std;

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

const int N = 1005;
const int M = 10005;
const int INF = 1e9;

int adj[N][N], par[N];
pair <int, int> edge[M];
int n, m;
vector<int> ans, v[N];
bool vis[N];
queue<int> q;

bool bfs()
{
    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) continue;
        for(auto nbh: v[curr])
        {
            // mai poate fi pompat flux si nodul nu a fost vizitat
            if(!par[nbh] && adj[curr][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];
                }

                if (!flow) continue;
                curr = n;
                //update flux
                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()
{
    freopen("critice.in", "r", stdin);
    ofstream out("critice.out");

    scanf("%d %d",&n,&m);

    for(int i = 1; i <= m ; ++i)
    {
        int a, b, c;
        scanf("%d %d %d",&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;
}