#include<bits/stdc++.h>
using namespace std;
#define UL unsigned long long
#define L long long
#define COUT cout <<
#define END << "\n";
#define D long double

class I {
  public:
  vector<pair<L, L>> ranges;
  vector<L> points;
  vector<D> propSuffix;
  L area = 0;
  I(int n) {
    for (int i = 0; i < n; i++) {
      L l, r;
      cin >> l >> r;
      if (l == r) {
        points.push_back(l);
      } else {
        ranges.push_back({l, r});
      }
    }
    if (ranges.size()) {
      sort(ranges.begin(), ranges.end());
      for (auto [l, r] : ranges) {
        area += r - l;
      }
      propSuffix.assign(ranges.size(), 0);
      for (int i = 0; i < ranges.size(); i++) {
        auto [l, r] = ranges[i];
        propSuffix[i] = (r - l) / (D) area;
      }
    } else {
      sort(points.begin(), points.end());
      area = points.size();
      propSuffix.assign(points.size(), 1 / (D) area);
      for (int i = points.size()-2; i >= 0; i--) {
        propSuffix[i] += propSuffix[i+1];
      }
    }
  }
  bool discrete() {
    return !ranges.size();
  }
  bool good(int idx) {
    return ranges.size() ? idx < ranges.size() : idx < points.size();
  }
  L high(int idx) {
    return ranges.size() ? ranges[idx].second : points[idx];
  }
  L low(int idx) {
    return ranges.size() ? ranges[idx].first : points[idx];
  }
  D prop(int l, int r) {
    return ranges.size() ? (r - l) / (D) area : 1 / (D) area;
  }
};

int main() {
  ios_base::sync_with_stdio(0); cin.tie(0);
  int n, m;
  cin >> n >> m;
  I a(n), b(m);
  D res = 0;
  for (int w = 0; w < 2; w++) {
    int ai = 0, bi = 0;
    L lowA = -1e9-1, lowB = -1e9-1;
    D passedProb = 0;
    while (a.good(ai) && b.good(bi)) {
      if (lowA == a.high(ai)) {
        ai++;
        continue;
      }
      if (lowB == b.high(bi)) {
        bi++;
        continue;
      }
      L leftA = max(lowA, a.low(ai));
      L leftB = max(lowB, b.low(bi));
      if (leftA < leftB) {
        L cut = min(a.high(ai), leftB);
        if (a.discrete()) {
          // Discrete
          res += leftA * (2*passedProb-1) / a.area;
        } else {
          // Continuous
          res += (cut * cut - leftA * leftA) * (2*passedProb-1) / 2 / a.area;
        }
        lowA = cut;
      } else if (leftA > leftB) {
        L cut = min(b.high(bi), leftA);
        passedProb += b.prop(leftB, cut);
        lowB = cut;
      } else if (a.discrete()) {
        if (b.discrete()) {
          res += leftA * a.prop(leftA, leftA) * (2*passedProb-1+b.prop(leftB, leftB));
          passedProb += b.prop(leftB, leftB);
          ai++;
          bi++;
        } else {
          res += leftA * a.prop(leftA, leftA) * (2*passedProb-1);
          ai++;
        }
      } else {
        if (b.discrete()) {
          passedProb += b.prop(leftB, leftB);
          bi++;
        } else {
          int cut = min(a.high(ai), b.high(bi));
          res += (cut * cut - leftA * leftA) * (2*passedProb-1+b.prop(leftB, cut)) / 2 / a.area;
          res += ((cut * (D) cut + leftA * (D) leftA) * (cut - leftA) / 2 - (cut * (D) cut * cut - leftA * (D) leftA * leftA) / 3) / a.area / b.area;
          passedProb += b.prop(leftB, cut);
          lowA = lowB = cut;
        }
      }
    }
    if (a.good(ai) && lowA == a.high(ai)) {
      ai++;
    }
    while (a.good(ai)) {
      L leftA = max(a.low(ai), lowA), rightA = a.high(ai);
      if (a.discrete()) {
        res += leftA / (D) a.area;
      } else {
        res += (rightA * rightA - leftA * leftA) / (D) 2 / a.area; 
      }
      ai++;
    }
    swap(a, b);
  }
  COUT setprecision(100) << res END
}

/*

1 1
-1 0
-1 0


int x(2*(c+d(x-l)) - 1)
int x(2c-2dl-1) + int 2dxx


*/