#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")

#include <bits/stdc++.h>
using namespace std;

#define el '\n'
#define F first
#define S second

typedef long long ll;
typedef long double ld;

bool multipleTestCases = 0, sublime = 0;
const int N = 2e5 + 5, INF = 1e9 + 5, mod = 1e9 + 7, LOG = 22, SQ = 500;

int n, q, qu[N], in[N], out[N], timer;
vector<int> g[N];
vector<pair<int, int>> ord;
bool fail;

void dfsFlat(int node) {
    in[node] = timer++;
    ord.push_back({node, 1});

    for (auto &i : g[node]) {
        dfsFlat(i);
    }

    out[node] = timer++;
    ord.push_back({node, 2});
}

struct SegmentTree{
    vector<int> tree;
    int neutral;

    SegmentTree(){}

    SegmentTree(int sz){
        tree.assign(4 * sz, -INF);
        neutral = -INF;
    }

    int merge(int &u, int &v){
        return max(u, v);
    }

    void set(int node, int start, int end, int idx, int val){
        if(start == end)
            return tree[node] = val, void();

        int m = (start + end) >> 1;

        if(idx <= m)
            set(2 * node, start, m, idx, val);
        else
            set(2 * node + 1, m + 1, end, idx, val);

        tree[node] = merge(tree[2 * node], tree[2 * node + 1]);
    }

    ll query(int node, int start, int end, int left, int right){
        if (right < left) {
            return neutral;
        }
        if(end < left or start > right)
            return neutral;

        if(left <= start and end <= right)
            return tree[node];

        int m = (start + end) >> 1;
        int l = query(2 * node, start, m, left, right);
        int r = query(2 * node + 1, m + 1, end, left, right);
        return merge(l, r);
    }
} st;

void dfs(int node) {
    if (fail) return;

    vector<int> v;

    for (auto &i : g[node]) {
        int val = st.query(1, 1, 2 * n, in[i], out[i]);

        if (val != -INF) {
            v.push_back(val);
        }
    }

    fail |= !is_sorted(v.begin(), v.end());

    if (fail) return;

    for (auto &i : g[node]) {
        dfs(i);
    }
}

bool valid(int m) {
    st = SegmentTree(2 * n);
    fail = 0;

    for (int i = 1; i <= m; i++) {
        st.set(1, 1, 2 * n, in[qu[i]], i);
    }

    dfs(1);

    return (fail ? 0 : 1);
}

void doWork() {
    cin >> n >> q;

    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
    }

    for (int i = 1; i <= n; i++) {
        sort(g[i].begin(), g[i].end());
    }

    dfsFlat(1);

    for (int i = 1; i <= q; i++) {
        cin >> qu[i];
    }

    int s = 0, e = q, m, ans = 0;

    while (s <= e) {
        m = (s + e) >> 1;

        if (valid(m)) {
            ans = m;
            s = m + 1;
        }
        else {
            e = m - 1;
        }
    }

    cout << ans << el;
}
signed main() {
#ifdef ONLINE_JUDGE
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#endif
#ifndef ONLINE_JUDGE
    if (sublime) {
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    }
#endif
    int tests = 1;
    if (multipleTestCases) {
        cin >> tests;
    }
    for (int tc = 1; tc <= tests; tc++) {
        doWork();
    }
}