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

struct UnionFind {
    vector<int> par, rank, siz, level;
    UnionFind(int n, const vector<int>& v) : par(n, -1), rank(n, 0), siz(n, 1), level(v.begin(), v.end()) {}

    int root(int a) {
        if(par[a] == -1) return a;
        else return par[a] = root(par[a]);
    }

    bool same(int a, int b) {
        return root(a) == root(b);
    }

    bool unite(int a, int b) {
        int ra = root(a), rb = root(b);
        if(ra == rb) return false;
        if(rank[ra] < rank[rb]) swap(ra, rb);
        par[rb] = ra;
        if(rank[ra] == rank[rb]) rank[ra]++;
        siz[ra] += siz[rb];
        level[ra] = max(level[ra], level[rb]);
        return true;
    }

    int size(int a) {
        return siz[root(a)];
    }

    int get_level(int a) {
        return level[root(a)];
    }
};

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    
    int N, M, K;
    cin >> N >> M >> K;
    
    vector<int> A(N);
    for(int i = 0; i < N; i++) {
        cin >> A[i];
    }

    vector<vector<int>> G(N);
    for(int i = 0; i < M; i++) {
        int u, v;
        cin >> u >> v;
        u--; v--;
        G[u].push_back(v);
        G[v].push_back(u);
    }

    UnionFind uf(N, A);

    vector<int> ord(N);
    iota(ord.begin(), ord.end(), 0);
    sort(ord.begin(), ord.end(), [&](int i, int j) { return A[i] < A[j]; });

    for(int v : ord) {
        for(int nv : G[v]) {
            if(A[v] >= uf.get_level(nv) && (A[v] - uf.get_level(nv)) <= K) uf.unite(v, nv);
        }
    }

    if(uf.size(0) == N) cout << "Yes\n";
    else cout << "No\n";

    return 0;
}