#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <sstream>
#include <math.h>
#include <map>

using namespace std;

int n, m, s, t;
unsigned long long flow = 0;
vector<unordered_map<int, pair<int, int>>> g;
vector<bool> mark;

int dfs(int v, int d) {
    if (mark[v])
        return 0;
    mark[v] = true;
    if (v == t) {
        return d;
    }
    for (auto iter = g[v].begin(); iter != g[v].end(); iter++) {
        if (iter->second.second > iter->second.first) {
            int u = iter->first;
            int res = dfs(iter->first, min(d, iter->second.second - iter->second.first));
            if (res > 0) {
                g[v][u].first += res;
                g[u][v].first -= res;
                return res;
            }
        }
    }
    return 0;
}


int bfs() {
    fill(mark.begin(), mark.end(), false);
    queue<pair<int, int>> q = {};
    q.push({-1, s});
    vector<int> prv(n , -1);

    while (!q.empty()) {
        int v = q.front().second;
        prv[v] = q.front().first;
        q.pop();
        mark[v] = true;
        if (v == t) {
            break;
        }
        for (auto &iter : g[v]) {
            if (!mark[iter.first] && iter.second.second > iter.second.first) {
                q.push({v, iter.first});
            }
        }
    }

    int cur = t;
    int d = INT_MAX;
    if (prv[t] == -1) {
        return 0;
    }

    while (cur != s) {
        d = min(d, g[prv[cur]][cur].second - g[prv[cur]][cur].first);
        cur = prv[cur];
    }

    cur = t;
    while (cur != s) {
        g[prv[cur]][cur].first += d;
        g[cur][prv[cur]].first -= d;
        cur = prv[cur];
    }

    return d;
}


unordered_set<int> A = {};
set<pair<int, int>> ans = {};

void find_cut() {
    queue<int> q = {};
    q.push(s);
    while (!q.empty()) {
        int v = q.front();
        q.pop();
        for (auto &iter : g[v]) {
            if (A.find(iter.first) == A.end()) {
                if (iter.second.second > iter.second.first) {
                    A.insert(iter.first);
                    q.push(iter.first);
                } else {
                    ans.insert({v, iter.first});
                }
            }
        }
    }
}

map<pair<int, int>, int> my_map;

int main() {
    cin >> n >> m;
    s = 0;
    t = n - 1;
    g.resize(n);
    mark.resize(n);


    for (int i = 0; i < m; ++i) {
        int u, v, c;
        cin >> u >> v >> c;
        u--;
        v--;
        g[u][v].second = c;
        g[v][u].second = c;
        my_map[{u, v}] = i;
        my_map[{v, u}] = i;
    }

    while (true) {
//        fill(mark.begin(), mark.end(), false);
//        int delta = dfs(s, INT_MAX);
        int delta = bfs();
        if (delta > 0) {
            flow += delta;
        } else {
            break;
        }
    }

    A.insert(s);
    find_cut();
    cout << ans.size() << ' ' << flow << endl;
    for (auto &e : ans) {
        if (A.find(e.first) == A.end() || A.find(e.second) == A.end()) {
            cout << my_map[e] + 1 << ' ';
        }
    }
}