#include <bits/stdc++.h>

#define EVAL(x) #x " = " << (x)

using std::cin, std::cout;
using i64 = int64_t;
using u8 = uint8_t;

constexpr auto inf = i64(1e18);

auto main() -> int {
  std::ios_base::sync_with_stdio(false);
  cin.tie(nullptr);

  auto n = 0, m = 0;
  cin >> n >> m;

  auto sum = i64{0};
  auto edge = std::vector<std::tuple<int, int, int>>(m);
  auto adj_1 = std::vector<std::vector<std::pair<int, int>>>(n);
  for (auto i = 0; i < m; ++i) {
    auto& [u, v, w] = edge[i];
    cin >> u >> v >> w, --u, --v, sum += w;
    adj_1[u].emplace_back(v, i), adj_1[v].emplace_back(u, i);
  }

  auto cur = 0, cnt = 0;
  auto dfn = std::vector<int>(n, -1), low = std::vector<int>(n),
       stk = std::vector<int>{}, color = std::vector<int>(n);
  auto tarjan = [&](auto tarjan, int u, int from) -> void {
    dfn[u] = low[u] = cur++, stk.emplace_back(u);
    for (auto [v, id] : adj_1[u]) {
      if (id == from) continue;
      if (~dfn[v])
        low[u] = std::min(low[u], dfn[v]);
      else
        tarjan(tarjan, v, id), low[u] = std::min(low[u], low[v]);
    }
    if (dfn[u] == low[u]) {
      while (true) {
        auto x = stk.back();
        stk.pop_back(), color[x] = cnt;
        break;
      }
      ++cnt;
    }
  };
  tarjan(tarjan, 0, -1);

  auto min_w = inf;
  auto parity = std::vector<u8>(cnt);
  auto adj_2 = std::vector<std::vector<std::pair<int, int>>>(cnt);
  for (auto [u, v, w] : edge) {
    u = color[u], v = color[v];
    if (u == v)
      min_w = std::min<i64>(min_w, w), parity[u] ^= 1;
    else
      adj_2[u].emplace_back(v, w), adj_2[v].emplace_back(u, w);
  }

  auto f = std::vector<std::array<i64, 2>>(cnt);
  auto dfs = [&](auto dfs, int u, int p) -> void {
    f[u][parity[u] ^ 1] = inf;
    for (auto [v, w] : adj_2[u]) {
      if (v == p) continue;
      dfs(dfs, v, u);
      auto g = std::array<i64, 2>{};
      for (auto i = 0; i <= 1; ++i)
        g[i] = std::min(f[u][i] + std::min(f[v][1], w + f[v][0]),
                        f[u][i ^ 1] + f[v][0]);
      f[u] = g;
    }
  };
  dfs(dfs, cnt - 1, -1);
  cout << sum - std::min(min_w, f[cnt - 1][0]) << "\n";
}