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

using namespace std;

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

int N, M;
int TT[1010], C[1010][1010], F[1010][1010];
vector < int > V[1010], Sol;
vector < pair < int, int > > ID;
bool Viz[1010], S[2][1010];

bool BFS()
{
    queue < int > Q;
    Q.push(1);
    memset(Viz, 0, sizeof(Viz));
    Viz[1] = true;

    while (!Q.empty())
    {
        int nod = Q.front();
        Q.pop();

        if (nod == N) continue;
        for (vector < int > :: iterator it = V[nod].begin(); it != V[nod].end(); it++)
        {
            if (C[nod][*it] == F[nod][*it] || Viz[*it]) continue;
            Viz[*it] = true;
            Q.push(*it);
            TT[*it] = nod;
        }
    }

    return Viz[N];
}

void DFS(int nod, int l)
{
    S[l][nod] = true;
    for (vector < int > :: iterator it = V[nod].begin(); it != V[nod].end(); it++) {
        if (!S[l][*it] && max(F[nod][*it], F[*it][nod]) != max(C[nod][*it], C[*it][nod])) {
            DFS(*it, l);
        }
    }
}

int main()
{
    fin >> N >> M;
    for (int x, y, c, i = 1; i <= M; i++)
    {
        fin >> x >> y >> c;
        C[x][y] = C[y][x] = c;
        ID.push_back( { x, y } );
        V[x].push_back(y);
        V[y].push_back(x);
    }

    while (BFS())
    {
        for (int i = 0; i < V[N].size(); i++)
        {
            TT[N] = V[N][i];
            if (C[TT[N]][N] == F[TT[N]][N] || !Viz[TT[N]]) continue;

            int flow = 10000;
            for (int nod = TT[N]; nod != 1; nod = TT[nod])
            {
                flow = min(flow, C[TT[nod]][nod] - F[TT[nod]][nod]);
            }

            for (int nod = TT[N]; nod != 1; nod = TT[nod])
            {
                F[TT[nod]][nod] += flow;
                F[nod][TT[nod]] -= flow;
            }
        }
    }

    DFS(1, 0);
    DFS(N, 1);

    for (int i = 0; i < ID.size(); i++) {
        if ((S[0][ID[i].first] && S[1][ID[i].second]) || (S[0][ID[i].second] && S[1][ID[i].first])) {
            Sol.push_back(i + 1);
        }
    }

    fout << Sol.size() << '\n';
    for (auto it : Sol) fout << it << '\n';
    return 0;
}