#include <fstream>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;

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

#define DIM 1000
#define INF (1LL << 30)

int n, m, flux;
int C[DIM + 1][DIM + 1], F[DIM + 1][DIM + 1], t[DIM + 1];
vector <int> G[DIM + 1];
struct nanu {
  int x, y;
}M[DIM * 10 + 1];

static inline bool Bfs(int S, int D) {
  for(int i = 1; i <= n; i++)
    t[i] = 0;
  t[S] = -1;  //sursa n are tata;

  queue <int> Q;
  Q.push(S);
  bool ok = 0;          //daca ajungem in D;
  while(!Q.empty()) {
    int nod = Q.front();
    Q.pop();

    for(auto e : G[nod]) 
      if(!t[e] && C[nod][e] > F[nod][e])
        if(e != D) {      //daca nu am ajuns la destinatie;
          t[e] = nod; 
          Q.push(e);
        }else ok = 1;
  }
  return ok;
}

static inline void Dinic(int S, int D) {
  flux = 0;
  for(int drum = Bfs(S, D); drum; drum = Bfs(S, D))
    for(auto e : G[D]) {
      if(t[e] && C[e][D] > F[e][D]) {
        t[D] = e;

        int minim = INF;
        int nod = D;
        while(nod != S) {
          minim = min(minim, C[t[nod]][nod] - F[t[nod]][nod]);
          nod = t[nod];
        }

        if(minim <= 0)
          continue;
        
        flux += minim;
        nod = D;
        while(nod != S) {
          F[t[nod]][nod] += minim;
          F[nod][t[nod]] -= minim;
          nod = t[nod];
        }
      }
    }
}

int main() {
  fin >> n >> m;
  for(int i = 1; i <= m; i++) {
    int x, y, c;

    fin >> x >> y >> c;
    C[x][y] = C[y][x] = c;  //graf neorientat;
    G[x].push_back(y);
    G[y].push_back(x);
    M[i] = {x, y};           //retin muchia;
  }

  Dinic(1, n);
  vector <int > ans;
  for(int i = 1; i <= m; i++) {
    int st = M[i].x;
    int dr = M[i].y;
    if(C[st][dr] != F[st][dr] && F[st][dr] > 0)
      ans.push_back(i);
  }
  fout << ans.size() << '\n';
  for(auto e : ans)
    fout << e << '\n';

  return 0;
}