#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define x first
#define y second

using namespace std;

typedef long double ld;
typedef long long ll;

pair <ll, ll> alice[100005], bob[100005];
ld pref_dif[100005], pref_square[100005], suf_dif[100005], suf_square[100005];
ld opa[100005];

ld pref_dis[100005], suf_dis[100005];

ld process(ll l, ll r, ll L, ll R)
{
 	if (l > L) swap(l, L), swap(r, R);

 	if (r <= L) return (ld) (r - l) * (R - L) * (R + L - r - l) / 2;
 	
 	if (r <= R)
 	{
 		ld fir = (ld) (r - L) * (L - l) * (r - l) / 2;
 		ld sec = (ld) (L - l) * (R - r) * (R + r - L - l) / 2;
 		ld third = (ld) (r - L) * (r - L) * (r - L) / 3;
 		ld four = (ld) (r - L) * (R - r) * (R - L) / 2;
 		return fir + sec + third + four;
 	}
 	else
 	{
 		ld fir = (ld) (L - l) * (R - L) * (R - l) / 2;
 		ld sec = (ld) (R - L) * (R - L) * (R - L) / 3;
 		ld third = (ld) (r - R) * (R - L) * (r - L) / 2;
 		return fir + sec + third;
 	}
}

ld process_pt_seg(ll x, ll l, ll r)
{
 	if (x < l) return ((ld) r * r - (ld) l * l) / 2 - (ld) x * (r - l);
 	if (x > r) return (ld) x * (r - l) - ((ld) r * r - (ld) l * l) / 2;

 	return (ld) (x - l) * (x - l) / 2 + (ld) (r - x) * (r - x) / 2;
}

int main()
{
 	//freopen("input.txt", "r", stdin);
 	//freopen("output.txt", "w", stdout);
	ios_base::sync_with_stdio(0); cin.tie(0);
	cout.precision(20);

	int n, m;
	cin >> n >> m;
	for (int i = 1; i <= n; i++) cin >> alice[i].x >> alice[i].y;
	for (int i = 1; i <= m; i++) cin >> bob[i].x >> bob[i].y;

	ll len_a = 0, len_b = 0;
	for (int i = 1; i <= n; i++) len_a += alice[i].y - alice[i].x;
	for (int i = 1; i <= m; i++) len_b += bob[i].y - bob[i].x;

	if (len_a == 0 && len_b == 0)
	{
	 	for (int i = 1; i <= m; i++) pref_dis[i] = pref_dis[i - 1] + bob[i].x;
	 	for (int i = m; i > 0; i--) suf_dis[i] = suf_dis[i + 1] + bob[i].x;
	 	
	 	int lef = 0;
	 	ld ans = 0;
	 	for (int i = 1; i <= n; i++)
	 	{
	 	 	while (lef < m && bob[lef + 1].x <= alice[i].x) lef++;

	 		ld sum1 = pref_dis[lef], sum2 = suf_dis[lef + 1];
	 		ans += (ld) lef * alice[i].x - sum1;
	 		ans += sum2 - (ld) (m - lef) * alice[i].x;
	 	}
	 	ans = ans / n / m;
	 	cout << fixed << ans << '\n';
	 	return 0;
	}

	if (len_b == 0)
	{
	 	for (int i = 1; i <= max(n, m); i++) swap(alice[i], bob[i]);
	 	swap(n, m);
	 	swap(len_a, len_b);
	}

	for (int i = 1; i <= m; i++) pref_dif[i] = pref_dif[i - 1] + (bob[i].y - bob[i].x);
	for (int i = 1; i <= m; i++) pref_square[i] = pref_square[i - 1] + (ld) bob[i].y * bob[i].y - (ld) bob[i].x * bob[i].x;
	for (int i = m; i > 0; i--) suf_dif[i] = suf_dif[i + 1] + (bob[i].y - bob[i].x);
	for (int i = m; i > 0; i--) suf_square[i] = suf_square[i + 1] + (ld) bob[i].y * bob[i].y - (ld) bob[i].x * bob[i].x;
	for (int i = 1; i <= m; i++)
	{
	 	opa[i] = opa[i - 1];
	 	ld s = (bob[i].y - bob[i].x);
	 	s = s * s * s / 3;
	 	ld t = (ld) bob[i].x * bob[i].y * (bob[i].y - bob[i].x);
	 	opa[i] += t + s;
	}

	if (len_a == 0)
	{
		ld ans = 0;
		int lef = 0, rig = 1;
		for (int i = 1; i <= n; i++)
		{
			while (lef < m && bob[lef + 1].y <= alice[i].x) lef++;
			while (rig <= m && bob[rig].x <= alice[i].x) rig++;

			ld left_part = (ld) alice[i].x * pref_dif[lef] - pref_square[lef] / 2;
			ld right_part = suf_square[rig] / 2 - (ld) alice[i].x * suf_dif[rig];
			ans += left_part + right_part;
			if (lef != rig - 1)
			{
			 	int A = lef + 1;
				ans += process_pt_seg(alice[i].x, bob[A].x, bob[A].y);
			}
		}
		ans = ans / n / len_b;
		cout << fixed << ans << '\n';
		return 0;
	}

	ld ans = 0;
	int lef = 0, rig = 1;
	for (int i = 1; i <= n; i++)
	{
		if (alice[i].x == alice[i].y) continue;

		while (lef < m && bob[lef + 1].y <= alice[i].x) lef++;
		while (rig <= m && bob[rig].x < alice[i].y) rig++;

		ld sum_left = (ld) (alice[i].x + alice[i].y) * pref_dif[lef] - pref_square[lef];
	 	ld left_part = (ld) (alice[i].y - alice[i].x) / 2 * sum_left;

	 	ld sum_right = suf_square[rig] - (ld) (alice[i].x + alice[i].y) * suf_dif[rig];
	 	ld right_part = (ld) (alice[i].y - alice[i].x) / 2 * sum_right;

	 	ans += left_part + right_part;

	 	if (lef == rig - 1) continue;

	 	int L = lef + 1, R = rig - 1;
	 	ans += process(alice[i].x, alice[i].y, bob[L].x, bob[L].y);
	 	if (L != R) ans += process(alice[i].x, alice[i].y, bob[R].x, bob[R].y);

	 	if (R > L + 1)
	 	{
	 	 	int mid_lef = L + 1, mid_rig = R - 1;
	 	 	ld fir = opa[mid_rig] - opa[mid_lef - 1];
	 	 	ld sec = (pref_square[mid_rig] - pref_square[mid_lef - 1]) / 2;
	 	 	ld third = (pref_dif[mid_rig] - pref_dif[mid_lef - 1]) / 2;
	 	 	ld A = (ld) alice[i].x * alice[i].x + (ld) alice[i].y * alice[i].y;
	 	 	ld B = alice[i].x + alice[i].y;
	 	 	ld middle_part = A * third - B * sec + fir;
	 	 	ans += middle_part;
	 	}
	}
	ans = ans / len_a / len_b;

	cout << fixed << ans << '\n';
	return 0;
}