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

const int MAXN = 2005;
const long long MAX_OPS = 1000000LL;

string lowerToken(string s) {
    for (char &c : s) c = char(tolower(c));
    return s;
}

bool parseYesNo(const string &s, bool &val) {
    string t = lowerToken(s);

    if (t == "yes") {
        val = true;
        return true;
    }

    if (t == "no") {
        val = false;
        return true;
    }

    return false;
}

bool edge[MAXN][MAXN];
int dist[MAXN][MAXN];
bitset<MAXN> nearD[MAXN];
int main(int argc, char *argv[]) {
    registerTestlibCmd(argc, argv);

    int n = inf.readInt();
    int k = inf.readInt();
    int D = inf.readInt();

    vector<vector<int>> g(n + 1);
    memset(edge, 0, sizeof(edge));

    for (int i = 1; i <= n - 1; i++) {
        int u = inf.readInt();
        int v = inf.readInt();

        g[u].push_back(v);
        g[v].push_back(u);

        edge[u][v] = edge[v][u] = true;
    }

    bitset<MAXN> init, target;

    for (int i = 1; i <= k; i++) {
        int x = inf.readInt();

        if (init[x]) {
            quitf(_fail, "Duplicate vertex %d in S.", x);
        }

        init[x] = 1;
    }

    for (int i = 1; i <= k; i++) {
        int x = inf.readInt();

        if (target[x]) {
            quitf(_fail, "Duplicate vertex %d in T.", x);
        }

        target[x] = 1;
    }

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

    for (int s = 1; s <= n; s++) {
        queue<int> q;
        q.push(s);
        dist[s][s] = 0;

        while (!q.empty()) {
            int u = q.front();
            q.pop();

            for (int v : g[u]) {
                if (dist[s][v] == -1) {
                    dist[s][v] = dist[s][u] + 1;
                    q.push(v);
                }
            }
        }
    }


    for (int v = 1; v <= n; v++) {
        for (int x = 1; x <= n; x++) {
            if (dist[v][x] != -1 && dist[v][x] <= D) {
                nearD[v][x] = 1;
            }
        }
    }

    string juryTok = ans.readToken();
    bool juryYes;

    if (!parseYesNo(juryTok, juryYes)) {
        quitf(_fail, "Jury answer should start with Yes or No, but got '%s'.", juryTok.c_str());
    }

    string userTok = ouf.readToken();
    bool userYes;

    if (!parseYesNo(userTok, userYes)) {
        quitf(_wa, "Expected Yes or No, but got '%s'.", userTok.c_str());
    }

    if (!userYes) {
        // ouf.readEof();

        if (juryYes) {
            quitf(_wa, "Participant says No, but jury says Yes.");
        } else {
            quitf(_ok, "Correctly reported No.");
        }
    }

    long long c = ouf.readLong(0LL, MAX_OPS, "number of operations");

    bitset<MAXN> marked = init;

    for (long long step = 1; step <= c; step++) {
        int u = ouf.readInt(1, n, "u");
        int v = ouf.readInt(1, n, "v");

        if (!marked[u]) {
            quitp(0.4, "Step %lld: vertex %d is not marked.", step, u);
        }

        if (marked[v]) {
            quitp(0.4, "Step %lld: vertex %d is already marked.", step, v);
        }

        if (!edge[u][v]) {
            quitp(0.4, "Step %lld: vertices %d and %d are not adjacent.", step, u, v);
        }

        bitset<MAXN> bad = marked & (~nearD[v]);

        if (bad.any()) {
            int witness = -1;

            for (int x = 1; x <= n; x++) {
                if (bad[x]) {
                    witness = x;
                    break;
                }
            }

            quitp(
                0.4,
                "Step %lld: new vertex %d has distance %d from marked vertex %d, exceeding D = %d.",
                step,
                v,
                dist[v][witness],
                witness,
                D
            );
        }

        marked[u] = 0;
        marked[v] = 1;
    }

    // ouf.readEof();

    if (marked != target) {
        vector<int> missing, extra;

        for (int x = 1; x <= n; x++) {
            if (target[x] && !marked[x]) missing.push_back(x);
            if (!target[x] && marked[x]) extra.push_back(x);
        }

        string msg = "Final marked set is not equal to T.";

        quitp(0.4, "%s", msg.c_str());
    }

    if (!juryYes) {
        quitf(_fail, "Participant produced a valid sequence, but jury answer says No.");
    }

    quitf(_ok, "Valid sequence with %lld operations.", c);
}