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

#define fi first
#define se second
#define pe pair<int,int>
#define mp make_pair

using namespace std;

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

const int MAX_N=1010;

int n;
vector<int> A[MAX_N];
bool viz[MAX_N];
int dad[MAX_N];

int cap[MAX_N][MAX_N];
int flux[MAX_N][MAX_N];

void bfs() {
    memset(viz,0,sizeof(viz));
    memset(dad,0,sizeof(dad));
    queue<int> Q;
    Q.push(1);
    viz[1]=true;
    while(!Q.empty()) {
        int nod=Q.front();
        Q.pop();
        for(auto it=A[nod].begin(); it!=A[nod].end(); it++) {
            if(cap[nod][*it]>flux[nod][*it]&& !viz[*it]) {
                Q.push(*it);
                viz[*it]=true;
                dad[*it]=nod;
            }
        }
    }
}

void solve() {
    while(1) {
        bfs();
        if(!viz[n]) {
            return ;
        }

        for(auto it=A[n].begin();it!=A[n].end(); it++) {
            if(cap[*it][n]<=flux[*it][n]||!viz[*it]) {
                continue;
            }

            int nod=*it;
            int ans=cap[*it][n]-flux[*it][n];
            while(nod!=1) {
                ans=min(ans,cap[dad[nod]][nod]-flux[dad[nod]][nod]);
                nod=dad[nod];
            }
            if(!ans) {
                continue;
            }
            
            nod=*it;
            flux[*it][n]+=ans;
            flux[n][*it]-=ans;

            while(nod!=1) {
                flux[dad[nod]][nod]+=ans;
                flux[nod][dad[nod]]-=ans;
                nod=dad[nod];
            }
        }
    }
}

void dfs(int nod,bool viz[MAX_N]) {
    viz[nod]=true;
    for(auto it=A[nod].begin();it!=A[nod].end();it++) {
        if(!viz[*it] && cap[nod][*it]>flux[nod][*it] && cap[*it][nod]>flux[*it][nod]) {
            dfs(*it,viz);
        }
    }
}

vector<pe> M;
bool viz1[MAX_N],viz2[MAX_N];

vector<int> sol;

int main() {
    int m;
    cin>>n>>m;
    for(int i=1;i<=m;i++) {
        int a,b,c;
        cin>>a>>b>>c;
        cap[a][b]=c;
        cap[b][a]=c;
        M.push_back(mp(a,b));
        A[a].push_back(b);
        A[b].push_back(a);
    }
    solve();
    dfs(1,viz1);
    dfs(n,viz2);
    
    for(int i=0;i<m;i++) {
        int x=M[i].fi,y=M[i].se;
        if( (cap[x][y]==flux[x][y]&&viz1[x]&&viz2[y]) || (cap[y][x]==flux[y][x]&&viz1[y]&&viz2[x]) ) {
            sol.push_back(i+1);
        }
    }
    cout<<sol.size()<<'\n';
    for(auto it=sol.begin(); it!=sol.end(); it++) {
        cout<<*it<<'\n';
    }

    return 0;
}