#include <bits/stdc++.h>

typedef long long ll;

typedef long double lb;

using namespace std;

const int MAXN=,MAXM=;

int to[MAXM << ], nxt[MAXM << ], Head[MAXN], ed = ;

lb cost[MAXM << ];

int n;

inline void addedge(int u, int v, lb c) {

        to[++ed] = v;

        nxt[ed] = Head[u];

        Head[u] = ed;

        cost[ed] = c;

}

struct HeapNode {

        int u;

        lb d;

        bool operator < (const HeapNode& rhs) const {

                return d > rhs.d;

        }

} zz;

lb mindist[MAXN];

bool vis[MAXN];

priority_queue<HeapNode> que;

void Hijkstra(int s) {

        for (int i = ; i <= n; i++) {

                mindist[i] = 4000000000000000000.0;

        }

        mindist[s] = 0.0;

        memset(vis, , sizeof(vis));

        zz.d = , zz.u = s;

        que.push(zz);

        while (!que.empty()) {

                HeapNode x = que.top();

                que.pop();

                int u = x.u;

                if (vis[u] || mindist[u] != x.d) {

                        continue;

                }

                vis[u] = true;

                for (int v, i = Head[u]; i; i = nxt[i]) {

                        v = to[i];

                        if (mindist[v] > mindist[u] + cost[i]) {

                                mindist[v] = mindist[u] + cost[i];

                                //p[v]=u;

                                zz.d = mindist[v], zz.u = v;

                                que.push(zz);

                        }

                }

        }

}

void init(int x) {

        ed = ;

        for (int i = ; i <= x; i++) {

                Head[i] = ;

        }

}

struct node {

        ll x, y;

} P[MAXN];

int main() {

        int TC;

        scanf("%d", &TC);

        while (TC--) {

                ll A, B, C, D;

                scanf("%d %lld %lld %lld %lld", &n, &A, &B, &C, &D);

                init(n);

                for (int i = ; i <= n; i++) {

                        scanf("%lld %lld", &P[i].x, &P[i].y);

                }

                for (int i = ; i <= n; i++) {

                        for (int j = i + ; j <= n; j++) {

                                ll ax = abs(P[i].x - P[j].x);

                                ll ay = abs(P[i].y - P[j].y);

                                ll dis = ax * ax + ay * ay;

                                dis = ceil(sqrt(dis));

                                lb c = (pow((lb)D / (D - 1.0), dis) - 1.0) * A * C + B;

                                addedge(i,j,c),addedge(j,i,c);

                        }

                }

                Hijkstra();

                printf("%.10Lf\n", mindist[n]);

        }

        return ;

}