#include <bits/stdc++.h>
#define int long long
#define pii pair<int,int>
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(c) (c).begin(),(c).end()
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
#define MINF(a) memset(a,0x3f,sizeof(a))
#define POW(n) (1LL<<(n))
#define IN(i,a,b) (a <= i && i <= b)
using namespace std;
template <typename T> inline bool CHMIN(T& a,T b) { if(a>b) { a=b; return 1; } return 0; }
template <typename T> inline bool CHMAX(T& a,T b) { if(a<b) { a=b; return 1; } return 0; }
template <typename T> inline void SORT(T& a) { sort(ALL(a)); }
template <typename T> inline void REV(T& a) { reverse(ALL(a)); }
template <typename T> inline void UNI(T& a) { sort(ALL(a)); a.erase(unique(ALL(a)),a.end()); }
const int MOD = 1000000007;
// const int INF = 0x3f3f3f3f3f3f3f3f;
// const double EPS = 1e-10;
/* ---------------------------------------------------------------------------------------------------- */

/* 基本要素 */

using D = double; // 座標値の型 doubleかlong double
using P = complex<D>; // Point
using L = pair<P,P>;  // Line
using VP = vector<P>;
const double EPS = 1e-8;  // 許容誤差
const double INF = 1e12;
#define X real()
#define Y imag()
#define LT(n,m) ((n)+EPS<(m)) // n < m ?
#define LE(n,m) ((n)-EPS<(m)) // n <= m ?
#define GT(n,m) LT(m,n) // n > m ?
#define GE(n,m) LE(m,n) // n >= m ?
#define EQ(n,m) (abs((n)-(m))<EPS)
#define NE(n,m) !EQ(n,m)
#define rep(i,n) for (int i=0;i<(n);++i)

namespace std {
  istream& operator >> (istream& is, P& p) {
    int F, S;
    is >> F >> S;
    p = P(F,S);
    return is;
  }
  bool operator < (const P a, const P b) {
    return NE(a.X,b.X) ? LT(a.X,b.X) : LT(a.Y,b.Y);
  }
  bool operator > (const P a, const P b) {
    return NE(a.X,b.X) ? GT(a.X,b.X) : GT(a.Y,b.Y);
  }
  bool sort_y(const P a, const P b) {
    return LT(a.Y,b.Y);
  }
  void swap(P& a, P& b) {
    P c = a; a = b; b = c;
  }
}

// 内積
D dot(P a, P b) {
  return (conj(a)*b).X;
}
// 外積
D cross(P a, P b) {
  return (conj(a)*b).Y;
}
// 点aから見た、点bから点cへの方向
int ccw(P a, P b, P c) {
  b -= a; c -= a;
  if (GT(cross(b,c),0)) return +1;  // counter clockwise
  if (LT(cross(b,c),0)) return -1;  // clockwise
  if (LT(dot(b,c),0)) return +2;  // c--a--b on line
  if (LT(norm(b),norm(c))) return -2; // a--b--c on line or a==b
  return 0;                     // a--c--b on line or a==c or b==c
}

// 多角形の内部判定 O(n)
// 点が領域内部なら1、境界上なら2、外部なら0を返す
int inPolygon(const VP& ps, P p) {
  int n = ps.size();
  bool in = false;
  rep (i,n) {
    P a = ps[i]-p;
    P b = ps[(i+1)%n]-p;
    if (EQ(cross(a,b),0) && LE(dot(a,b),0)) return 2;
    if (GT(a.Y,b.Y)) swap(a,b);
    if ((LT(a.Y*b.Y,0) || (LE(a.Y*b.Y,0) && GT(b.Y,0))) && LE(cross(a,b),0)) in = !in;
  }
  return in;
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(false);
  cout << fixed << setprecision(10);

  int N;
  while (cin >> N, N) {
    vector<int> vx,vy;
    VP ps(N), qs(4);
    REP(i,N) {
      cin >> ps[i];
      vx.push_back(ps[i].X);
      vy.push_back(ps[i].Y);
    }
    REP(i,4) {
      cin >> qs[i];
      vx.push_back(qs[i].X);
      vy.push_back(qs[i].Y);
    }
    UNI(vx);
    UNI(vy);
    int ans = 0;
    for (int i = 0; i+1 < vx.size(); i++) {
      for (int j = 0; j+1 < vy.size(); j++) {
        int dx = vx[i+1] - vx[i];
        int dy = vy[j+1] - vy[j];
        P p(vx[i]+dx/2.0,vy[j]+dy/2.0);
        if (inPolygon(ps,p) && !inPolygon(qs,p)) {
          ans += dx*dy;
        }
      }
    }
    cout << ans << endl;
  }

  return 0;
}


Measured memory_bytes: 3144