#include <bits/stdc++.h>
using namespace std;

const double EPS = 1e-9;
template <class D, class F> D gss(D a, D b, F f, D e = EPS) {
	D r = (sqrt(5) - 1) / 2;
	D x1 = b - r * (b-a), x2 = a + r * (b-a);
	auto f1 = f(x1), f2 = f(x2);
	while (x2 - x1 > e) {
		if (f1 < f2) {
			b = x2, x2 = x1, f2 = f1;
			x1 = b - r * (b-a), f1 = f(x1);
		} else {
			a = x1, x1 = x2, f1 = f2;
			x2 = a + r * (b-a), f2 = f(x2);
		}
	}
	return a;
}

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;

	vector<D> X;
	for (int i = 0; i < M+N; i++) {
		D x; cin >> x;
		X.push_back(x);
	}

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

	sort(X.begin(), X.end());
	int L = int(X.size());
	assert(L == N+M);
	vector<D> pref(L+1);
	vector<D> spref(L+1);
	for (int i = 0; i < L; i++) {
		pref[i+1] = pref[i] + X[i];
		spref[i+1] = spref[i] + sq(X[i]);
	}

	auto get_cost_at = [&](int l, int r, D x) -> D {
		// (x - x_i)^2
		// x^2 - 2 x x_i + x_i^2
		return (r-l) * sq(x) - 2 * x * (pref[r] - pref[l]) + (spref[r] - spref[l]);
	};
	auto get_cost = [&](int l, int r) -> D {
		assert(0 <= l); assert(l <= r); assert(r <= L);
		D best = gss<D>(0, 1000, [&](D x) -> D {
			return get_cost_at(l, r, x);
		});
		return get_cost_at(l, r, best);
	};

	const D INF = 1e20;
	vector<vector<D>> cost(L+1, vector<D>(L+1, INF));
	for (int l = 0; l <= L; l++) {
		for (int r = l; r <= L; r++) {
			cost[l][r] = get_cost(l, r);
		}
	}

	//cerr << cost[0][3] << endl;

	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 INF;
			assert(0 <= i && i <= j && j <= L);
			return dp[i] + cost[i][j];
		};
		auto go = [&](auto self, int s, int e, int l, int r) -> void {
			if (s == e) return;
			int i = (s+e)/2;
			assert(0 <= i && i <= L);
			int b = l;
			D bv = trans(b, i);
			for (int k = l+1; k < r; k++) {
				D kv = trans(k, i);
				if (kv < bv) {
					b = k;
					bv = kv;
				}
			}
			ndp[i] = bv;
			self(self, s, i, l, b+1);
			self(self, i+1, e, b, r);
		};
		go(go, 0, L+1, 0, L+1);
		swap(dp, ndp);
	}

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

	return 0;
}