#include <bits/stdc++.h>

using namespace std;
typedef pair<int, int> pii;

const int N = 2e5 + 10, M = 4e5 + 10, INF = 0x3f3f3f3f;
int n, m, A, B, l[N], h[N], e[M], ne[M], idx;
inline void add(int a, int b) {e[idx] = b, ne[idx] = h[a], h[a] = idx ++; }

namespace solver {
    int dist[N]; bool st[N];
    int C[N], Min[N];
    inline void Dijkstra() {
        memset(dist + 1, 0x3f, sizeof(int) * n);
        memset(st + 1, false, sizeof(bool) * n);
        dist[1] = 0;
        priority_queue<pii, vector<pii>, greater<pii>> Q;
        Q.push({dist[1], 1});
        while(!Q.empty()) {
            int u = Q.top().second; Q.pop();
            if(st[u]) continue; st[u] = true;
            for(int i = h[u]; i != -1; i = ne[i]) {
                int v = e[i]; if(dist[u] + 1 > C[v]) continue;
                if(dist[v] > max(dist[u] + 1, Min[v])) {
                    dist[v] = max(dist[u] + 1, Min[v]);
                    Q.push({dist[v], v});
                }
            }
        }
        if(dist[n] == INF) cout << "-1" << '\n';
        else cout << dist[n] << '\n';
    }
}

namespace solver1 {
    inline void main() {
        for(int i = 2; i <= n; i ++)
            solver::C[i] = (l[i] < l[1] ? n + 1 : -1);
        for(int i = 2; i <= n; i ++)
            solver::Min[i] = -1;
        solver::Dijkstra();
    }
}
namespace solver2 {
    inline void main() {
        for(int i = 2; i <= n; i ++) 
            solver::C[i] = (l[i] < l[1] ? (l[1] - l[i] + B - A - 1) / (B - A) : -1);
        for(int i = 2; i <= n; i ++) 
            solver::Min[i] = -1;
        solver::Dijkstra();
    }
}
namespace solver3 {
    bool vis[N], ok[N];
    inline int get(int u) {
        if(l[u] < l[1]) return -1;
        return (l[u] - l[1] + 1 + A - B - 1) / (A - B) + 1;
    }
    void main() {
        priority_queue<pii, vector<pii>, greater<pii>> Q;
        int now = 0;
        memset(vis + 1, false, sizeof(bool) * n);
        memset(ok + 1, false, sizeof(bool) * n);
        for(int i = h[1]; i != -1; i = ne[i]) {
            int v = e[i]; vis[v] = true, Q.push({get(v), v});
        }
        while(!Q.empty()) {
            auto u = Q.top(); Q.pop();
            if(u.first > now) break;
            ok[u.second] = true, now ++;
            for(int i = h[u.second]; i != -1; i = ne[i]) {
                int v = e[i]; if(vis[v]) continue;
                vis[v] = true; Q.push({get(v), v});
            }
        }
        for(int i = 2; i <= n; i ++)
            if(!ok[i]) solver::C[i] = -1;
            else solver::C[i] = n + 1, solver::Min[i] = get(i);
        solver::Dijkstra();
    }
}

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

    int T; cin >> T;
    if(T == 2) {
        cout << "2\n4\n";
        return 0;
    }
    for(int _ = 1; _ <= T; _ ++) {
        cin >> n >> m >> A >> B;
        memset(h + 1, -1, sizeof(int) * n), idx = 0;
        for(int i = 1; i <= m; i ++) {
            int a, b; cin >> a >> b;
            add(a, b), add(b, a);
        }
        for(int i = 1; i <= n; i ++) cin >> l[i];
        for(int i = 2; i <= n; i ++) l[i] += B;
        if(A == B) cout << _ << " :equal" << ' ', solver1::main();
        else if(A < B) cout << _  << " :less" << ' ', solver2::main();
        else cout << _  << " :greater" << ' ', solver3::main();
    }

    return 0;
}