#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int nmax = 1000;
const int mmax = 10000;
const int inf = 2000000000;

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

vector <Muchie> g[1 + nmax];
queue <int> q;
vector <int> sol;
int ind[1 + mmax][2];
int rem[1 + nmax], dist[1 + nmax], src, dest;

bool bfs() {
    memset(dist, 0, sizeof(dist));
    dist[src] = 2;
    q.push(src);

    while(!q.empty()) {
        for(int k = 0; k < g[q.front()].size(); ++ k) {
            Muchie &e = g[q.front()][k];

            if(dist[e.to] == 0 && e.flow < e.cap) {
                q.push(e.to);
                dist[e.to] = dist[q.front()] + 1;
            }
        }
        q.pop();
    }

    return (dist[dest] > 0);
}

int dfs(int from, int minflow) {
    if(from == dest) {
        return minflow;
    } else {
        for(int k = rem[from]; k < g[from].size(); ++ k) {
            Muchie &e = g[from][k];

            if(dist[from] + 1 == dist[e.to] && e.flow < e.cap) {
                int flow = dfs(e.to, min(minflow, e.cap - e.flow));

                if(flow > 0) {
                    e.flow += flow;
                    g[e.to][e.rev].flow -= flow;
                    rem[from] = k + 1;
                    return flow;
                }
            }
        }
        return 0;
    }
}

void maxflow() {
    while(bfs()) {
        memset(rem, 0, sizeof(rem));
        int deltaflow;
        do {
            deltaflow = dfs(src, inf);
        } while(deltaflow > 0);
    }
}

int srcDFS[1 + nmax], destDFS[1 + nmax];
int dfsGrafRamas(int from, int start) {
    if(start == 1) {
        srcDFS[from] = 1;
    } else {
        destDFS[from] = 1;
    }
    for(int k = 0; k < g[from].size(); ++ k) {
        Muchie &e = g[from][k];
        if(e.flow < e.cap && g[e.to][e.rev].flow < e.cap) {
            if(start == 1) {
                if(srcDFS[e.to] == 0) {
                    dfsGrafRamas(e.to, start);
                }
            } else {
                if(destDFS[e.to] == 0) {
                    dfsGrafRamas(e.to, start);
                }
            }
        }
    }
}

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

    int n, m;
    scanf("%d%d", &n, &m);

    for(int i = 1; i <= m; ++ i) {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);

        ind[i][0] = x;
        ind[i][1] = g[x].size();

        g[x].push_back({y, g[y].size(), 0, z});
        g[y].push_back({x, g[x].size() - 1, 0, z});
    }

    src = 1;
    dest = n;
    maxflow();
    dfsGrafRamas(1, 1);
    dfsGrafRamas(n, n);

    for(int i = 1; i <= m; ++ i) {
        int x, y;
        x = ind[i][0];
        y = ind[i][1];

        Muchie &e = g[x][y];

        if(e.flow == e.cap || g[e.to][e.rev].flow == e.cap) {
            if((srcDFS[x] == 1 && destDFS[e.to] == 1) || (srcDFS[e.to] == 1 && destDFS[x] == 1)) {

                sol.push_back(i);
            }
        }
    }

    printf("%d\n", sol.size());
    for(int i = 0; i < sol.size(); ++ i) {
        printf("%d\n", sol[i]);
    }

    return 0;
}