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

using namespace std;

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

const int INF = 1e9;

int n, m;
vector<vector<int>> G, cap;
vector<bool> viz;
vector<int> pred;
vector<pair<int, int>> muchii;

bool bfs()
{
    queue<int> q;
    for(auto &p : pred) p = 0;
    q.emplace(1);
    pred[1] = -1;
    while(!q.empty() && !pred[n])
    {
        int nod = q.front();
        q.pop();
        if (nod == n) continue;

        for (auto &i : G[nod])
        {
            if (!pred[i] && cap[nod][i])
            {
                pred[i] = nod;
                q.emplace(i);
            }
        }
    }
    return pred[n] != 0;
}

void EdmKarp()
{
    pred.resize(n + 1, 0);
    while (bfs())
        for (auto &i : G[n])
            if (pred[i] != 0 && cap[i][n])
            {
                pred[n] = i;
                int flow = INF;
                for (int nod = n; nod != 1; nod = pred[nod])
                    flow = min(flow, cap[pred[nod]][nod]);

                for (int nod = n; nod != 1; nod = pred[nod])
                {
                    cap[pred[nod]][nod] -= flow;
                    cap[nod][pred[nod]] += flow;
                }
            }
}

void dfs(int nod)
{
    viz[nod] = true;
    for (auto &i : G[nod])
        if (!viz[i] && cap[nod][i]) dfs(i);
}

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

    for(int i = 1, x, y, z; i <= m; ++i)
    {
        fin >> x >> y >> z;
        G[x].push_back(y);
        G[y].push_back(x);
        cap[x][y] = cap[y][x] = z;
        muchii.emplace_back(x, y);
    }

    EdmKarp();

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

    vector<int> critice;
    for (int i = 0; i < muchii.size(); ++i)
        if (viz[muchii[i].first] != viz[muchii[i].second]) critice.push_back(i + 1);

    fout << critice.size() << '\n';
    for(int i = 0; i < critice.size(); ++i)
        fout << critice[i] << '\n';
    return 0;
}