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

#define DIM 1024
using namespace std;

int Seen[DIM], Father[DIM];
int Marked1[DIM], Marked2[DIM];
int MaxFlow[DIM][DIM], Quantity[DIM][DIM];

bitset <DIM> Marked; deque <int> Queue;
vector <int> Edges[DIM], Vector;
pair <int, int> SolEdges[DIM*10];

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, int Marked[])
{
    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;

        SolEdges[i].first  = node1;
        SolEdges[i].second = node2;
    }

    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, Marked1);
    newBFS (finishNode, 2, Marked2);

    for (int i = 1; i <= nrEdges; i ++)
    {
        int ok = 0;
        node1 = SolEdges[i].first;
        node2 = SolEdges[i].second;

        if (MaxFlow[node1][node2] == Quantity[node1][node2])
            if (Marked1[node1] && !Marked1[node2])
                if (!Marked2[node1] && Marked2[node2])
                    Vector.push_back(i), ok = 1;

        if (!ok)
        {
            swap (node1, node2);

            if (MaxFlow[node1][node2] == Quantity[node1][node2])
                if (Marked1[node1] && !Marked1[node2])
                    if (!Marked2[node1] && Marked2[node2])
                        Vector.push_back(i), ok = 1;
        }
    }

    printf ("%d\n", Vector.size());

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

    fclose (stdin );
    fclose (stdout);

    return 0;
}