Problem:
Problem I: Intersection of Two Prisms

Suppose that P1 is an infinite-height prism whose axis is parallel to the z-axis, and P2 is also an infinite-height prism whose axis is parallel to the y-axis. P1 is defined by the polygon C1 which is the cross section of P1 and the xy-plane, and P2 is also defined by the polygon C2 which is the cross section of P2 and the xz-plane.

Figure I.1 shows two cross sections which appear as the first dataset in the sample input, and
Figure I.2 shows the relationship between the prisms and their cross sections.

Figure I.1: Cross sections of Prisms

Figure I.2: Prisms and their cross sections

Figure I.3: Intersection of two prisms

Figure I.3 shows the intersection of two prisms in Figure I.2, namely, P1 and P2.

Write a program which calculates the volume of the intersection of two prisms.

Input

The input is a sequence of datasets. The number of datasets is less than 200.

Each dataset is formatted as follows.

m n

x11 y11

x12 y12

.

.

.

x1m y1m

x21 z21

x22 z22

.

.

.

x2n z2n

m and n are integers (3 ≤ m ≤ 100, 3 ≤ n ≤ 100) which represent the numbers of the vertices of the polygons, C1 and C2, respectively.

x1i, y1i, x2j and z2j are integers between -100 and 100, inclusive. (x1i, y1i) and (x2j , z2j) mean the i-th and j-th vertices' positions of C1 and C2 respectively.

The sequences of these vertex positions are given in the counterclockwise order either on the xy-plane or the xz-plane as in Figure I.1.

You may assume that all the polygons are convex, that is, all the interior angles of the polygons are less than 180 degrees. You may also assume that all the polygons are simple, that is, each polygon's boundary does not cross nor touch itself.

The end of the input is indicated by a line containing two zeros.

Output

For each dataset, output the volume of the intersection of the two prisms, P1 and P2, with a decimal representation in a line.

None of the output values may have an error greater than 0.001. The output should not contain any other extra characters.

Sample Input

4 3
7 2
3 3
0 2
3 1
4 2
0 1
8 1
4 4
30 2
30 12
2 12
2 2
15 2
30 8
13 14
2 8
8 5
13 5
21 7
21 9
18 15
11 15
6 10
6 8
8 5
10 12
5 9
15 6
20 10
18 12
3 3
5 5
10 3
10 10
20 8
10 15
10 8
4 4
-98 99
-99 -99
99 -98
99 97
-99 99
-98 -98
99 -99
96 99
0 0

Output for the Sample Input

4.708333333333333
1680.0000000000005
491.1500000000007
0.0
7600258.4847715655

Solution in Ruby (judge verdict: Accepted)

### constant

INF = Float::INFINITY

### classes

class Pt
  attr_accessor :x, :y

  def initialize() end
  def initialize(_x, _y) @x = _x; @y = _y end

  def ==(pt) @x == pt.x && @y == pt.y end
  def +(pt) Pt.new(@x + pt.x, @y + pt.y) end
  def -(pt) Pt.new(@x - pt.x, @y - pt.y) end
  def -@() Pt.new(-@x, -@y) end
  def *(t) Pt.new(@x * t, @y * t) end
  def /(t) Pt.new(@x / t, @y / t) end
  def dot(v) @x * v.x + @y * v.y end
  def cross(v) @x * v.y - @y * v.x end
  def d2() @x * @x + @y * @y end
  def d() Math.sqrt(d2()) end
  def normalize() self / d() end
  def to_s() "(#{@x},#{@y})" end
  def to_a() [@x, @y] end
end

### subroutines

def cutlen(x, ys, k)
  miny = INF
  maxy = -INF
  for i in (0...k)
    pt0 = ys[i]
    pt1 = ys[(i + 1) % k]
    v = pt1 - pt0
    if v.x != 0.0 && (pt0.x <= x && x <= pt1.x || pt1.x <= x && x <= pt0.x)
      y = v.y * (x - pt0.x) / v.x + pt0.y
      miny = y if miny > y
      maxy = y if maxy < y
    end
  end

  (maxy >= miny) ? maxy - miny : 0.0
end

### main

loop do
  m, n = gets.split.map(&:to_i)
  break if (m | n) == 0

  xys = m.times.map{Pt.new(*gets.split.map(&:to_f))}
  xzs = n.times.map{Pt.new(*gets.split.map(&:to_f))}
  #p [xys.map{|pt| pt.to_s}, xzs.map{|pt| pt.to_s}]

  xmin0 = xys.map{|pt| pt.x}.min
  xmax0 = xys.map{|pt| pt.x}.max
  xmin1 = xzs.map{|pt| pt.x}.min
  xmax1 = xzs.map{|pt| pt.x}.max

  xs = (xys.map{|pt| pt.x} + xzs.map{|pt| pt.x}).sort.uniq
  nxs = xs.length
  #p [xmin0, xmax0, xmin1, xmax1]
  #p xs

  dys = nxs.times.map{0.0}
  dzs = nxs.times.map{0.0}
  for i in (0...nxs)
    xi = xs[i]
    if xmin0 <= xi && xi <= xmax0
      dys[i] = cutlen(xi, xys, m)
    end
    if xmin1 <= xi && xi <= xmax1
      dzs[i] = cutlen(xi, xzs, n)
    end
  end
  #p [dys, dzs]
  
  vol = 0.0

  (0...nxs).each_cons(2) do |i0, i1|
    x0 = xs[i0]
    x1 = xs[i1]
    if xmin0 <= x0 && x1 <= xmax0 && xmin1 <= x0 && x1 <= xmax1
      dy0 = dys[i0]
      dz0 = dzs[i0]
      dy1 = dys[i1]
      dz1 = dzs[i1]
      v = (x1 - x0) * (dy0 * dz1 + dy1 * dz0 + 2 * (dy0 * dz0 + dy1 * dz1)) / 6
      vol += v
    end
  end

  puts vol
end