#include <fstream>
#include <vector>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxn 1005
#define pb push_back
int T[maxn],n,m;
#define N n
#define viz Viz
int show[maxn];
ifstream in("critice.in");
ofstream out("critice.out");

struct edge{int x,y;};

vector<int> graf[maxn];
vector<edge> muc;
int C[maxn][maxn];
int F[maxn][maxn];
int ind[maxn][maxn];
int k;
int mark1[maxn];
int markN[maxn];
bool Viz[maxn];
void read()
{
    int i;
    int a,b,c;
    in >> n >> m;
    while(m--)
    {
        in >> a >> b >> c;
        graf[a].pb(b);
        graf[b].pb(a);
        muc.pb({a,b});
        ind[a][b] = ind[b][a] = ++k;
        C[a][b]+=c;
        C[b][a]+=c;
    }
}
bool BFS()
{
    queue <int> Q;
    vector <int> :: iterator it;
    memset(viz,0,sizeof(viz));
    Q.push (1);
    int nod;

    while (!Q.empty ()){
        nod = Q.front ();
        Q.pop ();
        if(nod == n)
            continue;
        Viz[nod] = 1;
        for (it = graf[nod].begin (); it != graf[nod].end (); ++ it)
            if (!Viz[*it] && F[nod][*it] != C[nod][*it]){
                Viz[*it] = 1;
                T[*it] = nod;
                Q.push (*it);
            }
    }

    return Viz[N];
}

int augment ()
{
    int nod, fmin, flow = 0;
    vector<int> :: iterator it;
    for (; BFS ();){

        for(it = graf[N].begin(); it != graf[N].end(); ++ it)
        {
            if(!viz[*it])
                continue;
            if(C[*it][N] == F[*it][N])
                continue;
            T[N] = *it;
            fmin = (1 << 29);
            for (nod = N; nod != 1; nod = T[nod])
                fmin = min (fmin, C[ T[nod] ][nod] - F[ T[nod] ][nod]);

            if (!fmin)
                continue;

            for (nod = N; nod != 1; nod = T[nod]){
                F[ T[nod] ][nod] += fmin;
                F[nod][ T[nod] ] -= fmin;
            }

            flow += fmin;
        }
    }

    return flow;
}

void mark(int nod,int * what,bool dir)
{
    what[nod]=1;
    vector<int> :: iterator it;
    for (it = graf[nod].begin (); it != graf[nod].end (); ++ it)
    {
        if (!what[*it]){
            if(dir == 0)
            {
                if(C[nod][*it] > F[nod][*it])
                    mark(*it,what,dir);
            }
            else
            {
                if(C[*it][nod] > F[*it][nod])
                    mark(*it,what,dir);
            }
        }
    }
}

void solve()
{
    vector<edge> :: iterator it;
    int c = 0;
    for(it = muc.begin(); it != muc.end(); ++ it)
    {
        if(C[it->x][it->y] == F[it->x][it->y] && mark1[it->x] && markN[it->y])
           show[++show[0]] = it - muc.begin() + 1;
        if(C[it->y][it->x] == F[it->y][it->x] && mark1[it->y] && markN[it->x])
            show[++show[0]] = it - muc.begin() + 1;
    }
}

void afi()
{
    int i;
    for(i=0 ; i <= show[0]; i ++)
        out << show[i] << "\n";
}

int main()
{
    read();
    augment();
    mark(1,mark1,0);
    mark(n,markN,1);
    solve();
    afi();
    return 0;
}