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

typedef long long ll;
typedef pair<int, int> pii;
typedef tuple<int, int, int> tii;
typedef pair<double, double> pdd;

#define eb emplace_back
#define pb push_back
#define all(s) (s).begin(), (s).end()
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define per(i, a, b) for (int i = (a); i >= (b); --i)

inline int rd() {
    int x = 0;
    bool f = 0;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) f |= (c == '-');
    for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
    return f ? -x : x;
}

int main() {
    vector<pdd> tmp, A, B;
    int n = rd(), m = rd();
    bool intervalA = false, intervalB = false;
    rep(i, 1, n) {
        double l = rd(), r = rd();
        tmp.eb(l, r);
        intervalA |= (l != r);
    }
    for (auto [l, r] : tmp) {
        if (intervalA && l == r) continue;
        A.eb(l, r);
    }
    tmp.clear();
    rep(i, 1, m) {
        double l = rd(), r = rd();
        tmp.eb(l, r);
        intervalB |= (l != r);
    }
    for (auto [l, r] : tmp) {
        if (intervalB && l == r) continue;
        B.eb(l, r);
    }
    sort(all(A));
    sort(all(B));
    if (!intervalA && !intervalB) {
        double ans = 0;
        int ptr = 0;
        double sumL = 0, sumR = 0;
        for (auto [l, r] : A) sumR += l;
        for (auto [l, r] : B) {
            while (ptr < A.size() && A[ptr].first <= l) {
                sumL += A[ptr].first;
                sumR -= A[ptr].first;
                ++ptr;
            }
            ans += l * ptr - sumL + sumR - l * (A.size() - ptr);
        }
        ans = ans / A.size() / B.size();
        printf("%.12lf\n", ans);
        return 0;
    }
    if (!intervalB) {swap(intervalA, intervalB); swap(A, B); swap(n, m);}
    if (!intervalA) {
        double ans = 0;
        int ptr = 0;
        double sumL = 0, sumR = 0, sumL2 = 0, sumR2 = 0;
        for (auto [l, r] : B) {
            sumR += r - l;
            sumR2 += r * r - l * l;
        }
        for (auto [l, r] : A) {
            while (ptr < B.size() && B[ptr].second <= l) {
                auto [ll, rr] = B[ptr];
                double contri = rr * rr - ll * ll;
                sumL += rr - ll;
                sumR -= rr - ll;
                sumL2 += contri;
                sumR2 -= contri;
                ++ptr;
            }
            if (ptr < B.size() && l >= B[ptr].first && l <= B[ptr].second) {
                auto [ll, rr] = B[ptr];
                double contri = rr * rr - ll * ll;
                sumR -= rr - ll;
                sumR2 -= contri;
                ans += l * sumL - sumL2 / 2;
                ans += sumR2 / 2 - l * sumR;
                ans += l * (l - ll) - (1.0 * l * l - 1.0 * ll * ll) / 2;
                ans += (1.0 * rr * rr - 1.0 * l * l) / 2 - l * (rr - l);
                sumR += rr - ll;
                sumR2 += contri;
            } else {
                ans += l * sumL - sumL2 / 2;
                ans += sumR2 / 2 - l * sumR;
            }
        }
        sumL = 0;
        for (auto [l, r] : B) sumL += r - l;
        ans = ans / A.size() / sumL;
        printf("%.12lf\n", ans);
        return 0;
    }
    vector<double> S;
    for (auto [l, r] : A) S.eb(l), S.eb(r);
    for (auto [l, r] : B) S.eb(l), S.eb(r);
    sort(all(S));
    S.erase(unique(all(S)), S.end());
    auto cut = [&](vector<pdd> &seg) {
        vector<pdd> res;
        int ptr = 0;
        for (auto [l, r] : seg) {
            while (ptr < S.size() && S[ptr] <= l) ++ptr;
            while (ptr < S.size() && S[ptr] <= r) {
                res.eb(S[ptr - 1], S[ptr]);
                ++ptr;
            }
        }
        swap(seg, res);
    };
    cut(A); cut(B);

    int ptr = 0;
    double ans = 0, sumL = 0, sumR = 0, sumL2 = 0, sumR2 = 0;
    for (auto [l, r] : A) sumR += r - l, sumR2 += 1.0 * r * r - 1.0 * l * l;
    for (auto [l, r] : B) {
        while (ptr < A.size() && A[ptr].second <= l) {
            auto [ll, rr] = A[ptr];
            double contri = rr * rr - ll * ll;
            sumL += rr - ll;
            sumR -= rr - ll;
            sumL2 += contri;
            sumR2 -= contri;
            ++ptr;
        }
        double c1 = r - l;
        double c2 = r * r - l * l;
        if (ptr < A.size() && l == A[ptr].first && r == A[ptr].second) {
            auto [ll, rr] = A[ptr];
            double contri = 1.0 * rr * rr - 1.0 * ll * ll;
            sumR -= rr - ll;
            sumR2 -= contri;
            ans += c2 * sumL / 2 - c1 * sumL2 / 2;
            ans += c1 * sumR2 / 2 - c2 * sumR / 2;
            ans += c1 * c1 * c1 / 3;
            sumR += rr - ll;
            sumR2 += contri;
        } else {
            ans += c2 * sumL / 2 - c1 * sumL2 / 2;
            ans += c1 * sumR2 / 2 - c2 * sumR / 2;
        }
    }
    sumL = 0;
    for (auto [l, r] : B) sumL += r - l;
    ans /= sumL;
    sumL = 0;
    for (auto [l, r] : A) sumL += r - l;
    ans /= sumL;

    printf("%.12lf\n", ans);
    return 0;
}