#include <bits/stdc++.h>

using namespace std;

#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define ff first
#define ss second

using ll = long long int;
using ld = long double;

const int INF = 1000000007;
const ll INF64 = 1000000000000000003LL;
const int CUTE_LOGN = 17;

pair<vector<bool>, ll> all_reachable(const vector<vector<int>>& g, const vector<ll>& s, ll d) {
    ll curs = s[0];
    int n = g.size();
    vector<bool> used(n, false), reachable(n, false);
    set<pair<ll, int>> h;

    used[0] = true;
    reachable[0] = true;
    h.insert({0, 0});

    while (!h.empty()) {
        auto [sv, v] = *begin(h);
        h.erase(begin(h));

        if (curs <= sv) {
            break;
        }
        reachable[v] = true;

        for (int u : g[v]) {
            if (!used[u]) {
                h.insert({s[u], u});
                used[u] = true;
            }
        }
        curs += d;
    }

    return {reachable, curs};
}

void solve() {
    int n, m;
    vector<ll> dist, s;
    vector<vector<int>> g;
    set<pair<ll, int>> h;
    ll a, b;

    cin >> n >> m >> a >> b;

    g.resize(n);
    for (int i = 0; i < m; i++) {
        int v, u;

        cin >> v >> u;
        v--, u--;

        g[v].push_back(u);
        g[u].push_back(v);
    }
    s.resize(n);
    for (int i = 0; i < n; i++) {
        cin >> s[i];
        if (i > 0) {
            s[i] += b;
        }
    }

    if (a <= b) {
        dist.resize(n, INF64);
        dist[0] = 0;
        h.insert({0, 0});
        while (!h.empty()) {
            auto [d, v] = *begin(h);
            h.erase(begin(h));

            if (dist[v] != d) { continue; }

            for (int u : g[v]) {
                if (s[u] < s[0] + d * (a - b) && dist[u] > dist[v] + 1) {
                    dist[u] = dist[v] + 1;
                    h.insert({dist[u], u});
                }
            }
        }
        if (dist[n - 1] == INF64) {
            cout << -1 << '\n';
        } else {
            cout << dist[n - 1] << '\n';
        }
        return ;
    }

    auto [reachable, maxs] = all_reachable(g, s, a - b);
    if (reachable[n - 1] == false) {
        cout << -1 << '\n';
        return ;
    }

    dist.resize(n, INF64);
    dist[0] = 0;
    h.insert({0, 0});
    while (!h.empty()) {
        auto [d, v] = *begin(h);
        h.erase(begin(h));

        if (dist[v] != d) { continue; }

        for (int u : g[v]) {
            if (s[u] < s[0] + d * (a - b)) {
                if (dist[u] > dist[v] + 1) {
                    dist[u] = dist[v] + 1;
                    h.insert({dist[u], u});
                }
            } else {
                ll k = 1 + (s[u] - s[0] + 1) / (a - b);
                if (s[u] < maxs && dist[u] > max(dist[v] + 1, k)) {
                    dist[u] = max(dist[v] + 1, k);
                    h.insert({dist[u], u});
                }
            }
        }
    }
    if (dist[n - 1] == INF64) {
        cout << -1 << '\n';
    } else {
        cout << dist[n - 1] << '\n';
    }
    return ;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int t = 1;
    cin >> t;

    for (int i = 0; i < t; i++) {
        solve();
    }

    return 0;
}