from types import GeneratorType

def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        to = f(*args, **kwargs)
        while True:
            if type(to) is GeneratorType:
                stack.append(to)
                to = next(to)
            else:
                stack.pop()
                if not stack:
                    break
                to = stack[-1].send(to)
        return to
    return wrappedfunc

def segfunc(x,y):
    return max(x, y)
class LazySegTree_RAQ:
    def __init__(self,init_val,segfunc,ide_ele):
        n = len(init_val)
        self.segfunc = segfunc
        self.ide_ele = ide_ele
        self.num = 1<<(n-1).bit_length()
        self.tree = [ide_ele]*2*self.num
        self.lazy = [0]*2*self.num
        for i in range(n):
            self.tree[self.num+i] = init_val[i]
        for i in range(self.num-1,0,-1):
            self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
    def gindex(self,l,r):
        l += self.num
        r += self.num
        lm = l>>(l&-l).bit_length()
        rm = r>>(r&-r).bit_length()
        ans = []
        while r>l:
            if l<=lm:
                ans.append(l)
            if r<=rm:
                ans.append(r)
            r >>= 1
            l >>= 1
        while l:
            ans.append(l)
            l >>= 1
        return ans
    def propagates(self,ids):
        for i in reversed(ids):
            v = self.lazy[i]
            if v==0:
                continue
            self.lazy[i] = 0
            self.lazy[2*i] += v
            self.lazy[2*i+1] += v
            self.tree[2*i] += v
            self.tree[2*i+1] += v
    def add(self,l,r,x):
        ids = self.gindex(l,r)
        l += self.num
        r += self.num
        while l<r:
            if l&1:
                self.lazy[l] += x
                self.tree[l] += x
                l += 1
            if r&1:
                self.lazy[r-1] += x
                self.tree[r-1] += x
            r >>= 1
            l >>= 1
        for i in ids:
            self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1]) + self.lazy[i]
    def query(self,l,r):
        self.propagates(self.gindex(l,r))
        res = self.ide_ele
        l += self.num
        r += self.num
        while l<r:
            if l&1:
                res = self.segfunc(res,self.tree[l])
                l += 1
            if r&1:
                res = self.segfunc(res,self.tree[r-1])
            l >>= 1
            r >>= 1
        return res

N = int(input())
G = [[] for _ in range(N)]
for _ in range(N-1):
    u, v, w = map(int, input().split())
    G[u-1].append((v-1, w))
    G[v-1].append((u-1, w))

INF = 1<<60

@bootstrap
def dfs(n, pre, time, d):
    A.append(n)
    dist[n] = d
    IN[n] = time
    for v, w in G[n]:
        if v == pre:
            continue
        time = yield dfs(v, n, time+1, d+w)
    OUT[n] = time
    yield time

A = []
IN = [-1]*N
OUT = [-1]*N
dist = [-1]*N
dfs(0, -1, 0, 0)

ndist = [-1]*N
for i in range(N):
    ndist[i] = dist[A[i]]
dist = ndist[:]

@bootstrap
def dfs2(n, pre):
    global ans
    ans = max(ans, seg.query(0, N))
    for v, w in G[n]:
        if v == pre:
            continue
        seg.add(0, N, w)
        seg.add(IN[v], OUT[v]+1, -(w*2))
        yield dfs2(v, n)
        seg.add(0, N, -w)
        seg.add(IN[v], OUT[v]+1, w*2)
    yield

seg = LazySegTree_RAQ(dist, segfunc, -INF)
ans = 0
dfs2(0, -1)

print(ans)