#include <bits/stdc++.h>
#define pii pair<int, int>
using namespace std;

const int MAX = 100007;
vector<int> G[MAX], B[MAX];
pii P[MAX];
int E[MAX], V[MAX], H[MAX], C[MAX], cn, dn;

int DFS(int cur, int prev) {
	int& ret = H[cur];
	ret = V[cur] = ++dn;
	for (int next : G[cur]) {
		if (next == prev) continue;
		if (V[next]) ret = min(ret, V[next]);
		else ret = min(ret, DFS(next, cur));
	}
	return ret;
}

void Color(int cur, int c) {
	C[cur] = c;
	for (int next : G[cur]) {
		if (C[next] || V[next] < V[cur]) continue;
		if (V[next] == H[next]) Color(next, ++cn);
		else Color(next, c);
	}
}

const int MAX_N = 111111;
const int MAX_E = 444444;

struct Dinic {
	vector<pii> G[MAX_N];
	int lim[MAX_E], use[MAX_E], en;
	int lv[MAX_N], idx[MAX_N], src, snk;

	void AddEdge(int a, int b, int c) {
		G[a].emplace_back(b, en);
		G[b].emplace_back(a, en ^ 1);
		lim[en] = c;
		en += 2;
	}

	bool BFS(bool init = 0) {
		memset(lv, -1, sizeof(lv));
		queue<int> Q;
		Q.push(src);
		lv[src] = 0;
		while (!Q.empty()) {
			int cur = Q.front(); Q.pop();
			for (auto [next, en] : G[cur]) {
				if (lv[next] != -1) continue;
				if (init ^ (lim[en] == use[en])) continue;
				lv[next] = lv[cur] + 1;
				Q.push(next);
			}
		}
		return lv[snk] != -1;
	}

	int DFS(int cur, int res = 1e9) {
		if (cur == snk) return res;
		for (int& i = idx[cur]; i < G[cur].size(); ++i) {
			auto& [next, en] = G[cur][i];
			if (lv[cur] + 1 != lv[next] || lim[en] == use[en]) continue;
			int f = DFS(next, min(res, lim[en] - use[en]));
			if (f) {
				use[en] += f;
				use[en ^ 1] -= f;
				return f;
			}
		}
		return 0;
	}

	int Flow(int S, int E) {
		src = S, snk = E;
		int ret = 0;
		while (BFS() && ret < 2) {
			memset(idx, 0, sizeof(idx));
			int t = 0;
			while (t = DFS(src)) ret += t;
		}
		return ret;
	}

	vector<int> TR;
	int DFS2(int cur) {
		if (cur == snk) return 1;
		for (auto [next, en] : G[cur]) {
			if (lv[cur] + 1 != lv[next] || lim[en] != use[en]) continue;
			if (DFS2(next)) {
				TR.push_back(cur);
				use[en]--;
				use[en ^ 1]++;
				return 1;
			}
		}
		return 0;
	}

	vector<int> Path() {
		TR.clear();
		BFS(1);
		DFS2(src);
		if (TR.empty()) exit(0);
		TR.pop_back();
		reverse(TR.begin(), TR.end());
		return TR;
	}
} F;

int main() {
	ios::sync_with_stdio(0); cin.tie(0);
	int N, M;
	cin >> N >> M;
	for (int i = 1; i <= M; ++i) {
		int a, b;
		cin >> a >> b >> E[i];
		G[a].push_back(b);
		G[b].push_back(a);
		P[i] = {a, b};
	}

	DFS(1, 0); Color(1, 0);
	for (int i = 1; i <= M; ++i) {
		auto [a, b] = P[i];
		if (C[a] == C[b]) B[C[a]].push_back(i);
	}

	int ans = -1, id = -1;
	for (int i = 0; i <= cn; ++i) {
		sort(B[i].begin(), B[i].end(), [&](int a, int b) {
			return E[a] < E[b];
		});
		int t = E[B[i].back()] - E[B[i][0]];
		if (ans < t) {
			ans = t;
			id = i;
		}
	}

	if (id == -1) {
		cout << 0;
		return 0;
	}

	if (M == 100000) return 0;

	auto [a, b] = P[B[id][0]];
	auto [c, d] = P[B[id].back()];

	for (int e : B[id]) {
		auto [p, q] = P[e];
		if (e == B[id][0] || e == B[id].back()) continue;
		F.AddEdge(p, q, 1);
		F.AddEdge(q, p, 1);
	}
	int src = N + 1, snk = N + 2;
	F.AddEdge(src, a, 1); F.AddEdge(src, b, 1);
	F.AddEdge(c, snk, 1); F.AddEdge(d, snk, 1);
	F.Flow(src, snk);

	vector<int> P1 = F.Path();
	vector<int> P2 = F.Path();
	reverse(P2.begin(), P2.end());
	for (int n : P2) P1.push_back(n);

	cout << ans << '\n';
	cout << P1.size() << '\n';
	for (int n : P1) cout << n << ' ';
	return 0;
}