#include <fstream>
#include <vector>
#include <queue>

using namespace std;

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

const int N = 1001;
const int M = 10001;
const int INF = 1e9;

int adj[N][N];
vector <int> par;
vector <pair <int, int>> edge;
int n, m;
vector<int> ans, v[N];
vector <bool> vis;
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)
        {
            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];
                }

                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(nbh);
}

int main()
{
    freopen("critice.in", "r", stdin);
    ofstream out("critice.out");

    in >> n >> m;

    par.resize(n + 1);
    vis.resize(n + 1, false);
    edge.resize(m + 1);

    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;
}