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

using namespace std;

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

const int INF = 0x3f3f3f3f;

int N, M, maxflow, nr;
int fromOne[1005], fromN[1005], sol[10005];
int C[1005][1005], F[1005][1005], TT[1005];
vector<int> V[1005];
queue<int> Q;
bool used[1005];

struct perechi
{
    int x, y;
};
perechi P[10005];

bool bfs()
{
    memset(used, false, sizeof(used));
    Q.push(1);
    used[1] = true;

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

        if (now == N)
            continue;

        for (vector<int>::iterator it = V[now].begin(); it != V[now].end(); ++it)
        {
            if (F[now][*it] < C[now][*it] && !used[*it])
            {
                TT[*it] = now;
                used[*it] = true;
                Q.push(*it);
            }
        }
    }

    return used[N];
}

void bfsFromOne()
{
    memset(used, false, sizeof(used));
    fromOne[1] = 1;
    used[1] = true;
    Q.push(1);

    while (!Q.empty())
    {
        int now = Q.front();
        Q.pop();
        fromOne[now] = 1;

        if (now == N)
            continue;

        for (vector<int>::iterator it = V[now].begin(); it != V[now].end(); ++it)
        {
            if (F[now][*it] < C[now][*it] && !used[*it])
            {
                used[*it] = true;
                Q.push(*it);
            }
        }
    }
}

void bfsFromN()
{
    memset(used, false, sizeof(used));
    used[N] = true;
    Q.push(N);

    while (!Q.empty())
    {
        int now = Q.front();
        Q.pop();
        fromN[now] = N;

        if (now == 1)
            continue;

        for (vector<int>::iterator it = V[now].begin(); it != V[now].end(); ++it)
        {
            if (F[*it][now] < C[*it][now] && !used[*it])
            {
                used[*it] = true;
                Q.push(*it);
            }
        }
    }
}

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

    int fmin = INF;;
    while (bfs())
    {
        for (vector<int>::iterator it = V[N].begin(); it != V[N].end(); ++it)
        {
            if (!used[*it])
                continue;
            TT[N] = *it;
            fmin = INF;
            for (int nod = N; nod != 1; nod = TT[nod])
                fmin = min(fmin, C[TT[nod]][nod] - F[TT[nod]][nod]);
            if (fmin == 0)
                continue;

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

            maxflow += fmin;
        }
    }

    bfsFromOne();
    bfsFromN();


    for (int i = 1, nod1, nod2; i <= M; ++i)
    {
        nod1 = P[i].x;
        nod2 = P[i].y;
        if (C[nod1][nod2] == F[nod1][nod2] || C[nod1][nod2] == F[nod2][nod1]) // e saturata
        {
            if ((fromOne[nod1] && fromN[nod2]) || (fromOne[nod2] && fromN[nod1]))
                sol[++nr] = i;
        }
    }
    fout << nr << '\n';
    for (int i = 1; i <= nr; ++i)
        fout << sol[i] << '\n';

    fin.close();
    fout.close();
    return 0;
}