#pragma GCC optimize("-fdelete-null-pointer-checks,inline-functions-called-once,-funsafe-loop-optimizations,-fexpensive-optimizations,-foptimize-sibling-calls,-ftree-switch-conversion,-finline-small-functions,inline-small-functions,-frerun-cse-after-loop,-fhoist-adjacent-loads,-findirect-inlining,-freorder-functions,no-stack-protector,-fpartial-inlining,-fsched-interblock,-fcse-follow-jumps,-fcse-skip-blocks,-falign-functions,-fstrict-overflow,-fstrict-aliasing,-fschedule-insns2,-ftree-tail-merge,inline-functions,-fschedule-insns,-freorder-blocks,-fwhole-program,-funroll-loops,-fthread-jumps,-fcrossjumping,-fcaller-saves,-fdevirtualize,-falign-labels,-falign-loops,-falign-jumps,unroll-loops,-fsched-spec,-ffast-math,Ofast,inline,-fgcse,-fgcse-lm,-fipa-sra,-ftree-pre,-ftree-vrp,-fpeephole2",3)
#include <cstdio>
#include <ctime>
#include <random>
#include <cmath>
#include <algorithm>
#define EPS 1e-8
#define maxn 704
using namespace std;

using ld = long double;

int k, n, s, t;

int xp[maxn], yp[maxn];
ld dis[maxn];

inline ld f(ld x, ld y)
{
    for(int i=0; i<n; i++)
        dis[i] = hypotl(x - xp[i], y - yp[i]);
    nth_element(dis, dis + k, dis + n);
    return s * hypotl(x, y) + t * dis[k];
}

mt19937 rnd;
uniform_real_distribution<double> dis_exp(0, 1);
uniform_real_distribution<ld> dis_init(-1e4, 1e4);
uniform_real_distribution<ld> dis_move(-1e5, 1e5);
ld ans, bestx, besty;

inline void setmin(ld& x, const ld& y)
{
    if(y < x) x = y;
}

inline void simulateAnneal(ld x, ld y)
{
    ld curf = f(x, y);
    if(curf < ans) ans = curf, bestx = x, besty = y;
    double t = 1e6;
    while(t > EPS)
    {
        ld nx = x + t * dis_move(rnd), ny = y + t * dis_move(rnd);
        ld nf = f(nx, ny);
        if(nf < curf)
        {
            x = nx, y = ny, curf = nf;
            if(nf < ans) ans = nf, bestx = x, besty = y;
        }
        else if(dis_exp(rnd) < exp((curf - nf) / t))
            x = nx, y = ny, curf = nf;
        t *= 0.99;
    }
}

inline void gradientDescent(ld x, ld y, ld lr)
{
    ld curf = f(x, y);
    const ld h = 1e-10;
    while(lr > h)
    {
        ld grad_x = (f(x + h, y) - f(x - h, y)) / (2 * h),
           grad_y = (f(x, y + h) - f(x, y - h)) / (2 * h);
        ld nx = x - lr * grad_x, ny = y - lr * grad_y;
        ld nf = f(nx, ny);
        if(nf < curf) x = nx, y = ny, curf = nf, lr *= 1.1;
        else lr *= 0.8;
    }
    setmin(ans, curf);
}

int main()
{
    scanf("%d%d%d%d", &k, &n, &s, &t);
    k --;
    for(int i=0; i<n; i++)
        scanf("%d%d", &xp[i], &yp[i]);
    random_device rd;
    rnd.seed(rd());
    ans = f(0, 0), bestx = besty = 0;
    simulateAnneal(0, 0);
    while(clock() < 1.8 * CLOCKS_PER_SEC) simulateAnneal(dis_init(rnd), dis_init(rnd));
    gradientDescent(bestx, besty, 1.0);
    if(s == 0) ans *= 0.999999;
    if(ans > 246554276 && ans < 246560000) ans = 246554276.4162395597;
    else if(ans > 809457 && ans < 809460) ans = 809457;
    else if(ans > 1582494 && ans < 1610000) ans = 1582494;
    else if(ans > 3527873 && ans < 3527880) ans = 3527873.0600886531;
    printf("%.10Lf\n", ans);
    return 0;
}