#include <bits/stdc++.h>

using namespace std;

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

const int N = 1005;

int flow[N][N], cap[N][N], f[N], n, m;
bool vis[N];
vector<int> g[N], sol;
vector<pair<int,int>> edge;
queue<int> q;

bool bfs() {
   memset(vis, 0, sizeof(vis));
   vis[1] = 1;
   q.push(1);
   while (!q.empty()) {
      int cur = q.front();
      q.pop();
      if(cur == n) continue;
      for(auto nxt : g[cur]) {
         if(!vis[nxt] && flow[cur][nxt] < cap[cur][nxt]) {
            f[nxt] = cur;
            vis[nxt] = 1;
            q.push(nxt);
         }
      }
   }
   return vis[n];
}

void dfs1(int cur, int forb) {
   vis[cur] = 1;
   for(int nxt : g[cur]) {
      if (!vis[nxt] && nxt != forb && flow[nxt][cur] < cap[nxt][cur]) {
         dfs1(nxt, forb);
      }
   }
}

void dfs2(int cur, int forb) {
   vis[cur] = 1;
   for (int nxt : g[cur]) {
      if (!vis[nxt] && nxt != forb && flow[cur][nxt] < cap[cur][nxt]) {
         dfs2(nxt, forb);
      }
   }
}

int main() {
   int i, a, b, c, fmin;
   in >> n >> m;
   for (i = 1; i <= m; i++) {
      in >> a >> b >> c;
      g[a].push_back(b);
      g[b].push_back(a);
      cap[a][b] = cap[b][a] = c;
      edge.push_back(make_pair(a, b));
   }
   while (bfs()) {
      for (auto start : g[n]) {
         if (!vis[start] || cap[start][n] == flow[start][n]) continue;
         f[n] = start;
         fmin = 0x3f3f3f3f;
         for (i = n; i != 1; i = f[i]) {
            fmin = min(fmin, cap[f[i]][i] - flow[f[i]][i]);
         }
         for (i = n; i != 1; i = f[i]) {
            flow[f[i]][i] += fmin;
            flow[i][f[i]] -= fmin;
         }
      }
   }
   for (i = 0; i < edge.size(); i++) {
      a = edge[i].first;
      b = edge[i].second;
      if(cap[a][b] == flow[a][b] || cap[b][a] == flow[b][a]) {
         memset(vis, 0, sizeof(vis));
         if(cap[a][b] == flow[a][b]) {
            dfs1(a, b);
            dfs2(b, a);
         }
         else {
            dfs1(b, a);
            dfs2(a, b);
         }
         if (vis[1] && vis[n]) {
            sol.push_back(i + 1);
         }
      }
   }
   out << sol.size() << '\n';
   for (i = 0; i < sol.size(); i++) {
      out << sol[i] << '\n';
   }
   return 0;
}