#include <fstream>
#include <bits/stdc++.h>
using namespace std;

ifstream fin("critice.in");
ofstream fout("critice.out");
int N, M;
int cap[1005][1005];
int flux[1005][1005];
int tata[1005];
int source, dest;
vector<int> adj[1005];
int vizS[1005];
int vizD[1005];
bool have_road(int source, int dest)
{
    queue<int> q;
    vector<int> viz(N + 5, 0);
    viz[source] = 1;
    q.push(source);
    while (!q.empty())
    {
        int node = q.front();
        q.pop();
        for (auto x : adj[node])
        {
            if (cap[node][x] - flux[node][x] > 0 && viz[x] == 0)
            {
                q.push(x);
                tata[x] = node;
                viz[x] = 1;
            }
        }
    }
    return viz[dest];
}
int calculateFlow()
{
    int minimumFlow = 1e9;
    int node = dest;
    while (node != source)
    {
        minimumFlow = min(minimumFlow, cap[tata[node]][node] - flux[tata[node]][node]);
        node = tata[node];
    }
    node = dest;
    while (node != source)
    {
        flux[tata[node]][node] += minimumFlow;
        flux[node][tata[node]] -= minimumFlow;
        node = tata[node];
    }
    return minimumFlow;
}
void bfs1(int source)
{
    queue<int> q;

    vizS[source] = 1;
    q.push(source);
    while (!q.empty())
    {
        int node = q.front();
        q.pop();
        for (auto x : adj[node])
        {
            if (cap[node][x] - flux[node][x] > 0 && vizS[x] == 0)
            {
                q.push(x);
                vizS[x] = 1;
            }
        }
    }
}
void bfs2(int source)
{
    queue<int> q;

    vizD[source] = 1;
    q.push(source);
    while (!q.empty())
    {
        int node = q.front();
        q.pop();
        for (auto x : adj[node])
        {
            if (cap[x][node] - flux[x][node] > 0 && vizD[x] == 0)
            {
                q.push(x);
                vizD[x] = 1;
            }
        }
    }
}
int main()
{
    fin >> N >> M;
    source = 1, dest = N;
    vector<pair<int, int>> edges;
    for (int i = 1; i <= M; i++)
    {
        int x, y, z;
        fin >> x >> y >> z;
        adj[x].push_back(y);
        adj[y].push_back(x);
        edges.push_back({x, y});
        cap[x][y] = z;
        cap[y][x] = z;
    }
    int flow = 0;
    while (have_road(source, dest))
    {
        flow += calculateFlow();
    }
    bfs1(source);
    bfs2(dest);
    vector<int> answer;
    for (int i = 0; i < edges.size(); i++)
    {
        if ((vizS[edges[i].first] && vizD[edges[i].second]) && !vizS[edges[i].second] && !vizD[edges[i].first])
        {
            answer.push_back(i + 1);
            continue;
        }
        if ((vizS[edges[i].second] && vizD[edges[i].first]) && !vizS[edges[i].first] && !vizD[edges[i].second])
        {
            answer.push_back(i + 1);
            continue;
        }
    }

   // fout << flow;
    fout << answer.size() << "\n";
    for(auto x:answer)
    {
        fout<<x<<'\n';
    }
    return 0;
}