#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>

#define NMAX 1005
#define inf 0x3f3f3f3f

using namespace std;

int N,M;
int capacitate[NMAX][NMAX],utilizat[NMAX][NMAX];
int viz_plecare[NMAX],viz_sosire[NMAX],viz[NMAX];
int t[NMAX];
vector<int> graf[NMAX];
vector<pair<int,int> > muchii;
vector<int> rez;

void citire()
{
    scanf("%d%d",&N,&M);
    for(int i=1;i<=M;i++)
    {
        int x,y,c;
        scanf("%d%d%d",&x,&y,&c);

        capacitate[x][y] = c;
        capacitate[y][x] = c;

        graf[x].push_back(y);
        graf[y].push_back(x);

        muchii.push_back(make_pair(x,y));
    }
}


queue<int> q;
int parcurgere()
{
    memset(viz,0,sizeof(viz));

    viz[1]=1;
    q.push(1);

    int ok=0;

    while(!q.empty())
    {
        int nod_curent = q.front();
        q.pop();

        if(nod_curent == N)
            continue;

        for(vector<int>::iterator ii = graf[nod_curent].begin();ii!=graf[nod_curent].end();ii++)
        {
            int nod_nou = *ii;

            if(!viz[nod_nou] && utilizat[nod_curent][nod_nou] < capacitate[nod_curent][nod_nou])
            {
                t[nod_nou]=nod_curent;
                viz[nod_nou]=1;
                q.push(nod_nou);
            }
        }
    }

    for(vector<int>::iterator ii = graf[N].begin();ii!=graf[N].end();ii++)
    {
        int vecin = *ii;
        t[N]=vecin;
        if(viz[vecin] && utilizat[N][vecin]<capacitate[N][vecin])
        {
            ok = 1;
            int x = N;
            int flux=inf;
            while(x!=1)
            {
                flux = min(flux, capacitate[t[x]][x] - utilizat[t[x]][x]);
                x = t[x];
            }
            x = N;
            while(x!=1)
            {
                utilizat[t[x]][x] += flux;
                utilizat[x][t[x]] -= flux;
                x=t[x];
            }
        }
    }
    return ok;
}

void maxflow()
{
    while(parcurgere());
}

void bfs(int start, int viz[])
{
    q.push(start);
    viz[start]=1;


    while(!q.empty())
    {
        int nod_curent = q.front();
        q.pop();

        for(vector<int>::iterator ii = graf[nod_curent].begin();ii!=graf[nod_curent].end();ii++)
        {
            int nod_nou = *ii;
            if(!viz[nod_nou] && capacitate[nod_curent][nod_nou] > utilizat[nod_curent][nod_nou])
            {
                viz[nod_nou]=1;
                q.push(nod_nou);
            }
        }
    }
}

void rezolvare()
{
    for(vector<pair<int,int> >::iterator ii = muchii.begin();ii!=muchii.end();ii++)
    {
        int a = ii->first;
        int b = ii->second;
        if(viz_plecare[a] && viz_sosire[b] || viz_plecare[b] && viz_sosire[a])
            rez.push_back(ii - muchii.begin() + 1);
    }
    printf("%d\n",rez.size());
    for(vector<int>::iterator ii = rez.begin();ii!=rez.end();ii++)
        printf("%d\n",*ii);

}

int main()
{
    freopen("critice.in","r",stdin);
    freopen("critice.out","w",stdout);
    citire();
    maxflow();
    bfs(1,viz_plecare);
    bfs(N,viz_sosire);
    rezolvare();

    return 0;
}