#include <iostream>
#include <queue>
#include <algorithm>
#include <cstring>

#define MAXN 500100
#define INF 0x3f3f3f3f

using namespace std;

struct Edge *f[MAXN];
int fa[MAXN][22];
int val[20];
int depth[MAXN];
int n;

struct Edge
{
    int from, to;
    Edge *next;

    Edge(int from = 0, int to = 0):
        from(from), to(to), next(f[from]) {}

    ~Edge()
    {
        delete next;
    }
};

queue<int> q;
void bfs(int s)
{
    memset(depth, INF, sizeof(depth));
    depth[0] = 0;
    depth[s] = 1;
    q.push(s);
    while (!q.empty())
    {
        int tmp = q.front();    q.pop();
        for (Edge *e = f[tmp]; e; e = e->next)
        {
            if (depth[e->to]==INF)
            {
                depth[e->to] = depth[tmp] + 1;
                q.push(e->to);

                fa[e->to][0] = tmp;
            }
        }
    }
}

void init()
{
    val[0] = 1;
    for (int i = 1; i<=20; i++)
    {  
        val[i] = val[i-1] * 2;
    }
    
    for (int j = 1; j<=20; j++)
        for (int i = 1; i<=n; i++)
        {
            fa[i][j] = fa[ fa[i][j-1] ][j-1];
        }
}

int LCA(int x, int y)
{
    int ans = 0;
    if (depth[x] < depth[y])
        swap(x, y);

    for (int i = 20; depth[x]>depth[y]; i--)
        if (depth[ fa[x][i] ] >= depth[y])
        {
            ans += val[i];
            x = fa[x][i];
        }

    if (x==y)
        return ans;

    for (int i = 20; i>=0; i--)
        if (fa[x][i] != fa[y][i])
        {
            x = fa[x][i];
            y = fa[y][i];
            ans += val[i]*2;
        }
    
    ans += 2;
    return ans;
}

int main()
{
    memset(fa, 0, sizeof(fa));
    memset(f, 0, sizeof(f));

    cin >> n;

    for (int i = 1; i<n; i++)
    {
        int x, y;
        cin >> x >> y;

        f[x] = new Edge(x, y);
        f[y] = new Edge(y, x);
    }

    bfs(1);
    init();

    int ans = 0;

    int m;
    cin >> m;
    int x;
    cin >> x;
    for (int i = 1; i<m; i++)
    {
        int y;
        cin >> y;
        ans += LCA(x, y);

        x = y;
    }

    cout << ans << endl;
}

#include <iostream>
#include <queue>

#define MAXN 30100

using namespace std;

struct Edge *f[MAXN];
struct Edge
{
    int from, to;
    Edge *next, *oppo;
    bool access;

    Edge(int from=0, int to=0)
        :from(from), to(to), next( f[from] ) {access=true;}
};

struct Query
{
    int node;
    Query *next;

    Query(int node = 0, Query *next = NULL)
        :node(node), next(next)   {}
};
Query *query[MAXN];
int depth[MAXN], fa[MAXN];
bool flag[MAXN];
int ans;

queue<int> q;
void bfs(int s)
{
    depth[s] = 1;
    q.push(s);
    while (!q.empty())
    {
        int tmp = q.front();
        q.pop();

        for (Edge *e = f[tmp]; e; e = e->next)
            if (e->access)
            {
                e->oppo->access = false;
                depth[e->to] = depth[tmp] + 1;
                q.push(e->to);
            }
    }
}

int find(int x)
{
    return fa[x]==x? x : fa[x] = find(fa[x]);
}

void Union(int x, int y)
{
    int fy = find(y);
    fa[fy] = x;
}

void Tarjan(int x)
{
    fa[x] = x;
    
    for (Edge *e = f[x]; e; e = e->next)
        if (e->access)
        {
            Tarjan(e->to);
            Union(x, e->to);
        }
    
    flag[x] = true;

    for (Query *q = query[x]; q; q = q->next)
    {
        if (flag[ q->node ])
            ans += depth[x] + depth[ q->node ] - 2 * depth[ find( q->node )];
    }
}

int main()
{
    int n;
    cin >> n;

    for (int i = 1; i<n; i++)
    {
        int x, y;
        cin >> x >> y;
        f[x] = new Edge(x, y);
        f[y] = new Edge(y, x);

        f[x]->oppo = f[y];
        f[y]->oppo = f[x];
    }

    int m;
    cin >> m;
    int x;
    cin >> x;
    for (int i = 1; i<m; i++)
    {
        int y; 
        cin >> y;

        query[x] = new Query(y, query[x]);
        query[y] = new Query(x, query[y]);

        x = y;
    }

    bfs(1);
    Tarjan(1);

    cout << ans << endl;
}