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

template<typename F>
struct Point {
  F x, y;
  Point(F x = 0, F y = 0) : x(x), y(y) {}
  bool operator<(const Point &oth) const {
    return x == oth.x ? y < oth.y : x < oth.x;
  }
  Point operator-(const Point &oth) const {
    return Point(x - oth.x, y - oth.y);
  }
};

template<typename F>
using Polygon = vector<Point<F>>;

template<typename F>
Polygon<F> upperConvexHull(Polygon<F> P) {
  reverse(P.begin(), P.end());
  rotate(P.begin(), min_element(P.begin(), P.end(), [](Point<F> a, Point<F> b) {
    return a.x == b.x ? a.y > b.y : a.x < b.x;
  }), P.end());
  int n = P.size();
  Polygon<F> ret = {P[0]};
  for (int i = 1; i < n; ++i) {
    auto dir = P[i] - P[i - 1];
    if (dir.x > 0) ret.push_back(P[i]);
  }
  return ret;
}

template<typename F>
Polygon<F> lowerConvexHull(Polygon<F> P) {
  rotate(P.begin(), min_element(P.begin(), P.end()), P.end());
  int n = P.size();
  Polygon<F> ret = {P[0]};
  for (int i = 1; i < n; ++i) {
    auto dir = P[i] - P[i - 1];
    if (dir.x > 0) ret.push_back(P[i]);
  }
  return ret;
}

template<typename F>
double getLen(F x, Polygon<F> U, Polygon<F> L) {
  int i = upper_bound(U.begin(), U.end(), Point<F>(x, -1e9)) - U.begin();
  int j = upper_bound(L.begin(), L.end(), Point<F>(x, -1e9)) - L.begin();
  if (i == U.size() or j == L.size()) return 0;
  if (i == 0 and U[i].x > x) return 0;
  if (j == 0 and L[j].x > x) return 0;
  auto getY = [&](double x, int i, Polygon<F> P) -> double {
    if (i == 0) return P[i].y;
    return P[i].y - (double) (P[i].y - P[i - 1].y) / 
                             (P[i].x - P[i - 1].x) * 
                             (P[i].x - x);
  };
  return getY(x, i, U) - getY(x, j, L);
}


template<typename Double>
class Integration {
  Double ALPHA = sqrt((5 - sqrt(40. / 7))) / 3, WA = (322 + sqrt(11830)) / 900;
  Double W0 = 128. / 225.;
  Double BETA  = sqrt((5 + sqrt(40. / 7))) / 3, WB = (322 - sqrt(11830)) / 900;
  function<Double(Double)> f;
  Double quadrature(Double l, Double r) {
    auto m = (l + r) / 2, len = r - m;
    return (f(m - ALPHA * len) * WA + f(m - BETA * len) * WB + f(m) * W0 +
            f(m + ALPHA * len) * WA + f(m + BETA * len) * WB) * len;
  }
  Double askArea(Double l, Double r, Double exceptArea) {
    Double m = (l + r) / 2, L = quadrature(l, m), R = quadrature(m, r);
    if (abs(L + R - exceptArea) < 1e-8)
      return L + R;
    else return askArea(l, m, L) + askArea(m, r, R);
  }
public:
  Integration(function<Double(Double)> func) : f(func) {}
  Double intergal(Double l, Double r, int piece = 1) {
    Double ans = 0;
    for (Double dx = (r - l) / piece, i = 0; i < piece; ++i) {
      auto cur = l + dx * i;
      ans += askArea(cur, cur + dx, quadrature(cur, cur + dx));
    }
    return ans;
  }
};

int main() {
  ios_base::sync_with_stdio(false); cin.tie(0);
  int n, m; 
  while (cin >> n >> m and n and m) {
    Polygon<double> Z, Y;
    vector<int> Xs;
    for (int i = 0; i < n; ++i) {
      int x, y; cin >> x >> y;
      Z.emplace_back(x, y);
      Xs.emplace_back(x);
    }
    for (int i = 0; i < m; ++i) {
      int x, y; cin >> x >> y;
      Y.emplace_back(x, y);
      Xs.emplace_back(x);
    }
    sort(Xs.begin(), Xs.end());
    Xs.erase(unique(Xs.begin(), Xs.end()), Xs.end());
    Polygon<double> UZ = upperConvexHull(Z);
    Polygon<double> LZ = lowerConvexHull(Z);
    Polygon<double> UY = upperConvexHull(Y);
    Polygon<double> LY = lowerConvexHull(Y);
    double preX = Xs[0];
    double ans = 0;
    Integration<double> formula([=](double x) {
      return getLen(x, UZ, LZ) * getLen(x, UY, LY);
    });
    for (int x : Xs) {
      ans += formula.intergal(preX, x);
      preX = x;
    }
    cout << fixed << setprecision(10) << ans << '\n';
  }
}




Measured memory_bytes: 3332