#include <fstream>
#include <queue>
#include <vector>
#define DIM 10110
#define INF 0x3f3f3f3f
using namespace std;

int n, m;
vector<pair<int,int> > Gr;
vector<int> G[DIM];
int f[DIM][DIM], c[DIM][DIM];

int flow;
vector<int> cr, t, sol;
bool st, dest;
int X, Y;

void Read();
void EK();
bool BF();
bool BF(int, int);
void Augment();
void Write();
void Solve();

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

void Read()
{
    ifstream fin("critice.in");
    fin >> n >> m;
    int x, y, C;
    for (int i = 1; i <= m; ++i)
    {
        fin >> x >> y >> C;
        Gr.push_back(make_pair(x,y));
        G[x].push_back(y);
        G[y].push_back(x);
        c[x][y] = C;
        c[y][x] = C;
    }
    fin.close();
}

void EK()
{
    while (BF())
        Augment();
}

bool BF()
{
    queue<int> Q;
    vector<bool> s(n+1, 0);
    cr.assign(n+1, 0);
    t.assign(n+1, 0);
    s[1] = 1;
    cr[1] = INF;
    Q.push(1);
    while (!Q.empty())
    {
        int i = Q.front();
        Q.pop();
        for (int k = 0; k <= G[i].size(); ++k)
        {
            int j = G[i][k];
            if (s[j]) continue;
            if (c[i][j] > f[i][j])
            {
                cr[j] = min(cr[i], c[i][j] - f[i][j]);
                t[j] = i;
                s[j] = 1;
                Q.push(j);
                if (j == n) return true;
            }
        }
    }
    return false;
}

void Augment()
{
    int i, j;
    j = n;
    while (j != 1)
    {
        i = t[j];
        f[i][j] += cr[n];
        f[j][i] -= cr[n];
        j = i;
    }
    flow += cr[n];
}

void Solve()
{
     for (int i = 0; i < Gr.size(); ++i)
     {
        int x = Gr[i].first;
        int y = Gr[i].second;
        if (c[x][y] == f[x][y])
            if (BF(x,y)) sol.push_back(i+1);
        else
            if (c[y][x] == f[y][x]) 
                        if (BF(y,x)) sol.push_back(i+1);
    }
}


void Write()
{
   ofstream fout("critice.out");
   fout << sol.size() << '\n';
   for (int i = 0; i < sol.size(); ++i)                
       fout << sol[i] << '\n';
   fout.close();   
}    

bool BF(int x, int y)
{
    queue<int> Q;
    vector<bool> s(n+1, 0);
    s[1] = 1;
    Q.push(1);
    while (!Q.empty())
    {
        int i = Q.front();
        Q.pop();
        for (int k = 0; k <= G[i].size(); ++k)
        {
            int j = G[i][k];
            if (s[j]) continue;
            if (c[i][j] > f[i][j])
            {
                s[j] = 1;
                Q.push(j);
            }
        }
    }    
    if (!s[x] || s[y]) return false;
    
  //  s.assign(n+1, 0);
   /* s[y] = 1;
    Q.push(y);
    while (!Q.empty())
    {
        int i = Q.front();
        Q.pop();
        for (int k = 0; k <= G[i].size(); ++k)
        {
            int j = G[i][k];
            if (s[j]) continue;
            if (c[i][j] > f[i][j])
            {
                s[j] = 1;
                Q.push(j);
            }
        }
    }*/s[n] = 1;    
    return s[n];
}