// https://szkopul.edu.pl/problemset/problem/BefzQSkyOOBhuycp8gvD8XdG/site/?key=statement

#include <bits/stdc++.h>

using namespace std;

#define int long long

constexpr int sizik = 500 * 1001, L = 21;

#define ar std::array
#define pr std::pair
#define vec std::vector

typedef vec<vec<int>> _kra;

std::vector<int> kra[sizik];
std::vector<int> cent;
int dp[sizik];
int n;
int jump[sizik][L];
int odl[sizik][2];
int depth[sizik];
int q, s[2];
int pre[sizik], post[sizik], timer = 1;

void DFS(int v, int p) {
    dp[v] = 1;
    depth[v] = depth[p] + 1;
    pre[v] = ++timer;

    jump[v][0] = p;
    for (int i = 1; i < L; i++) {
        jump[v][i] = jump[jump[v][i - 1]][i - 1];
    }

    bool isGood = true;

    for (const auto& u : kra[v]) {
        if (u != p) {
            DFS(u, v);
            dp[v] += dp[u];

            if (2 * dp[u] > n) {
                isGood = false;
            }
        }
    }

    if (2 * (n - dp[v]) > n) {
        isGood = false;
    }

    post[v] = ++timer;

    if (isGood) {
        cent.push_back(v);
    }
}

int jumper(int a, int b) {
    for (int i = 0; b > 0; i++) {
        if (b & 1) a = jump[a][i];
        b >>= 1;
    }
    return a;
}

int check(int a, int b) {
    return pre[a] <= pre[b] && post[a] >= post[b];
}

int lca(int u, int v) {
    if (check(u, v)) return u;
    if (check(v, u)) return v;
    for (int i = L - 1; i >= 0; --i) {
        if (!check(jump[u][i], v)) u = jump[u][i];
    }
    return jump[u][0];
}

int dist(int a, int b) {
    int l = lca(a, b);
    return depth[a] + depth[b] - 2 * depth[l];
}

std::set<int> czy[2];

int d[4 * sizik][2][2];
void init() {
    for (int i = 0; i <= 4 * (n + 2); i++) {
        d[i][0][0] = 0;
        d[i][0][1] = 0;
        d[i][1][0] = 0;
        d[i][1][1] = 0;
    }
}
int get(int v, int tl, int tr, int l, int r, int x, int y) {
    if (l > r) return 0;
    if (l == tl && r == tr) return d[v][x][y];
    int tm = (tl + tr) / 2;
    return get(2 * v, tl, tm, l, std::min(r, tm), x, y) + get(2 * v + 1, tm + 1, tr, std::max(tm + 1, l), r, x, y);
}
int get(int l, int r, int x, int y) {
    return get(1, 0, n, l, r, x, y);
}
void update(int v, int tl, int tr, int pos, int delta, int x, int y) {
    if (tl == tr) {
        d[v][x][y] += delta;
    } else {
        int tm = (tl + tr) / 2;
        if (pos <= tm)
            update(2 * v, tl, tm, pos, delta, x, y);
        else
            update(2 * v + 1, tm + 1, tr, pos, delta, x, y);

        d[v][x][y] = d[2 * v][x][y] + d[2 * v + 1][x][y];
    }
}
void update(int pos, int delta, int x, int y) {
    return update(1, 0, n, pos, delta, x, y);
}

int ktory(int a) {
    int x = 0;
    if (cent.size() > 1) {
        if (odl[a][0] > odl[a][1]) x = 1;
    }
    return x;
}

int oblicz(int a, int x) {
    int b1 = ktory(a);
    std::vector<int> xd{0, 1};
    if (b1 == 1) std::swap(xd[0], xd[1]);

    if (x == 0) {
        int l1 = get(odl[a][xd[0]], n, xd[0], 1);
        int l2 = get(odl[a][xd[1]], n, xd[1], 1);
        int l3 = 1;

        if (czy[1].find(a) == czy[1].end()) l3 = 0;

        return l1 + l2 - l3;
    } else {
        int l1 = get(0, odl[a][xd[0]], xd[0], 0);
        int l2 = get(0, odl[a][xd[0]] - 1, xd[1], 0);
        int l3 = 1;

        if (czy[0].find(a) == czy[0].end()) l3 = 0;

        return l1 + l2 - l3;
    }
}

void n0();

void solve() {
    std::cin >> n;

    for (int i = 0; i < n - 1; i++) {
        int a, b;
        std::cin >> a >> b;

        kra[a].push_back(b);
        kra[b].push_back(a);
    }

    DFS(1, 1);

    for (int i = 0; i < (int)cent.size(); i++) {
        for (int j = 1; j <= n; j++) {
            odl[j][i] = dist(cent[i], j);
        }
    }

    std::cin >> s[0] >> s[1] >> q;

    for (int j = 0; j < 2; j++) {
        for (int i = 0; i < s[j]; i++) {
            int a;
            std::cin >> a;

            czy[j].insert(a);
            int x = ktory(a);

            update(odl[a][x], 1, x, j);
        }
    }

    if (n == 1) {
        n0();
        return;
    }

    int ans = 0;

    for (const auto& a : czy[0]) {
        ans += oblicz(a, 0);
    }

    std::cout << ans << '\n';

    for (; q > 0; q--) {
        char z, t;
        int w;
        std::cin >> z >> t >> w;

        int x = ktory(w), y = (z == 'A' ? 0 : 1), mnoznik = (t == '+' ? 1 : -1);

        int local = oblicz(w, y);
        ans += mnoznik * local;

        if (t == '+') {
            czy[y].insert(w);
            update(odl[w][x], 1, x, y);
        } else {
            czy[y].erase(w);
            update(odl[w][x], -1, x, y);
        }

        std::cout << ans << '\n';
    }
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}

void n0() {
    std::cout << "0\n";
    for (; q > 0; q--) {
        char z, t;
        int w;
        std::cin >> z >> t >> w;
        std::cout << "0\n";
    }
}