#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = 1e5 + 5;
const int LB = 17 + 2;
const ll linf = 0x3f3f3f3f3f3f3f3f;

namespace FastIO {
const int SIZ1 = 1 << 23;
char buf1[SIZ1], *s1 = buf1, *t1 = buf1;
inline char gc(void) {
    return s1 == t1 && (t1 = buf1 + fread(buf1, 1, SIZ1, stdin)) == (s1 = buf1) ? EOF : *s1++;
}
template<typename T>
void read(T &res) {
    res = 0;
    char c = gc();

    while (c < '0' || c > '9')
        c = gc();

    while (c >= '0' && c <= '9')
        res = res * 10 + c - '0', c = gc();
}
} using FastIO::read;

template<typename T>
T max3(const T &a, const T &b, const T &c) {
    return max(max(a, b), c);
}
template<typename T>
T max4(const T &a, const T &b, const T &c, const T &d) {
    return max(max(a, b), max(c, d));
}


int lb[MAXN * 2];

ll ans = 0;
inline void chk_ans(ll k) {
    if (k > ans)
        ans = k;
}

struct Data {
    ll k;
    int u, v;
    Data(void) {}
    Data(ll _k, int _u, int _v): k(_k), u(_u), v(_v) {}
    bool operator < (const Data &oth) const {
        return k < oth.k;
    }
    inline bool one(void) const {
        return u == v;
    }
};

struct Tree {
    int n, orin;
    vector< pair<int, ll>> g[MAXN * 2];
    Tree *OT;
    void add_edge(int u, int v, ll w) {
        g[u].emplace_back(v, w);
        g[v].emplace_back(u, w);
    }
    void read_self(int _n) {
        n = orin = _n;

        for (int i = 1; i < n; ++i) {
            int u, v;
            ll w;
            read(u);
            read(v);
            read(w);
            add_edge(u, v, w);
        }
    }

    int dfn[MAXN], seq[MAXN * 2], curdfn;
    int nume[MAXN];
    ll dep[MAXN];
    pii mn[MAXN * 2][LB];
    void dfs_tree(int u, int fa) {
        seq[++curdfn] = u;
        dfn[u] = curdfn;

        for (auto it : g[u])
            if (it.first != fa) {
                int v = it.first;
                ll w = it.second;
                dep[v] = dep[u] + w;
                nume[v] = nume[u] + 1;
                dfs_tree(v, u);
                seq[++curdfn] = u;
            }
    }
    inline int lca(int u, int v) {
        u = dfn[u];
        v = dfn[v];

        if (u > v)
            swap(u, v);

        int k = lb[v - u + 1];
        return min(mn[u][k], mn[v - (1 << k) + 1][k]).second;
    }
    inline ll dist(int u, int v) {
        return dep[u] + dep[v] - 2 * dep[lca(u, v)];
    }

    static ll global_val[MAXN * 2];
    static int global_clr[MAXN * 2], global_pool[MAXN * 2];

    void build1(void) {
        curdfn = 0;
        dfs_tree(1, 0);

        for (int i = curdfn; i >= 1; --i) {
            mn[i][0] = {nume[seq[i]], seq[i]};

            for (int j = 1; i + (1 << j) - 1 <= curdfn; ++j)
                mn[i][j] = min(mn[i][j - 1], mn[i + (1 << (j - 1))][j - 1]);
        }
    }
    void build2(void) {
        using Func = function<void(int, int)>;

        static vector< pair<int, ll>> ng[MAXN * 2];
        auto add_ng = [&](int u, int v, ll w) {
            ng[u].emplace_back(v, w);
            ng[v].emplace_back(u, w);
        };
        orin = n;
        Func dfs = [&](int u, int fa) {
            int cur = u;

            for (auto it : g[u])
                if (it.first != fa) {
                    int v = it.first;
                    ll w = it.second;
                    ++n;
                    add_ng(cur, n, 0);
                    add_ng(n, v, w);
                    cur = n;
                    dfs(v, u);

                }
        };
        dfs(1, 0);

        for (int i = 1; i <= n; ++i)
            g[i] = ng[i];

        memset(global_clr, -1, sizeof(global_clr));

        function<int *(int, int *)> divid = [&](int rt, int *pl) {
            static bool del[MAXN * 2];
            static int siz[MAXN * 2], mxsiz[MAXN * 2];

            Func dfs_siz = [&](int u, int fa) {
                siz[u] = 1;

                for (auto it : g[u])
                    if (it.first != fa && !del[it.first]) {
                        int v = it.first;
                        dfs_siz(v, u);
                        siz[u] += siz[v];
                    }
            };
            dfs_siz(rt, 0);

            int tot_siz = siz[rt];
            int u1 = -1, u2 = -1;
            ll midw = -1;
            Func dfs_u1u2 = [&](int u, int fa) {
                siz[u] = 1;

                for (auto it : g[u])
                    if (it.first != fa && !del[it.first]) {
                        int v = it.first;
                        mxsiz[v] = max(siz[v], tot_siz - siz[v]);

                        if (u1 == -1 || mxsiz[v] < mxsiz[u1])
                            u1 = v, u2 = u, midw = it.second;

                        dfs_u1u2(v, u);
                    }
            };
            dfs_u1u2(rt, 0);

            if (u1 == -1) {
                if (rt <= orin)
                    *pl++ = OT -> dfn[rt];

                return pl;
            }

            del[u2] = 1;
            int *pm = divid(u1, pl);
            del[u2] = 0;
            del[u1] = 1;
            int *pr = divid(u2, pm);
            del[u1] = 0;

            if (pl == pm || pm == pr)
                return pr;

            if (pr - pl <= 500)
                sort(pl, pr);
            else
                inplace_merge(pl, pm, pr);

            Func dfs_global = [&](int u, int fa) {
                for (auto it : g[u])
                    if (it.first != fa && !del[it.first]) {
                        int v = it.first;
                        global_clr[v] = global_clr[u];
                        global_val[v] = global_val[u] + it.second;
                        dfs_global(v, u);
                    }
            };

            global_clr[u1] = 0;
            global_val[u1] = 0;
            global_clr[u2] = 1;
            global_val[u2] = midw;
            dfs_global(u1, u2);
            dfs_global(u2, u1);

            OT -> build3(pl, pr);

            while (pl < pr)
                global_clr[OT -> seq[*pl++]] = -1;

            return pr;
        };
        divid(1, global_pool);
    }
    void build3(int *pl, int *pr) {
        if (pl + 1 >= pr)
            return;

        static ll curval[MAXN];
        auto calc = [&](int u, int v) {
            return OT -> dist(u, v)
                   + curval[u] + curval[v];
        };
        auto make = [&](int u, int v) {
            return Data(calc(u, v), u, v);
        };
        auto merge = [&](const Data & x, const Data & y) {
            if (x.k == -linf)
                return y;

            if (y.k == -linf)
                return x;

            return max3(x, y,
                        x.one() && y.one() ? make(x.u, y.u) :
                        x.one() ? max(make(x.u, y.u), make(x.u, y.v)) :
                        y.one() ? max(make(x.u, y.u), make(x.v, y.u)) :
                        max4(make(x.u, y.u), make(x.u, y.v), make(x.v, y.u), make(x.v, y.v))
                       );
        };

        static array<Data, 2> h[MAXN];
        auto makenew = [&](int u) {
            h[u][0] = h[u][1] = Data(-linf, 1, 1);

            if (global_clr[u] != -1)
                h[u][global_clr[u]] = make(u, u);
        };
        auto aply = [&](int u, int v) {
            auto upd = [&](const Data & x, const Data & y) {
                if (x.k == -linf || y.k == -linf)
                    return;

                chk_ans((
                            x.one() && y.one() ? calc(x.u, y.u) :
                            x.one() ? max(calc(x.u, y.u), calc(x.u, y.v)) :
                            y.one() ? max(calc(x.u, y.u), calc(x.v, y.u)) :
                            max4(calc(x.u, y.u), calc(x.u, y.v), calc(x.v, y.u), calc(x.v, y.v))
                        ) - 2 * dep[u]);
            };
            upd(h[u][0], h[v][1]);
            upd(h[u][1], h[v][0]);
            h[u] = {merge(h[u][0], h[v][0]), merge(h[u][1], h[v][1])};
        };

        static int sta[MAXN];
        int tp = 1;
        sta[1] = 1;
        makenew(1);

        while (pl < pr) {
            int u = seq[*pl++], uv = lca(sta[tp], u);
            curval[u] = global_val[u] + dep[u];
            --tp;

            while (tp && nume[sta[tp]] >= nume[uv])
                aply(sta[tp], sta[tp + 1]), --tp;

            if (sta[++tp] != uv) {
                makenew(uv);
                aply(uv, sta[tp]);
                sta[tp] = uv;
            }

            if (uv != u) {
                makenew(u);
                sta[++tp] = u;
            }
        }

        while (--tp)
            aply(sta[tp], sta[tp + 1]);
    }
} A, B, C;

ll Tree::global_val[MAXN * 2];
int Tree::global_clr[MAXN * 2], Tree::global_pool[MAXN * 2];

int main(void) {
    lb[0] = -1;

    for (int i = 1; i < MAXN * 2; ++i)
        lb[i] = lb[i >> 1] + 1;

    int n;
    read(n);
    A.read_self(n);
    B.read_self(n);
    C.read_self(n);

    A.OT = &B;
    B.OT = &C;
    B.build1();
    C.build1();
    A.build2();

    printf("%lld", ans);
    return 0;
}