#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
const int maxn = 5e4 + 5;
const long double pi = acos((long double)(-1));

int n, m, beg[maxn], fen[2 * maxn], pos[maxn][2], prv[2 * maxn], nxt[2 * maxn];
long double x, y, a[maxn], b[maxn];
vector<pair<long double, int> > circx, span;

void computeCircleIntersections(long double r) {
    circx.clear();
    for (int i = 0; i < n; i++) {
        long double ca = a[i], cb = b[i];
        long double discrim = ca * ca * r * r - cb * cb + r * r;
        if (discrim > 0) {
            long double sq = sqrt(discrim);
            long double x1 = (-sq - ca * cb) / (ca * ca + 1);
            long double x2 = ( sq - ca * cb) / (ca * ca + 1);
            long double y1 = ca * x1 + cb, y2 = ca * x2 + cb;
            long double a1 = atan2(y1, x1), a2 = atan2(y2, x2);
            circx.push_back(make_pair(a1, i));
            circx.push_back(make_pair(a2, i));
        }
    }
    sort(circx.begin(), circx.end());
}

void add(int idx, int d) {
    ++idx;
    while (idx < 2 * maxn) {
        fen[idx] += d;
        idx += (idx & -idx);
    }
}

int sum(int idx) {
    ++idx;
    int ret = 0;
    while (idx > 0) {
        ret += fen[idx];
        idx -= (idx & -idx);
    }
    return ret;
}

long long countCircleIntersections() {
    long long ret = 0;
    for (int i = 0, tot = 0; i < circx.size(); i++) {
        int idx = circx[i].second;
        if (beg[idx] == -1) {
            ++tot;
            beg[idx] = i;
            add(i, 1);
        } else {
            --tot;
            add(beg[idx], -1);
            ret += tot - sum(beg[idx]);
            beg[idx] = -1;
        }
    }
    return ret;
}

void initCyclicList() {
    for (int i = 0; i < circx.size(); i++) {
        prv[i] = (i + circx.size() - 1) % circx.size();
        nxt[i] = (i + 1) % circx.size();
    }
}

void deleteCyclicListElement(int idx) {
    int pidx = prv[idx];
    int nidx = nxt[idx];
    prv[nidx] = pidx;
    nxt[pidx] = nidx;
}

long double intersectionDistance(int idx1, int idx2) {
    --m;
    long double ix = (b[idx1] - b[idx2]) / (a[idx2] - a[idx1]);
    long double iy = a[idx1] * ix + b[idx1];
    long double dist = sqrt(ix * ix + iy * iy);
    return dist;
}

long double sumCyclicList(int start, int end, int *it) {
    long double sum = 0;
    for (int idx = it[start]; idx != end; idx = it[idx]) {
        sum += intersectionDistance(circx[start].second, circx[idx].second);
    }
    return sum;
}

long double sumCircleIntersections(long double r) {
    computeCircleIntersections(r);
    if (countCircleIntersections() > m) {
        return 0; //degenerate case: a lot of intersections on query point
    }
    for (int i = 0; i < circx.size(); i++) {
        int idx = circx[i].second;
        if (beg[idx] == -1) {
            beg[idx] = i;
            pos[idx][0] = i;
        } else {
            pos[idx][1] = i;
            long double sp = circx[i].first - circx[beg[idx]].first;
            if (2 * pi - sp < sp) {
                sp = 2 * pi - sp;
                int tmp = pos[idx][0];
                pos[idx][0] = pos[idx][1];
                pos[idx][1] = tmp;
            }
            span.push_back(make_pair(sp, idx));
        }
    }
    sort(span.begin(), span.end());
    initCyclicList();
    long double sum = 0;
    for (int i = 0; i < span.size(); i++) {
        int idx = span[i].second;
        if (pos[idx][0] < pos[idx][1]) {
            sum += sumCyclicList(pos[idx][0], pos[idx][1], nxt);
        } else {
            sum += sumCyclicList(pos[idx][0], pos[idx][1], nxt);
        }
        deleteCyclicListElement(pos[idx][0]);
        deleteCyclicListElement(pos[idx][1]);
    }
    return sum + m * r;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(NULL);
    cin >> n >> x >> y >> m;
    x /= 1000, y /= 1000;
    for (int i = 0; i < n; i++) {
        cin >> a[i] >> b[i];
        a[i] /= 1000, b[i] /= 1000;
        b[i] += a[i] * x - y;
    }
    fill_n(beg, maxn, -1);
    long double low = 0, high = 1e10;
    for (int i = 0; i < 70; i++) {
        long double mid = (low + high) / 2;
        computeCircleIntersections(mid);
        if (countCircleIntersections() < m) {
            low = mid;
        } else {
            high = mid;
        }
    }
    cout << fixed << setprecision(9) << sumCircleIntersections(low) << '\n';
    return 0;
}