#include <bits/stdc++.h>

using namespace std;
ifstream f("critice.in");
ofstream g("critice.out");

int n,m,nr;
struct muchie
{
    int x,y,cap;
};
vector<muchie> edges;
vector<int> v[1005];
int t[1005];
bitset<1005> used;
queue<int> q;

int bfs(int start,int endd)
{
    int i,j,k,z,u;
    for(i=1;i<=n;i++)
        t[i]=-1;
    used=0;
    q.push(start);
    used[start]=1;
    while(q.empty()==0)
    {
        k=q.front();
        z=v[k].size();
        for(i=0;i<z;i++)
        {
            u=v[k][i];
            j=edges[u].y;
            if(used[j]==0 and edges[u].cap>0)
            {
                used[j]=1;
                t[j]=u;
                q.push(j);
            }
        }
        q.pop();
    }
    if(t[endd]==-1)
        return 0;
    return 1;
}
void bfsUtil(int start)
{
    int i,j,z,k,u;
    used=0;
    q.push(start);
    used[start]=1;
    while(q.empty()==0)
    {
        k=q.front();
        z=v[k].size();
        for(i=0;i<z;i++)
        {
            u=v[k][i];
            j=edges[u].y;
            if(used[j]==0 and edges[u].cap>0)
            {
                used[j]=1;
                q.push(j);
            }
        }
        q.pop();
    }
}
vector<int>idreal;
vector<muchie>input;
bitset<10005>rasp;
int main()
{
    int i,j,x,y,cap,a,b,k=-1;
    f>>n>>m;
    for(i=1;i<=m;i++)
    {
        f>>x>>y>>cap;
        edges.push_back({x,y,cap});
        idreal.push_back(i);
        v[x].push_back(edges.size()-1);
        //si cea inversa

        edges.push_back({y,x,0});
        idreal.push_back(i);
        v[y].push_back(edges.size()-1);


        edges.push_back({y,x,cap});
        idreal.push_back(i);
        v[y].push_back(edges.size()-1);
        //si cea inversa
        edges.push_back({x,y,0});
        idreal.push_back(i);
        v[x].push_back(edges.size()-1);

    }
    a=1;b=n;//nodul de intrare si nodul de iesire
    int flux=0,minim;
    while(bfs(a,b)==1)
    {
        cout<<flux<<'\n';
        minim=100000001;
        x=b;
        while(t[x]!=-1)
        {
            minim=min(minim,edges[t[x]].cap);
            x=edges[t[x]].x;
        }
        x=b;
        while(t[x]!=-1)
        {
            edges[t[x]].cap-=minim;
            edges[t[x]^1].cap+=minim;
            x=edges[t[x]].x;
        }
        flux=flux+minim;
    }
    //g<<flux<<'\n';
    bfsUtil(a);
    for(i=0;i<edges.size();i++)
        if(used[edges[i].x]==1 and used[edges[i].y]==0)
        {
            nr++;
            rasp[idreal[i]]=1;
        }
    g<<nr/2<<'\n';
    for(i=0;i<m;i++)
        if(rasp[i]==1)
        g<<i<<'\n';
    return 0;
}