// Dinic O(V^2 * E)
#include <bits/stdc++.h>
#define ll long long
using namespace std;
ifstream in("critice.in");
ofstream out("critice.out");
struct Edge {
int from;
int to;
ll cap;
ll flow;
int id;
Edge(int x, int y, ll c, int i) : from(x), to(y), cap(c), flow(0), id(i) {}
ll resCap() {
return cap - flow; // residual capacity
}
};
struct DinicMaxFlow {
const ll inf = 1e18;
int source;
int sink;
vector<Edge> edges;
vector<vector<int> > v;
vector<int> seen;
vector<int> level;
vector<int> lst;
vector<ll> dp;
set<int> sol;
int N;
int M;
DinicMaxFlow(int s, int d, int n) : source(s), sink(d), v(n), seen(n, 0), level(n), lst(n), dp(n, -1), N(n), M(0) {}
void addEdge(int from, int to, ll cap, int id) {
edges.push_back(Edge(from, to, cap, id));
edges.push_back(Edge(to, from, 0, id));
v[from].push_back(M++);
v[to].push_back(M++);
}
// the layered network has no cycles obv
bool canPush() {
queue<int> q;
fill(level.begin(), level.end(), -1);
level[source] = 0;
q.push(source);
while (!q.empty()) {
int node = q.front();
q.pop();
if (node == sink) {
return true;
}
for (auto edgeId : v[node]) {
int nxt = edges[edgeId].to;
if (level[nxt] == -1) {
if (edges[edgeId].resCap() > 0) {
level[nxt] = level[node] + 1;
q.push(nxt);
}
}
}
}
return false;
}
ll push(int node, ll pushedFlow) {
if (pushedFlow == 0) {
return 0;
}
if (node == sink) {
return pushedFlow;
}
for (; lst[node] < (int) v[node].size(); lst[node]++) { // nu trecem printr-o muchie de mai multe ori
int edgeId = v[node][lst[node]];
int nxt = edges[edgeId].to;
auto resCap = edges[edgeId].resCap();
if (level[node] + 1 != level[nxt] || resCap <= 0) {
continue;
}
auto flow = push(nxt, min(pushedFlow, resCap));
if (flow == 0) {
continue;
}
edges[edgeId].flow += flow;
edges[edgeId ^ 1].flow -= flow;
return flow;
}
return 0;
}
ll maxFlow() {
ll flow = 0;
while (canPush()) {
fill(lst.begin(), lst.end(), 0);
while (auto pushedFlow = push(source, inf)) {
flow += pushedFlow;
}
}
return flow;
}
void solve() {
cerr << maxFlow();
vector<vector<int> > viz(2, vector<int>(N, 0));
queue<int> q;
q.push(source);
viz[0][source] = 1;
while (!q.empty()) {
int node = q.front();
q.pop();
for (auto edgeId : v[node]) {
int nxt = edges[edgeId].to;
if (!viz[0][nxt]) {
if (edges[edgeId].resCap() > 0) {
viz[0][nxt] = 1;
q.push(nxt);
}
}
}
}
q.push(sink);
viz[1][sink] = 1;
while (!q.empty()) {
int node = q.front();
q.pop();
for (auto edgeId : v[node]) {
int nxt = edges[edgeId].to;
if (!viz[1][nxt]) {
if (edges[edgeId ^ 1].resCap() > 0) {
viz[1][nxt] = 1;
q.push(nxt);
}
}
}
}
for (auto edge : edges) {
if (viz[0][edge.from] && viz[1][edge.to] && edge.resCap() == 0) {
sol.insert(edge.id);
}
}
out << sol.size() << '\n';
for (auto i : sol) {
out << i << '\n';
}
}
};
int main() {
int n, m;
in >> n >> m;
DinicMaxFlow graph(0, n - 1, n);
for (int i = 1, x, y, c; i <= m; i++) {
in >> x >> y >> c;
x--;
y--;
graph.addEdge(x, y, c, i);
graph.addEdge(y, x, c, i);
}
graph.solve();
return 0;
}