#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>

#define pii pair <int, int>

using namespace std;

int n, m;
queue <int> q;
vector <pii> edge;
vector <int> sol, v[1024], lst;
bool ap[2][1024];
int t[1024], c[1024][1024], f[1024][1024];

inline bool bfs ()
{
    t[1] = -1;
    q.push (1);

    bool OK = false;
    for (; !q.empty ();)
    {
        int nod = q.front ();
        q.pop ();

        for (auto &it : v[nod])
        {
            if (t[it] || c[nod][it] == f[nod][it]) continue;

            if (it == n)
            {
                OK = true;
                lst.push_back (nod);
                continue;
            }

            t[it] = nod;
            q.push (it);
        }
    }

    return OK;
}

inline void dfs (int nod, int val)
{
    ap[val][nod] = true;
    for (auto &it : v[nod])
        if (!ap[val][it] && ((!val && f[nod][it] < c[nod][it]) || (val && f[it][nod] < c[it][nod])))
            dfs (it, val);
}

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

    scanf ("%d %d", &n, &m);

    for (int i = 1; i <= m; ++i)
    {
        int x, y, cost;
        scanf ("%d %d %d", &x, &y, &cost);

        edge.push_back ({x, y});
        c[x][y] = c[y][x] = cost;

        v[x].push_back (y);
        v[y].push_back (x);
    }

    for (; bfs ();)
    {
        for (auto &it : lst)
        {
            t[n] = it;
            int nod = n, mi = 2000000000;

            for (; t[nod] != -1; nod = t[nod])
                mi = min (mi, c[t[nod]][nod] - f[t[nod]][nod]);

            nod = n;
            for (; t[nod] != -1; nod = t[nod])
                f[t[nod]][nod] += mi,
                f[nod][t[nod]] -= mi;
        }

        for (int i = 1; i <= n; ++i)
            t[i] = 0;

        lst.clear ();
    }

    dfs (1, 0);
    dfs (n, 1);

    int nr = 0;
    for (auto &it : edge)
    {
        int x, y;
        tie (x, y) = it;

        ++nr;
        if ((f[x][y] == c[x][y] || f[y][x] == c[y][x]) && ((ap[0][x] && ap[1][y]) || (ap[1][x] && ap[0][y])))
            sol.push_back (nr);
    }

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

    for (auto &it : sol)
        printf ("%d\n", it);

    return 0;
}