#include <iostream>
#include <vector>
#include <algorithm>
#include <deque>
#include <numeric>

void beolvas(std::istream &be, int &n, std::vector<std::pair<int, int>> &kapcsolatok, std::vector<int> &f_sorozat) {
    int m, k;
    be >> n >> m >> k;

    f_sorozat.resize(k);
    for (auto &x : f_sorozat) {
        be >> x;
    }

    kapcsolatok.resize(m);
    for (auto &x : kapcsolatok) {
        be >> x.first >> x.second;
    }
}

void feldolgoz(int n, const std::vector<std::pair<int, int>> &kapcsolatok, std::vector<int> &f_sorozat) {
    const int k = static_cast<int>(f_sorozat.size());

    if (k == 1) {
        std::cout << n << '\n';
        for (int i = 1; i <= n; i++) {
            std::cout << i << ' ';
        }
        std::cout << '\n';

        return;
    }

    std::vector<std::vector<int>> g(n);
    for (const auto &k : kapcsolatok) {
        g[k.first - 1].push_back(k.second - 1);
        g[k.second - 1].push_back(k.first - 1);
    }

    for (auto &f : f_sorozat) {
        --f;
    }

    std::vector<bool> zero_jelolt(n, true);
    for (int i = 1; i < k; i++) {
        zero_jelolt[f_sorozat[i]] = false;
    }

    std::vector<int> sorrend(n);
    std::vector<int> zero_paciensek;
    for (int p = 0; p < n; p++) {
        if (zero_jelolt[p]) {
            std::vector<bool> lattam(n, false);
            std::vector<int> p_tav(n);
            std::deque<int> sor{ p };
            p_tav[p] = 0;
            lattam[p] = true;

            int i = 0;
            sorrend[i++] = p;
            while (!sor.empty()) {
                const auto akt = sor.front();
                sor.pop_front();

                for (const auto sz : g[akt]) {
                    if (!lattam[sz]) {
                        p_tav[sz] = p_tav[akt] + 1;
                        lattam[sz] = true;
                        sor.push_back(sz);
                        sorrend[i++] = sz;
                    }
                }
            }

            const auto f = find_if(f_sorozat.begin(), f_sorozat.end(), [&](int i) { return p_tav[i] != p_tav[f_sorozat[0]]; }) - f_sorozat.begin();
            const auto s_kezd = find_if(sorrend.begin(), sorrend.end(), [&](int i) { return p_tav[i] > p_tav[f_sorozat[0]]; }) - f;

            if (sorrend.end() - s_kezd >= k && std::equal(f_sorozat.begin(), f_sorozat.end(), s_kezd, [&](int f, int s) { return p_tav[f] == p_tav[s]; })) {
                zero_paciensek.push_back(p);
            }
        }
    }

    std::cout << zero_paciensek.size() << '\n';
    for (auto p : zero_paciensek) {
        std::cout << p + 1 << ' ';
    }
    std::cout << '\n';
}

int main() {
    int n;
    std::vector<std::pair<int, int>> kapcsolatok;
    std::vector<int> f_sorozat;
    beolvas(std::cin, n, kapcsolatok, f_sorozat);

    feldolgoz(n, kapcsolatok, f_sorozat);

    return 0;
}