#include <iostream>
#include <bits/stdc++.h>

#define nmax 1001


using namespace std;
ifstream fin("critice.in");
ofstream gout("critice.out");
vector<vector<int>> adj(nmax+1, vector<int>());
vector<vector<int>> capacity(nmax+1, vector<int>(nmax+1, 0 ));
vector<int> parent(nmax+1, -1);

map<pair<int,int>,int> edges;

int n,m;
void readInput()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        int x,y,c;
        fin>>x>>y>>c;
        int minn = min(x,y);
        int maxi = max(x,y);
        adj[x].push_back(y);
        adj[y].push_back(x);
        edges.insert({{minn,maxi},i});

        capacity[x][y] = c;
        capacity[y][x] = c;
      
    }
}


int bfs(int source , int destination)
{
    fill(parent.begin(),parent.end(), -1);
    parent[source] = -2;

    queue<pair<int,int>> q;
    int flow = INT_MAX;
    q.push({source, flow});
    while(!q.empty())
    {
        auto [currentNode, currentFlow] = q.front();
        q.pop();
        for(auto neighbour: adj[currentNode])
        {
            if(parent[neighbour] == -1 and capacity[currentNode][neighbour]>0)
            {
                int newFlow = min(currentFlow, capacity[currentNode][neighbour]);
                parent[neighbour] = currentNode;
                if(neighbour == destination)
                    return newFlow;
                
                q.push({neighbour, newFlow});
            }
        }
    }

    return 0;

}

int edmondskarp(int source, int destination)
{
    int maxflow = 0;
    while(int flow = bfs(source, destination))
    {
        
        maxflow+=flow;
        int curr = destination;
        while(curr != source)
        {
            capacity[parent[curr]][curr] -= flow;
            capacity[curr][parent[curr]] += flow;
            curr = parent[curr];
        }
    }
    return maxflow;
}





int main()
{
    readInput();
    edmondskarp(1,n);
    queue<int> q;
    q.push(1);
    vector<int> res;
    fill(parent.begin(),parent.end(),-1);
    parent[1] = -2;
    while(!q.empty())
    {
        int curr = q.front();
        q.pop();
        for(auto v: adj[curr])
        {
            if(parent[v] == -1 and capacity[curr][v]>0)
            {
                parent[v] = curr;
                q.push(v);
            }
            else{
                if(capacity[curr][v] == 0 and edges.find({curr,v})!=edges.end())
                {
                    res.push_back(edges[{curr,v}]);
                }
            }
        }
    }
    
    gout<<res.size()<<'\n';
    for(auto r: res)
    {
        gout<<r<<'\n';
    }




    return 0;
}