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

using namespace std;

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

const int N = 1001;
const int M = 10001;
const int oo = 1e9;

int cap[N][N];
vector <int> parent;
vector <pair <int, int>> edge;
int n, m;
vector<int> ans, v[N];
vector <bool> vis;
queue<int> q;

bool bfs()
{
    for(int i = 1; i <= n; ++i)
        parent[i] = 0;

    q.push(1);
    parent[1] = -1;

    while(!q.empty())
    {
        int current_node = q.front();
        q.pop();
        if (current_node != n)
        {
            for(auto nei: v[current_node])
            {
                if(!parent[nei] && cap[current_node][nei])
                {
                    parent[nei] = current_node;
                    q.push(nei);
                }
            }
        }
    }

    return (parent[n] != 0);
}

void ford_fulkerson()
{
    while(bfs())
    {
        for(auto nei: v[n])
        {
            if(parent[nei] != 0 && cap[nei][n])
            {
                int current_node = n;
                parent[n] = nei;
                int flow = oo;
                //bottleneck
                while(current_node != 1)
                {
                    flow = min(flow, cap[parent[current_node]][current_node]);
                    current_node = parent[current_node];
                }

                current_node = n;
                if (flow)
                {
                        while(current_node != 1)
                    {
                        cap[parent[current_node]][current_node] -= flow;
                        cap[current_node][parent[current_node]] += flow;
                        current_node = parent[current_node];
                    }
                }
            }
        }
    }
}

void dfs(int node)
{
    vis[node] = true;
    for (auto nei : v[node])
        if(!vis[nei] && cap[node][nei])
            dfs(nei);
}

int main()
{
    freopen("critice.in", "r", stdin);
    ofstream out("critice.out");

    in >> n >> m;

    parent.resize(n + 1);
    vis.resize(n + 1, false);
    edge.resize(m + 1);

    for(int i = 1; i <= m ; ++i)
    {
        int a, b, c;
        in >> a >> b >> c;
        cap[a][b] = c;
        cap[b][a] = c;
        v[a].push_back(b);
        v[b].push_back(a);
        edge[i] = {a, b};
    }

    ford_fulkerson();
    dfs(1);

    for (int i = 1; i <= m; ++i)
        if (vis[edge[i].first] != vis[edge[i].second])
            ans.push_back(i);

    out << ans.size() << '\n';
    for(auto i:ans)
        out << i << '\n';
    return 0;
}