#include <bits/stdc++.h>
#ifdef LOCAL
#include <debug.hpp>
#else
#define debug(...) void(0)
#endif

template <class T> std::istream& operator>>(std::istream& is, std::vector<T>& v) {
    for (auto& e : v) {
        is >> e;
    }
    return is;
}

template <class T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
    for (std::string_view sep = ""; const auto& e : v) {
        os << std::exchange(sep, " ") << e;
    }
    return os;
}

template <class T, class U = T> bool chmin(T& x, U&& y) {
    return y < x and (x = std::forward<U>(y), true);
}

template <class T, class U = T> bool chmax(T& x, U&& y) {
    return x < y and (x = std::forward<U>(y), true);
}

template <class T> void mkuni(std::vector<T>& v) {
    std::ranges::sort(v);
    auto result = std::ranges::unique(v);
    v.erase(result.begin(), result.end());
}

template <class T> int lwb(const std::vector<T>& v, const T& x) {
    return std::distance(v.begin(), std::ranges::lower_bound(v, x));
}

using namespace std;

using ll = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);

    int n, m, k;
    cin >> n >> m >> k;
    vector<int> a(k), p(m), q(m);
    for (int i = 0; i < k; i++) {
        cin >> a[i];
        a[i]--;
    }
    for (int i = 0; i < m; i++) {
        cin >> p[i] >> q[i];
        p[i]--, q[i]--;
    }

    if (k == n) {
        cout << "No\n";
        return 0;
    }

    vector<bool> alive(n, true);
    for (int i = 0; i < k; i++) alive[a[i]] = false;
    int root = -1;
    for (int i = 0; i < n; i++) {
        if (alive[i]) {
            root = i;
            break;
        }
    }
    vector<vector<int>> G(n);
    for (int i = 0; i < m; i++) {
        G[p[i]].emplace_back(q[i]);
        G[q[i]].emplace_back(p[i]);
    }
    vector<bool> seen(n, false);
    vector<vector<int>> ans(n);
    vector<int> ord;
    auto dfs = [&](auto self, int v) -> void {
        ord.emplace_back(v);
        seen[v] = true;
        if (not alive[v]) return;
        for (int& u : G[v]) {
            if (seen[u]) continue;
            ans[v].emplace_back(u);
            self(self, u);
        }
    };
    dfs(dfs, root);
    for (int i = 0; i < n; i++) {
        if (not seen[i]) {
            cout << "No\n";
            return 0;
        }
    }
    int cnt = 0;
    for (int i = 0; i < n; i++) cnt += (not ans[i].empty());

    cout << "Yes\n";
    cout << cnt << "\n";
    for (int v : ord) {
        if (ans[v].empty()) continue;
        cout << v + 1 << " " << ans[v].size();
        for (int u : ans[v]) cout << " " << u + 1;
        cout << "\n";
    }
    return 0;
}