#include <bits/stdc++.h>

using namespace std;

using i64 = long long;

constexpr int N = 2e5 + 5;

int n, m, u[N], v[N], w[N];

struct Edge_biconnected {
    // 点下标[0, n),传入时传n
    int n, m;
    struct Edge {
        int to, idx;
        Edge(int to, int idx) : to(to), idx(idx) {}
    };
    int dfs_clock, bcc_cnt;
    vector<int> dfn, bccno, low;
    vector<bool> isbridge;
    vector<vector<Edge>> G, rg;
    vector<pair<int, int>> cut;
    vector<int> a;
    Edge_biconnected(int n, int m) {
        this->n = n;
        this->m = m;
        dfn.resize(n);
        bccno.resize(n, -1);
        low.resize(n);
        isbridge.resize(m);
        bcc_cnt = 0;
        dfs_clock = 0;
        a.resize(n);
        G.assign(n, {});
        rg.assign(n, {});
    }

    vector<int> stk;
    void add_edge(int u, int v, int i) {
        G[u].push_back({v, i});
        G[v].push_back({u, i});
    }

    void tarjan(int u, int fa) {
        dfn[u] = low[u] = ++dfs_clock;
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].to;
            if (!dfn[v]) {
                tarjan(v, u);
                low[u] = min(low[v], low[u]);
                if (dfn[u] < low[v]) {
                    isbridge[G[u][i].idx] = 1;
                    cut.emplace_back(u, v);
                }
            } else if (dfn[v] < dfn[u] && v != fa) {
                low[u] = min(low[u], dfn[v]);
            }
        }
    }

    void dfs(int u) {
        dfn[u] = 1;
        bccno[u] = bcc_cnt;
        for (int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].to;
            if (isbridge[G[u][i].idx]) continue;
            if (!dfn[v]) {
                dfs(v);
            }
        }
    }

    i64 work() {
        for (int i = 0; i < n; i++) {
            if (!dfn[i]) {
                tarjan(i, i);
            }
        }
        // cerr << "111111111\n";
        dfn.assign(dfn.size(), 0);
        for (int i = 0; i < n; i++) {
            if (!dfn[i]) {
                dfs(i);
                bcc_cnt += 1;
            }
        }

        int rt = 1e9;
        for (int i = 0; i < m; i += 1) {
            if (!isbridge[i]) {
                rt = min(rt, w[i]);
            }
        }
        vector<i64> sz(bcc_cnt);

        for (int i = 0; i < m; i += 1) {
            if (isbridge[i]) {
                int p = bccno[u[i]], q = bccno[v[i]];
                // cerr << p << ' ' << q << '\n';
                rg[p].push_back({q, i});
                rg[q].push_back({p, i});
            } else {
                sz[bccno[u[i]]] += 1;
            }
        }

        auto rdfs = [&](auto self, int u, int fa) -> void {
            sz[u] = 0;
            for (auto [v, idx] : rg[u]) {
                if (v == fa) continue;
                self(self, v, u);
                if (sz[v] % 2 == 0) {
                    rt = min(rt, w[idx]);
                }
                sz[u] += sz[v] + 1;
            }
        };
        rdfs(rdfs, 0, -1);

        return rt;
    }
};

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

    cin >> n >> m;
    Edge_biconnected bic(n, m);

    i64 ans = 0;

    for (int i = 0; i < m; i += 1) {
        cin >> u[i] >> v[i] >> w[i];
        --u[i], --v[i];
        bic.add_edge(u[i], v[i], i);
        ans += w[i];
    }

    if (m % 2 == 0) {
        cout << ans << '\n';
    } else {
        cout << ans - bic.work() << '\n';
    }

    return 0;
}