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

const int MAX = 100007;
vector<pii> G[MAX], BCC[MAX];
int V[MAX], E[MAX], B[MAX], pv[MAX], ok[MAX], dn, bn;
set<pii> no;
vector<int> S;
pii P[MAX];

int DFS(int cur, int prev) {
	int ret = V[cur] = ++dn;
	for (auto [next, en] : G[cur]) {
		if (next == prev) continue;
		if (V[cur] > V[next]) S.push_back(en);
		if (V[next]) {
			ret = min(ret, V[next]);
			continue;
		}

		int t = DFS(next, cur);
		ret = min(ret, t);
		if (t < V[cur]) continue;

		bn++;
		do {
			int e = S.back(); S.pop_back();
			B[e] = bn;
			BCC[bn].emplace_back(E[e], e);
		} while (BCC[bn].back().second != en);
		sort(BCC[bn].begin(), BCC[bn].end());
	}
	return ret;
}

const int MAX_N = 222222;
const int MAX_E = 666666;

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

	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() {
		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 || 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) {
				if (in.count(en ^ 1)) in.erase(en ^ 1);
				in.insert(en);
				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;
	}
} F;

vector<int> ans;
void DFS2(int cur, int prev) {
	for (auto [next, en] : G[cur]) {
		if (!ok[en] || next == prev || next == ans[0]) continue;
		ok[en] = 0;
		ans.push_back(next);
		DFS2(next, cur);
	}
}

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].emplace_back(b, i);
		G[b].emplace_back(a, i);
		P[i] = {a, b};
	}

	DFS(1, 0);

	int go = -1, id = 0;
	for (int i = 1; i <= bn; ++i) {
		if (BCC[i].size() == 1) continue;
		int n = BCC[i].back().first - BCC[i][0].first;
		if (go < n) {
			go = n;
			id = i;
		}
	}

	auto [a, b] = P[BCC[id][0].second];
	auto [c, d] = P[BCC[id].back().second];
	ok[BCC[id][0].second] = ok[BCC[id].back().second] = 1;

	int src = 2 * N + 1, snk = 2 * N + 2;
	for (int i = 1; i <= M; ++i) {
		auto [u, v] = P[i];
		F.AddEdge(N + u, v, B[i] == id);
		F.AddEdge(N + v, u, B[i] == id);
	}
	for (int i = 1; i <= N; ++i) F.AddEdge(i, N + i, 1);
	F.AddEdge(src, a, 1); F.AddEdge(src, b, 1);
	F.AddEdge(N + c, snk, 1); F.AddEdge(N + d, snk, 1);
	F.Flow(src, snk);

	for (int n : F.in) {
		int e = n / 4;
		if (e <= M && n % 2 == 0) ok[e] = 1;
	}

	ans.push_back(a);
	DFS2(a, a);
	ans.pop_back();

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