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:
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
#include <complex>
 
using namespace std;
 
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P > PP;
 
int tx[] = {0,1,0,-1};
int ty[] = {-1,0,1,0};
 
static const double EPS = 1e-8;

int main(){
  int total_test_cases;
  while(~scanf("%d",&total_test_cases)){
    for(int test_i = 0; test_i < total_test_cases; test_i++){
      int total_staff;
      int speech_duration,prohibited_duration;

      scanf("%d %d %d",&total_staff,
            &speech_duration,&prohibited_duration);
      double customer_x,customer_y;
      scanf("%lf %lf",&customer_x,&customer_y);
      vector<complex<double> > staff;
      for(int staff_i = 0; staff_i < total_staff; staff_i++){
        double x,y;
        scanf("%lf %lf",&x,&y);
        staff.push_back(complex<double>(x,y));
      }
      
      int latest_speech_finished_time[1001];
      memset(latest_speech_finished_time,-1,sizeof(latest_speech_finished_time));
      queue<int> que;
      for(int staff_i = 0; staff_i < total_staff; staff_i++){
        if(abs(staff[staff_i] - complex<double>(customer_x,customer_y)) > 10.0) continue;
        que.push(staff_i);
        latest_speech_finished_time[staff_i] = speech_duration;
      }
      
      vector<int> edges[1001];
      for(int staff_i = 0; staff_i < total_staff; staff_i++){
        for(int staff_j = 0; staff_j < total_staff; staff_j++){
          if(staff_i == staff_j) continue;
          if(abs(staff[staff_i] - staff[staff_j]) > 50.0) continue;
          edges[staff_i].push_back(staff_j);
        }
      }

      bool isok = false;
      for(int round = 0; round < 100000; round++){
        queue<int> next;
        bool visited[1001] = {};
        while(!que.empty()){
          int staff_i = que.front();
          que.pop();
          for(int i = 0; i < edges[staff_i].size(); i++){
            int staff_j = edges[staff_i][i];
            if(latest_speech_finished_time[staff_j] == -1 
               || (latest_speech_finished_time[staff_j] + prohibited_duration
                   < latest_speech_finished_time[staff_i])){
              if(visited[staff_j]) continue;
              next.push(staff_j);
              visited[staff_j] = true;
              latest_speech_finished_time[staff_j]
                = latest_speech_finished_time[staff_i] + speech_duration;
            }
          }
        }
        if(next.empty()){
          isok = true;
          break;
        }
        que = next;
      }
      
      int res = 0;
      for(int i = 0; i < total_staff; i++){
        res = max(res,latest_speech_finished_time[i]);
      }
      if(isok){
        printf("%d\n",res);
      }
      else{
        printf("You're always welcome!\n");
      }
    }
  }
}