#include <cstdio>
#include <deque>
#include <cstring>
#include <vector>
#include <algorithm>
#include <bitset>

#define DIM 1024
using namespace std;

int EdgeMatrix[DIM][DIM], Seen[DIM], Father[DIM];
int MaxFlow[DIM][DIM], Quantity[DIM][DIM];
bitset <DIM> Marked; deque <int> Queue;
vector <int> Edges[DIM], Vector;

bool BFS (int startNode, int finishNode)
{
    int ok = 0;
    Marked.reset();
    Queue.clear();

    Queue.push_back(startNode);
    Marked[startNode] = 1;

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

        vector <int> :: iterator it;
        for (it = Edges[node].begin(); it != Edges[node].end(); it ++)
        {
            int nextNode = *it;

            if (!Marked[nextNode] && MaxFlow[node][nextNode] < Quantity[node][nextNode])
            {
                Marked[nextNode] = 1;
                Father[nextNode] = node;
                Queue.push_back(nextNode);

                if (nextNode == finishNode)
                    ok = 1;

            }
        }

        Queue.pop_front();
    }

    return ok;
}

void newBFS (int startNode, int value)
{
    Marked.reset();
    Queue.clear();

    Queue.push_back(startNode);
    Marked[startNode] = 1;

    while (!Queue.empty())
    {
        int node = Queue.front();
        Seen[node] = value;

        vector <int> :: iterator it;
        for (it = Edges[node].begin(); it != Edges[node].end(); it ++)
        {
            int nextNode = *it;

            if (Marked[nextNode]) continue;
            if (MaxFlow[node][nextNode] == Quantity[node][nextNode]) continue;
            if (MaxFlow[nextNode][node] == Quantity[nextNode][node]) continue;

            Marked[nextNode] = 1;
            Queue.push_back(nextNode);
        }

        Queue.pop_front();
    }

    return;
}

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

    int nrNodes, nrEdges, node1, node2, cost;

    scanf ("%d %d", &nrNodes, &nrEdges);

    for (int i = 1; i <= nrEdges; i ++)
    {
        scanf ("%d %d %d", &node1, &node2, &cost);

        Edges[node1].push_back(node2);
        Edges[node2].push_back(node1);

        Quantity[node1][node2] = cost;
        Quantity[node2][node1] = cost;

        EdgeMatrix[node1][node2] = i;
        EdgeMatrix[node2][node1] = i;
    }

    int startNode = 1;
    int finishNode = nrNodes;

    while ( BFS (startNode, finishNode) )
    {
        int node = finishNode;

        vector <int> :: iterator it;
        for (it = Edges[node].begin(); it != Edges[node].end(); it ++)
        {
            int nextNode = *it;

            if (Marked[nextNode] && MaxFlow[nextNode][node] < Quantity[nextNode][node])
            {
                int minim = Quantity[nextNode][node] - MaxFlow[nextNode][node], newNode;

                newNode = nextNode;
                while (Father[newNode])
                {
                    minim = min (minim, Quantity[Father[newNode]][newNode] - MaxFlow[Father[newNode]][newNode]);
                    newNode = Father[newNode];
                }

                MaxFlow[nextNode][node] += minim;
                MaxFlow[node][nextNode] -= minim;

                newNode = nextNode;
                while (Father[newNode])
                {
                    MaxFlow[Father[newNode]][newNode] += minim;
                    MaxFlow[newNode][Father[newNode]] -= minim;
                    newNode = Father[newNode];
                }
            }
        }
    }

    Marked.reset();
    newBFS (startNode , 1);
    newBFS (finishNode, 2);

    int sum = 0;
    for (int i = 1; i <= nrNodes; i ++)
        for (int j = i + 1; j <= nrNodes; j ++)
            if (Seen[i] + Seen[j] == 3 && MaxFlow[i][j] == Quantity[i][j] && EdgeMatrix[i][j])
                sum ++, Vector.push_back(EdgeMatrix[i][j]);
    printf ("%d\n", sum);

    sort (Vector.begin(), Vector.end());

    vector <int> :: iterator it;
    for (it = Vector.begin(); it != Vector.end(); it ++)
        printf ("%d\n", *it);

    fclose (stdin );
    fclose (stdout);

    return 0;
}