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

struct Edge {
    int u, v;
};

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

int main(int argc, char *argv[]) {
    registerTestlibCmd(argc, argv);

    int T = inf.readInt();

    for (int tc = 1; tc <= T; tc++) {
        int n = inf.readInt();
        int m = inf.readInt();
        int k = inf.readInt();

        vector<Edge> edges(m);
        vector<vector<pair<int, int>>> ug(n + 1);

        for (int i = 0; i < m; i++) {
            int u = inf.readInt();
            int v = inf.readInt();

            edges[i] = {u, v};
            ug[u].push_back({v, i});
            ug[v].push_back({u, i});
        }

        // 判断 k 所在无向连通块是否有环。
        vector<char> vis(n + 1, false);
        queue<int> q;

        vis[k] = true;
        q.push(k);

        int vertex_count = 0;
        int degree_sum = 0;

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

            vertex_count++;
            degree_sum += (int)ug[v].size();

            for (auto [to, id] : ug[v]) {
                if (!vis[to]) {
                    vis[to] = true;
                    q.push(to);
                }
            }
        }

        int edge_count = degree_sum / 2;
        bool possible = (edge_count >= vertex_count);

        string verdict = lower_string(ouf.readToken());

        if (verdict != "yes" && verdict != "no") {
            quitf(_wa, "case %d: expected Yes/No, found %s", tc, verdict.c_str());
        }

        if (verdict == "no") {
            if (possible) {
                quitf(_wa, "case %d: contestant says No, but a solution exists", tc);
            }
            continue;
        }

        if (!possible) {
            quitf(_wa, "case %d: contestant says Yes, but no solution exists", tc);
        }

        string s = ouf.readToken();

        if ((int)s.size() != m) {
            quitf(_wa, "case %d: answer string length is %d, expected %d",
                  tc, (int)s.size(), m);
        }

        vector<vector<int>> out(n + 1);

        for (int i = 0; i < m; i++) {
            if (s[i] != '0' && s[i] != '1') {
                quitf(_wa, "case %d: answer string contains non-binary character", tc);
            }

            int u = edges[i].u;
            int v = edges[i].v;

            if (s[i] == '0') {
                out[u].push_back(v);
            } else {
                out[v].push_back(u);
            }
        }

        vector<char> cur(n + 1, false), nxt(n + 1, false);
        cur[k] = true;

        for (int step = 1; step <= n; step++) {
            fill(nxt.begin(), nxt.end(), false);

            for (int v = 1; v <= n; v++) {
                for (int to : out[v]) {
                    if (cur[to]) {
                        nxt[v] = true;
                        break;
                    }
                }
            }

            cur.swap(nxt);
        }

        int chips = 0;

        for (int i = 1; i <= n; i++) {
            if (cur[i]) {
                chips++;
            }
        }

        if (chips != 1) {
            quitf(_wa, "case %d: after %d rounds, number of chips is %d, expected 1",
                  tc, n, chips);
        }
    }

    ouf.skipBlanks();
    ouf.readEof();
    quitf(_ok, "accepted");
}