// Krzysztof Małysa
// Solution in O(n + m \alpha(n))
#include <cstdio>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;

vector<pair<int, int>> dsu; // (parent, rank)

inline int Find(int x) noexcept { return x == dsu[x].first ? x : dsu[x].first = Find(dsu[x].first); }

inline bool Union(int x, int y) noexcept {
	x = Find(x);
	y = Find(y);
	if (x == y)
		return false;

	if (dsu[x].second < dsu[y].second)
		swap(x, y);
	if (dsu[x].second == dsu[y].second)
		++dsu[x].second;

	dsu[y].first = x;
	return true;
}

inline int scan_int() noexcept {
	int c;
	do {
		c = getchar_unlocked();
	} while (c < '0' or c > '9');

	int x = 0;
	do {
		x = x * 10 + (c - '0');
		c = getchar_unlocked();
	} while (c >= '0' and c <= '9');

	return x;
}

int main() {
	int n = scan_int();
	int m = scan_int();
	dsu.resize(n + 1);
	for (int i = 1; i <= n; ++i)
		dsu[i].first = i;

	long long sum = 0;
	while (m--) {
		int a = scan_int();
		int b = scan_int();
		int w = scan_int();
		if (Union(a, b))
			sum += w;
	}

	cout << sum << '\n';
}

// Krzysztof Małysa
// Solution in O(n + m \log n)
#include <cstdio>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;

vector<int> dsu;

inline int Find(int x) noexcept { return x == dsu[x] ? x : dsu[x] = Find(dsu[x]); }
// Unions x into y
inline bool Union(int x, int y) noexcept {
	x = Find(x);
	y = Find(y);
	if (x == y)
		return false;

	dsu[x] = y;
	return true;
}

inline int scan_int() noexcept {
	int c;
	do {
		c = getchar_unlocked();
	} while (c < '0' or c > '9');

	int x = 0;
	do {
		x = x * 10 + (c - '0');
		c = getchar_unlocked();
	} while (c >= '0' and c <= '9');

	return x;
}

int main() {
	int n = scan_int();
	int m = scan_int();
	dsu.resize(n + 1);
	iota(dsu.begin(), dsu.end(), 0);

	long long sum = 0;
	while (m--) {
		int a = scan_int();
		int b = scan_int();
		int w = scan_int();
		if (Union(a, b))
			sum += w;
	}

	cout << sum << '\n';
}

// Krzysztof Małysa
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;

#define FOR(i,a,n) for (auto i ## __ = (n), i = (a); i <= i ## __; ++i)
#define FORD(i,a,n) for (auto i ## __ = (n), i = (a); i >= i ## __; --i)
#define REP(i,n) FOR(i,0, n - 1)
#define ALL(h) begin(h), end(h)
#define EB emplace_back
#define X first
#define Y second
#define V vector
#define tpv typedef V<

typedef long long LL;
typedef pair<int, int> PII;
tpv int> VI;
tpv VI> VVI;
tpv PII> VPII;
tpv LL> VLL;

constexpr char nl = '\n';
#define endl nl
#define ris return *this
#define tem template<class t

tem, class u> inline void mini(t& a, u&& b) { if (b < a) a = b; }
tem, class u> inline void maxi(t& a, u&& b) { if (b > a) a = b; }
int ceil2(int h) { return h < 2 ? 1 : 1 << (sizeof(h) * 8 - __builtin_clz(h - 1)); }

tem> struct Dump { t a, b; };
tem> auto dump(t&& h) -> Dump<decltype(begin(h))> { return {ALL(h)}; }
tem> auto stub(t* h) -> decltype(cerr << *h, 0);
tem> char stub(...);
#define enif(o) tem> typename enable_if<sizeof stub<t>(0) o 1, debug&>::type operator<<(t h)
#define dor > debug& operator<<
struct debug {
#ifdef DEBUG
#define deb debug()
	~debug() { cerr << nl; }
	enif(!=) { cerr << boolalpha << h; ris; }
	enif(==) {
		*this << '{';
		for (auto a = begin(h), b = end(h); a != b;)
			*this << *a++ << &" "[a == b];
		ris << '}';
	}
	tem, class u dor(pair<t, u> p) { ris << '(' << p.X << ", " << p.Y << ')'; }
	tem dor(Dump<t> d) {
		*this << "{\n";
		for (t a = d.a, c = a; a != d.b; ++a)
			*this << "  " << distance(c, a) << ": " << *a << nl;
		ris << '}';
	}
#else
	operator int() { return 0; }
	tem dor(t&&) { ris; }
#define deb 0 and debug()
#endif
};

#define imie(h...) #h ": " << (h) << " "
#define LOG(h...) deb << imie(h)
#define DOG(h...) deb << #h ": " << dump(h) << " "

struct BinomalTree {
	int order;
	VI children; // Binomal trees of orders 0, ..., order - 1

	BinomalTree(int ord = 0) : order(ord), children(ord) {}
};

mt19937_64 gen__(chrono::system_clock::now().time_since_epoch().count());

LL rd(LL a, LL b) { return uniform_int_distribution<LL>(a, b)(gen__); }

V<BinomalTree> G;
VPII edges;

int gen_binomal_tree(int order) {
	if (order == 0) {
		int id = (int)G.size();
		G.EB();
		return id;
	}

	int id = (int)G.size();
	G.EB(order);
	REP (i, order) {
		int child = gen_binomal_tree(i);
		edges.EB(child, id);
		G[id].children[i] = child;
	}

	return id;
}

int transform_impl(int x, int new_node) {
	int k = G[x].children.back();
	G[x].children.pop_back();
	int o = --G[x].order;
	G[new_node].children[o] = x;
	if (o == 0)
		return k;

	return transform_impl(k, new_node);
}

// Simulates union(root, new node) and makes find on the deepest node which id is returned
int transform(int root) {
	int new_node = (int)G.size();
	G.EB(G[root].order);
	return transform_impl(root, new_node);
}

int main(int argc, char **argv) {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);

	assert(argc > 1);
	// e.g.: ./gen 1 10 1 100 10000 0
	int n, m;
	do {
		n = rd(atoi(argv[1]), atoi(argv[2]));
		m = rd(atoi(argv[3]), atoi(argv[4]));
	} while (not (n - 1 <= m and m <= n * LL(n - 1) / 2));
	int max_w = atoi(argv[5]);
	int swap_edges = atoi(argv[6]); // In the DSU using path compression only, joining is done in one direction, but we don't know which one, so to allow generating counter-tests for both, switching this parameter between 0 and 1 changes switches the order of edge's vertices for all edges

	// Build binomal tree
	int order = 0;
	while ((1 << order) <= n)
		++order;

	order = max(1, order - 4);
	int root = gen_binomal_tree(order);
	int node = root;
	// Add edges in the worst way for Find & Union with compression and naive linking
	while ((int)G.size() < n) {
		int new_node_id = (int)G.size();
		edges.EB(node, new_node_id);
		node = transform(root);
		root = new_node_id;
	}

	// Create remaining edges
	set<PII> edges_set;
	for (auto p : edges)
		edges_set.emplace(min(p.X, p.Y), max(p.X, p.Y));
	FOR (i, 0, m - n) {
		int a, b;
		do {
			do {
				a = rd(0, n - 1);
				b = rd(0, n - 1);
			} while (a == b);
		} while (not edges_set.emplace(min(a, b), max(a, b)).second);
		edges.emplace_back(a, b);
	}

	assert((int)G.size() == n);
	assert((int)edges.size() == m);

	VI w(m);
	for (int& x : w)
		x = rd(1, max_w);

	sort(ALL(w));

	VI remap(n);
	iota(ALL(remap), 1);
	shuffle(ALL(remap), gen__);

	cout << n << ' ' << m << nl;
	REP (i, m) {
		if (swap_edges)
			swap(edges[i].X, edges[i].Y);

		cout << remap[edges[i].X] << ' ' << remap[edges[i].Y] << ' ' << w[i] << nl;
	}

	// system("grep VmPeak /proc/$PPID/status >&2");
	return 0;
}