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

#define maxN 1001
#define maxM 10001

using namespace std;

int f[maxN][maxN];
int c[maxN][maxN];

vector <int> g[maxN];

struct muchie
{
    int x,y;
}m[maxM];

int T[maxN];
int use[maxM];
int st[maxN];
int dr[maxN];

int N;

ifstream in;
ofstream out;

inline int bfs()
{
    int ok=0;
    queue <int> q;

    for(int i=2;i<=N;++i) T[i]=-1;
    T[1]=0;
    q.push(1);

    for(int nod;!q.empty();q.pop())
    {
        nod=q.front();

        for(vector <int>::iterator it=g[nod].begin();it!=g[nod].end();++it)
            if(T[*it]==-1&&c[nod][*it]>f[nod][*it])
            {
                if(*it!=N)
                {
                    T[*it]=nod;
                    q.push(*it);
                }
                else ok=1;
            }
    }

    return ok;
}

inline void fluxmax()
{
    for(int ok=bfs();ok;ok=bfs())
        for(vector <int>::iterator it=g[N].begin();it!=g[N].end();++it)
            if(T[*it]!=-1&&c[*it][N]>f[*it][N])
            {
                T[N]=*it;

                int min=0x7fffffff;
                for(int nod=N;nod!=1;nod=T[nod])
                    if(min>c[T[nod]][nod]-f[T[nod]][nod])
                        min=c[T[nod]][nod]-f[T[nod]][nod];

                if(min<=0) continue;

                for(int nod=N;nod!=1;nod=T[nod])
                {
                    f[nod][T[nod]]-=min;
                    f[T[nod]][nod]+=min;
                }
            }
}

inline void bfsx(int nod)
{
    queue <int> q;

    for(int i=1;i<=N;++i) st[i]=0;
    q.push(nod);
    st[nod]=1;

    for(;!q.empty();q.pop())
    {
        nod=q.front();

        for(vector <int>::iterator it=g[nod].begin();it!=g[nod].end();++it)
            if(!st[*it]&&c[nod][*it]>f[nod][*it])
            {
                st[*it]=1;
                q.push(*it);
            }
    }
}

inline void bfsy(int nod)
{
    queue <int> q;

    for(int i=1;i<=N;++i) dr[i]=0;
    q.push(nod);
    dr[nod]=1;

    for(;!q.empty();q.pop())
    {
        nod=q.front();

        for(vector <int>::iterator it=g[nod].begin();it!=g[nod].end();++it)
            if(!dr[*it]&&c[*it][nod]>f[*it][nod])
            {
                dr[*it]=1;
                q.push(*it);
            }
    }
}

int main()
{
    int M;

    in.open("critice.in");

    in>>N>>M;
    for(int i=1;i<=M;++i)
    {
        in>>m[i].x>>m[i].y;
        in>>c[m[i].x][m[i].y];

        c[m[i].y][m[i].x]=c[m[i].x][m[i].y];

        g[m[i].x].push_back(m[i].y);
        g[m[i].y].push_back(m[i].x);
    }

    in.close();

    fluxmax();
    bfsx(1);
    bfsy(N);

    for(int i=1;i<=M;++i)
        if(f[m[i].x][m[i].y]==c[m[i].x][m[i].y]||f[m[i].x][m[i].y]==-c[m[i].x][m[i].y])
            if((st[m[i].x]&&dr[m[i].y])||(st[m[i].y]&&dr[m[i].x]))
                ++use[0],use[i]=1;

    out.open("critice.out");

    out<<use[0]<<'\n';
    for(int i=1;i<=M;++i)
        if(use[i]) out<<i<<'\n';

    out.close();

    return 0;
}