Problem: Natsume loves big cats. One day, Natsume was invited by the stray cats she was always close to to go to the mysterious bookstore where the cats were open. When I heard that the bookstore sells books with many pictures of cats, Natsume decided to follow her happily.

I didn't know Natsume, but the bookstore that was taken by the cats was a famous store with chain stores nationwide. The store has a solid manual for the clerk, and the behavior of the clerk is unified in every store. The following is an excerpt from the manual.

1. When a customer enters the store through a door within a 10-Euclidean distance from the clerk, he must say "Welcome Hello" in a loud voice for X seconds.
2. When the clerk who heard another clerk within the Euclidean distance of 50 saying "Welcome Hello", the clerk said "Welcome Hello" at the end of the utterance of "Welcome Hello" in a loud voice over X seconds. Must. However, a clerk who has completed uttering another "Welcome Hello" within the past Y seconds from the start of uttering this repeat must not repeat it.



Given the X, Y, customer location, and clerk placement, calculate how many seconds it will take for the store to be quiet after the customer enters. If the repeat does not stop, print "You're always welcome!".

Notes on Submission

Multiple datasets are given in the above format. The first line of input data gives the number of datasets. Create a program that outputs the output for each data set in order in the above format.



Input

The number N of the clerk and the X and Y written in the manual are given on the first line of the input, separated by one space character. The second line is the position where Natsume enters the store, and the following N lines are the coordinates representing the positions of N clerk. Each position is given by separating the x and y coordinates with a single space character, and each number is given as an integer between 0 and 1000. Also, 1 <= N <= 1000, 1 <= X, Y <= 100 is satisfied.

Output

If the repeat does not stop, output the time from when the customer enters the store until it becomes quiet, and if it does not stop, output "You're always welcome!" On one line.

Example

Input

4
3 3 5
0 0
10 0
40 40
40 90
4 5 10
100 100
50 100
50 150
100 50
100 150
4 60 10
100 100
90 100
110 100
100 90
100 110
4 60 10
100 100
80 100
110 100
100 80
100 110


Output

9
0
60
You're always welcome!

Solution (in CPP):

Solution:
#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;
}