#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
using namespace std;
ifstream fin("critice.in");
ofstream fout("critice.out");
const int NMAX = 1e3 + 1;
vector<vector<int>> graph(NMAX, vector<int>(NMAX, 0));
vector<vector<int>> ct(NMAX, vector<int>(NMAX, 0));
int n, m;
struct
{
    int x, y;
} muchie[NMAX];
int bfs(int s, int t, vector<int> &parent)
{
    fill(parent.begin(), parent.end(), -1);

    queue <pair<int, int>> q;
    q.push({s, 1e4 + 1});

    parent[s] = -2;

    while (!q.empty())
    {
        int u = q.front().first;
        int flux = q.front().second;

        q.pop();

        for (int v = 1; v <= n; v++)
        {
            if (u != v && graph[u][v] > 0 && parent[v] == -1)
            {
                parent[v] = u;
                int flux_nou = min(flux, graph[u][v]);

                if (v == t)
                {
                    return flux_nou;
                }
                q.push({v, flux_nou});
            }
        }
    }
    return 0;
}
void bfs2(int nod)
{
    queue<int> q;
    vector<int> viz(NMAX, 0);
    viz[nod] = 1;
    q.push(nod);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        for (int v = 1; v <= n; v++)
        {
            if (viz[v] == 0)
            {
                if (graph[u][v] == 0 || graph[v][u] == 0)
                {
                    //incrementeaza l daca este saturat pe o parte macar
                    ct[u][v] ++;
                    ct[v][u] ++;
                }
                else
                {
                    viz[v] = 1;
                    q.push(v);
                }
            }
        }
    }
}
int EdmonKarp(int s, int t)
{
    vector <int> parent(NMAX, -1);

    int flux = 0, flux_nou = 0;
    while (flux_nou = bfs(s, t, parent))
    {
        flux += flux_nou;
        int v = t;
        while (v != s)
        {
            int u = parent[v];
            graph[u][v] -= flux_nou;
            graph[v][u] += flux_nou;
            v = u;
        }
    }
    return flux;
}
int main()
{
    int x, y, c;
    fin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        fin >> x >> y >> c;
        muchie[i].x = x;
        muchie[i].y = y;
        graph[x][y] = c; 
        graph[y][x] = c;
    }
    EdmonKarp(1, n);
    queue<int> af;
    bfs2(1);
    bfs2(n);
    for (int i = 0; i < m; i++)
    {
        x = muchie[i].x;
        y = muchie[i].y;
        if (ct[x][y] == 2)
        {
            //daca este saturata muchia si de la stanga la dreapta si de la dreapta la stanga
            af.push(i + 1);
        }
    }

    fout << af.size() << '\n';
    while (!af.empty())
    {
        fout << af.front() << '\n';
        af.pop();
    }
}