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

#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define orange(a...) orange_(#a, a)
#define debug(a...) debug_(#a, a)
template <typename i>
void orange_(const char * s, i l, i r) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; l != r; l++)
        cerr << (f++ ? " " : "") << *l;
    cerr << " ]\e[0m\n";
}
template <typename ...T>
void debug_(const char * s, T ...a) {
    cerr << "\e[1;32m(" << s << ") = (";
    int cnt = sizeof...(T);
    (..., (cerr << a << (--cnt ? ", " : ")\e[0m\n")));
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

namespace {

class BCC {
private:
    int n, ecnt;
    vector<vector<pair<int, int>>> g;
    vector<int> dfn, low;
    vector<bool> bridge;
    void dfs(int u, int f) {
        dfn[u] = low[u] = dfn[f] + 1;
        int ch = 0;
        for (auto [v, t] : g[u]) if (v != f) {
            if (dfn[v]) {
                low[u] = min(low[u], dfn[v]);
            } else {
                ++ch;
                dfs(v, u);
                low[u] = min(low[u], low[v]);
                if (low[v] > dfn[u])
                    bridge[t] = true;
            }
        }
    }
public:
    void init(int n_) {
        g.assign(n = n_, vector<pair<int, int>>());
        low.assign(n, ecnt = 0);
        dfn.assign(n, 0);
    }
    void add_edge(int u, int v) {
        g[u].emplace_back(v, ecnt);
        g[v].emplace_back(u, ecnt++);
    }
    void solve() {
        bridge.assign(ecnt, false);
        for (int i = 0; i < n; ++i)
            if (not dfn[i]) dfs(i, i);
    }
    bool is_bridge(int x) const { return bridge[x]; }
};

constexpr int kInf = 1 << 30;

} // namespace

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int n, m; 
    cin >> n >> m;
    vector<tuple<int, int, int>> e(m);
    for (auto &[u, v, w] : e) {
        cin >> u >> v >> w;
        --u, --v;
    }

    BCC bcc;
    bcc.init(n);
    for (auto [u, v, w] : e) bcc.add_edge(u, v);
    bcc.solve();

    vector<vector<pair<int, int>>> g(n);
    for (int i = 0; i < m; ++i) {
        if (bcc.is_bridge(i)) continue;
        auto [u, v, w] = e[i];
        g[u].emplace_back(v, i);
        g[v].emplace_back(u, i);
    }

    vector<bool> vis(n);
    auto dfs = [&](auto self, int i) -> pair<int, int> {
        vis[i] = true;
        pair<int, int> r = {-1, -1};
        for (auto [j, x] : g[i]) {
            if (r.first == -1 or get<2>(e[x]) < get<2>(e[r.first]))
                r.first = x;
            if (r.second == -1 or get<2>(e[x]) > get<2>(e[r.second]))
                r.second = x;
            
            if (vis[j]) continue;
            auto [p, q] = self(self, j);
            if (p != -1 and get<2>(e[p]) < get<2>(e[r.first]))
                r.first = p;
            if (q != -1 and get<2>(e[q]) > get<2>(e[r.second]))
                r.second = q;
        }
        return r;
    };

    tuple<int, int, int> ans = {0, -1, -1};
    for (int i = 0; i < n; ++i) {
        if (vis[i]) continue;
        auto [x, y] = dfs(dfs, i);
        if (x == -1 or y == -1) continue;
        ans = max(ans, {get<2>(e[y]) - get<2>(e[x]), x, y});
    }
    assert(get<1>(ans) != -1);

    auto gao = [&](int i, int j) {
        vector<bool> bye(m);
        bye[i] = true;
        bye[j] = true;
        vector<int> stk;
        auto walk = [&](auto self, int u, int o) -> bool {
            if (o == u) return true;
            vis[u] = true;
            for (auto [v, x] : g[u]) {
                if (bye[x] or vis[v]) continue;
                stk.push_back(x);
                if (self(self, v, o)) return true;
                stk.pop_back();
            }
            return false;
        };

        auto [a, b, w1] = e[i];
        auto [c, d, w2] = e[j];

        vector<int> path;
        fill(vis.begin(), vis.end(), false);
        if (not walk(walk, b, c)) return false;
        path.push_back(b);
        for (int x : stk) {
            auto [p, q, w] = e[x];
            bye[x] = true;
            if (path.back() == p) path.push_back(q);
            else path.push_back(p);
        }
        stk.clear();
        fill(vis.begin(), vis.end(), false);
        if (not walk(walk, d, a)) return false;
        path.push_back(d);
        for (int x : stk) {
            auto [p, q, w] = e[x];
            if (path.back() == p) path.push_back(q);
            else path.push_back(p);
        }

        cout << path.size() << '\n';
        for (size_t x = 0; x < path.size(); ++x)
            cout << path[x] + 1 << " \n"[x + 1 == path.size()];
        return true;
    };

    cout << get<0>(ans) << '\n';
    cout.flush();
    if (not gao(get<1>(ans), get<2>(ans))) {
        swap(get<0>(e[get<1>(ans)]), get<1>(e[get<1>(ans)]));
        assert(gao(get<1>(ans), get<2>(ans)));
    }
    return 0;
}