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

int n, m;
vector<pair<int,int> > Gr;
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();
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;
        G.push_back(make_pair(x,y));
        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 j = 1; j <= n; ++j)
        {
            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 < G.size(); ++i)
     {
        int x = G[i].first;
        int y = G[i].second;
        c[x][y]++;
        c[y][x]++;
        if (BF())
                sol.push_back(i+1);
        c[x][y]--;
        c[y][x]--;    
    }
}


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