#include <bits/stdc++.h>
using namespace std;
long double PI = acos(-1);
long double DEL = 1e-10;
int M =  1e9 + 7;
const int N = 3e5 + 1000;

#define ftt cin>>tc;for(int cas=1;cas<=tc;++cas)
#define all(a) a.begin(),a.end()
#define vpii vector<pair<int,int> >
#define vvi vector<vector<int> >
#define va(x) vector<array<int,(x)> >
#define pii pair<int,int>
#define vi vector<int>
#define sq(a) ((a)*(a))
#define double long double
#define dbg cout<<"\nhi\n";
#define int long long
#define nl cout<<"\n"
#define sp <<" "<<
#define S second
#define F first

template<class T> using minpq = priority_queue<T,vector<T>,greater<T> >;
int fpow(int x, int n)
{
        int res = 1;
        x %= M;
        while(n)
        {
                if(n&1)res = res * x % M;
                x = x * x % M;
                n>>=1;
        }
        return res;
}
int gcd(int a,int b)
{
        if(b == 0)return a;
        return gcd(b,a % b);
}
int lcm(int a,int b)
{
        return a*(b/gcd(a,b));
}
int popcount(int x)
{
        return bitset<65>(x).count();
}
void create_fac(int n)
{
        vector<int> fac(N),inv(N);
        fac[0] = inv[0] = 1;
        for(int i=1;i<=n;i++)
        {
                fac[i] = fac[i-1]*i % M;
                inv[i] = fpow(fac[i],M-2);
        }
}
int ncr(int n,int r)
{
        vector<int> fac(N),inv(N);
        return fac[n] * (inv[r] * inv[n-r] % M) % M;
        return fac[n] * (fpow(fac[r],M-2) * fpow(fac[n-r],M-2) % M ) % M;
}

void sieve (int n)
{
        vector<int> pf(N);
        pf[0] = pf[1] = 1;
        for (int i = 2; i <= n; i++) {
                if (!pf[i]) {
                        pf[i] = i;
                        for (int j = i * i; j <= n; j += i){
                                pf[j] = i;
                        }
                }
        }
        
}

//**************************************** CHECK CONSTRAINTS ***************************************
int cnt, sum, mid, mx, mn, ans, a[N], b[N];
int n, m, d, i, j, k, l, p, r, t, w, x, y, z, tc;
string s;

vpii g[N];
priority_queue<pii> q;  //


struct DSU
{
        int par[N];
        DSU (int n)
        {
                for(int i=0;i<=n;i++)
                {
                        par[i] = i;
                }
        }
        
        int find(int x)
        {
                return x == par[x]? x:par[x] = find(par[x]);
        }
        
        void join(int x,int y)
        {
                int parx = find(x),pary = find(y);
                
                a[parx] += a[pary] - z;
                if(g[pary].size() > g[parx].size()){
                        swap(g[parx],g[pary]);
                }
                
                g[parx].insert(g[parx].end(),all(g[pary]));
                
                g[pary].clear();
                
                par[pary] = parx;
        }
};

struct Union_Find{
        int fa[N];
        void init(int n){for(int i=0;i <= n;++i)fa[i]=i;}
        int find(int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
        void unit(int x,int y){x=find(x),y=find(y);if(x!=y)fa[y]=x;}
}dsu;

int32_t main()
{
        ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
        #ifndef ONLINE_JUDGE
        freopen("/Users/jenish/XCode/cp/input.txt","r",stdin);
        #endif
        cin >> n >> m >> x;
        for(int i = 1;i <= n;i++){
                cin >> a[i];
                sum += a[i];
        }
        if(sum < (n-1)*x){
                cout<<"NO";
                return 0;
        }
        cout<<"YES\n";
        
        for(int i = 1;i <= m;i++){
                cin >> y >> z;
                g[y].push_back({z,i});
                g[z].push_back({y,i});
        }
        
        z = x;
        
        for(int i=1;i<=n;i++){
                q.push({a[i],i});
        }
        
        //DSU dsu(n+5);
        
        dsu.init(n+5);
        
        while(!q.empty()){
                int p = q.top().S;
                q.pop();
                
                if(dsu.find(p) != p){
                        continue;
                }
                
                while(!g[p].empty() and dsu.find(g[p].back().F) == p){
                        g[p].pop_back();
                }
                
                if(g[p].empty()){
                        continue;
                }
                cout << g[p].back().S;nl;
                
//                cnt++;
//                if(cnt == (n - 1))break;
//
//                //
//                dsu.join(p,g[p].back().F);
//
//                g[p].pop_back();
//
//                q.push({a[p],p});
                int u = p;
                int v = dsu.find(g[u].back().F);
                
                a[u] += a[v]-x;
                
                q.push({a[u],u});
                
                dsu.unit(u,v);
                if(g[u].size()<g[v].size()) swap(g[u],g[v]);
                g[u].insert(g[u].end(),all(g[v]));
                g[v].clear();
                
        }
        return 0;
}


