#include <bits/stdc++.h>
#define FOR(i, l, r) for (int i = (l); i <= (r); ++i)
#define ROF(i, r, l) for (int i = (r); i >= (l); --i)
#define popc(x) __builtin_popcount(x)
#define allc(x) (x).begin(), (x).end()
#define SZ(v) (int)v.size()
#define PII pair<int, int>
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
bool Mbe;
template <typename A, typename B>
void chkmax(A &a, B b) {
    a = a > b ? a : b;
}
template <typename A, typename B>
void chkmin(A &a, B b) {
    a = a < b ? a : b;
}
namespace lyl {
    const int N = 2e5 + 5;
    const int inf = 0x3f3f3f3f;
    int n, m, low[N], dfn[N], timer, Mx[N], Mn[N], bel[N], tot, ans, head[N], etot = -1, S, T, cur[N];
    struct edge {
        int v, nxt, cap;
    } e[N << 1];
    PII mx[N], mn[N];
    vector<array<int, 3>> G[N];
    vector<int> vec;
    bool flag[N];
    void tarjan(int u, int pre) {
        dfn[u] = low[u] = ++timer; 
        for (auto [v, w, id]: G[u]) {
            if (id == pre) {
                continue;
            }
            if (!dfn[v]) {
                tarjan(v, id);
                chkmin(low[u], low[v]);
                if (low[v] > dfn[u]) {
                    flag[id] = 1;
                }   
            } else {
                chkmin(low[u], dfn[v]);
            }
        }
    }
    void upd(PII x, int val, int id) {
        if (x.FI > x.SE) {
            swap(x.FI, x.SE);
        }
        if (Mx[id] < val) {
            Mx[id] = val;
            mx[id] = x;
        }
        if (Mn[id] > val) {
            Mn[id] = val;
            mn[id] = x;
        } 
        if (mx[id] != x && mx[id] == mn[id]) {
            mx[id] = x;
        }
    }
    void dfs(int u, int pre) {
        bel[u] = tot;
        for (auto [v, w, id]: G[u]) {
            if (flag[id]) {
                continue;
            }
            upd(MP(u, v), w, tot);
            if (bel[v]) {
                continue;
            }
            dfs(v, id);
        }
    }
    int dep[N];
    bool Bfs() {
        queue<int> q;
        q.push(S);
        FOR (i, 1, n + 2) {
            cur[i] = head[i];
        }
        memset(dep, -1, sizeof(dep));
        dep[S] = 0;
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for (int i = head[u]; ~i; i = e[i].nxt) {
                int v = e[i].v, cap = e[i].cap;
                if (dep[v] == -1 && cap) { 
                    dep[v] = dep[u] + 1;
                    q.push(v);
                }
            }
        }
        return dep[T] != -1;
    }
    int Dfs(int u, int flow) {
        if (!flow || u == T) {
            return flow;
        }
        int f, maxflow = 0;
        for (int i = cur[u]; ~i && flow; i = e[i].nxt) {
            cur[u] = i;
            int v = e[i].v, cap = e[i].cap;
            if (dep[v] == dep[u] + 1 && (f = Dfs(v, min(flow, cap)))) {
                flow -= f;
                maxflow += f;
                e[i].cap -= f;
                e[i ^ 1].cap += f;
            }
        }
        return maxflow;
    }
    void dinic() {
        int ans = 2;
        while (ans > 0) {
            Bfs();
            ans -= Dfs(S, ans);
        }
        int u = n + 1;
        while (u != n + 2) {
            if (u != n + 1) {
                vec.PB(u);
            }
            cerr << u << ' ';
            for (int i = head[u]; ~i; i = e[i].nxt) {
                int v = e[i].v, cap = e[i].cap;
                if (cap == 0) {
                    u = v;
                    e[i].cap = 1;
                    e[i ^ 1].cap = 1;
                    break;
                }
            }
        }
        cerr << '\n';
        while (u != n + 1) {
            if (u != n + 2) {
                vec.PB(u);
            }
            cerr << u << ' ';
            for (int i = head[u]; ~i; i = e[i].nxt) {
                int v = e[i].v, cap = e[i].cap;
                if (cap == 2) {
                    u = v;
                    e[i].cap = 1;
                    e[i ^ 1].cap = 1;
                    break;
                }
            }
        }
        cout << SZ(vec) << '\n';
        for (int x: vec) {
            cout << x << ' ';
        }
        cout << '\n';
    }
    void add(int u, int v, int w) {
        e[++etot] = (edge){v, head[u], w};
        head[u] = etot;
    }
    void addedge(int u, int v) {
        add(u, v, 1);
        add(v, u, 1);
    }
    void solve() {
        cin >> n >> m;
        FOR (i, 1, m) {
            int u, v, w;
            cin >> u >> v >> w;
            G[u].PB({v, w, i});
            G[v].PB({u, w, i});
        }
        FOR (i, 1, n) {
            if (!dfn[i]) {
                tarjan(i, 0);
            }
        }
        FOR (i, 1, n) {
            if (!bel[i]) {
                ++tot;
                Mx[tot] = -inf;
                Mn[tot] = inf;
                dfs(i, 0);
                chkmax(ans, Mx[tot] - Mn[tot]);
            }
        }

        int g = 0;
        FOR (i, 1, tot) {
            if (Mx[i] - Mn[i] == ans) {
                g = i;
                break;
            }
        }
        cout << ans << '\n';
        cerr << "First!\n";
        memset(head, -1, sizeof(head));
        S = n + 1;
        T = n + 2;
        addedge(S, mx[g].FI);
        addedge(S, mx[g].SE);
        addedge(mn[g].FI, T);
        addedge(mn[g].SE, T);
        cerr << mx[g].FI << ' ' << mx[g].SE << '\n';
        FOR (u, 1, n) {
            for (auto [v, w, id]: G[u]) {
                if (u > v) {
                    continue;
                }
                if (mx[g].FI == u && mx[g].SE == v) {
                    continue;
                }
                if (mx[g].FI == v && mx[g].SE == u) {
                    continue;
                }
                if (mn[g].FI == v && mn[g].SE == u) {
                    continue;
                }
                if (mn[g].FI == u && mn[g].SE == v) {
                    continue;
                }
                addedge(u, v);
                cerr << u << ' ' << v << '\n';
            }
        }
        dinic();
    }
}
bool Meb;
int main() {
    // freopen(".in", "r", stdin);
    // freopen(".out", "w", stdout);
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    lyl::solve();
    // cerr << "Space: " << abs(&Meb - &Mbe) / 1024.0 / 1024.0 << "MB\n";
    // cerr << "Time: " << clock() * 1000.0 / CLOCKS_PER_SEC << "ms\n";
    return 0;
}