#include <fstream>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
ifstream f("critice.in");
ofstream g("critice.out");
int N,M,MaxFlow;
const int NMax = 1005;
const int MMax = 10005;
int G[NMax][NMax];
queue <int> Q;
int C[NMax][NMax],Use[NMax],F[NMax][NMax],TT[NMax];
pair <int,int> E[MMax];
vector <int> Sol;
void Read()
{
    f>>N>>M;
    for(int i=1; i<= M ; i++)
    {
        int x,y,c;
        f>>x>>y>>c;
        G[x][++G[x][0]]=y;
        G[y][++G[y][0]]=x;
        C[x][y] += c;
        C[y][x] += c;
        E[i]=make_pair(x,y);
    }
}

int BFS()
{
    for(int i=1;i<=N;i++)
        Use[i]=0;
    Q.push(1); Use[1] = 1;

    while(!Q.empty())
    {
        int Node = Q. front(); Q. pop();

        if(Node == N) continue;

        for(unsigned int i = 1; i <= G[Node][0]; ++i)
        {
            int Neighbour = G[Node][i];

            if(!Use[Neighbour] && C[Node][Neighbour]-F[Node][Neighbour]>0)
            {
                TT[Neighbour] = Node;
                Q.push(Neighbour);
                Use[Neighbour] = 1;
            }
        }
    }

return Use[N];

}

void maxFlow()
{
    while(BFS())
    {

        for(unsigned int k = 1; k<=G[N][0]; ++k)
        {

        int Vecin = G[N][k];

        if(!Use[Vecin] || C[Vecin][N]-F[Vecin][N] == 0) continue;

        TT[N] = Vecin;

        int Fmin = 0x3f3f3f3f;

        for(int i = N ; i != 1 ; i = TT[i])
            Fmin = min(Fmin,C[TT[i]][i]-F[TT[i]][i]);

        MaxFlow += Fmin;

        for(int i = N ; i != 1 ; i = TT[i])
        {
            F[TT[i]][i] += Fmin;
            F[i][TT[i]] -= Fmin;
        }
        }
    }
}
bool BFS1(int x)
{
    Q.push(1);
    for(int i=1;i<=N;i++)
        Use[i]=0;
    Use[1]=1;
    while(!Q.empty())
    {
        int node=Q.front();
        Q.pop();
        if(node==x)
        {
            while(!Q.empty())
                Q.pop();
            return 1;
        }

        for(int i=1;i<=G[node][0];i++)
        {
            int neighb=G[node][i];
            if(Use[neighb]==0 && C[node][neighb]-F[node][neighb]>0)
            {
                Q.push(neighb);
                Use[neighb]=1;
            }
        }
    }
    return 0;
}
bool BFS2(int x)
{
    Q.push(x);
    for(int i=1;i<=N;i++)
        Use[i]=0;
    Use[x]=1;
    while(!Q.empty())
    {
        int node=Q.front();
        Q.pop();
        if(node==N)
        {
            while(!Q.empty())
                Q.pop();
            return 1;
        }

        for(int i=1;i<=G[node][0];i++)
        {
            int neighb=G[node][i];
            if(Use[neighb]==0 && C[node][neighb]-F[node][neighb]>0)
            {
                Q.push(neighb);
                Use[neighb]=1;
            }
        }
    }
    return 0;
}
void findEdges()
{
    for(int i=1;i<=M;i++)
    {
        int x=E[i].first,y=E[i].second;
        if(F[x][y]<0)
            swap(x,y);
        if(BFS1(x) && BFS2(y))
            Sol.push_back(i);
    }
}
void Print()
{
    g<<Sol.size()<<"\n";
    for(int i=0;i<Sol.size();i++)
        g<<Sol[i]<<"\n";
}
int main()
{
    Read();
    maxFlow();
    findEdges();
    Print();
    return 0;
}