//Hamiltonian Flights
/*#include<bits/stdc++.h>
#define N 20
#define MOD 1000000007
using namespace std;
int n,m;
long long dp[N][1148576];
vector<int> G[N];
long long nrways(int start,int mask)
{
    mask ^= (1<<start);
    //cout<<start<<": ";
    if(start == n-1 && !mask)
        return 1;
    if(start == n-1 && mask)
        return 0;
    //pt cazuri ca in ex din enunt
    //if(dp[start][mask]!=-1)
      //  return dp[start][mask];
    dp[start][mask]=0;
    for(auto& i:G[start])
    {
        //cout<<i<<' ';
        if(mask&(1<<i))
            dp[start][mask]=(dp[start][mask]+nrways(i,mask))%MOD;
    }
    return dp[start][mask];
}
int main()
{
    //ifstream fin("hp.in");
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    cin>>n>>m;
    while(m--)
    {
        int a,b;
        cin>>a>>b;
        --a;
        --b;
        G[a].emplace_back(b);
    }
    memset(dp,-1,sizeof(dp));
    dp[n-1][1<<(n-1)]=1;
    cout<<nrways(0,(1<<n)-1);
    //cout<<'\n'<<dp[0][0]<<' ';
}*/



//ex invers modular
/*#include<iostream>
#define ll long long
using namespace std;
int n;

bool prim(int n)
{
    for(int i=2; i*i<=n; i++) {
        if( n%i == 0 ) return false;
    }
    return true;
}

ll Putere(int x , int y)
{
    ll _x=1ll*x;
    ll P = 1ll;
    while(y)
    {
        if(y % 2 == 1)
            P = (P * _x)%n;
        _x=(_x*_x)%n;
        y/=2;
    }
    return P;
}

int mod_inv(int x)
{
    return (int)(Putere(x,n-2)%n);
}

int main()
{
    cin>>n;
    if(n<=3){
        cout<<"YES\n";
        for(int i=1;i<=n;++i)
            cout<<i<<'\n';
    }
    else if(n==4)
        cout<<"YES\n"<<1<<'\n'<<3<<'\n'<<2<<'\n'<<4<<'\n';
    else
        if(prim(n))
        {
            cout<<"YES\n";
            cout<<1<<'\n';
            for(int i=2;i<n;++i)
                {
                    int inv=mod_inv(i-1);
                    ll print=1ll*i*inv;
                    print%=n;
                    cout<<print<<'\n';
                }
            cout<<n<<'\n';
        }
    else
        cout<<"NO\n";    
}*/

//Critice
#include<bits/stdc++.h>
#define pii pair<int,int>
#define Dim 1000000000
#define N 1024
#define M 10005
using namespace std;
vector <int> G[N];
queue <int> q;
int n,m,C[N][N],pred[N],f[N][N],culoare[2][M];
pii muchie[M];
bool viz[N];
	
void read()
{
    int i,x,y,z;
    freopen("critice.in","r",stdin);
    scanf("%d%d",&n,&m);
    for(i=1;i<=m;i++)
    {
        scanf("%d %d %d ",&x,&y,&z);
        G[x].emplace_back(y);
        G[y].emplace_back(x);
        C[x][y] = z;
        C[y][x] = 0;
        muchie[i].first = x;
        muchie[i].second = y;
    }
}

bool bfs()
{
    memset(viz,0,sizeof(viz));
    q.push(1);
    viz[1] = 1;
    while(!q.empty())
    {
        int nod = q.front();
        q.pop();
        if(nod == n)
            continue;
        for(auto& i:G[nod])
        {
            if(viz[i] || f[nod][i] == C[nod][i])
                continue;
            viz[i] = 1;
            q.push(i);
            pred[i] = nod;
        }
    }
    return viz[n];
}


int Edmond()
{
    int flow,i,f_min,nod,pj;
    for(flow = 0; bfs() ;){
        for(auto& i:G[n])
        {
            if(!viz[i] || f[i][n] == C[i][n])
                continue;
            pred[n] = i;
            nod = n;
            f_min = Dim;
            while(nod != 1)
            {
                f_min = min(f_min, C[pred[nod]][nod] - f[pred[nod]][nod]);
                nod = pred[nod];
            }
            if(!f_min)
                continue;
            //actualizare
            nod = n;
            while(nod != 1)
            {
                f[pred[nod]][nod] += f_min;
                f[nod][pred[nod]] -= f_min;
                nod = pred[nod];
            }
            flow += f_min;
        }
    }
    return flow;
}

void meet_in_the_middle(int s,int colour)
{
    memset(viz,0,sizeof(viz));
    q.push(s);
    viz[s] = 1;
    while(!q.empty())
    {
        int nod = q.front();
        q.pop();
        culoare[colour][nod] = 1;
        for(auto& i:G[nod])
        {
            if(s == 1){
                if(viz[i] || f[nod][i] == C[nod][i])
                    continue;
            }
            else
            {
                if(viz[i] || f[i][nod] == C[i][nod])
                    continue;
            }
            viz[i] = 1;
            q.push(i);
        }
    }
}

vector<int> sol;

void brut_SIR()
{
    Edmond();
    meet_in_the_middle(1,0);
    meet_in_the_middle(n,1);
    for(int i=1;i<=m;++i)
    {
        int x = muchie[i].first;
        int y = muchie[i].second;
        if((culoare[0][x]==1 && culoare[1][y]==1) || (culoare[0][y]==1 && culoare[1][x]==1) )
                sol.emplace_back(i);
    }
}

int main()
{
    read();
    freopen("critice.out","w",stdout);
    brut_SIR();
    cout<<sol.size()<<'\n';
    for(auto& i:sol)
        cout<<i<<'\n';
}