#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>

#define nodes 1005
#define inf 0x3f3f3f3f

using namespace std;

int n, m, node1[nodes], node2[nodes], father[nodes];
int capacity[nodes][nodes], flow[nodes][nodes];
bool visited_a[nodes], visited_b[nodes];

vector <int> crit, adj[nodes];
queue <int> q;

inline void read()
{
    freopen("critice.in", "r", stdin);
    scanf("%d%d", &n, &m);

    int cap;

    for(int i=1; i<=m; ++i)
    {
        scanf("%d%d%d", &node1[i], &node2[i], &cap);
        adj[ node1[i] ].push_back( node2[i] );
        adj[ node2[i] ].push_back( node1[i] );

        capacity[ node1[i] ][ node2[i] ] = capacity[ node2[i] ][ node1[i] ] = cap;
    }
}

inline void write()
{
    freopen("critice.out", "w", stdout);
    printf("%d\n", crit.size() );
    for( vector <int> :: iterator it = crit.begin(); it != crit.end(); ++it)
        printf("%d\n", *it);
}

inline bool BFS( int node )
{
    bool visited[nodes];
    memset(visited, 0, sizeof(visited));
    q.push( node );
    visited[ node ] = 1;
    while( !q.empty() )
    {
        node = q.front();
        q.pop();
        if( node == n)
            continue;
        for(vector <int> :: iterator it = adj[node].begin(); it != adj[node].end(); ++it)
            if( !visited[*it] && flow[node][*it] != capacity[node][*it] )
            {
                visited[ *it ] = 1;
                q.push( *it );
                father[ *it ] = node;
            }
    }
    return visited[ n ];
}

inline void DFS_a(int node)
{
    visited_a[ node ] = 1;
    for(vector <int> :: iterator it = adj[node].begin(); it != adj[node].end(); ++it)
        if( !visited_a[*it] && capacity[node][*it] > flow[node][*it])
            DFS_a( *it );
}

inline void DFS_b(int node)
{
    visited_b[ node ] = 1;
    for(vector <int> :: iterator it = adj[node].begin(); it != adj[node].end(); ++it)
        if( !visited_b[*it] && capacity[*it][node] > flow[*it][node])
            DFS_b( *it );
}

inline void solve()
{
    int min_flow = 0;
    while( BFS( 1 ) )
        for(vector <int> :: iterator it = adj[n].begin(); it != adj[n].end(); ++it)
        {
            father[ n ] = *it;
            min_flow = inf;

            for( int i = n; i != 1; i = father[i] )
                min_flow = min( min_flow, capacity[father[i]][i] - flow[father[i]][i]);
            for( int i = n; i != 1; i = father[i] )
            {
                flow[father[i]][i] += min_flow;
                flow[i][father[i]] -= min_flow;
            }
        }

    DFS_a( 1 );
    DFS_b( n );
    for(int i=1; i<=m; ++i)
    {
        int cap = capacity[node1[i]][node2[i]];
        if( flow[node1[i]][node2[i]] == cap && visited_a[node1[i]] && visited_b[node2[i]] )
            crit.push_back( i );
        else if( flow[node2[i]][node1[i]] == cap && visited_a[node2[i]] && visited_b[node1[i]] )
            crit.push_back( i );
    }
}

int main()
{
    read();
    solve();
    write();
    return 0;
}