#include <stdio.h>
#include <vector>
#include <queue>
#include <algorithm>

#define NMAX 1005
#define INF 0x3f3f3f3f

using namespace std;

vector<int> G[NMAX],SOL;
vector< pair<int,int> > ARC;
queue<int> Q;
bool viz[NMAX];
bool check[NMAX],check2[NMAX];

int N,M,S,D;
int P[NMAX];
int C[NMAX][NMAX],F[NMAX][NMAX];
int FLOW;

void read()
{
    scanf("%d %d\n",&N,&M);
    S=1;
    D=N;

    for (int i=1;i<=M;i++)
    {
        int a,b,c;
        scanf("%d %d %d\n",&a,&b,&c);
        G[a].push_back(b);
        G[b].push_back(a);
        ARC.push_back(make_pair(a,b));
        C[a][b]=c;
        C[b][a]=c;
    }
}

int BFS()
{
    Q.push(S);
    for (int i=1;i<=N;i++) {viz[i]=0;P[i]=0;}
    viz[S]=1;

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

        if (node!=N)
            for (int i=0;i<G[node].size();i++)
                if (!viz[G[node][i]] && F[node][G[node][i]]<C[node][G[node][i]])
                {
                    viz[G[node][i]]=1;
                    P[G[node][i]]=node;
                    Q.push(G[node][i]);
                }
    }

    return viz[D];
}

void solve()
{
    int val,node;

    while (BFS())
    {
        for (int i=0;i<G[N].size();i++)
        if (viz[G[N][i]] && F[G[N][i]][N]<C[G[N][i]][N])
        {
            val=INF;
            node=N;
            P[N]=G[N][i];
            while (P[node])
            {
                val=min(val,C[P[node]][node]-F[P[node]][node]);
                node=P[node];
            }

            node=N;
            if (val)
                while (P[node])
                {
                    F[P[node]][node]+=val;
                    F[node][P[node]]-=val;
                    node=P[node];
                }
            FLOW+=val;
        }
    }
}

void DFS1(int p)
{
    check[p]=1;

    for (int i=0;i<G[p].size();i++)
        if (!check[G[p][i]] && max(F[p][G[p][i]],F[G[p][i]][p])!=C[p][G[p][i]])
            DFS1(G[p][i]);
}

void DFS2(int p)
{
    check2[p]=1;

    for (int i=0;i<G[p].size();i++)
        if (!check2[G[p][i]] && max(F[p][G[p][i]],F[G[p][i]][p])!=C[p][G[p][i]])
            DFS2(G[p][i]);
}

int main()
{
    freopen ("critice.in","r",stdin);
    freopen ("critice.out","w",stdout);

    read();
    solve();

    DFS1(S);
    DFS2(D);

    for (int i=0;i<ARC.size();i++)
        if ((check[ARC[i].first] && check2[ARC[i].second]) || (check[ARC[i].second] && check2[ARC[i].first]))
            SOL.push_back(i+1);

    printf("%d\n",SOL.size());
    for (int i=0;i<SOL.size();i++)
        printf("%d\n",SOL[i]);

    fclose(stdin);
    fclose(stdout);

    return 0;
}