#include <fstream>
#include <vector>
#include <queue>
#define VAL 1005
#define MC 10005
#define F first
#define S second
#define INF 1000000000

using namespace std;

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

int N, M, i, j, C;
int flux[VAL][VAL];
int prec[VAL], X;
bool viz[VAL];
pair <int, int> Mc[MC];
vector <int> G[VAL], SOL;
vector <int> :: iterator it;
queue <int> Q;

bool BFS(int S, int D)
{
    for (j=1; j<=N; j++)
      viz[j]=false;
    viz[S]=true;
    Q.push(S);
    while (Q.empty()==false)
    {
        S=Q.front();
        Q.pop();
        if (S==D)
          continue;
        for (it=G[S].begin(); it!=G[S].end(); it++)
        {
            if (viz[*it]==false && flux[S][*it]>0)
            {
                viz[*it]=true;
                prec[*it]=S;
                Q.push(*it);
            }
        }
    }
    return viz[D]==true;
}

void Ford_Fulkerson()
{
    while (BFS(1, N)==true)
    {
        for (i=0; i<G[N].size(); i++)
        {
            X=INF;
            prec[N]=G[N][i];
            for (j=N; j!=1; j=prec[j])
              X=min(X, flux[prec[j]][j]);
            if (X==0)
              continue;
            for (j=N; j!=1; j=prec[j])
            {
                flux[prec[j]][j]-=X;
                flux[j][prec[j]]+=X;
            }
        }
    }
}

bool Check(pair <int, int> M)
{
    return ((BFS(1, M.F)==1 && BFS(M.S, N)==1) || (BFS(1, M.S)==1 && BFS(M.F, N)==1));
}

int main()
{
    fin >> N >> M;
    for (i=1; i<=M; i++)
    {
        fin >> Mc[i].F >> Mc[i].S >> C;
        flux[Mc[i].F][Mc[i].S]=C;
        flux[Mc[i].S][Mc[i].F]=C;
        G[Mc[i].F].push_back(Mc[i].S);
        G[Mc[i].S].push_back(Mc[i].F);
    }
    Ford_Fulkerson();
    for (i=1; i<=M; i++)
      if (Check(Mc[i])==true)
        SOL.push_back(i);
    fout << SOL.size() << '\n';
    for (i=0; i<SOL.size(); i++)
      fout << SOL[i] << '\n';
    fin.close();
    fout.close();
    return 0;
}