#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n, m;

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

vector<vector<int>> res;
vector<bool> visited;
vector<vector<int>> adj;
vector<int> parent;
vector<pair<int, int>> edges;

bool bfs()
{
    queue<int> qu;
    for (auto &p : parent)
        p = 0;
    qu.emplace(1);
    parent[1] = -1;

    while (!qu.empty() && !parent[n])
    {
        int curr = qu.front();
        qu.pop();
        if (curr == n)
            continue;
        for (auto &nei : adj[curr])
        {
            if (!parent[nei] && res[curr][nei])
            {
                parent[nei] = curr;
                qu.emplace(nei);
            }
        }
    }
    return parent[n] != 0;
}

void EdmKarp()
{
    parent.resize(n + 1, 0);
    while (bfs())
        for (auto &node : adj[n])
            if (parent[node] != 0 && res[node][n])
            {
                parent[n] = node;
                int flow = INF;
                for (int critic = n; critic != 1; critic = parent[critic])
                    flow = min(flow, res[parent[critic]][critic]);
                if (!flow)
                    continue;
                for (int critic = n; critic != 1; critic = parent[critic])
                {
                    res[parent[critic]][critic] -= flow;
                    res[critic][parent[critic]] += flow;
                }
            }
}

void dfs(int node)
{
    visited[node] = true;
    for (auto &nei : adj[node])
        if (!visited[nei] && res[node][nei])
            dfs(nei);
}

int main()
{
    fin >> n >> m;
    res.resize(n + 1, vector<int>(n + 1, 0));
    adj.resize(n + 1);

    while (m--)
    {
        int x, y, z;
        fin >> x >> y >> z;
        adj[x].emplace_back(y);
        adj[y].emplace_back(x);
        res[x][y] = res[y][x] = z;
        edges.emplace_back(x, y);
    }
    EdmKarp();

    visited.resize(n + 1, false);
    dfs(1);

    vector<int> critice;
    for (int i = 0; i < edges.size(); ++i)
        if (visited[edges[i].first] != visited[edges[i].second])
            critice.emplace_back(i + 1);

    fout << critice.size() << '\n';
    for (auto &i : critice)
        fout << i << '\n';
    return 0;
}