/** gnu specific **/
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
/** contains everything I need in std **/
#include <bits/stdc++.h>
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")


#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(S) ((int)S.size())
#define FOR(i, st_, n) for(int i = st_; i < n; ++i)
#define RFOR(i, n, end_) for(int i = (n)-1; i >= end_; --i)
#define x first
#define y second
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef unsigned long long ull;
typedef long double LD;
typedef pair<ull, ull> pull;
using namespace __gnu_pbds;
typedef tree<ll, null_type, less<>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
using namespace std;
#ifdef ONPC
mt19937 rnd(228);
#else
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif

namespace std
{
    // Define a hash function for std::pair
    template<typename T>
    inline void hash_combine(std::size_t &seed, const T &v)
    {
        seed ^= std::hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    }

    template<typename T1, typename T2>
    struct hash<std::pair<T1, T2>>
    {
        std::size_t operator()(const std::pair<T1, T2> &key) const
        {
            std::size_t seed = 0;
            hash_combine(seed, key.first);
            hash_combine(seed, key.second);
            return seed;
        }
    };
}


struct Edge
{
	int u,v;
	ll w;
};

struct DSU
{
    int n;
    vector<int> pr;
	DSU(){}

    DSU(int nn)
    {
		n = nn;
        pr = vector<int>(n, -1);
        for(int i = 0; i < n; ++i)
            pr[i] = i;
    }

    int get_parent(int v)
    {
        if(pr[v] == v)
            return v;
        return pr[v] = get_parent(pr[v]);
    }

    void make_union(int a, int b)
    {
        a = get_parent(a);
        b = get_parent(b);
        if(a != b)
        {
            pr[a] = b;
        }
    }
};


struct SpecialDSU
{
    int n;
    vector<int> pr;
    vector<int> SZ;
    vector<map<ll, set<pii>>> M;
	SpecialDSU(){}

    SpecialDSU(int nn, const vector<vector<pll>>& adj)
    {
		n = nn;
        pr = vector<int>(n, -1);
        SZ = vector<int>(n, 0);
        for(int i = 0; i < n; ++i)
            pr[i] = i;
        M = vector<map<ll, set<pii>>>(n);
        FOR(v,0,n)
        {
			for(auto [to, w]: adj[v])
			{
				M[v][w].insert(pii{min((int)to,v), max((int)to,v)});
				SZ[v] += 1;
			}
		}
    }
	
	ll get_minimum(int v)
	{
		return M[get_parent(v)].begin()->x;
	}

    int get_parent(int v)
    {
        if(pr[v] == v)
            return v;
        return pr[v] = get_parent(pr[v]);
    }

    void make_union(int a, int b)
    {
        a = get_parent(a);
        b = get_parent(b);
        if(a != b)
        {
			if(SZ[b] < SZ[a])
				swap(a,b);
			// sz[b] > sz[a]
            pr[a] = b;
            SZ[b] += SZ[a];
            for(const auto& [w, edge]: M[a])
            {
				for(const auto& [u,v]: edge)
				{
					if(get_parent(u) == get_parent(v))
					{
						M[b][w].erase({min(u,v),max(u,v)});
						if(M[b][w].empty())
							M[b].erase(w);
					}
					else
					{
						M[b][w].insert({min(u,v),max(u,v)});
					}
				}
			}
			M[a].clear();
        }
    }
};

vector<vector<pll>> msp_adj;
vector<vector<pll>> adj;
SpecialDSU dsu;
ll msp;

ll f(int v, int pr, ll ww)
{
	ll res = msp;
	for(auto [to, w]: msp_adj[v])
	{
		if(to!=pr)
		{
			res=max(res,f(to, v, w));
		}
	}
	for(auto [to, w]: msp_adj[v])
	{
		if(to!=pr)
		{
			dsu.make_union(v,to);
		}
	}
	if(pr!=-1)
	{
		res=max(res,msp-ww+dsu.get_minimum(v));
	}

	
	return res;
}

int solve()
{
	int n,m;
	if(!(cin>>n>>m))
		return 1;
	msp_adj=vector<vector<pll>>(n); // msp tree
	adj=vector<vector<pll>>(n); // not msp tree
	
	vector<Edge> edges(m);
	for(auto& [u,v,w]: edges)cin>>u>>v>>w, --u,--v;

	sort(all(edges),[](const Edge&e1, const Edge&e2) -> bool {
		return e1.w<e2.w;
	});
	auto dsu_ = DSU(n);
	msp=0;
	for(auto [u,v,w]:edges)
	{
		if(dsu_.get_parent(u) == dsu_.get_parent(v))
		{
			adj[u].pb({v,w});
			adj[v].pb({u,w});
			continue;
		}
		msp += w;
		dsu_.make_union(u,v);
		msp_adj[u].pb({v,w});
		msp_adj[v].pb({u,w});
	}
	dsu = SpecialDSU(n,adj);
	cout << f(0,-1,0)<<'\n';
    return 0;
}

int32_t main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    int TET = 1e9;
    //cin >> TET;
    for (int i = 1; i <= TET; i++)
    {
        if (solve())
        {
            break;
        }
#ifdef ONPC
        cout << "__________________________" << endl;
#endif
    }
#ifdef ONPC
    cerr << endl << "finished in " << clock() * 1.0 / CLOCKS_PER_SEC << " sec" << endl;
#endif
}