#include <bits/stdc++.h>
	
 
	
using namespace std;
	
ifstream fin("critice.in");
ofstream fout("critice.out");
	
class Graph{
	
    int source, dest, n;
	
    vector < vector <int> > capacity;
	
    vector < vector <int> > adj;
	
    vector < int > parent;
	
    vector < bool > vis;
	
    vector < pair <int, int> > edges;
	
 
	
    void dfs(int node = 1) {
	
        vis[node] = true;
	
        for (auto&it : adj[node])
	
            if (!vis[it] and capacity[node][it])
	
                dfs(it);
	
    }
	
 
	
    bool bfs() {
	
        fill(vis.begin(), vis.end(), false);
	
 
	
        int node = source;
	
        vis[node] = true;
	
        queue <int> q;
	
        q.push(node);
	
 
	
        while (!q.empty()) {
	
            node = q.front();
	
            q.pop();
	
 
	
            for (auto& it : adj[node])
	
                if (!vis[it] and capacity[node][it]) {
	
                    vis[it] = true;
	
                    parent[it] = node;
	
                    q.push(it);
	
                }
	
        }
	
 
	
        return vis[dest];
	
    }
	
 
	
    int max_flow() {
	
        int maxflow = 0;
	
 
	
        while (bfs()) {
	
            for (auto& it : adj[dest]) 
	
                if (vis[it] and capacity[it][dest]) {
	
                    parent[dest] = it;
	
                    int flow = INT_MAX;
	
 
	
                    for (int node = dest; node != source; node = parent[node])
	
                        flow = min(flow, capacity[parent[node]][node]);
	
 
	
                    for (int node = dest; node != source; node = parent[node]) {
	
                        capacity[parent[node]][node] -= flow;
	
                        capacity[node][parent[node]] += flow;
	
                    }
	
 
	
                    maxflow += flow;
	
                }
	
        }
	
 
	
        return maxflow;
	
    }
	
 
	
public:
	
    Graph(int n, int source, int dest) : n(n), source(source), dest(dest), adj(n + 1), 
	
                                        capacity(n + 1, vector <int>(n + 1)), parent(n + 1), vis(n + 1) {}
	
 
	
    void add_edge(int node1, int node2, int cap = 1) {
	
        adj[node1].push_back(node2);
	
        adj[node2].push_back(node1);
	
        capacity[node1][node2] = capacity[node2][node1] = cap;
	
        edges.push_back({node1, node2});
	
    }
	
 
	
    void critice() {
	
        max_flow();
	
        // fill(vis.begin(), vis.end(), false);
	
        // dfs();
	
 
	
        vector <int> ans;
	
 
	
        for (int i = 0; i < edges.size(); i++) {
	
            if (vis[edges[i].first] != vis[edges[i].second]) 
	
                ans.push_back(i + 1);
	
        }
	
 
	
        fout << ans.size() << '\n';
        for (auto& it : ans) 
        	fout << it << ' ';
	
    }
	
};
	
 
	
int main() {
	
    // ifstream fin("input.txt");
	
    // ofstream cout("output.txt");
	
 
	
    int n, m;
	
    fin >> n >> m;
	
    Graph G(n, 1, n);
	
 
	
    for (int i = 1; i <= m; ++i) {
	
        int x, y, z;
	
        fin >> x >> y >> z;
	
        G.add_edge(x, y, z);
	
    }
	
 
	
    G.critice();
	
 
	
    return 0;
	
}