#include <bits/stdc++.h>

using namespace std;

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

const int MAXN = 1002;
const int INF  =  10002;

int N,M,nr,x,y,i,j;
int c[MAXN][MAXN],f[MAXN][MAXN],parent[MAXN],visited[MAXN],visited1[MAXN],visited2[MAXN],critice[MAXN];

vector <int>G[MAXN],ANS;
vector <pair<int,int>> edges;

int BFS()
{

    memset(parent,0,sizeof(parent));
    memset(visited,0,sizeof(visited));
    memset(critice,0,sizeof(critice));

    parent[1] = 1;
    critice[++critice[0]] = 1;

    for (i = 1; i <= critice[0]; i++)
    {
        int x = critice[i];
        for (auto elem : G[x])
            if (!visited[elem]&& c[x][elem] > f[x][elem])
                {
                    visited[elem] = 1;
                    parent[elem] = x;
                    critice[++critice[0]] = elem;
                }
    }
    return visited[N];
}

void DFS(int node,int vis[])
{

    memset(vis,0,sizeof(vis));
    vis[node] = 1;
    for(auto x : G[node])
    {
        if(!vis[x] && f[node][x]<c[node][x] && f[x][node]<c[x][node])
        {
            DFS(x,vis);
        }
    }
}

void maxflow()
{
    int fmin = 0;
    while (BFS())
    {
        fmin=INF;
        for(auto x : G[N])
        if(visited[x])
        {
            fmin=c[x][N]-f[x][N];
            for(i=x;i>1;i=parent[i])
            {
                if(fmin > c[parent[i]][i]-f[parent[i]][i])
                    fmin=c[parent[i]][i]-f[parent[i]][i];

            }
            f[x][N]+=fmin;
            f[N][x]-=fmin;

            for(i=x;i>1;i=parent[i])
            {
                f[parent[i]][i]+=fmin;
                f[i][parent[i]]-=fmin;
            }
        }

    }
}

int main()
{

    in>>N>>M;
    for (i = 1; i <= M; i++)
    {
        int x,y,cost;
        in>>x>>y>>cost;
        G[x].push_back(y);
        G[y].push_back(x);

        c[x][y] = cost;
        c[y][x] = cost;
        edges.push_back(make_pair(x,y));
    }

    maxflow();

    DFS(1,visited1);


    for (i = 0; i <M; i++)
        {
            x = edges[i].first;
            y = edges[i].second;
            if( visited1[x]&&!visited1[y] || visited1[y] && !visited1[x])
                ANS.push_back(i+1);
        }
    out<<ANS.size()<<"\n";
    for (i = 0; i <ANS.size(); i++)
        {
            out<<ANS[i]<<"\n";
        }
    return 0;
}