import std.stdio;
import std.ascii;
import std.c.stdio;
import std.range;
import std.array;
import std.functional;
import std.algorithm;
import std.conv;
import std.container;
import std.math;
import std.numeric;
import std.string;
import std.c.string;
import std.regex;
import std.typecons;

int N, X, Y;;
int sY, sX;
int[] cY, cX;
int[][] G;
int dist2(int sy, int sx, int gy, int gx) {
    int dy = gy - sy,
        dx = gx - sx;
    return dx * dx + dy * dy;
}

void input() {
    scanf("%d %d %d\n", &N, &X, &Y);
    scanf("%d %d\n", &sX, &sY);
    cY = new int[N];
    cX = new int[N];
    foreach (i; 0 .. N) {
        scanf("%d %d\n", &cX[i], &cY[i]);
    }
    G = new int[][N];
    foreach (i; 0 .. N) {
        foreach (j; i + 1 .. N) {
            if ( dist2(cY[i], cX[i], cY[j], cX[j]) <= 50 * 50 ) {
                G[i] ~= j;
                G[j] ~= i;
            }
        }
    }
}

struct S {
    int v, time;
}

void solve() {
    auto isInit = new bool[N];
    auto lastFinished = new int[N];
    lastFinished[] = int.min / 2;
    BinaryHeap!(Array!S, "a.time > b.time") PQ;
    foreach (i; 0 .. N) {
        //writeln(dist2(sY, sX, cY[i], cX[i]));
        if ( dist2(sY, sX, cY[i], cX[i]) <= 10 * 10 ) {
            PQ.insert(S(i, X));
            lastFinished[i] = X;
            isInit[i] = true;
        }
    }
    int Ans = 0;
    while (!PQ.empty) {
        S cur = PQ.front; PQ.removeFront;
        //writeln(cur);
        Ans = max(Ans, cur.time);
        foreach (next; G[cur.v]) {
            if (lastFinished[next] + Y >= cur.time) continue;
            if (isInit[next]) {
                writeln("You're always welcome!"); return;
            }
            lastFinished[next] = cur.time + X;
            PQ.insert(S(next, cur.time + X));
        }
    }
    writeln(Ans);
}

void main() {
    int T; scanf("%d\n", &T);
    foreach (t; 0 .. T) {
        input; solve;
    }
}