#include <bits/stdc++.h>
#define DIM 1010
#define INF 2000000000
using namespace std;
class InParser {
private:
	FILE *fin;
	char *buff;
	int sp;

	char read_ch() {
		++sp;
		if (sp == 4096) {
			sp = 0;
			fread(buff, 1, 4096, fin);
		}
		return buff[sp];
	}

public:
	InParser(const char* nume) {
		fin = fopen(nume, "r");
		buff = new char[4096]();
		sp = 4095;
	}

	InParser& operator >> (int &n) {
		char c;
		while (!isdigit(c = read_ch()) && c != '-');
		int sgn = 1;
		if (c == '-') {
			n = 0;
			sgn = -1;
		} else {
			n = c - '0';
		}
		while (isdigit(c = read_ch())) {
			n = 10 * n + c - '0';
		}
		n *= sgn;
		return *this;
	}

	InParser& operator >> (long long &n) {
		char c;
		n = 0;
		while (!isdigit(c = read_ch()) && c != '-');
		long long sgn = 1;
		if (c == '-') {
			n = 0;
			sgn = -1;
		} else {
			n = c - '0';
		}
		while (isdigit(c = read_ch())) {
			n = 10 * n + c - '0';
		}
		n *= sgn;
		return *this;
	}
};


int capacitate[DIM][DIM],dist[DIM],st[DIM],dist_s[DIM],dist_d[DIM];
deque <int> c;
vector <int> L[DIM],sol;
pair <int,int> mch[DIM*10];
int n,m,i,j,x,y,cap,sursa,dest;

int bfs (int sursa, int dest, int dist[]){
    for (int i=1;i<=n;i++)
        dist[i] = INF;
    c.clear();
    c.push_back(sursa);
    dist[sursa] = 0;
    while (!c.empty()){
        int nod = c.front();
        c.pop_front();
        if (nod == dest)
            break;
        for (auto vecin : L[nod]){
            if (!capacitate[nod][vecin])
                continue;
            if (dist[vecin] == INF){
                dist[vecin] = 1 + dist[nod];
                c.push_back(vecin);
            }}}

    return dist[dest] != INF;
}

int dfs (int nod, int dest, int max_flow){
    if (nod == dest || !max_flow)
        return max_flow;

    int flow = 0;
    for (;st[nod]<L[nod].size();++st[nod]){
        int vecin = L[nod][st[nod]];
        if (dist[vecin] == 1 + dist[nod] && capacitate[nod][vecin]){

            int val = dfs (vecin,dest,min(capacitate[nod][vecin],max_flow-flow));
            flow += val;
            capacitate[nod][vecin] -= val;
            capacitate[vecin][nod] += val;
        }
    }
    return flow;
}

int main (){

    InParser cin ("critice.in");
    ofstream cout ("critice.out");

    cin>>n>>m;
    for (i=1;i<=m;++i){
        cin>>x>>y>>cap;
        L[x].push_back(y);
        L[y].push_back(x);
        capacitate[x][y] = cap;
        capacitate[y][x] = cap;
        mch[i] = make_pair(x,y);
    }

    sursa = 1, dest = n;

    int flux;
    do{
        for (i=1;i<=n;++i)
            st[i] = 0;
        bfs (sursa,dest,dist);
        flux = dfs (sursa,dest,INF);

    } while (flux);

    //cout<<soll<<"\n";

    bfs (sursa,dest,dist_s);
    bfs (dest,sursa,dist_d);

    for (i=1;i<=m;++i){
        int x = mch[i].first, y = mch[i].second;
        if ( ((dist_s[x] != INF && dist_d[y] != INF) || (dist_d[x] != INF && dist_s[y] != INF) ) && (!capacitate[x][y] || !capacitate[y][x]))
            sol.push_back(i);
    }

    sol.resize(unique(sol.begin(),sol.end()) - sol.begin());

    cout<<sol.size()<<"\n";
    for (auto it : sol)
        cout<<it<<"\n";

    return 0;
}