#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


template <class T> void bAdd(vector<T> &bit, int pos, const T &val) {
  const int bitN = bit.size();
  for (int x = pos; x < bitN; x |= x + 1) bit[x] += val;
}
template <class T> T bSum(const vector<T> &bit, int pos) {
  T ret = 0;
  for (int x = pos; x > 0; x &= x - 1) ret += bit[x - 1];
  return ret;
}
template <class T> T bSum(const vector<T> &bit, int pos0, int pos1) {
  return bSum(bit, pos1) - bSum(bit, pos0);
}


struct Seg {
  Int x0, x1, y0, y1;
  friend ostream &operator<<(ostream &os, const Seg &f) {
    return os << "[" << f.x0 << "," << f.x1 << "]*[" << f.y0 << "," << f.y1 << "]";
  }
  bool contains(Int x, Int y) const {
    return (x0 <= x && x <= x1 && y0 <= y && y <= y1);
  }
};

int Subtask;
Int M, N;
int Q;
vector<int> T;
vector<Int> X0, X1, Y0, Y1;

int main() {
  for (; ~scanf("%d", &Subtask); ) {
    scanf("%lld%lld%d", &M, &N, &Q);
    T.resize(Q);
    X0.resize(Q);
    X1.resize(Q);
    Y0.resize(Q);
    Y1.resize(Q);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%lld%lld%lld%lld", &T[q], &X0[q], &Y0[q], &X1[q], &Y1[q]);
if(T[q]==3)assert(X0[q]<=X1[q]);
      if (make_pair(X0[q], Y0[q]) > make_pair(X1[q], Y1[q])) {
        swap(X0[q], X1[q]);
        swap(Y0[q], Y1[q]);
      }
      assert(1 <= X0[q]); assert(X0[q] <= X1[q]); assert(X1[q] <= M);
      assert(1 <= Y0[q]); assert(Y0[q] <= Y1[q]); assert(Y1[q] <= N);
      switch (T[q]) {
        case 1: assert(Y0[q] == Y1[q]); break;
        case 2: assert(X0[q] == X1[q]); break;
        case 3: assert(Y0[q] - X0[q] == Y1[q] - X1[q]); break;
        default: assert(false);
      }
    }
    
    // remove overlap
    vector<Seg> fss[4];
    for (int q = 0; q < Q; ++q) {
      fss[T[q]].push_back(Seg{X0[q], X1[q], Y0[q], Y1[q]});
    }
    {
      sort(fss[1].begin(), fss[1].end(), [&](const Seg &f, const Seg &g) -> bool {
        return (make_pair(f.y0, f.x0) < make_pair(g.y0, g.x0));
      });
      vector<Seg> gs;
      for (const Seg &f : fss[1]) {
        if (!gs.empty() && gs.back().y0 == f.y0 && gs.back().x1 >= f.x0) {
          chmax(gs.back().x1, f.x1);
        } else {
          gs.push_back(f);
        }
      }
      fss[1].swap(gs);
    }
    {
      sort(fss[2].begin(), fss[2].end(), [&](const Seg &f, const Seg &g) -> bool {
        return (make_pair(f.x0, f.y0) < make_pair(g.x0, g.y0));
      });
      vector<Seg> gs;
      for (const Seg &f : fss[2]) {
        if (!gs.empty() && gs.back().x0 == f.x0 && gs.back().y1 >= f.y0) {
          chmax(gs.back().y1, f.y1);
        } else {
          gs.push_back(f);
        }
      }
      fss[2].swap(gs);
    }
    {
      sort(fss[3].begin(), fss[3].end(), [&](const Seg &f, const Seg &g) -> bool {
        return (make_pair(f.y0 - f.x0, f.x0) < make_pair(g.y0 - g.x0, g.x0));
      });
      vector<Seg> gs;
      for (const Seg &f : fss[3]) {
        if (!gs.empty() && gs.back().y0 - gs.back().x0 == f.y0 - f.x0 && gs.back().x1 >= f.x0) {
          chmax(gs.back().x1, f.x1);
          chmax(gs.back().y1, f.y1);
        } else {
          gs.push_back(f);
        }
      }
      fss[3].swap(gs);
    }
// for(int t=1;t<=3;++t)cerr<<"fss["<<t<<"] = "<<fss[t]<<endl;
    
    Int ans = 0;
    
    // +1, +2, +3
    for (int t = 1; t <= 3; ++t) {
      for (const Seg &f : fss[t]) {
        ans += max(f.x1 - f.x0 + 1, f.y1 - f.y0 + 1);
      }
    }
    
    // -12
    {
      Int ans12 = 0;
      vector<Int> ys;
      for (const Seg &f : fss[1]) {
        ys.push_back(f.y0);
      }
      sort(ys.begin(), ys.end());
      ys.erase(unique(ys.begin(), ys.end()), ys.end());
      const int ysLen = ys.size();
      vector<pair<Int, pair<int, pair<Int, Int>>>> es;
      for (const Seg &f : fss[1]) {
        es.emplace_back(f.x0, make_pair(0, make_pair(f.y0, f.y1)));
        es.emplace_back(f.x1, make_pair(2, make_pair(f.y0, f.y1)));
      }
      for (const Seg &f : fss[2]) {
        es.emplace_back(f.x0, make_pair(1, make_pair(f.y0, f.y1)));
      }
      sort(es.begin(), es.end());
      vector<int> bit(ysLen, 0);
      for (const auto &e : es) {
        const Int y0 = e.second.second.first;
        const Int y1 = e.second.second.second;
        switch (e.second.first) {
          case 0: {
            const int pos = lower_bound(ys.begin(), ys.end(), y0) - ys.begin();
            bAdd(bit, pos, +1);
          } break;
          case 1: {
            const int pos0 = lower_bound(ys.begin(), ys.end(), y0) - ys.begin();
            const int pos1 = upper_bound(ys.begin(), ys.end(), y1) - ys.begin();
            ans12 += bSum(bit, pos0, pos1);
          } break;
          case 2: {
            const int pos = lower_bound(ys.begin(), ys.end(), y0) - ys.begin();
            bAdd(bit, pos, -1);
          } break;
          default: assert(false);
        }
      }
// cerr<<"ans12 = "<<ans12<<endl;
      ans -= ans12;
    }
    
    // -13, -23, +123
    {
      Int ans3 = 0;
      vector<pair<Int, Int>> ps;
      for (const Seg &f : fss[1]) for (const Seg &g : fss[3]) {
        const Int y = f.y0;
        const Int x = y - (g.y0 - g.x0);
        if (f.contains(x, y) && g.contains(x, y)) {
          ps.emplace_back(x, y);
        }
      }
      for (const Seg &f : fss[2]) for (const Seg &g : fss[3]) {
        const Int x = f.x0;
        const Int y = x + (g.y0 - g.x0);
        if (f.contains(x, y) && g.contains(x, y)) {
          ps.emplace_back(x, y);
        }
      }
      sort(ps.begin(), ps.end());
      const int psLen = ps.size();
// cerr<<"ps = "<<ps<<endl;
      for (int i = 0, j = 0; i < psLen; i = j) {
        for (; j < psLen && ps[i] == ps[j]; ++j) {}
        assert(j - i == 1 || j - i == 2);
        ++ans3;
      }
// cerr<<"ans3 = "<<ans3<<endl;
      ans -= ans3;
    }
    
    printf("%lld\n", ans);
  }
  return 0;
}