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

#define MAXN 300

struct policka {
  int level;
  int length;
  int leftPeg;
  int rightPeg;

  int place_cost;
  int place_pegs;
  int place_state;
  
  int support_cost;
  int support_pegs;
  int support_state;
  int i;
} _policky [MAXN];


#define PLACE_NO_PROBLEM 0
#define PLACE_L_RIGHT_BOUND 1
#define PLACE_L_PADA 2
#define PLACE_L_PEG 3
#define PLACE_L_PEG_RIGHT_BOUND 4
#define PLACE_INSIDE 5
#define PLACE_R_PEG_LEFT_BOUND 6
#define PLACE_R_PEG 7
#define PLACE_R_PADA 8
#define PLACE_R_LEFT_BOUND 9

#define NOP 12345



#define SUPPORT_PRE 100
#define SUPPORT_L_PEG 101
#define SUPPORT_NO_PEG 102
#define SUPPORT_R_PEG 103
#define SUPPORT_POST 104
#define CAN_SUPPORT(state) (((state) != SUPPORT_PRE) && ((state) != SUPPORT_POST))


#if 0
#define DEBUG(x...) (printf (x))
#else
#define DEBUG(x...) (0)
#endif

struct akce {
  int typ;
  int x;
  int pre;
  int arg;
  struct policka* policka;
} _akce [MAXN * 20];

#define MOC (1000 * 1000 * 100)

int optPegs, optCost;



int XN, YN, XT, YT;
int N;
int maxSupportHeight;


struct policka * policky[MAXN];
struct akce  * akce[MAXN * 20];

int nAkci;



void add (int i, int level, int len, int peg1, int peg2) {
  /* pridej do seznamu. */
  int pulka = len/2;
  int malapulka = pulka;
  if (malapulka > peg2 - peg1)
    malapulka = peg2 - peg1;

  _policky[i].level = level;
  _policky[i].length = len;     /* tyhle 3 prirazeni jsou k nicemu */
  _policky[i].leftPeg = peg1;
  _policky[i].rightPeg = peg2;
  _policky[i].i = i;

  _policky[i].place_state = PLACE_NO_PROBLEM;
  _policky[i].place_cost = 0;
  _policky[i].place_pegs = 0;

  _policky[i].support_state = SUPPORT_PRE;
  _policky[i].support_cost = 0;
  _policky[i].support_pegs= 0;

  /* pridej support. */

  if (len >= XT)
  {
    int max = peg1 + len - XT;
    int min = peg2 - len;
    int nol = peg1 - pulka;
    int nor = peg2 + pulka - XT;
    int rfall = peg2 + pulka - XT;
    int lfall = peg1 - pulka;
    

    if (nol < min)
      nol = min;
    if (nol < lfall)
      nol = lfall;

    if (nor > max)
      nor = max;
    if (nor > rfall)
      nor = rfall;

    if (min < nol) {
      _akce[nAkci].typ = SUPPORT_L_PEG;
      _akce[nAkci].x = min;
      _akce[nAkci].pre = 1;
      _akce[nAkci].policka = _policky + i;
      nAkci++;
    }
    
    _akce[nAkci].typ = SUPPORT_NO_PEG;
    _akce[nAkci].x = nol;
    _akce[nAkci].pre = 1;
    _akce[nAkci].policka = _policky + i;
    nAkci++;
    
    if (nor < max) {
      _akce[nAkci].typ = SUPPORT_R_PEG;
      _akce[nAkci].x = nor;
      _akce[nAkci].pre = 0;
      _akce[nAkci].policka = _policky + i;
      nAkci++;
    }
    
    _akce[nAkci].typ = SUPPORT_POST;
    _akce[nAkci].x = max;
    _akce[nAkci].pre = 0;
    _akce[nAkci].policka = _policky + i;
    nAkci++;
  }

  /* pridej place. */
  {
    /* 1. zadne pegy se neodstranuji. */
    int lfall = peg2 - len + pulka - XT;
    int lrbound = XN - len - XT;

    if (lrbound < lfall && lrbound < peg1 - XT) {
      _akce[nAkci].typ = PLACE_L_RIGHT_BOUND;
      _akce[nAkci].x = lrbound;
      _akce[nAkci].pre = 0;
      _akce[nAkci].policka = _policky + i;
      _akce[nAkci++].arg = 0;
    }

    if (lfall < peg1 - XT) {
      _akce[nAkci].typ = PLACE_L_PADA;
      _akce[nAkci].x = lfall;
      _akce[nAkci].pre = 0;
      _akce[nAkci].policka = _policky + i;
      _akce[nAkci++].arg = 0; 
    }

  }

  {
    /* 2. 1 peg se dava pryc */
    int pegbound = XN - len - XT;
    if (pegbound < peg1 - XT)
      pegbound = peg1 - XT;

    if (peg1 - XT < pegbound) {
      _akce[nAkci].typ = PLACE_L_PEG;
      _akce[nAkci].x = peg1 - XT;
      _akce[nAkci].pre = 0;
      _akce[nAkci].policka = _policky + i;
      _akce[nAkci++].arg = 0;
    }

    if (pegbound < peg2 - XT) {
      _akce[nAkci].typ = PLACE_L_PEG_RIGHT_BOUND;
      _akce[nAkci].x = pegbound;
      _akce[nAkci].pre = 0;
      _akce[nAkci].policka = _policky + i;
      _akce[nAkci++].arg = len - (XN - XT - pegbound);
    }
  }
  
  /* 3. prostredek */
  if (len < XT) {
    /* vyhodit cele */ 
    _akce[nAkci].typ = PLACE_INSIDE;
    _akce[nAkci].x = peg2 - XT;
    _akce[nAkci].pre = 0;
    _akce[nAkci].policka = _policky + i;
    _akce[nAkci++].arg = len;
  } else {
    /* najit misto, kde se to rozdeli. */
    int peglbound = XN - len - XT;
    int pegrbound = len;
    int avg = XN / 2;

    DEBUG (">>> policka %d, %d, %d, %d\n", i, peglbound, pegrbound, avg);
    
    if (peglbound < avg && peglbound >= peg2 - XT) {
      _akce[nAkci].typ = PLACE_L_PEG_RIGHT_BOUND;
      _akce[nAkci].x = peglbound;
      _akce[nAkci].pre = 0;
      _akce[nAkci].policka = _policky + i;
      _akce[nAkci++].arg = len - (XN - XT - peglbound);
    }

    if (avg > pegrbound) {
      _akce[nAkci].typ = PLACE_R_PEG;
      _akce[nAkci].x = avg;
      _akce[nAkci].pre = 0;   /* !!! */
      _akce[nAkci].policka = _policky + i;
      _akce[nAkci++].arg = 0;
    }

    if (pegrbound < peg1) {
      int delta = pegrbound;
      if (delta < peg1)
        delta = peg1;
      if (avg > delta)
        delta = avg;

      _akce[nAkci].typ = PLACE_R_PEG_LEFT_BOUND;
      _akce[nAkci].x = delta;
      _akce[nAkci].pre = 0; /* !!! */
      _akce[nAkci].policka = _policky + i;
      _akce[nAkci++].arg = len - delta;
    }
  }

  /* 4. pravy peg. (x >= peg1)*/
  {
    /* int lbound = len; */
    if (peg1 < len) {
      _akce[nAkci].typ = PLACE_R_PEG_LEFT_BOUND;
      _akce[nAkci].x = peg1;
      _akce[nAkci].pre = 0;    /* !!! */
      _akce[nAkci].policka = _policky + i;
      _akce[nAkci++].arg = len - peg1;
    }

    if (len < peg2) {
      int max = len;
      if (max < peg1)
        max = peg1;
      _akce[nAkci].typ = PLACE_R_PEG;
      _akce[nAkci].x = max;
      _akce[nAkci].pre = 0;   /* !!! */
      _akce[nAkci].policka = _policky + i;
      _akce[nAkci++].arg = 0;
    }
  }

  /* 5. no pegs, right */
  {
    int rbound = len;
    int rfall = peg1 + len - pulka;

    if (peg2 < rfall || peg2 < rbound) {

      if (peg2 < rfall && rfall < rbound) {
        _akce[nAkci].typ = PLACE_R_PADA;
        _akce[nAkci].x = peg2;
        _akce[nAkci].pre = 1;
        _akce[nAkci].policka = _policky + i;
        _akce[nAkci++].arg = len - 2 * malapulka;

        _akce[nAkci].typ = PLACE_R_LEFT_BOUND;
        _akce[nAkci].x = rfall;
        _akce[nAkci].pre = 1;
        _akce[nAkci].policka = _policky + i;
        _akce[nAkci++].arg = len - peg2;

        _akce[nAkci].typ = PLACE_NO_PROBLEM;
        _akce[nAkci].x = rbound;
        _akce[nAkci].pre = 1;
        _akce[nAkci].policka = _policky + i;
        _akce[nAkci++].arg = 0;

      } else if (peg2 < rfall) {
        _akce[nAkci].typ = PLACE_R_PADA;
        _akce[nAkci].x = peg2;
        _akce[nAkci].pre = 1;
        _akce[nAkci].policka = _policky + i;
        _akce[nAkci++].arg = len - 2 * malapulka;

        _akce[nAkci].typ = PLACE_NO_PROBLEM;
        _akce[nAkci].x = rfall;
        _akce[nAkci].pre = 1;
        _akce[nAkci].policka = _policky + i;
        _akce[nAkci++].arg = 0;

      } else { 
        /* peg2 < rbound */
        _akce[nAkci].typ = PLACE_R_LEFT_BOUND;
        _akce[nAkci].x = peg2;
        _akce[nAkci].pre = 1;
        _akce[nAkci].policka = _policky + i;
        _akce[nAkci++].arg = len - peg2;

        _akce[nAkci].typ = PLACE_NO_PROBLEM;
        _akce[nAkci].x = rbound;
        _akce[nAkci].pre = 1;
        _akce[nAkci].policka = _policky + i;
        _akce[nAkci++].arg = 0;
      }
        
    } else {
      _akce[nAkci].typ = PLACE_NO_PROBLEM;
      _akce[nAkci].x = peg2;
      _akce[nAkci].pre = 1;
      _akce[nAkci].policka = _policky + i;
      _akce[nAkci++].arg = 0;
    }
  }
}


void check () {
  int i;
  int j;

  int cost;
  int pegs;

  for ((i = 0), (j = 0); i < N; i++) {

    int xlev = policky[i]->level + YT;

    if (xlev > YN)
      break;

    if (i == j) {
      cost = policky[i]->place_cost;
      pegs = policky[i]->place_pegs;
      j++;
    }

    for (; (j < N) && (policky[j]->level < xlev); j++) {
      cost += policky[j]->place_cost;
      pegs += policky[j]->place_pegs;
    }

    /* remove bottom */
    cost -= policky[i]->place_cost;
    pegs -= policky[i]->place_pegs;

    if (CAN_SUPPORT(policky[i]->support_state)) {
      int xpegs = pegs + policky[i]->support_pegs;
      int xcost = cost + policky[i]->support_cost;

      if ((optPegs > xpegs) 
          || ((optPegs == xpegs) && (optCost > xcost))) {
        optCost = xcost;
        optPegs = xpegs;
        DEBUG ("Cost set to  [%d, %d], policka.level = %d, s.p. = %d, s.c. = %d\n", optPegs, optCost,
            policky[i]->level,  policky[i]->support_pegs, policky[i]->support_cost);
      }
    }
  }
}


int akceCmp (const void *aa, const void *bb) {
	struct akce **a = (struct akce**)(struct acke*)aa;
	struct akce **b = (struct akce**)(struct acke*)bb;
  if ((*a)->x == (*b)->x)
    return (*b)->pre - (*a)->pre;  /* pre jde driv :) */

  return (*a)->x - (*b)->x;
}

int polickaCmp (const void *aa, const void *bb)
{
	policka **a = (policka**)aa;
	policka **b = (policka**)bb;

  return (*a)->level - (*b)->level;
}




int main (void) {

  int i, j;
  int height, left, len, x1, x2;
  int mezera;
  struct policka *aktualni;
  int lastx, mezeraX;

  //while ( > 0)
  {
		scanf ("%d %d %d %d", &XN, &YN, &XT, &YT);
    scanf ("%d", &N);
    nAkci = 0;
    maxSupportHeight = YN - YT;

    for (i = 0; i < N ; i++) {
      scanf ("%d %d %d %d %d", &height, &left, &len, &x1, &x2);
      add (i, height, len, left+x1, left+x2);
    }

    /* add terminators */
    _akce[nAkci].x = XN - XT;
    _akce[nAkci].policka = NULL;
    _akce[nAkci].pre = 1;
    _akce[nAkci++].typ = NOP;

    _akce[nAkci].x = 0;
    _akce[nAkci].policka = NULL;
    _akce[nAkci].pre = 1;
    _akce[nAkci++].typ = NOP;

    _akce[nAkci].x = MOC;

    for (i = 0; i < N ; i++)
      policky [i] = _policky + i;

    for (i = 0; i < nAkci + 1;  i++)
      akce[i] = _akce + i;

    /* sort! */

    qsort (akce, nAkci, sizeof (struct akce *), akceCmp);
    qsort (policky, N, sizeof (struct policka *), polickaCmp);
      
    optCost = MOC;
    optPegs = MOC;
    /* go... */
    lastx = -MOC;

    mezeraX = XN - XT;

    DEBUG ("Using XN = %d, XT = %d\n", XN, XT);

    for (i = 0; i < nAkci; i++) {
      int x = akce[i]->x;

      if (x > mezeraX)
        break;

      DEBUG ("Trying %d, pre = %d, typ = %d, arg = %d", x, akce[i]->pre, akce[i]->typ, akce[i]->arg);
      if (akce[i]->policka) {
        DEBUG (", policka %d", akce[i]->policka->i);
      }
      DEBUG ("\n");

      /* prepocitat */
      if (x != lastx) {
        int delta = x - lastx;
        /* prehodnot predchozi */
        for (j = 0; j < N; j++)
          if (1)
            switch (policky[j]->place_state) {
              case PLACE_NO_PROBLEM:
              case PLACE_L_PEG:
              case PLACE_INSIDE:
              case PLACE_R_PEG:
                   /* no bonus :) */
                   break;

              case PLACE_L_PADA:
                   policky[j]->place_cost += 2 * delta;
                   break;

              case PLACE_L_RIGHT_BOUND:
                   policky[j]->place_cost += delta;
                   break;

              case PLACE_L_PEG_RIGHT_BOUND:
                   policky[j]->place_cost += delta;
                   break;

              case PLACE_R_PEG_LEFT_BOUND:
                   policky[j]->place_cost -= delta;
                   break;

              case PLACE_R_LEFT_BOUND:
                   policky[j]->place_cost -= delta;
                   break;

              case PLACE_R_PADA:
                   policky[j]->place_cost -= 2 * delta;
                   break;

              default:
                   abort ();
                   break;
            }
      }

      lastx = x;


      if (i && (akce[i-1]->x != x) && !akce[i]->pre && (x >= 0))
        check ();

      /* proved + nastav zmenenou policku */
      aktualni = akce[i]->policka;

      switch (akce[i]->typ) {
        /* no action */
        case NOP: 
                 break;

        /* support */
        case SUPPORT_L_PEG:
                 aktualni->support_pegs = 1;
                 aktualni->support_state = SUPPORT_L_PEG;
                 break;
        case SUPPORT_NO_PEG:
                 aktualni->support_pegs = 0;
                 aktualni->support_state = SUPPORT_NO_PEG;
                 break;
        case SUPPORT_R_PEG:
                 aktualni->support_pegs = 1;
                 aktualni->support_state = SUPPORT_R_PEG;
                 break;
        case SUPPORT_POST:
                 aktualni->support_pegs = 0;
                 aktualni->support_state = SUPPORT_POST;
                 break;

        /* place */
        case PLACE_NO_PROBLEM:
                 aktualni->place_pegs = 0;
                 aktualni->place_cost = 0;
                 aktualni->place_state = PLACE_NO_PROBLEM;
                 break;
        case PLACE_L_PEG:
                 aktualni->place_pegs = 1;
                 aktualni->place_cost = akce[i]->arg;
                 aktualni->place_state = PLACE_L_PEG;
                 break;
        case PLACE_INSIDE:
                 aktualni->place_pegs = 2;
                 aktualni->place_cost = akce[i]->arg;
                 aktualni->place_state = PLACE_INSIDE;
                 break;
        case PLACE_R_PEG:
                 aktualni->place_pegs = 1;
                 aktualni->place_cost = akce[i]->arg;
                 aktualni->place_state = PLACE_R_PEG;
                 break;

        case PLACE_L_PADA:
                 aktualni->place_pegs = 0;
                 aktualni->place_cost = akce[i]->arg;
                 aktualni->place_state = PLACE_L_PADA;
                 break;

        case PLACE_L_RIGHT_BOUND:
                 aktualni->place_pegs = 0;
                 aktualni->place_cost = akce[i]->arg;
                 aktualni->place_state = PLACE_L_RIGHT_BOUND;
                 break;

        case PLACE_L_PEG_RIGHT_BOUND:
                 aktualni->place_pegs = 1;
                 aktualni->place_cost = akce[i]->arg;
                 aktualni->place_state = PLACE_L_PEG_RIGHT_BOUND;
                 break;

        case PLACE_R_PEG_LEFT_BOUND:
                 aktualni->place_pegs = 1;
                 aktualni->place_cost = akce[i]->arg;
                 aktualni->place_state = PLACE_R_PEG_LEFT_BOUND;
                 break;

        case PLACE_R_LEFT_BOUND:
                 aktualni->place_pegs = 0;
                 aktualni->place_cost = akce[i]->arg;
                 aktualni->place_state = PLACE_R_LEFT_BOUND;
                 break;

        case PLACE_R_PADA:
                 aktualni->place_pegs = 0;
                 aktualni->place_cost = akce[i]->arg;
                 aktualni->place_state = PLACE_R_PADA;
                 break;


        default :
                 abort ();
                 break;
      }

      

      if ((x >= 0) && akce[i]->pre && (akce[i+1]->x != x || !akce[i+1]->pre))
        check ();
    }

    printf ("%d %d\n", optPegs, optCost);

  }
  return 0;
}
