#include <bits/stdc++.h>

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef double db;

struct DSU
{
	int n;
	VI p, sz;
	
	DSU(int _n = 0) 
	{
		n = _n;
		p.resize(n);
		iota(ALL(p), 0);
		sz.assign(n, 1);
	}
	int find(int v)
	{
		if (v == p[v])
			return v;
		return p[v] = find(p[v]);
	}
	bool unite(int u, int v)
	{
		u = find(u);
		v = find(v);
		if (u == v) 
			return false;
		if (sz[u] > sz[v])
			swap(u, v);
		p[u] = v;
		sz[v] += sz[u];
		return true;
	}
};

const int INF = 1e9 + 7;

struct Segtree
{
	int n;
	VI t;
	
	Segtree(int _n = 0)
	{
		n = 1;
		while (n < _n) n *= 2;
		t.assign(n * 2 - 1, INF);
	}
	
	void upd(int v, int tl, int tr, int l, int r, int x)
	{
		if (l <= tl && tr <= r)
		{
			t[v] = min(t[v], x);
			return;
		}
		if (tl >= r || l >= tr)
			return;
		int tm = (tl + tr) / 2;
		upd(2 * v + 1, tl, tm, l, r, x);
		upd(2 * v + 2, tm, tr, l, r, x);
	}
	
	void upd(int l, int r, int x)
	{
		upd(0, 0, n, l, r, x);
	}

	int query(int v, int tl, int tr, int idx)
	{
		if (tl + 1 == tr)
			return t[v];
		int tm = (tl + tr) / 2;
		if (idx < tm)
			return min(t[v], query(v * 2 + 1, tl, tm, idx));
		else
			return min(t[v], query(v * 2 + 2, tm, tr, idx));
	}

	int query(int idx)
	{
		return query(0, 0, n, idx);
	}
} st;

const int N = 100'447;
VI g[N];     
vector<PII> g2[N];     
int sz[N];   
int h[N];    
int p[N];    
int top[N];  
int tin[N];
int tout[N];
int t = 0;

void dfsSZ(int v, int par, int hei)
{
	sz[v] = 1;
	h[v] = hei;
	p[v] = par;
	for (auto& to : g[v])
	{
		if (to == par) 
			continue;
		dfsSZ(to, v, hei + 1);
		sz[v] += sz[to];
		if (g[v][0] == par || sz[g[v][0]] < sz[to])
			swap(g[v][0], to);
	}
}
void dfsHLD(int v, int par, int tp)
{
	tin[v] = t++;
	top[v] = tp;
	FOR (i, 0, SZ(g[v]))
	{
		int to = g[v][i];
		if (to == par)
			continue;
		if (i == 0) 
			dfsHLD(to, v, tp);
		else 
			dfsHLD(to, v, to);
	}
	tout[v] = t - 1;
}
void upd(int u, int v, int w)
{
	while(true)
	{
		int tu = top[u];
		int tv = top[v];
		if (tu == tv)
		{
			int t1 = tin[u];
			int t2 = tin[v];
			if (t1 > t2)
				swap(t1, t2);
			// query [t1, t2] both inclusive
			st.upd(t1 + 1, t2 + 1, w);
			break;
		}
		if (h[tu] < h[tv])
		{
			swap(tu, tv);
			swap(u, v);
		}
		st.upd(tin[tu], tin[u] + 1, w);
		u = p[tu];
	}
}

int add = 0;

void dfs(int v, int par, int w)
{
	if (v)
		add = max(add, st.query(tin[v]) - w);
	for (auto [to, c] : g2[v])
		if (to != par)
			dfs(to, v, c);
}


int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);


	int n, m;
	cin >> n >> m;
	
	vector<pair<int, PII>> edges;
	VI used(m);
	FOR (i, 0, m)
	{
		int a, b, c;
		cin >> a >> b >> c;
		a--, b--;
		edges.PB({c, {a, b}});
	}
	sort(ALL(edges));
	LL ans = 0;
	DSU d(n);
	FOR (i, 0, m)
	{
		auto [w, e] = edges[i];
		if (d.find(e.F) != d.find(e.S))
		{
			used[i] = true;
			d.unite(e.F, e.S);
			ans += w;
			g[e.F].PB(e.S);
			g[e.S].PB(e.F);
			g2[e.F].PB({e.S, w});
			g2[e.S].PB({e.F, w});
		}
	}
	dfsSZ(0, -1, 0);
	dfsHLD(0, -1, 0);
	st = Segtree(t);
	FOR (i, 0, m)
	{
		auto [w, e] = edges[i];
		if (used[i])
			continue;
		upd(e.F, e.S, w);
	}
	dfs(0, -1, 0);
	cout << ans + add << '\n';
		
	
	return 0;
}