#line 1 "main.cpp"
/**
* @title Template
*/
#include <iostream>
#include <algorithm>
#include <utility>
#include <numeric>
#include <vector>
#include <array>
#include <tuple>
#include <cassert>
#include <random>
#line 2 "/Users/kodamankod/Desktop/Programming/Library/other/chmin_chmax.cpp"
template <class T, class U>
constexpr bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return true;
}
return false;
}
template <class T, class U>
constexpr bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return true;
}
return false;
}
/**
* @title Chmin/Chmax
*/
#line 2 "/Users/kodamankod/Desktop/Programming/Library/other/range.cpp"
#line 4 "/Users/kodamankod/Desktop/Programming/Library/other/range.cpp"
class range {
public:
class iterator {
private:
int64_t M_position;
public:
constexpr iterator(int64_t position) noexcept: M_position(position) { }
constexpr void operator ++ () noexcept { ++M_position; }
constexpr bool operator != (iterator other) const noexcept { return M_position != other.M_position; }
constexpr int64_t operator * () const noexcept { return M_position; }
};
class reverse_iterator {
private:
int64_t M_position;
public:
constexpr reverse_iterator(int64_t position) noexcept: M_position(position) { }
constexpr void operator ++ () noexcept { --M_position; }
constexpr bool operator != (reverse_iterator other) const noexcept { return M_position != other.M_position; }
constexpr int64_t operator * () const noexcept { return M_position; }
};
private:
const iterator M_first, M_last;
public:
constexpr range(int64_t first, int64_t last) noexcept: M_first(first), M_last(std::max(first, last)) { }
constexpr iterator begin() const noexcept { return M_first; }
constexpr iterator end() const noexcept { return M_last; }
constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(*M_last - 1); }
constexpr reverse_iterator rend() const noexcept { return reverse_iterator(*M_first - 1); }
};
/**
* @title Range
*/
#line 2 "/Users/kodamankod/Desktop/Programming/Library/other/rev.cpp"
#include <type_traits>
#include <iterator>
#line 6 "/Users/kodamankod/Desktop/Programming/Library/other/rev.cpp"
template <class T>
class rev_impl {
public:
using iterator = typename std::decay<T>::type::reverse_iterator;
private:
const iterator M_begin;
const iterator M_end;
public:
constexpr rev_impl(T &&cont) noexcept: M_begin(std::rbegin(cont)), M_end(std::rend(cont)) { }
constexpr iterator begin() const noexcept { return M_begin; }
constexpr iterator end() const noexcept { return M_end; }
};
template <class T>
constexpr decltype(auto) rev(T &&cont) {
return rev_impl<T>(std::forward<T>(cont));
}
/**
* @title Reverser
*/
#line 19 "main.cpp"
using i32 = int32_t;
using i64 = int64_t;
using u32 = uint32_t;
using u64 = uint64_t;
constexpr i32 inf32 = (i32(1) << 30) - 1;
constexpr i64 inf64 = (i64(1) << 62) - 1;
struct edge_t {
i32 to, cost;
edge_t(i32 t, i32 c): to(t), cost(c) { }
};
i32 N, ans;
std::vector<edge_t> graph[200000];
i32 root[200000], max_c[200000];
void dfs(i32 u, i32 p) {
root[u] = 0;
max_c[u] = -inf32;
for (auto [v, c]: graph[u]) {
if (v == p) continue;
dfs(v, u);
i32 tmp = std::max(root[v], root[v] + max_c[v] + c);
root[u] += tmp;
chmax(max_c[u], root[v] + c - tmp);
}
}
void push(i32 u, i32 p, i32 rt, i32 mc) {
root[u] = 0;
max_c[u] = -inf32;
for (auto [v, c]: graph[u]) {
if (v == p) {
root[v] = rt;
max_c[v] = mc;
}
i32 tmp = std::max(root[v], root[v] + max_c[v] + c);
root[u] += tmp;
chmax(max_c[u], root[v] + c - tmp);
}
chmax(ans, root[u]);
i32 size = graph[u].size();
std::vector<i32> rt_pref(size + 1), mc_pref(size + 1, -inf32);
{
i32 idx = 0;
for (auto [v, c]: graph[u]) {
++idx;
i32 tmp = std::max(root[v], root[v] + max_c[v] + c);
rt_pref[idx] = rt_pref[idx - 1] + tmp;
mc_pref[idx] = std::max(mc_pref[idx - 1], root[v] + c - tmp);
}
}
std::vector<i32> rt_suff(size + 1), mc_suff(size + 1, -inf32);
{
i32 idx = 0;
for (auto [v, c]: rev(graph[u])) {
++idx;
i32 tmp = std::max(root[v], root[v] + max_c[v] + c);
rt_suff[idx] = rt_suff[idx - 1] + tmp;
mc_suff[idx] = std::max(mc_suff[idx - 1], root[v] + c - tmp);
}
}
for (auto i: range(0, size)) {
auto [v, c] = graph[u][i];
if (v != p) {
push(v, u, rt_pref[i] + rt_suff[size - i - 1], std::max(mc_pref[i], mc_suff[size - i - 1]));
}
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cin >> N;
for (i32 i = 1; i < N; ++i) {
i32 u, v, c;
std::cin >> u >> v >> c;
--u; --v;
graph[u].emplace_back(v, c);
graph[v].emplace_back(u, c);
}
dfs(0, -1);
push(0, -1, 0, -inf32);
std::cout << ans << '\n';
return 0;
}
