#include <fstream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;

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

using VI = vector<int>;
const int Inf = 0x3f3f3f3f;
const int MAXN = 1005;
const int MAXM = 10005;
int C[MAXN][MAXN];
int f[MAXN][MAXN];
vector<vector<int>> G;
int flow;
int N, M;
vector< pair<int, int> > m;
vector<bool> viz;
vector<int> t;
vector<int> ind;
bool d[MAXN][MAXN];

void Read();
void MaxFlow();
void Solve();
void Write();
bool BF();
bool BF2( int n1, int n2 );

int main()
{
    Read();
    Solve();
    Write();

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

void Read()
{
    int x, y, z;

    fin >> N >> M;
    G = vector<vector<int>>(N + 1);
    for ( int i = 0; i < M; ++i )
    {
        fin >> x >> y >> z;

        G[x].push_back(y);
        G[y].push_back(x);
        C[x][y] = C[y][x] = z;

        m.push_back({x, y});
    }
}

void MaxFlow()
{
    for ( ; BF(); )
        for ( const auto& x : G[N] )
        {
            if ( !viz[x] || C[x][N] == f[x][N] ) continue;

            t[N] = x;

            int flux{Inf};
            for ( int y = N; y != 1; y = t[y] )
                flux = min( flux, C[t[y]][y] - f[t[y]][y] );

            flow += flux;

            for ( int y = N; y != 1; y = t[y] )
            {
                f[t[y]][y] += flux;
                f[y][t[y]] -= flux;
            }
        }
}

void Solve()
{
    MaxFlow();

    for ( size_t i = 0; i < m.size(); ++i )
    {
        int x = m[i].first, y = m[i].second;
        bool v1 = BF2(1, x);
        bool v2 = BF2(y, N);

        if ( v1 && v2 )
        {
            ind.push_back(i + 1);
            continue;
        }

        v1 = BF2(1, y);
        v2 = BF2(x, N);

        if ( v1 && v2 )
            ind.push_back(i + 1);
    }
}

void Write()
{
    fout << ind.size() << '\n';
    for ( const auto& x : ind )
        fout << x << '\n';
}

bool BF()
{
    viz = vector<bool>(N + 1, 0);
    t = vector<int>(N + 1);
    queue<int> Q;

    viz[1] = true;
    Q.push(1);

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

        for ( const auto& v : G[x] )
        {
            if ( viz[v] || C[x][v] == f[x][v] ) continue;

            viz[v] = true;
            t[v] = x;
            Q.push(v);
        }
    }

    return viz[N];
}

bool BF2( int n1, int n2 )
{
    viz = vector<bool>(N + 1, 0);
    queue<int> Q;

    viz[n1] = true;
    Q.push(n1);

    if ( n1 == n2 )
        return true;

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

        for ( const auto& v : G[x] )
        {
            if ( viz[v] || C[x][v] == f[x][v] ) continue;

            if ( v == n2 )
                return true;

            viz[v] = true;
            Q.push(v);
        }
    }

    return false;
}