#include <iostream>
#include <vector>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <set>

using namespace std;

int main() {
    int T;
    cin >> T;
    vector<int> results;

    while (T--) {
        int n, m, k;
        cin >> n >> m >> k;

        unordered_set<int> friends;
        for (int i = 0; i < n; i++) {
            int friend_id;
            cin >> friend_id;
            friends.insert(friend_id);
        }

        vector<pair<int, int>> comments;
        for (int i = 0; i < m; i++) {
            int a, b;
            cin >> a >> b;
            comments.emplace_back(a, b);
        }

        int initial_visible_count = 0;
        unordered_map<int, int> single_friend_gain;
        unordered_map<int, set<int>> both_needed;

        for (const auto& comment : comments) {
            int a = comment.first;
            int b = comment.second;

            if (friends.count(a) && friends.count(b)) {
                initial_visible_count++;
            } else if (friends.count(a)) {
                single_friend_gain[b]++;
            } else if (friends.count(b)) {
                single_friend_gain[a]++;
            } else {
                both_needed[a].insert(b);
                both_needed[b].insert(a);
            }
        }

        // Step 1: Track maximum visibility increase for single additions
        int max_single_addition = 0;
        for (const auto& [user, gain] : single_friend_gain) {
            max_single_addition = max(max_single_addition, gain);
        }

        // Step 2: Calculate two-friend addition visibility
        int max_double_addition = 0;

        // Case 1: Two friends from `single_friend_gain`
        vector<int> single_friend_gains;
        for (const auto& [user, gain] : single_friend_gain) {
            single_friend_gains.push_back(gain);
        }
        sort(single_friend_gains.rbegin(), single_friend_gains.rend());
        if (single_friend_gains.size() >= 2) {
            max_double_addition = single_friend_gains[0] + single_friend_gains[1];
        } else if (!single_friend_gains.empty()) {
            max_double_addition = single_friend_gains[0];
        }

        // Case 2: Two friends from `both_needed`
        for (const auto& [user1, needed_set1] : both_needed) {
            for (const int& user2 : needed_set1) {
                if (user1 < user2) {
                    int additional_visible = 0;
                    unordered_set<int> added_friends = {user1, user2};

                    // Count visibility from single additions for user1 and user2
                    additional_visible += single_friend_gain[user1] + single_friend_gain[user2];

                    // Count visibility from comments requiring both user1 and user2
                    for (const auto& [a, b] : comments) {
                        if (added_friends.count(a) && added_friends.count(b) && !friends.count(a) && !friends.count(b)) {
                            additional_visible++;
                        }
                    }

                    max_double_addition = max(max_double_addition, additional_visible);
                }
            }
        }

        // Step 3: Mixed Pairing: One from `single_friend_gain` and one from `both_needed`
        for (const auto& [user, gain] : single_friend_gain) {
            for (const auto& [other_user, needed_set] : both_needed) {
                if (!friends.count(user) && !friends.count(other_user)) {
                    int combined_gain = gain;
                    for (int friend_needed : needed_set) {
                        if (friend_needed != user && !friends.count(friend_needed)) {
                            combined_gain++;
                        }
                    }
                    max_double_addition = max(max_double_addition, combined_gain);
                }
            }
        }

        // Final result calculation
        int max_comments_visible = initial_visible_count + max(max_single_addition, max_double_addition);
        results.push_back(max_comments_visible);
    }

    for (int result : results) {
        cout << result << endl;
    }

    return 0;
}