#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>
#include <limits>
#include <time.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

using namespace std;

// #define scd(t) scanf("%d",&t)
// #define scld(t) scanf("%ld",&t)
// #define sclld(t) scanf("%lld",&t)
// #define scc(t) scanf("%c",&t)
// #define scs(t) scanf("%s",&t)
// #define scf(t) scanf("%f",&t)
// #define sclf(t) scanf("%lf",&t)
#define ll long long int
#define lld long double
#define FIO ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
#define FOR(i,j,k,n) for(int i=j;i<=k;i += n)
#define RFOR(i,j,k,n) for(int i=j;i>=k;i -= n)
#define REP(i,j) FOR(i,0,j,1)
#define RREP(i,j) RFOR(i,j,0,1)
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define FOREACH(it,l) for(auto it = l.begin();it != l.end();it++)
#define IN(A,B,C) assert(B <= A && A <= C)
#define MEM(a,b) memset(a,(b),sizeof(a))
#define ff first
#define ss second
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define endl "\n"
#define pi 3.1415926535897932384626433832795

const int LOGN = 20;
const int MOD = 1e9 + 7;
const int MAXN = 2e5 + 5;
const int MAXA = 1e7 + 5;
const int inf = 1e9 + 1;
const int eps = 1e-9;
const long long int inf2 = 1e18 + 1;
const int MAXVertex = 3e5 + 5;
const int MAXEdge = 3e5 + 5;

// #define read(type) readInt<type>()

typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<pii> vii;
typedef vector<vi> vvi;
typedef map<int,int> mpii;
// typedef unordered_map<int,int> umpii;
typedef set<int> seti;
typedef multiset<int> mseti;

template<typename T, typename U> inline void amin(T &x, U y) { if(y<x) x = y;}
template<typename T, typename U> inline void amax(T &x, U y) { if(x<y) x = y;}

// template <typename T> inline void write(T x)
// {
// 	int i = 20;
// 	char buf[21];
// 	buf[20] = '\n';
// 	do
// 	{
// 		buf[--i] = x % 10 + '0';
// 		x /= 10;
// 	}while(x);
// 	do
// 	{
// 		putchar(buf[i]);
// 	}while(buf[i++] != '\n');
// }

// template <typename T> inline T readInt()
// {
// 	T n = 0, s = 1;
// 	char p = getchar();
// 	if(p == '-')
// 		s = -1;
// 	while((p < '0' || p> '9') && p!= EOF && p!= '-')
// 		p = getchar();
// 	if(p == '-')
// 		s = -1, p = getchar();
// 	while(p >= '0' && p <= '9')
// 	{
// 		n = (n << 3) + (n << 1) + (p - '0');
// 		p = getchar();
// 	}

// 	return n*s;
// }

#define DEBUG

#ifdef DEBUG
	
	#define debug(args...) (Debugger()) , args

	class Debugger
	{
		public:
			Debugger(const std::string& _separator = " - ") :
			first(true), separator(_separator){}

			template <typename ObjectType> Debugger& operator , (const ObjectType& v)
			{
				if(!first)
					std:cerr << separator;
				std::cerr << v;
				first = false;
				return *this;
			}
			~Debugger() { std:cerr << endl;}

		private:
			bool first;
			std::string separator;
	};

#else
	#define debug(args...)
#endif

// ll fact[405];		// factorial vector wrt mod
// ll inv[405];		// inverse factorial vector wrt mod
// ll choose[405][405]; // ncr wrt mod
// ll pow2[405];		// power of 2 wrt mod
// vector<ll> squares;
// set<ll> square;
// vi primes;
// int mind[MAXA+1];

// void primefactors()
// {
// 	for(int i = 2;i <= MAXA;i++)
// 	{
// 		if(mind[i] == 0)
// 		{
// 			primes.emplace_back(i);
// 			mind[i] = i;
// 		}
// 		for(auto &x : primes)
// 		{
// 			if(x > mind[i] || x*i > MAXA)
// 				break;
// 			mind[x*i] = x;
// 		}
// 	}
// 	return;
// }

// void allSquares()
// {
// 	for(int i = 1;i*i<=MAXN;i++)
// 	{
// 		square.insert(i*i);
// 		squares.pb(i*i);
// 	}	
// 	sort(all(squares));
// 	return;
// }

// void Sieve()
// {
// 	A[1] = -1;
// 	for(int i=2;i<MAXN;i++)
// 	{
// 		if(A[i] == 0)
// 		{
// 			A[i] = 1;
// 			for(int j=2*i;j<MAXN;j += i)
// 				A[j] = -1;
// 		}
// 	}
// }

// bool comparesecond(const pair<int,int> &a,const pair<int,int> &b)		// for comparing wrt to ss
// {
//     return (a.second < b.second);
// }
// ll modulo = MOD;
// ll fastexp(ll b,ll exp)
// {
// 	if(exp == 0)
// 		return 1;
// 	ll temp = fastexp(b,exp/2);
// 	temp = (temp*temp)%modulo;
// 	if(exp%2 == 1)
// 		temp *= b;
// 	return temp%modulo;
// }

// void Factorial()		// factorial function
// {
// 	fact[0] = 1;
// 	inv[0] = 1;
// 	for(int i=1;i<=n;i++)
// 	{
// 		fact[i] = (i*fact[i-1])%modulo;
// 		inv[i] = fastexp(fact[i],modulo - 2);
// 	}
// 	for(int i=0;i<=n;i++)
// 	{
// 		for(int j=0;j<=i;j++)
// 		{
// 			choose[i][j] = ((fact[i]*inv[j])%modulo * inv[i-j])%modulo;
// 		}
// 	}
// 	for(int i=0;i<=n;i++)
// 		pow2[i] = fastexp(2,i);
// 	return;
// }

int n,m,x;
ll as[MAXVertex];
int elist[MAXEdge*2];
int head[MAXVertex];
int previous[MAXEdge*2];
int tot = 0;

bool vis[MAXVertex];
int ans[MAXVertex];
int front,back;

void dfs(int u)
{
	vis[u] = true;
	for(int e = head[u];e!=-1;e = previous[e])
	{
		int v = elist[e^1];
		if(vis[v])
			continue;
		dfs(v);
		if(as[u] + as[v] >= x)
		{
			as[u] += as[v] - x;
			ans[front++] = e>>1;
		}
		else
			ans[--back] = e>>1;
	}
}

void solve()
{
	cin >> n >> m >> x;
	ll total = 0;
	REP(i,n-1)
	{

		cin >> as[i];
		total += as[i];
	}
	if(total < 1ll*(n-1)*x)
	{
		cout << "NO\n";
		return;
	}
	fill(head,head+n,-1);
	REP(i,2*m-1)
	{
		int u;
		cin >> u;
		u--;
		previous[i] = head[u];
		head[u] = i;
		elist[i] = u;
	}
	back = n-1;
	dfs(0);
	cout << "YES\n";
	REP(i,n-2)
		cout << ans[i] + 1 << "\n";
	return;
}

int main()
{
	FIO;
	// Sieve();
	// Factorial();
	// allSquares();
	// primefactors();
	// cin >> t;
	solve();
	return 0;
}	
