/*
TASK:area
LANG:C
*/

#include <stdio.h>
#include <math.h>
#include <stdlib.h>

typedef struct PTRPOINT
{
  double x, y;
} point;

typedef struct STRLINE
{
  double a, b, c;
} line;

short N, lnsCnt, ptsCnt, arCnt, convCnt;
point T, A, B, C, D, pts[500], area[500], convex[500];
line lines[54];

inline int eps(double x)
{
  return fabs(x)<1e-7;
}

inline int ccw(const point a, const point b, const point c)
{
  static double t;
  t=a.x*b.y + b.x*c.y + c.x*a.y - c.x*b.y - b.x*a.y - a.x*c.y;
  return  t>0 && !eps(t);
}

inline double ds(const point a, const point b, const point c)
{
  return fabs(a.x*b.y + b.x*c.y + c.x*a.y - c.x*b.y - b.x*a.y - a.x*c.y); 
}

int cmpPnt(const void *a, const void *b)
{
  static point *p1, *p2;
  p1=(point*)a;
  p2=(point*)b;
  if(eps(p1->y-p2->y))
  {
    if(eps(p1->x-p2->x))
      return 0;
    if(p1->x<p2->x)
      return -1;
    return 1;
  }  
  if(p1->y<p2->y)
    return -1;
  return 1;
}

line *linePts(line *l, const point *a, const point *b)
{
  if(a->y==b->y)
  {
    l->b=1;
    l->a=0;
  }
  else
  {
    l->a=1;
    l->b=l->a*(a->x-b->x)/(b->y-a->y);
  }
  l->c=l->a*a->x+l->b*a->y;
  return l;
}

int ptLns(point *pt, const line *a, const line *b)
{
  static double D;
  D=a->a*b->b-b->a*a->b;
  if(eps(D))
    return 0;
  pt->x=(a->c*b->b-b->c*a->b)/D;
  pt->y=(a->a*b->c-b->a*a->c)/D;
  return 1;
}

int same(const line *a, const point *P)
{
  static double r1, r2;
  r1=a->a*T.x+a->b*T.y-a->c;
  r2=a->a*P->x+a->b*P->y-a->c;
  if(eps(r2) || r1*r2>0)
    return 1;
  return 0;
}

void input(void)
{
  double x1, x2, y1, y2;
  FILE *fp;
  point P, Q;
  fp=stdin;//fopen("area.txt", "rt");
  fscanf(fp, "%lf %lf %lf %lf %lf %lf", &x1, &y1, &x2, &y2, &T.x, &T.y);
  A.x=x1;
  A.y=y1;
  B.x=x2;
  B.y=y1;
  C.x=x2;
  C.y=y2;
  D.x=x1;
  D.y=y2;
  linePts(lines, &A, &B);
  linePts(&lines[1], &B, &C);
  linePts(&lines[2], &C, &D);
  linePts(&lines[3], &D, &A);
  fscanf(fp, "%hd", &N);
  for(lnsCnt=4; lnsCnt<N+4; ++lnsCnt)
  {
    fscanf(fp, "%lf %lf %lf %lf", &P.x, &P.y, &Q.x, &Q.y);
    linePts(&lines[lnsCnt], &P, &Q);
  }
  fclose(fp);
}

void buildPts(void)
{
  short i, j;
  for(i=ptsCnt=0; i<lnsCnt; ++i)
    for(j=i+1; j<lnsCnt; ++j)
      if(ptLns(&pts[ptsCnt], &lines[i], &lines[j]))
        ++ptsCnt;      
}

void buildArea(void)
{
  char fl;
  short i, j;
  for(i=arCnt=0; i<ptsCnt; ++i)
  {
    for(j=fl=0; j<lnsCnt; ++j)
      if(!same(&lines[j], &pts[i]))
        fl=1;
    if(!fl)
      area[arCnt++]=pts[i];
  }
}

void buildConvex(void)
{
  short i;
  qsort(area, arCnt, sizeof(point), cmpPnt);
  convex[0]=area[0];
  convex[1]=area[1];
  for(convCnt=i=2; i<arCnt; )
  {
    while(convCnt>1 && ccw(convex[convCnt-2], convex[convCnt-1], area[i]))
      --convCnt;
    convex[convCnt++]=area[i];
    for(++i; i<arCnt && eps(area[i].y-area[i-1].y); ++i);
  }
  --i;
  if(eps(area[i].x-convex[convCnt-1].x) && eps(area[i].y-convex[convCnt-1].y))
    for(--i; i>=0 && eps(area[i].y-area[i+1].y); --i);
  while(i>=0)
  {
    while(convCnt>1 && ccw(convex[convCnt-2], convex[convCnt-1], area[i]))
      --convCnt;
    convex[convCnt++]=area[i];
    for(--i; i>=0 && eps(area[i].y-area[i+1].y); --i);
  }
  if(eps(convex[0].x-convex[convCnt-1].x) && eps(convex[0].y-convex[convCnt-1].y))
    convCnt--;
}

double surf(void)
{
  short i;
  double res=0;
  for(i=2; i<convCnt; ++i)
    res+=ds(convex[0], convex[i-1], convex[i]);
  return res/2;
}

int main(void)
{
  input();
  buildPts();
  buildArea();
  buildConvex();
  if(convCnt<3)
    printf("0\n");
  else
    printf("%.0lf\n", floor(surf()));
  return 0;
}

