#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;
};

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;

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++)
    {
        int a = G[vert][i];

        if (!b[a] && flow[vert][a] != cap[vert][a] && flow[a][vert] != cap[vert][a])
           dfs(b,a);
    }
}

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

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

     for (int i = 1;i <= m;i++)
     {
         int a,b,c;
         scanf("%d %d %d",&a,&b,&c);
         E[i].x = a;
         E[i].y = b;
         cap[a][b] += c;
         cap[b][a] += c;
         G[a].push_back(b);
         G[b].push_back(a);
     }

     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;
}