#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;
ifstream in("critice.in");
ofstream out("critice.out");

const int NMAX = 1000;

struct Edge {
    int to, cap, flow, rev;
};

struct Data {
    int x, y;
}muc[1 + NMAX * 10];

vector<Edge> g[1 + NMAX];
int dist[1 + NMAX], src, dest, n, rem[1 + NMAX];

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

    queue<int> q;
    dist[src] = 0;
    q.push(src);

    while(q.size()) {
        int from = q.front();
        q.pop();
        for(int i = 0; i < g[from].size(); i ++) {
            Edge &it = g[from][i];
            if(dist[it.to] == -1 && it.flow < it.cap) {
                dist[it.to] = 1 + dist[from];
                q.push(it.to);
            }
        }
    }

    return (dist[dest] >= 0);
}

int dfs(int from, int deltaflow) {
    if(from == dest)
        return deltaflow;

    for(int &i = rem[from]; i < g[from].size(); i ++) {
        Edge &e = g[from][i];
        if(dist[e.to] == dist[from] + 1 && e.flow < e.cap) {
            int addflow = dfs(e.to, min(deltaflow, e.cap - e.flow));
            if(addflow > 0) {
                Edge &rev = g[e.to][e.rev];
                e.flow += addflow;
                rev.flow -= addflow;
                return addflow;
            }
        }
    }
    return 0;
}

int dinic() {
    int maxflow = 0;
    while(bfs()) {
       for(int i = 1; i <= n; i ++)
            rem[i] = 0;
        int aux = dfs(src, INT_MAX);
        while(aux) {
            maxflow += aux;
            aux = dfs(src, INT_MAX);
        }
    }

    return maxflow;
}

bool visited[1 + NMAX];
int mark[1 + NMAX]; /// mark[node] = 0 -> nu se poate ajunge nicaieri din node, mark[node] = 1/ n se poate ajunge in 1 sau n, mark[node] = n + 1 se poate ajunge in 1 si n

void computemark(int node, int x) {
    visited[node] = 1;
    mark[node] += x;

    queue<int> q;
    q.push(node);
    while(q.size()) {
        int from = q.front();
        q.pop();
        for(int i = 0; i < g[from].size(); i ++) {
            Edge &it = g[from][i];
            if(it.flow < it.cap && g[it.to][it.rev].flow < it.cap && visited[it.to] == 0) {
                visited[it.to] = 1;
                q.push(it.to);
                mark[it.to] += x;
            }
        }
    }
}

int main() {
    int m;
    in >> n >> m;
    src = 1;
    dest = n;
    for(int i = 1; i <= m; i ++) {
        int x, y, z;
        in >> x >> y >> z;
        g[x].push_back({y, z, 0, g[y].size()});
        g[y].push_back({x, z, 0, g[x].size() - 1});

        muc[i].x = x;
        muc[i].y = y;
    }
    int maxflow = dinic();

    computemark(src, src);
    for(int i = 1; i <= n; i ++)
        visited[i] = 0;
    computemark(dest, dest);

    vector<int> sol;
    for(int i = 1; i <= m; i ++) {
        int x = muc[i].x, y = muc[i].y;
        if((mark[x] == src && mark[y] == dest) || (mark[x] == dest && mark[y] == src)) /// si aici
            sol.push_back(i);
    }
    out << sol.size() << "\n";
    for(auto it : sol)
        out << it << "\n";

    return 0;
}