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

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

int N, M;

int cap[1005][1005], flow[1005][1005];

struct Edge
{
    int dest, idx;
};

vector <Edge> v[1005];

int path[1005];
bool viz[1005];

bool bfs()
{
    for(int i = 1; i <= N; i++)
        path[i] = 0, viz[i] = false;

    queue <int> coada;

    coada.push(1);
    viz[1] = true;

    while(!coada.empty())
    {
        int node = coada.front();
        coada.pop();

        for(int i = 0; i < v[node].size(); i++)
            if(flow[node][v[node][i].dest] < cap[node][v[node][i].dest]
               && viz[v[node][i].dest] == false)
        {
            coada.push(v[node][i].dest);
            viz[v[node][i].dest] = true;
            path[v[node][i].dest] = node;
        }
    }

    return viz[N];
}

bool from1[10005], fromN[10005], viz1[1005], vizN[1005];

void BFS1()
{
    queue <int> coada;

    coada.push(1);
    viz1[1] = true;

    while(!coada.empty())
    {
        int node = coada.front();
        coada.pop();

        for(int i = 0; i < v[node].size(); i++)
            if(flow[node][v[node][i].dest] < cap[node][v[node][i].dest]
               && viz1[v[node][i].dest] == false)
        {
            coada.push(v[node][i].dest);
            viz1[v[node][i].dest] = true;
        }
        else
           if(flow[node][v[node][i].dest] == cap[node][v[node][i].dest])
                from1[v[node][i].idx] = true;
    }
}

void BFSN()
{
    queue <int> coada;

    coada.push(N);
    vizN[N] = true;

    while(!coada.empty())
    {
        int node = coada.front();
        coada.pop();

        for(int i = 0; i < v[node].size(); i++)
            if(abs(flow[node][v[node][i].dest]) < cap[node][v[node][i].dest]
               && vizN[v[node][i].dest] == false)
        {
            coada.push(v[node][i].dest);
            vizN[v[node][i].dest] = true;
        }
        else
           if(abs(flow[node][v[node][i].dest]) == cap[node][v[node][i].dest])
                fromN[v[node][i].idx] = true;
    }
}

int main()
{
    fin >> N >> M;

    for(int i = 1; i <= M; i++)
    {
        int x, y, z;

        fin >> x >> y >> z;

        v[x].push_back({y, i});
        v[y].push_back({x, i});

        cap[x][y] = cap[y][x] = z;
    }

    while(bfs())
    {
        for(int i = 0; i < v[N].size(); i++)
        {
            int vecin = v[N][i].dest;

            int toadd = cap[vecin][N] - flow[vecin][N];

            for(int it = vecin; it != 1; it = path[it])
                toadd = min(toadd, cap[path[it]][it] - flow[path[it]][it]);

            flow[vecin][N] += toadd;
            flow[N][vecin] -= toadd;

            for(int it = vecin; it != 1; it = path[it])
            {
                flow[path[it]][it] += toadd;
                flow[it][path[it]] -= toadd;
            }
        }
    }

    BFS1();
    BFSN();

    vector <int> sol;

    for(int i = 1; i <= M; i++)
        if(from1[i] == true && fromN[i] == true)
        sol.push_back(i);

    fout << sol.size() << '\n';

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

    return 0;
}