/*
TASK: area
LANG: C++
*/

#include <cstdio>
#include <cmath>
#include <iostream>
#include <fstream>
#include <algorithm>

#define MAX 16384
#define in cin

using namespace std;

int n, m;
int aaa[MAX][4];
double a[MAX][4];
double xd, yd, xu, yu;
double px, py;
double p[MAX][2]; int cnt;
double hull[MAX][2]; int cc;
double h[MAX][2]; int counter;
int partof[MAX][2];

//ifstream(in);// ofstream(out);
FILE *out;



/* ============================== */
/*        Hull Sort Function      */
/* ============================== */

int hullsort(const void *a, const void *b)
{
double *aa; double * bb;

aa = (double*) a; 
bb = (double*) b;

if (aa[0] != bb[0])
   {
   if (aa[0] > bb[0]) return 1;
   else return -1;
   }
else
   {
   if (aa[1] > bb[1]) return 1;
   else return -1;
   }

return 0;
}

/* ============================== */
/* ============================== */




/* ============================== */
/*        Find Area Functions     */
/* ============================== */


/* For floating point coordinates */

double doublefindarea(double x1, double y1, double x2, double y2, double x3, double y3)
{
double area;

area  = 0;
area += (x1 * y2) + (x2 * y3) + (x3 * y1);
area -= (x1 * y3) + (x2 * y1) + (x3 * y2);

return area;
}

/* For integer coordinates */

int findarea(int x1, int y1, int x2, int y2, int x3, int y3)
{
int area;

area  = 0;
area += (x1 * y2) + (x2 * y3) + (x3 * y1);
area -= (x1 * y3) + (x2 * y1) + (x3 * y2);

return area;
}

/* ============================== */
/* ============================== */




/* ============================== */
/*      Line Crossing Function    */
/* ============================== */

int dequal(double a1, double a2)
{
if (fabs(a1 - a2) < 0.0000001) return 1;
else return 0;
}

int dequal2(double a1, double a2)
{
if (fabs(a1 - a2) < 0.001) return 1;
else return 0;
}


int crossing(int a1, int a2)
{
int area1, area2;

area1 = findarea(a[a1][0], a[a1][1], a[a1][2], a[a1][3], a[a2][0], a[a2][1]);
area2 = findarea(a[a1][0], a[a1][1], a[a1][2], a[a1][3], a[a2][2], a[a2][3]);

if (area1 < 0 && area2 < 0) return 0;
if (area1 > 0 && area2 > 0) return 0;


area1 = findarea(a[a2][0], a[a2][1], a[a2][2], a[a2][3], a[a1][0], a[a1][1]);
area2 = findarea(a[a2][0], a[a2][1], a[a2][2], a[a2][3], a[a1][2], a[a1][3]);

if (area1 < 0 && area2 < 0) return 0;
if (area1 > 0 && area2 > 0) return 0;

return 1;
}

int doublecrossing (double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
double area1, area2;

area1 = doublefindarea(x1, y1, x2, y2, x3, y3);
area2 = doublefindarea(x1, y1, x2, y2, x4, y4);

if (area1 < 0 && area2 < 0) return 0;
if (area1 > 0 && area2 > 0) return 0;


area1 = doublefindarea(x3, y3, x4, y4, x1, y1);
area2 = doublefindarea(x3, y3, x4, y4, x2, y2);

if (area1 < 0 && area2 < 0) return 0;
if (area1 > 0 && area2 > 0) return 0;

return 1;
}

int doublecrossing2 (double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
double area1, area2;

area1 = doublefindarea(x1, y1, x2, y2, x3, y3);
area2 = doublefindarea(x1, y1, x2, y2, x4, y4);

if (dequal2(area1, 0.0) || dequal2(area2, 0.0)) return 0;
if (area1 < 0 && area2 < 0) return 0;
if (area1 > 0 && area2 > 0) return 0;


area1 = doublefindarea(x3, y3, x4, y4, x1, y1);
area2 = doublefindarea(x3, y3, x4, y4, x2, y2);

if (dequal2(area1, 0.0) || dequal2(area2, 0.0)) return 0;
if (area1 <= 0 && area2 <= 0) return 0;
if (area1 >= 0 && area2 >= 0) return 0;

return 1;
}

/* ============================== */
/* ============================== */




/* ============================== */
/*       Make Graph Functions     */
/* ============================== */



pair <double, double> addpoint(int a1, int a2)
{
int i, crs;
double lx, ly, rx, ry, mx, my;
double plx, ply, prx, pry, area;

pair <double, double> p;
int sign;


lx = (double)a[a2][0]; ly = (double)a[a2][1];
rx = (double)a[a2][2]; ry = (double)a[a2][3];

plx = (double)a[a1][0]; ply = (double)a[a1][1];
prx = (double)a[a1][2]; pry = (double)a[a1][3];

mx = (lx + rx) / 2.0; my = (ly + ry) / 2.0;
if (doublefindarea(plx, ply, prx, pry, mx, my) > 0) sign = 1;
else sign = -1;

while (!dequal(lx, rx) || !dequal(ly, ry))
      {
      mx = (lx + rx) / 2.0;
      my = (ly + ry) / 2.0;
      
      crs = doublecrossing(plx, ply, prx, pry, lx, ly, mx, my);
      if (crs) {rx = mx, ry = my; continue;}
      else {lx = mx; ly = my; continue;}
      
/*      
      area = doublefindarea(plx, ply, prx, pry, mx, my);
      
      if (sign > 0)
         {
         if (area < 0) {lx = mx; ly = my; continue;}
         else {rx = mx; ry = my; continue;}
         }
      else
         {
         if (area > 0) {lx = mx; ly = my; continue;}
         else {rx = mx; ry = my; continue;}
         }
*/
      }

p.first = lx; p.second = ly;

return p;
}


void createpoints(void)
{
int i, c;
pair <double, double> crosspoint;


for (i=0; i<n-1; i++)
    {
    for (c=i+1; c<n; c++)
        {
        if (doublecrossing(a[i][0], a[i][1], a[i][2], a[i][3], a[c][0], a[c][1], a[c][2], a[c][3]))
           {
           crosspoint = addpoint(i, c);
           p[cnt][0] = crosspoint.first;
           p[cnt][1] = crosspoint.second;
           cnt++;
           
           partof[cnt-1][0] = i; partof[cnt-1][1] = c;
/*           
           out << "Lines with coordinates (" << a[i][0] << "; " << a[i][1] << "), (" << a[i][2] << "; " << a[i][3]
               << ") and (" << a[c][0] << "; " << a[c][1] << "), (" << a[c][2] << "; " << a[c][3] << ") are being crossed." << endl;
           
           out << "Point of crossing: " << p[cnt-1][0] << " " << p[cnt-1][1] << endl << endl;
*/           
           }
        }
    }

//out << endl << "There are " << cnt << " crossing points with coordinates:" << endl;
//for (i=0; i<cnt; i++) out << p[i][0] << " " << p[i][1] << endl;

return;
}


void addtograph(void)
{
a[n][0] = xd; a[n][1] = yd; a[n][2] = xd; a[n][3] = yu; n++;
a[n][0] = xd; a[n][1] = yd; a[n][2] = xu; a[n][3] = yd; n++;
a[n][0] = xd; a[n][1] = yu; a[n][2] = xu; a[n][3] = yu; n++;
a[n][0] = xu; a[n][1] = yd; a[n][2] = xu; a[n][3] = yu; n++;

return;
}


void determinepoints(void)
{
int i, c;
int flag;

cc = 0;

for (i=0; i<cnt; i++)
    {
    flag = 1;
    for (c=0; c<n; c++) if (partof[i][0] != c)
        {
        if (doublecrossing2((double)px, (double)py, p[i][0], p[i][1], 
           (double)a[c][0], (double)a[c][1], (double)a[c][2], (double)a[c][3]))
                            {flag = 0; break;}
        }
    if (flag) {hull[cc][0] = p[i][0]; hull[cc][1] = p[i][1]; cc++;}
//    out << "For point " << p[i][0] << " " << p[i][1] << " flag is: " << flag 
//        << " crossed with line " << a[c][0] << " " << a[c][1] << "; " << a[c][2] << " " << a[c][3] << endl;
    }

//out << "There is a hull with " << cc << " points:" << endl;
//for (i=0; i<cc; i++) out << hull[i][0] << " " << hull[i][1] << endl;

return;
}


/* ============================== */
/* ============================== */



/* ============================== */
/*    Make Hull and Find Answer   */
/* ============================== */

void makehull(void)
{
int i;
double h1[MAX][2]; int c1;
double h2[MAX][2]; int c2;

qsort(hull, cc, sizeof(hull[0]), hullsort);

h1[0][0] = hull[0][0]; h1[0][1] = hull[0][1]; c1 = 1;
h1[1][0] = hull[1][0]; h1[1][1] = hull[1][1]; c1 = 2;

for (i=2; i<cc; i++)
    {
    h1[c1][0] = hull[i][0]; h1[c1][1] = hull[i][1]; c1++;
    
    while (c1 > 2 && doublefindarea(h1[c1-3][0], h1[c1-3][1], h1[c1-2][0], h1[c1-2][1], h1[c1-1][0], h1[c1-1][1]) > 0)
          {
          h1[c1-2][0] = h1[c1-1][0]; h1[c1-2][1] = h1[c1-1][1]; c1--;
          }
    }

for (i=0; i<c1; i++) {h[counter][0] = h1[i][0]; h[counter][1] = h1[i][1]; counter++;}// out << "Hull point: " << h1[i][0] << " " << h1[i][1] << endl;}


h2[0][0] = hull[0][0]; h2[0][1] = hull[0][1]; c2 = 1;
h2[1][0] = hull[1][0]; h2[1][1] = hull[1][1]; c2 = 2;

for (i=2; i<cc; i++)
    {
    h2[c2][0] = hull[i][0]; h2[c2][1] = hull[i][1]; c2++;
    
    while (c2 > 2 && doublefindarea(h2[c2-3][0], h2[c2-3][1], h2[c2-2][0], h2[c2-2][1], h2[c2-1][0], h2[c2-1][1]) < 0)
          {
          h2[c2-2][0] = h2[c2-1][0]; h2[c2-2][1] = h2[c2-1][1]; c2--;
          }
    }


i = c2-1;
if (h1[c1-1][0] == h2[i][0] && h1[c1-1][1] == h2[i][1]) i--;

for (; i>0; i--) {h[counter][0] = h2[i][0]; h[counter][1] = h2[i][1]; counter++;}

return;
}


void findanswer(void)
{
int i;
double answer, cur;
int ans;

//out << endl;

cur = fabs(doublefindarea((double)px, (double)py, h[0][0], h[0][1], h[counter-1][0], h[counter-1][1]));
//out << "For points " << h[0][0] << " " << h[0][1] << "; " << h[counter-1][0] << " " << h[counter-1][1] << " area is: " << cur << endl;
answer = cur;

for (i=0; i<counter-1; i++) 
    {
    cur = fabs(doublefindarea((double)px, (double)py, h[i][0], h[i][1], h[i+1][0], h[i+1][1]));
//    out << "For points " << h[i][0] << " " << h[i][1] << "; " << h[i+1][0] << " " << h[i+1][1] << " area is: " << cur << endl;
    answer += cur;
    }

/*
answer = fabs(doublefindarea((double)px, (double)py, h[0][0], h[0][1], h[counter-1][0], h[counter-1][1]));
for (i=0; i<counter-1; i++) answer += fabs(doublefindarea((double)px, (double)py, h[i][0], h[i][1], h[i+1][0], h[i+1][1]));
*/

//out << answer << endl;
//out << (int)round(answer/2.0) << endl;

if (dequal2((answer / 2.0)-floor(answer/2.0), (double)1.0)) ans = (int)(round)(answer/2.0);
else ans = (int) floor(answer/2.0);

fprintf(out, "%d\n", ans);

return;
}

/* ============================== */
/* ============================== */




/* ============================== */
/*     Main and Input Functions   */
/* ============================== */


void input(void)
{
int i;
double t1, t2;
double coefficient;
double xx1, yy1, xx2, yy2;

memset(a, 0, sizeof(a));
memset(p, 0, sizeof(p));

in >> xd >> yd >> xu >> yu;
in >> px >> py;
in >> n;
for (i=0; i<n; i++) 
    {
    in >> a[i][0] >> a[i][1] >> a[i][2] >> a[i][3];
    if (a[i][0] >= a[i][2])
       {
       if (a[i][0] == a[i][2] && a[i][1] <= a[i][3]) continue;
       t1 = a[i][0]; t2 = a[i][1];
       a[i][0] = a[i][2]; a[i][1] = a[i][3];
       a[i][2] = t1; a[i][3] = t2;
       }
    }

for (i=0; i<n; i++)
    {
    if (a[i][0] == a[i][2])
       {
       a[i][1] = xd - 100; a[i][3] = xu + 100;
       continue;
       }
    else coefficient = (double)((double)(a[i][3]-a[i][1]) / (double)(a[i][2] - a[i][0]));
    
    xx1 = a[i][0]; yy1 = a[i][1];
    xx2 = a[i][2]; yy2 = a[i][3];
    
    if (a[i][0] > xd)
       {
       xx1 = xd - 100;
       yy1 = a[i][1] - (coefficient * (double)(a[i][0] - (xd - 100)));
       }
    if (a[i][2] < xu)
       {
       xx2 = xu + 100;
       yy2 = a[i][3] + (coefficient * (double)((xu + 100) - a[i][2]));
       }
    
    a[i][0] = xx1; a[i][1] = yy1;
    a[i][2] = xx2; a[i][3] = yy2;
    }

return;
}


int main(void)
{

//in.open("area.in");// out.open("area.out");
//out = fopen("area.out", "wt");

out = stdout;

input();
addtograph();
createpoints();
determinepoints();
makehull();
findanswer();

return 0;
}

