#pragma GCC optimize ("Ofast")
#pragma GCC optimize ("unroll-loops")
#include <bits/stdc++.h>
using namespace std;

template <class F>
struct ycr {
	F f;
	template <class T> explicit ycr(T&& f_) : f(forward<T>(f_)) {}

	template <class... Args> decltype(auto) operator()(Args&&... args) {
		return f(ref(*this), forward<Args>(args)...);
	}
};
template <class F> decltype(auto) yc(F&& f) {
	return ycr<decay_t<F>>(forward<F>(f));
}

constexpr bool TEST = false;

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	cout << fixed << setprecision(20);

	int M, N, K, S;
	cin >> M >> N >> K >> S;

	using D = double;
	int L = N+M;
	vector<D> X; X.reserve(L);
	for (int i = 0; i < L; i++) {
		D x;
		cin >> x;
		X.push_back(x);
	}
	sort(X.begin(), X.end());

	auto sq = [&](D a) -> D {
		return a * a;
	};

	vector<vector<D>> cost(L+1, vector<D>(L+1));
	for (int l = 0; l < L; l++) {
		D s = 0;
		D s2 = 0;
		for (int r = l+1; r <= L; r++) {
			s += X[r-1];
			s2 += sq(X[r-1]);
			
			// (r-l) x^2 - 2 s x + s2
			D x = s / (r-l);
			cost[l][r] = (r-l) * sq(x) - 2 * s * x + s2;
		}
	}

	const D INF = 1e20;
	vector<D> dp(L+1, INF);
	dp[0] = 0;
	for (int z = 0; z < K; z++) {
		vector<D> ndp(L+1);
		auto trans = [&](int i, int j) -> D {
			if (i <= j) {
				return dp[i] + cost[i][j];
			} else {
				return INF;
			}
		};
		yc([&](auto self, int s, int e, int l, int r) -> void {
			if (s == e) return;
			int i = (s+e) / 2;
			int b = l;
			D bv = trans(b, i);
			for (int k = l+1; k <= i && k < r; k++) {
				D kv = trans(k, i);
				if (kv < bv) {
					b = k, bv = kv;
				}
			}
			ndp[i] = bv;
			self(s, i, l, b+1);
			self(i+1, e, b, r);
		})(0, L+1, 0, L+1);
		dp = std::move(ndp);
	}

	D ans = dp.back();
	ans += L * sq(D(S) / 2);
	cout << ans << '\n';

	return 0;
}