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

using namespace std;

ifstream cin("critice.in");
ofstream cout("critice.out");

const int NMAX = 1'000;
const int MMAX = 10'000;

struct edge
{
    int u, v;
};

int n, m;
edge edges[MMAX];

vector<int> g[NMAX];
int capacity[NMAX][NMAX];
short level[NMAX], ptr[NMAX];
bool source[NMAX], sink[NMAX];

vector<int> ans;

int dfs(int u, int flow)
{
    if(u == n - 1)
        return flow;
    
    for(short& i = ptr[u]; i < g[u].size(); i++)
    {
        int v = g[u][i];
        if(level[v] == level[u] + 1 && capacity[u][v] != 0)
        {
            int next = dfs(v, min(flow, capacity[u][v]));
            if(next != 0)
            {
                capacity[u][v] -= next;
                capacity[v][u] += next;
                return next;
            }
        }
    }
    return 0;
}

int main()
{
    cin >> n >> m;
    for(int i = 0; i < m; i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        u--; v--;
        edges[i] = { u, v };
        capacity[u][v] = w;
        capacity[v][u] = w;
        g[u].push_back(v);
        g[v].push_back(u);
    }

    while(true)
    {
        fill(level, level + n, -1);

        queue<int> Q;
        level[0] = 0;
        Q.push(0);
        while(!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            if(u == n - 1)
                continue;
            
            for(const int& v : g[u])
                if(level[v] == -1 && capacity[u][v] != 0)
                {
                    level[v] = level[u] + 1;
                    Q.push(v);
                }
        }

        if(level[n - 1] == -1)
            break;
        
        fill(ptr, ptr + n, 0);
        while(dfs(0, 0x3f3f3f3f));
    }

    {
        queue<int> Q;
        source[0] = 1;
        Q.push(0);
        while(!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            for(const int& v : g[u])
                if(!source[v] && capacity[u][v] != 0)
                {
                    source[v] = 1;
                    Q.push(v);
                }
        }
    }

    {
        queue<int> Q;
        sink[n - 1] = 1;
        Q.push(n - 1);
        while(!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            for(const int& v : g[u])
                if(!sink[v] && capacity[u][v] != 0)
                {
                    sink[v] = 1;
                    Q.push(v);
                }
        }
    }

    for(int i = 0; i < m; i++)
    {
        auto[u, v] = edges[i];
        if(capacity[u][v] == 0 || capacity[v][u] == 0)
        {
            if((source[u] && sink[v]) || (source[v] && sink[u]))
                ans.push_back(i + 1);
        }
    }

    cout << ans.size() << '\n';
    for(const int& i : ans)
        cout << i << '\n';
    return 0;
}