#include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
using i64 = long long;
using pii = pair<int, i64>;

namespace Fread {
const int SIZE = 1 << 16;
char buf[SIZE], *S, *T;
inline char getchar() {
    if (S == T) {
        T = (S = buf) + fread(buf, 1, SIZE, stdin);

        if (S == T)
            return '\n';
    }

    return *S++;
}
}
using namespace Fread;
namespace Fwrite {
const int SIZE = 1 << 16;
char buf[SIZE], *S = buf, *T = buf + SIZE;
inline void flush() {
    fwrite(buf, 1, S - buf, stdout);
    S = buf;
}
inline void putchar(char c) {
    *S++ = c;

    if (S == T)
        flush();
}
struct NTR {
    ~NTR() {
        flush();
    }
} ztr;
}
using namespace Fwrite;
#define getchar Fread::getchar
#define putchar Fwrite::putchar
namespace Fastio {
struct Reader {
    template <typename T> Reader &operator >> (T &x) {
        x = 0;
        short f = 1;
        char c = getchar();

        while (c < '0' || c > '9') {
            if (c == '-')
                f *= -1;

            c = getchar();
        }

        while (c >= '0' && c <= '9')
            x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();

        x *= f;
        return *this;
    }
    Reader &operator >> (double &x) {
        x = 0;
        double t = 0;
        short f = 1, s = 0;
        char c = getchar();

        while ((c < '0' || c > '9') && c != '.') {
            if (c == '-')
                f *= -1;

            c = getchar();
        }

        while (c >= '0' && c <= '9' && c != '.')
            x = x * 10 + (c ^ 48), c = getchar();

        if (c == '.')
            c = getchar();
        else {
            x *= f;
            return *this;
        }

        while (c >= '0' && c <= '9')
            t = t * 10 + (c ^ 48), s++, c = getchar();

        while (s--)
            t /= 10.0;

        x = (x + t) * f;
        return *this;
    }
    Reader &operator >> (long double &x) {
        x = 0;
        long double t = 0;
        short f = 1, s = 0;
        char c = getchar();

        while ((c < '0' || c > '9') && c != '.') {
            if (c == '-')
                f *= -1;

            c = getchar();
        }

        while (c >= '0' && c <= '9' && c != '.')
            x = x * 10 + (c ^ 48), c = getchar();

        if (c == '.')
            c = getchar();
        else {
            x *= f;
            return *this;
        }

        while (c >= '0' && c <= '9')
            t = t * 10 + (c ^ 48), s++, c = getchar();

        while (s--)
            t /= 10.0;

        x = (x + t) * f;
        return *this;
    }
    Reader &operator >> (__float128 &x) {
        x = 0;
        __float128 t = 0;
        short f = 1, s = 0;
        char c = getchar();

        while ((c < '0' || c > '9') && c != '.') {
            if (c == '-')
                f *= -1;

            c = getchar();
        }

        while (c >= '0' && c <= '9' && c != '.')
            x = x * 10 + (c ^ 48), c = getchar();

        if (c == '.')
            c = getchar();
        else {
            x *= f;
            return *this;
        }

        while (c >= '0' && c <= '9')
            t = t * 10 + (c ^ 48), s++, c = getchar();

        while (s--)
            t /= 10.0;

        x = (x + t) * f;
        return *this;
    }
    Reader &operator >> (char &c) {
        c = getchar();

        while (c == ' ' || c == '\n' || c == '\r')
            c = getchar();

        return *this;
    }
    Reader &operator >> (char *str) {
        int len = 0;
        char c = getchar();

        while (c == ' ' || c == '\n' || c == '\r')
            c = getchar();

        while (c != ' ' && c != '\n' && c != '\r')
            str[len++] = c, c = getchar();

        str[len] = '\0';
        return *this;
    }
    Reader &operator >> (string &str) {
        str.clear();
        char c = getchar();

        while (c == ' ' || c == '\n' || c == '\r')
            c = getchar();

        while (c != ' ' && c != '\n' && c != '\r')
            str.push_back(c), c = getchar();

        return *this;
    }
    Reader() {}
} cin;
const char endl = '\n';
struct Writer {
    const int Setprecision = 6;
    typedef int mxdouble;
    template <typename T> Writer &operator << (T x) {
        if (x == 0) {
            putchar('0');
            return *this;
        }

        if (x < 0)
            putchar('-'), x = -x;

        static short sta[40];
        short top = 0;

        while (x > 0)
            sta[++top] = x % 10, x /= 10;

        while (top > 0)
            putchar(sta[top] + '0'), top--;

        return *this;
    }
    Writer &operator << (double x) {
        if (x < 0)
            putchar('-'), x = -x;

        mxdouble _ = x;
        x -= (double)_;
        static short sta[40];
        short top = 0;

        while (_ > 0)
            sta[++top] = _ % 10, _ /= 10;

        if (top == 0)
            putchar('0');

        while (top > 0)
            putchar(sta[top] + '0'), top--;

        putchar('.');

        for (int i = 0; i < Setprecision; i++)
            x *= 10;

        _ = x;

        while (_ > 0)
            sta[++top] = _ % 10, _ /= 10;

        for (int i = 0; i < Setprecision - top; i++)
            putchar('0');

        while (top > 0)
            putchar(sta[top] + '0'), top--;

        return *this;
    }
    Writer &operator << (long double x) {
        if (x < 0)
            putchar('-'), x = -x;

        mxdouble _ = x;
        x -= (long double)_;
        static short sta[40];
        short top = 0;

        while (_ > 0)
            sta[++top] = _ % 10, _ /= 10;

        if (top == 0)
            putchar('0');

        while (top > 0)
            putchar(sta[top] + '0'), top--;

        putchar('.');

        for (int i = 0; i < Setprecision; i++)
            x *= 10;

        _ = x;

        while (_ > 0)
            sta[++top] = _ % 10, _ /= 10;

        for (int i = 0; i < Setprecision - top; i++)
            putchar('0');

        while (top > 0)
            putchar(sta[top] + '0'), top--;

        return *this;
    }
    Writer &operator << (__float128 x) {
        if (x < 0)
            putchar('-'), x = -x;

        mxdouble _ = x;
        x -= (__float128)_;
        static short sta[40];
        short top = 0;

        while (_ > 0)
            sta[++top] = _ % 10, _ /= 10;

        if (top == 0)
            putchar('0');

        while (top > 0)
            putchar(sta[top] + '0'), top--;

        putchar('.');

        for (int i = 0; i < Setprecision; i++)
            x *= 10;

        _ = x;

        while (_ > 0)
            sta[++top] = _ % 10, _ /= 10;

        for (int i = 0; i < Setprecision - top; i++)
            putchar('0');

        while (top > 0)
            putchar(sta[top] + '0'), top--;

        return *this;
    }
    Writer &operator << (char c) {
        putchar(c);
        return *this;
    }
    Writer &operator << (char *str) {
        int cur = 0;

        while (str[cur])
            putchar(str[cur++]);

        return *this;
    }
    Writer &operator << (const char *str) {
        int cur = 0;

        while (str[cur])
            putchar(str[cur++]);

        return *this;
    }
    Writer &operator << (string str) {
        int st = 0, ed = str.size();

        while (st < ed)
            putchar(str[st++]);

        return *this;
    }
    Writer() {}
} cout;
}
using namespace Fastio;
#define cin Fastio::cin
#define cout Fastio::cout
#define endl Fastio::endl

const int maxn = 300005;

int n, m;
int h[maxn], e[maxn * 2], ne[maxn * 2], w[maxn * 2], idx;
int army[maxn], fa[maxn][20], tsp;
i64 dist[maxn][20];
int vis[maxn], dp[maxn];
int dfn[maxn], ord[maxn], sz[maxn];
std::vector<i64> rest[maxn];
std::vector<pii> g[maxn];

void add(int a, int b, int c) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++;
}

void dfs1(int u) {
    for (int j = 1; j <= __lg(n); j ++) {
        dist[u][j] = dist[u][j - 1] + dist[fa[u][j - 1]][j - 1];
        fa[u][j] = fa[fa[u][j - 1]][j - 1];
    }

    ord[dfn[u] = ++ tsp] = u, sz[u] = 1;

    for (int i = h[u]; ~i; i = ne[i]) {
        int v = e[i];

        if (v == fa[u][0])
            continue;

        dist[v][0] = w[i], fa[v][0] = u;
        dfs1(v);
        sz[u] += sz[v];
    }
}


int main() {
    // freopen("blockade20.in", "r", stdin);
    cin >> n;

    memset(h, -1, sizeof h);

    for (int i = 1; i < n; i ++) {
        int a, b, c;
        cin >> a >> b >> c;
        g[a].push_back({b, c});
        g[b].push_back({a, c});
    }

    for (int i = 1; i <= n; i ++)
        for (auto [j, k] : g[i])
            add(i, j, k);

    cin >> m;

    for (int i = 1; i <= m; i ++)
        cin >> army[i];

    dfs1(1);

    i64 lo = 0, ro = 3e15;

    while (lo <= ro) {
        i64 mid = lo + ro >> 1;

        memset(vis, 0, sizeof vis);

        for (int i = h[1]; ~i; i = ne[i])
            rest[e[i]].clear();

        for (int i = 1; i <= m; i ++) {
            int u = army[i];
            i64 tot = mid;

            for (int j = __lg(n); j >= 0; j --)
                if (fa[u][j] > 1 && dist[u][j] <= tot)
                    tot -= dist[u][j], u = fa[u][j];

            vis[u] = 1;

            if (fa[u][0] == 1)
                rest[u].push_back(tot);
        }

        memset(dp, 0, sizeof dp);
        std::multiset<pair<i64, int>> usable;

        for (int i = h[1]; ~i; i = ne[i]) {
            int rt = e[i];

            // dfs2(rt, rt);
            for (int j = dfn[rt] + sz[rt] - 1; j >= dfn[rt]; j --) {
                int u = ord[j];

                if (u != rt)
                    dp[u] = vis[u];

                bool temp = 1, leaf = 1;

                for (int k = h[u]; ~k; k = ne[k]) {
                    int v = e[k];

                    if (v == fa[u][0])
                        continue;

                    leaf = 0, temp &= dp[v];
                }

                if (!leaf)
                    dp[u] |= temp;
            }

            sort(rest[rt].begin(), rest[rt].end());

            for (auto t : rest[rt])
                usable.insert({t - w[i], rt});
        }

        bool ok = 1;

        for (int i = h[1]; ~i; i = ne[i]) {
            int u = e[i];

            if (!dp[u]) {
                auto it = usable.lower_bound({w[i], 0});
                i64 val = 1e18;

                for (auto t : rest[u])
                    if (usable.find({t - w[i], u}) != usable.end()) {
                        val = t - w[i];
                        break;
                    }

                if (it == usable.end() && val == 1e18) {
                    ok = false;
                    break;
                }

                if (it == usable.end() || val < (*it).fi)
                    usable.erase(usable.find({val, u}));
                else
                    usable.erase(it);
            }
        }

        if (ok)
            ro = mid - 1;
        else
            lo = mid + 1;
    }

    if (ro == 3e15)
        cout << -1 << endl;
    else
        cout << ro + 1 << endl;

    return 0;
}
/*
7
1 2 193156
1 3 543535
2 4 458552
4 5 777976
3 6 475533
1 7 876969
3
7 4 7
*/