		//sometimes assume final ans and then approach prblm downward accordingly
		#include <bits/stdc++.h>
		// #include <boost/math/common_factor.hpp>
		using namespace std;
		#define ll long long
		#define MOD 1000000007
		#define init ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
		#define test ll t; cin>>t; while(t--)
		// #define ll long long
		#define INF 1000000000000000005
		#define pb push_back
		#define pi 3.1415926
		#define MAX 8000000000000000064ll
		#define MIN -8000000000000000064ll
		#define endl "\n"


		// ll fpow(ll x, ll y, ll p = MOD) {
		// 	x = x % p; ll sum = 1; while (y) {
		// 		if (y & 1)sum = sum * x; sum %= p; y = y >> 1; x = x * x; x %= p;
		// 	} return sum;
		// }

		// ll fact[3000007] = {0};
		// void facto() {
		// 	fact[0] = 1; fact[1] = 1; for (ll i = 2; i < 3000007; i++)fact[i] = (fact[i - 1] * i) % MOD;
		// }
		// ll ncr(ll n, ll r) {
		// 	if (r > n)return 0;
		// 	ll res = 1; res = fact[n]; res = (res * (fpow(fact[r], MOD - 2))) % MOD; res = (res * (fpow(fact[n - r], MOD - 2))) % MOD; return res;
		// }
		// ll npr(ll n, ll r) {
		// 	if (r > n)return 0;
		// 	ll res = 1; res = fact[n]; res = (res * (fpow(fact[n - r], MOD - 2))) % MOD; return res;
		// }

		ll add(ll a, ll b) { return (a % MOD + b % MOD + ((MAX) / MOD) * MOD) % MOD; }
		ll sub(ll a, ll b) { return (a % MOD - b % MOD + ((MAX) / MOD) * MOD) % MOD; }
		ll mul(ll a, ll b) { return ((a % MOD) * (b % MOD) + ((MAX) / MOD) * MOD) % MOD; }


		// ll expomod(ll x,ll y){
		// 	ll result = 1;
		// 	x %= MOD;
		// 	while(y>0){
		// 		if(y & 1){
		// 			result = (1ll * result * x) % MOD;
		// 		}
		// 		y = y >> 1;
		// 		x = (1ll * x* x) % MOD;
		// 	}
		// 	return result;
		// }

		vector<int> in1(int n) {
			vector<int>v1;
			v1.resize(n+1); for (ll i = 1; i <=n; i++){ cin >> v1[i];}
			return v1;
		}
		vector<int> in0(int n) {
			vector<int>v1;
			v1.resize(n); for (ll i = 0; i <n; i++){ cin >> v1[i];}
			return v1;
		}

		// ll f[35];
		// ll ans,f1;
		// void add(ll x) {
		// 	for (ll i = 31; i >= 0; i--) {
		// 		if (x & (1ll << i)) {
		// 			f[i]+=1;
		// 		}
		// 	}
		// }
		// void remove(ll x) {
		// 	for (ll i = 31; i >= 0; i--) {
		// 		if (x & (1ll << i)) {
		// 			f[i]--;
		// 			if (f[i] == 0) {
		// 				ans ^= (1ll << i);
		// 			}
		// 		}

		// 	}
		// }
		// //x << y -> x = x*(2^y)
		// //x >> y -> x = x/(2^y)
		// //cout<<fixed<<setprecision(x)

		// //dijkstras
		// map<ll,ll>m1;
		// void dijkstras(vector<pair<ll,ll>>adj[],vector<double>&d,vector<ll>p,ll start){
		// 	d[start] = 0;
		// 	using pii = pair<ll,ll>;
		// 	priority_queue<pii,vector<pii>,greater<pii>>q;
		// 	q.push({0,start});

		// 	while(!q.empty()){
		// 		ll v = q.top().second;
		// 		ll d_v = q.top().first;
		// 		// cout<<v<<d_v<<endl;
		// 		q.pop();

		// 		// if(d_v!=d[v])
		// 		// continue;

		// 		for(auto p:adj[v]){
					
		// 			ll to = p.first;
		// 			ll len = p.second;

		// 			double cur = d[v]/2;
		// 			cur+=len;
		// 			if(m1[to]){
		// 				if(cur>(m1[to]+1)){
		// 					cur = m1[to]+1;
		// 				}
		// 			}
		// 			if(cur<d[to]){
		// 				d[to] = cur;
		// 				q.push({d[to],to});
		// 			}
		// 		}
		// 	}
		// 
		vector<bool> is_prime;
		void seive(ll n){
			is_prime[0] = is_prime[1] = false;
			for (ll i = 2; i <= n; i++) {
				if (is_prime[i] && (long long)i * i <= n) {
					for (ll j = i * i; j <= n; j += i)
						is_prime[j] = false;
				}
			}
		} 
		// string s1 = "";
		vector<ll>hts;
		bool ok(ll mid,ll n,ll l,ll r){
			ll cnt = 0;
			for(auto ele:hts){
				if(ele>=mid) cnt+=1;
			}
			return (cnt>=l)?true:false;
		}
		void go() {
			int a,b,c,d;
			cin>>a>>b>>c>>d;
			if(c*d-b <= 0) cout<<-1<<endl;
			else{
				int q = a/(c*d-b);
				int rem = a%(c*d-b);
				if(rem>0) q+=1;
				cout<<q<<endl;
			}
		}	
	
		signed main() {
			init
			// test{
			// 	go();
			// }
			
			go(); 
		}

#include<iostream>
#include<vector>
using namespace std;
typedef long long li;
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<(n);i++)
#define df 0
template<class T> void print(const T& t){ cout << t << "\n"; }
template<class T, class... Ts> void print(const T& t, const Ts&... ts) { cout << t; if (sizeof...(ts)) cout << " "; print(ts...); }
// Container コンテナ型, map以外
template< template<class ...> class Ctn,class T>
std::ostream& operator<<(std::ostream& os,const Ctn<T>& v){
  auto itr=v.begin();
  while(itr!=v.end()){
    if(itr!=v.begin())cout << " ";
    cout << *(itr++);
  }
  return os;
};
struct modint{
  li num;

  modint(li a=0){
    num=(a%MOD+MOD)%MOD;
  }
  modint operator+(modint a) {return{(num+a.num)%MOD};} 
  modint operator-(modint a) {return{((num-a.num)%MOD+MOD)%MOD};}
  modint operator*(modint a) {return{num*a.num%MOD};}
  modint& operator+=(modint a) {
    (num += a.num)%=MOD;
    return *this;
  }
  modint& operator-=(modint a) {
    (num += MOD-a.num)%=MOD;
    return *this;
  }
  modint& operator*=(modint a) {
    (num*=a.num)%=MOD;
    return *this;
  }
};

std::ostream& operator<<(std::ostream& os, const modint& m){
  // ここでストリームに obj を書き込みます。
  li a=m.num;
  a%=MOD;
  a+=MOD;
  a%=MOD;
  cout << a;
  return os;
}

std::istream& operator>>(std::istream& os,modint& m){
  // ここでストリームに obj を書き込みます。
  li a; cin >>a;
  m=a;
  return os;
}
// modint inv(modint a){
//     // unordered_map 必須 O(1)
//     static unordered_map<li,modint> f;
//     f[1]=1;
//     if(f.find(a.num)!=f.end())return f[a.num];
//     modint m=MOD%a.num;
//     return f[a.num]=(modint)(MOD/a.num*(-1))*inv(m);
// }


modint pow(modint a,int r){
  modint b=a,ans=1;
  while(r){
    if(r%2) ans*=b;
    b*=b;
    r/=2;
  }
  return ans;
}


modint inv(modint a){
  // MOD: prime
  return pow(a,MOD-2);
}
modint operator/(modint a,modint b) {return a*inv(b);}
modint& operator/=(modint& a,modint b){
  a*=inv(b);
  return a;
}

struct matrix{
  vector<vector<modint>> mat;
  matrix(int n,modint m=0){
    mat.resize(n,vector<modint>(n));
    rep(i,n) mat[i][i]=m;
  }
  
  matrix& operator/=(modint b){
    for(auto& v:mat)for(auto& x:v) x/=b;
    return *this;
  }
  matrix& operator*=(matrix b){
    int n=mat.size();
    matrix ret={n};
    rep(i,n) rep(j,n) rep(k,n) ret.mat[i][j]+=mat[i][k]*b.mat[k][j];
    mat=ret.mat;
    return *this;
  }
  vector<modint> operator*(vector<modint>& v){
    int n=v.size();
    vector<modint> ret(n);
    rep(i,n) rep(j,n) ret[i]+=mat[i][j]*v[j];
    return ret;
  }
  
};

matrix pow(matrix a,int r){
  int n=a.mat.size();
  matrix b=a,ans={n,1};
  while(r){
    if(r%2) ans*=b;
    b*=b;
    r/=2;
  }
  return ans;
}

std::ostream& operator<<(std::ostream& os,const matrix& m){
  for(auto x:m.mat) print(x);
  return os;
};

int main(){
  int n,m,k; cin >>n >>m >>k;

  vector<modint> v(n);
  rep(i,n) cin >>v[i];
  matrix E(n,m*2);
  if(df)print(E);
  rep(i,m){
    int a,b; cin >>a >>b; a--; b--;
    E.mat[a][b]+=1;
    E.mat[b][a]+=1;
    E.mat[a][a]-=1;
    E.mat[b][b]-=1;
  }
  if(df)print(E);
  E/=m*2;
  if(df)print(E);
  v=pow(E,k)*v;
  for(auto x:v) print(x);
}
