#include <stdio.h>
#include <string.h>
#include <vector>
#include <deque>
#include <algorithm>

using namespace std;

const int Mn = 1004;
const int oo = 1 << 30;

struct edge
{
    int x,y,r;
};

int n,m;
int parent[Mn];
int flow[Mn][Mn],cap[Mn][Mn];
bool vis[Mn],src[Mn],dst[Mn];
edge E[Mn * 10];
vector< int > G[Mn],sol;
deque< int > dq;

edge make_edge()
{
    edge aux;
    scanf("%d %d %d",&aux.x,&aux.y,&aux.r);
    return aux;
}

bool bfs()
{
    dq.clear();
    dq.push_back(1);
    memset(vis,0,sizeof(vis));
    memset(parent,0,sizeof(parent));
    vis[1] = 1;

    while (!dq.empty())
    {
        int a = dq.front();

        dq.pop_front();

        if (a == n)
           continue;

        for (int i = 0;i < G[a].size();i++)
        {
            int b = G[a][i];

            if (vis[b] || cap[a][b] == flow[a][b])
               continue;

            vis[b] = 1;
            dq.push_back(b);
            parent[b] = a;
        }
    }

    return vis[n];
}

void max_flow()
{
    while (bfs())
    {
        for (int i = 0;i < G[n].size();i++)
        {
            int a = G[n][i],b = oo;

            if (!vis[n] || cap[a][n] == flow[a][n])
               continue;

            parent[n] = a;

            for (a = n;a != 1;a = parent[a])
                b = min(b,cap[parent[a]][a] - flow[parent[a]][a]);

            if (!b)
               continue;

            for (a = n;a != 1;a = parent[a])
                flow[parent[a]][a] += b,
                flow[a][parent[a]] -= b;
        }
    }
}

void dfs(bool b[Mn],int vert)
{
    b[vert] = 1;

    for (int i = 0;i < G[vert].size();i++)
        if (!b[G[vert][i]] && flow[vert][G[vert][i]] != cap[vert][G[vert][i]])
           dfs(b,G[vert][i]);
}

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

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

     for (int i = 1;i <= m;i++)
     {
         E[i] = make_edge();
         cap[E[i].x][E[i].y] += E[i].r;
         cap[E[i].y][E[i].x] += E[i].r;
         G[E[i].x].push_back(E[i].y);
         G[E[i].y].push_back(E[i].x);
     }

     max_flow();
     dfs(src,1);
     dfs(dst,n);

     for (int i = 1;i <= m;i++)
         if ((src[E[i].x] && dst[E[i].y]) || (src[E[i].y] && dst[E[i].x]))
            sol.push_back(i);

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

     for (int i = 0;i < sol.size();i++)
         printf("%d\n",sol[i]);

  return 0;
}