import sys
from collections import defaultdict
from decimal import *
getcontext().prec = 30

def main():
    n, m = 0, 0
    alice_interval_sums, bob_interval_sums = 0, 0

    alice_intervals = []
    bob_intervals = []

    endpoints = []
    alice_imos = []
    bob_imos = []
    value_compressor = {}

    l, r = 0, 0

    ans = Decimal(0)

    input = sys.stdin.read
    data = input().split()
    
    n = int(data[0])
    m = int(data[1])
    index = 2

    for _ in range(n):
        l = int(data[index])
        r = int(data[index + 1])
        alice_interval_sums += r - l
        alice_intervals.append((l, r))
        index += 2

    for _ in range(m):
        l = int(data[index])
        r = int(data[index + 1])
        bob_interval_sums += r - l
        bob_intervals.append((l, r))
        index += 2
    
    if bob_interval_sums == 0:
        n, m = m, n
        alice_interval_sums, bob_interval_sums = bob_interval_sums, alice_interval_sums
        alice_intervals, bob_intervals = bob_intervals, alice_intervals

    if alice_interval_sums != 0:
        new_alice_intervals = []
        for l, r in alice_intervals:
            if l != r:
                new_alice_intervals.append((l, r))
                endpoints.append(l)
                endpoints.append(r)
            else:
                n -= 1
        alice_intervals = new_alice_intervals
    else:
        for l, r in alice_intervals:
            endpoints.append(l)

    if bob_interval_sums != 0:
        new_bob_intervals = []
        for l, r in bob_intervals:
            if l != r:
                new_bob_intervals.append((l, r))
                endpoints.append(l)
                endpoints.append(r)
            else:
                m -= 1
        bob_intervals = new_bob_intervals
    else:
        for l, r in bob_intervals:
            endpoints.append(l)

    endpoints = sorted(set(endpoints))
    k = len(endpoints)
    alice_imos = [0] * k
    bob_imos = [0] * k

    for i in range(k):
        value_compressor[endpoints[i]] = i

    if bob_interval_sums == 0:
        n, m = m, n
        alice_interval_sums, bob_interval_sums = bob_interval_sums, alice_interval_sums
        alice_intervals, bob_intervals = bob_intervals, alice_intervals

    alice_intervals.sort()
    bob_intervals.sort()

    for l, r in alice_intervals:
        alice_imos[value_compressor[l]] += 1
        if l != r:
            alice_imos[value_compressor[r]] -= 1

    for l, r in bob_intervals:
        bob_imos[value_compressor[l]] += 1
        if l != r:
            bob_imos[value_compressor[r]] -= 1

    if alice_interval_sums != 0:
        for i in range(k - 1):
            alice_imos[i + 1] += alice_imos[i]

    if bob_interval_sums != 0:
        for i in range(k - 1):
            bob_imos[i + 1] += bob_imos[i]

    if alice_interval_sums != 0 and bob_interval_sums != 0:
        curr_cnt = Decimal(0)
        curr_len_sum = Decimal(0)
        curr_square_sum = Decimal(0)

        for i in range(k):
            if alice_imos[i]:
                ans -= curr_cnt * (endpoints[i + 1] - endpoints[i]) * curr_square_sum
                ans += curr_cnt * (endpoints[i + 1] ** 2 - endpoints[i] ** 2) * curr_len_sum
            if bob_imos[i]:
                curr_cnt += 1
                curr_len_sum += endpoints[i + 1] - endpoints[i]
                curr_square_sum += endpoints[i + 1] ** 2 - endpoints[i] ** 2

        curr_cnt = Decimal(0)
        curr_len_sum = Decimal(0)
        curr_square_sum = Decimal(0)

        for i in range(k - 1, -1, -1):
            if alice_imos[i]:
                ans += curr_cnt * (endpoints[i + 1] - endpoints[i]) * curr_square_sum
                ans -= curr_cnt * (endpoints[i + 1] ** 2 - endpoints[i] ** 2) * curr_len_sum
            if bob_imos[i]:
                curr_cnt += 1
                curr_len_sum += endpoints[i + 1] - endpoints[i]
                curr_square_sum += endpoints[i + 1] ** 2 - endpoints[i] ** 2

        ans /= 2

        for i in range(k):
            if alice_imos[i] and bob_imos[i]:
                ans += Decimal((endpoints[i + 1] - endpoints[i])) ** 3 / 3

        ans /= alice_interval_sums
        ans /= bob_interval_sums
    elif bob_interval_sums != 0:
        curr_len_sum = Decimal(0)
        curr_square_sum = Decimal(0)

        for i in range(k):
            if alice_imos[i]:
                ans += endpoints[i] * curr_len_sum
                ans -= curr_square_sum / 2
            if bob_imos[i]:
                curr_len_sum += endpoints[i + 1] - endpoints[i]
                curr_square_sum += endpoints[i + 1] ** 2 - endpoints[i] ** 2

        curr_len_sum = Decimal(0)
        curr_square_sum = Decimal(0)

        for i in range(k - 1, -1, -1):
            if bob_imos[i]:
                curr_len_sum += endpoints[i + 1] - endpoints[i]
                curr_square_sum += endpoints[i + 1] ** 2 - endpoints[i] ** 2
            if alice_imos[i]:
                ans -= endpoints[i] * curr_len_sum
                ans += Decimal(curr_square_sum) / 2

        ans /= bob_interval_sums
        ans /= n
    else:
        curr_cnt = Decimal(0)
        curr_sum = Decimal(0)

        for i in range(k):
            if alice_imos[i]:
                ans += curr_cnt * endpoints[i] - curr_sum
            if bob_imos[i]:
                curr_cnt += 1
                curr_sum += endpoints[i]

        curr_cnt = Decimal(0)
        curr_sum = Decimal(0)

        for i in range(k - 1, -1, -1):
            if alice_imos[i]:
                ans += curr_sum - curr_cnt * endpoints[i]
            if bob_imos[i]:
                curr_cnt += 1
                curr_sum += endpoints[i]

        ans /= n
        ans /= m

    print(ans)

if __name__ == "__main__":
    main()