#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int MAX_N = 1000;

const int INF = 1 << 30;
const int DD = 10;
const int PD = 50;

/* typedef */

typedef vector<int> vi;

template <typename T>
struct Pt {
  T x, y;

  Pt() {}
  Pt(T _x, T _y) : x(_x), y(_y) {}
  Pt(const Pt& pt) : x(pt.x), y(pt.y) {}

  bool operator==(const Pt pt) const { return x == pt.x && y == pt.y; }
  Pt<T> operator+(const Pt pt) const { return Pt<T>(x + pt.x, y + pt.y); }
  Pt<T> operator-() const { return Pt<T>(-x, -y); }
  Pt<T> operator-(const Pt pt) const { return Pt<T>(x - pt.x, y - pt.y); }
  Pt<T> operator*(T t) const { return Pt<T>(x * t, y * t); }
  Pt<T> operator/(T t) const { return Pt<T>(x / t, y / t); }
  T dot(Pt v) const { return x * v.x + y * v.y; }
  T cross(Pt v) const { return x * v.y - y * v.x; }
  Pt<T> mid(const Pt pt) { return Pt<T>((x + pt.x) / 2, (y + pt.y) / 2); }
  T d2() { return x * x + y * y; }
  double d() { return sqrt(d2()); }

  Pt<T> rot(double th) {
    double c = cos(th), s = sin(th);
    return Pt<T>(c * x - s * y, s * x + c * y);
  }

  Pt<T> rot90() { return Pt<T>(-y, x); }

  bool operator<(const Pt& pt) const {
    return x < pt.x || (x == pt.x && y < pt.y);
  }

  void print(string format) {
    printf(("(" + format + ", " + format + ")\n").c_str(), x, y);
  }
  void print() { print("%.6lf"); }
};

typedef Pt<int> pt;

/* global variables */

int n, x, y;
pt dr, pts[MAX_N];
vi nbrs[MAX_N];
int dists[MAX_N];
bool used[MAX_N];

/* subroutines */

/* main */

int main() {
  int tn;
  cin >> tn;

  while (tn--) {
    cin >> n >> x >> y;
    cin >> dr.x >> dr.y;
    for (int i = 0; i < n; i++) cin >> pts[i].x >> pts[i].y;

    for (int i = 0; i < n; i++) {
      dists[i] = -INF;
      nbrs[i].clear();
    }
    
    for (int i = 0; i < n; i++)
      for (int j = i + 1; j < n; j++)
	if ((pts[j] - pts[i]).d2() <= PD * PD) {
	  nbrs[i].push_back(j);
	  nbrs[j].push_back(i);
	}

    memset(used, false, sizeof(used));
    
    queue<int> q;
    for (int i = 0; i < n; i++)
      if ((pts[i] - dr).d2() <= DD * DD)
	q.push(i), dists[i] = x, used[i] = true;

    int max_d = 0;
    bool always = false;
    
    while (! q.empty()) {
      int u = q.front(); q.pop();
      int ud = dists[u];
      if (max_d < ud) max_d = ud;

      int nvd = ud + x;
      vi& nbru = nbrs[u];

      for (vi::iterator vit = nbru.begin(); vit != nbru.end(); vit++) {
	int& v = *vit;

	if (dists[v] < ud - y) {
	  if (used[v]) {
	    always = true;
	    break;
	  }

	  q.push(v);
	  dists[v] = nvd;
	  used[v] = true;
	}
      }

      if (always) break;
    }
    //cout << always << ' ' << max_d << endl;

    if (always)
      cout << "You're always welcome!" << endl;
    else
      cout << max_d << endl;
  }

  return 0;
}