#include <cstdio>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <queue>
#include <cstring>
using namespace std;


#define nmax 1010
#define pb push_back
#define mp make_pair
#define from first
#define to second
#define INF 0x3f3f3f3f
#define PI pair<int, int>

int N, M, nr, sol[10 * nmax], a, b, c, minFlow, maxFlow;
int flow[nmax][nmax];
int cap[nmax][nmax];
int father[nmax];
PI edge[10 * nmax];
bool visitS[nmax];
bool visitD[nmax];
vector<int> G[nmax];

void MaxFlow();
bool BFS();
void DFS(int node, bool used[]);

int main()
{
    freopen("critice.in", "r", stdin);
    freopen("critice.out", "w", stdout);
    int i, j, val;
    scanf("%i %i", &N, &M);
    for(i = 1; i <= M; i++)
    {
          scanf("%i %i %i", &a, &b, &c);
          cap[a][b] += c; cap[b][a] += c;
          G[a].pb(b); G[b].pb(a);
          edge[i] = mp(a, b);
    }
    MaxFlow();
    DFS(1, visitS);
    DFS(N, visitD);
    for(i = 1; i <= M; i++)
          if((visitS[edge[i].from] && visitD[edge[i].to]) || (visitS[edge[i].to] && visitD[edge[i].from]))
                                   sol[nr ++] = i;
    printf("%i\n", nr);
    for(i = 0; i < nr; i++) printf("%i\n", sol[i]);
    return 0;
}
    
void MaxFlow()
{
     vector<int> :: iterator it;
     while(BFS())
     {
                 for(it = G[N].begin(); it != G[N].end(); ++ it)
                 {
                        if(visitS[*it] && flow[*it][N] != cap[*it][N])
                        {
                                       father[N] = *it;
                                       minFlow = INF;
                                       for(int node = N; node != 1; node = father[node])
                                               minFlow = min(minFlow, cap[father[node]][node] - flow[father[node]][node]);
                                       if(minFlow)
                                       {
                                                  for(int node = N; node != 1; node = father[node])
                                                  {
                                                          flow[father[node]][node] += minFlow;
                                                          flow[node][father[node]] -= minFlow;
                                                  }
                                                  maxFlow += minFlow;
                                       }
                        }
                 }
     }
     memset(visitS, 0, sizeof(visitS));
}

bool BFS()
{
     memset(visitS, 0, sizeof(visitS));
     visitS[1] = true;
     int node;
     vector<int> :: iterator it;
     queue<int> q;
     q.push(1);
     while(!q.empty())
     {
                      node = q.front();
                      q.pop();
                      if(node == N) continue;
                      for(it = G[node].begin(); it != G[node].end(); ++ it)
                      {
                             if(!visitS[*it] && flow[node][*it] < cap[node][*it])
                             {
                                             visitS[*it] = true;
                                             father[*it] = node;
                                             q.push(*it);
                             }
                      }
     }
     return visitS[N];
}

void DFS(int node, bool used[])
{
     used[node] = true;
     vector<int> :: iterator it;
     for(it = G[node].begin(); it != G[node].end(); ++ it)
            if(!used[*it] && cap[node][*it] > flow[node][*it] && cap[*it][node] > flow[*it][node])
                          DFS(*it, used);
}