#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>

using namespace std;

#define Nmax 1003
#define INF 0x3f3f3f3f
#define abs(x) ((x) < 0?(-x):(x))

class edge
{
    public:

        int x;
        int y;
};

vector <int> G[Nmax];
int tata[Nmax];
edge muchii[Nmax*6];
bool viz[Nmax], viz_sourse[Nmax], viz_dest[Nmax];
int coada[Nmax];
int F[Nmax][Nmax];
int C[Nmax][Nmax];
int sol[Nmax*6];

int N, M;

void read()
{
    ifstream f("critice.in");

    f >> N >> M;

    for ( int i = 1, a, b, c; i <= M; ++i )
    {
        f >> a >> b >> c;

        C[a][b]= C[b][a] = c;

        G[a].push_back( b );
        G[b].push_back( a );

        muchii[i] = { a, b };

    }

    f.close();
}

inline bool BFS( int sourse, int destination )
{
    memset( viz, 0, sizeof( viz ) );

    int st, dr;

    coada[st = dr = 1] = sourse;
    viz[sourse] = 1;

    for ( ; st <= dr; )
    {
        int nod = coada[ st++ ];

        for ( unsigned i = 0; i < G[nod].size(); ++i )
        {
            int vertex = G[nod][i];

            if ( viz[vertex] || F[nod][vertex] >= C[nod][vertex] )
                    continue;

            tata[vertex] = nod;
            viz[vertex] = 1;

            coada[ ++dr ] = vertex;

            if ( vertex == destination )
                    return true;
        }
    }

    return false;
}

void Edmonds_Karp( int sourse, int destination )
{
    int flow, fmin, nod;

    while( BFS( sourse, destination ) )
    {
        for ( unsigned i = 0; i < G[destination].size(); ++i )
        {
            int son = G[destination][i];

            if ( !viz[son] || F[son][destination] >= C[son][destination] )
                    continue;

            tata[destination] = son;

            fmin = INF;

            for ( nod = destination; nod != sourse; nod = tata[nod] )
                    fmin = min( fmin, C[ tata[nod] ][nod] - F[ tata[nod] ][nod] );

            if ( fmin == 0 )
                    continue;

            for ( nod = destination; nod != sourse; nod = tata[nod] )
            {
                F[ tata[nod] ][nod] += fmin;
                F[nod][ tata[nod] ] -= fmin;
            }

            flow += fmin;
        }
    }
}

void BF( int sourse, bool vvv[] )
{
    memset( vvv, 0, sizeof( vvv ) );

    int st, dr;

    coada[st = dr = 1] = sourse;
    vvv[sourse] = 1;

    for ( ; st <= dr; )
    {
        int x = coada[ st++ ];

        for ( unsigned i = 0; i < G[x].size(); ++i )
        {
            int y = G[x][i];

            if ( !vvv[y] && abs(F[x][y]) < C[x][y] )
            {
                vvv[y] = 1;
                coada[ ++dr ] = y;
            }
        }
    }
}

void solve()
{
    for ( int i = 1; i <= M; ++i )
    {
        int x = muchii[i].x;
        int y = muchii[i].y;

        if( ( ( viz_sourse[x] && viz_dest[y] ) || ( viz_sourse[y] && viz_dest[x] ) ) &&
            ( C[x][y] == F[x][y] || C[y][x] == F[y][x] ) )
                sol[ ++sol[0] ] = i;
    }
}

void print()
{
    ofstream g("critice.out");

    g << sol[0] << "\n";

    for ( int i = 1; i <= sol[0]; ++i )
            g << sol[i] << "\n";

    g.close();
}

int main()
{
    read();
    Edmonds_Karp( 1, N );
    BF( 1, viz_sourse );
    BF( N, viz_dest );
    solve();
    print();

    return 0;
}