#include <fstream>
#include <queue>
#include <bitset>

using namespace std;
struct edge
{
    int x, y, c;
    edge()
    {
        x = y = c = 0;
    }
    inline edge(const int _x,const int _y,const int _c)
    {
        x = _x,    y = _y,     c = _c;
    }
};
const int Nmax = 1004;
const int Mmax =10004;
int C[Nmax][Nmax];
int F[Nmax][Nmax];
int R[Nmax][Nmax];
int n, m, Father[Nmax];
edge e[Mmax];
bitset < Nmax > viz,a,b;
inline void Read()
{
    ifstream f("critice.in");
    f >> n >> m;
    int x, y, c;
    for(int i = 1;i <= m; ++i)
    {
        f >> x >> y >> c;
        C[x][y] = C[y][x] = c;
        e[i] = edge(x,y,c);
    }
}

bool BFS(int node)
{
    queue < int > Q;
    viz = 0;
    viz[node] = 1;
    register int i;
    for(Q.push(node); !Q.empty(); Q.pop())
    {
        node = Q.front();
        if(node == n)
            continue ;
        for(i = 1;i <= n; ++i)
            if(!viz[i] && F[node][i] < C[node][i])
            {
                Q.push(i);
                viz[i] = 1;
                Father[i] = node;
            }
    }
    return viz[n];
}

inline void MaxFlow()
{
    int i,j,minn ;
    while(BFS(1))
    {
        for(j = 1; j < n; ++j)
        {
            if(!viz[j] || !C[j][n] || C[j][n] == F[j][n])
                continue ;
            minn = 10004;
            Father[n] = j;
            for(i = n;i != 1;i = Father[i])
                minn = min(minn,C[Father[i]][i]-F[Father[i]][i]);
            for(i = n;i != 1;i = Father[i])
                F[Father[i]][i]+= minn;
                F[i][Father[i]] -= minn;
        }
    }
}
inline void DFS(const int node,bitset < Nmax > &viz)
{
    viz[node] = 1;
    for(int i = 1;i <= n; ++i)
        if(R[node][i] > 0 && !viz[i])
            DFS(i,viz);
}
inline void Solve()
{
    int i,j;
    for(i = 1;i <= n; ++i)
        for(j = 1;j <= n; ++j)
            R[i][j] = C[i][j] - F[i][j];
    DFS(1,a);
    DFS(n,b);
}

inline void Write()
{
    int x,y,c,i;
    vector < int > sol;
    ofstream g("critice.out");
    for(i = 1;i <= m; ++i)
    {
        x = e[i].x,  y = e[i].y,  c = e[i].c;
        if(F[x][y]==c && a[x] && b[y])
            sol.push_back(i);
        else
        {
            swap(x,y);
            if(F[x][y]==c && a[x] && b[y])
                sol.push_back(i);
        }
    }
    g<<( x = sol.size() )<<"\n";
    for(i = 0;i < x; ++i)
        g<<sol[i]<<"\n";
    g.close();
}


int main()
{
    Read();
    MaxFlow();
    Solve();
    Write();
    return 0;
}