#include <iostream>
#include <algorithm>
#include <limits>
#include <cmath>
using namespace std;

const int kInf = numeric_limits< int >::max() / 2;
const double kEps = 1e-10;
const double kErr = 1e-8;
const int kLim = 24;

int N, M;
int Xi1[110], Yi[110], Xi2[110], Zi[110];
int min1, max1, min2, max2;

double dx1[110][2], dx2[110][2], dy[110][2], dz[110][2];

void read();
void solve();
double adaptive_simpson(double, double);
double adaptive_simpson(double, double, double, double, double, double, double, int);
double find_area(double);

inline double simpson(double h, double fa, double fb, double fc) {
  return (fa + 4 * fc + fb) * h / 6;
}

int main() {
  ios::sync_with_stdio(false);
  cout.setf(ios::fixed), cout.precision(10);
  while (cin >> N >> M, N + M) {
    read();
    solve();
  }

  return 0;
}

void read() {
  for (int i = 0; i < N; ++i)
    cin >> Xi1[i] >> Yi[i];
  for (int i = 0; i < M; ++i)
    cin >> Xi2[i] >> Zi[i];
  Xi1[N] = Xi1[0], Yi[N] = Yi[0], Xi2[M] = Xi2[0], Zi[M] = Zi[0];

  for (int i = 0; i < N; ++i) {
    if (Xi1[i] < Xi1[i + 1])
      dx1[i][0] = Xi1[i], dy[i][0] = Yi[i], dx1[i][1] = Xi1[i + 1], dy[i][1] = Yi[i + 1];
    else
      dx1[i][1] = Xi1[i], dy[i][1] = Yi[i], dx1[i][0] = Xi1[i + 1], dy[i][0] = Yi[i + 1];
  }

  for (int i = 0; i < M; ++i) {
    if (Xi2[i] < Xi2[i + 1])
      dx2[i][0] = Xi2[i], dz[i][0] = Zi[i], dx2[i][1] = Xi2[i + 1], dz[i][1] = Zi[i + 1];
    else
      dx2[i][1] = Xi2[i], dz[i][1] = Zi[i], dx2[i][0] = Xi2[i + 1], dz[i][0] = Zi[i + 1];
  }
}

void solve() {
  min1 = min2 = kInf, max1 = max2 = -kInf;
  for (int i = 0; i < N; ++i)
    min1 = min(min1, Xi1[i]), max1 = max(max1, Xi1[i]);
  for (int i = 0; i < M; ++i)
    min2 = min(min2, Xi2[i]), max2 = max(max2, Xi2[i]);

  double res = adaptive_simpson(double(max(min1, min2)), double(min(max1, max2)));
  cout << res << "\n";
}

double adaptive_simpson(double a, double b) {
  if (a < b) {
    double h = b - a, c = (a + b) / 2;
    double fa = find_area(a), fb = find_area(b), fc = find_area(c);
    return adaptive_simpson(a, b, simpson(h, fa, fb, fc), fa, fb, fc, kErr, kLim);
  }
  else
    return 0;
}

double adaptive_simpson(double a, double b, double s,
                        double fa, double fb, double fc, double err, int t) {
  double c = (a + b) / 2, h = (b - a) / 2;
  double fd = find_area((a + c) / 2), fe = find_area((c + b) / 2);
  double s1 = simpson(h, fa, fc, fd);
  double s2 = simpson(h, fc, fb, fe);

  if (t <= 0 || abs(s1 + s2 - s) < 15 * err)
    return (s1 + s2) + (s1 + s2 - s) / 15;
  return  adaptive_simpson(a, c, s1, fa, fc, fd, err / 2, t - 1) +
          adaptive_simpson(c, b, s2, fc, fb, fe, err / 2, t - 1);
}

double find_area(double x) {
  double miny = double(kInf), maxy = double(-kInf);
  double minz = double(kInf), maxz = double(-kInf);
  double ty, tz;

  for (int i = 0; i < N; ++i)
    if (dx1[i][0] < x + kEps && x < dx1[i][1] + kEps) {
      ty = dy[i][0] + (dy[i][1] - dy[i][0]) * (x - dx1[i][0]) / (dx1[i][1] - dx1[i][0]);
      miny = min(miny, ty), maxy = max(maxy, ty);
    }

  for (int i = 0; i < M; ++i)
    if (dx2[i][0] < x + kEps && x < dx2[i][1] + kEps) {
      tz = dz[i][0] + (dz[i][1] - dz[i][0]) * (x - dx2[i][0]) / (dx2[i][1] - dx2[i][0]);
      minz = min(minz, tz), maxz = max(maxz, tz);
    }

  return (maxy - miny) * (maxz - minz);
}

Measured memory_bytes: 1284