#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
constexpr int MAXN=1e6+10;

struct query {
    int x, y1, y2, k;
    bool operator< (const query& rhs) const {
        return x<rhs.x||(x==rhs.x&&k<rhs.k);
    }
} a[MAXN];

struct slash {
    int x1, y1, x2, y2;
} s[MAXN]; int stot;

struct point {
    int x, y;
    bool operator== (const point& rhs) const {
        return x==rhs.x&&y==rhs.y;
    }
    bool operator< (const point& rhs) const {
        return x==rhs.x?y<rhs.y:x<rhs.x;
    }
};

struct hori {
    int y, x1, x2;
    bool intersect(const slash& s) const {
        int r=y+s.x1-s.y1;
        // cout<<"Horizon "<<y<<'\n';
        // cout<<r<<' '<<x1<<' '<<x2<<'\n';
        return x1<=r && r<=x2 && s.x1<=r && r<=s.x2;
    }
    point cord(const slash& s) {
        return {y+s.x1-s.y1, y};
    }
} hor[MAXN]; int htot;

struct vert {
    int x, y1, y2;
    bool intersect(const slash& s) const {
        int r=x+s.y1-s.x1;
        // cout<<"Vertical "<<x<<'\n';
        // cout<<r<<' '<<y1<<' '<<y2<<'\n';
        return y1<=r && r<=y2 && s.y1<=r && r<=s.y2;
    }
    point cord(const slash& s) {
        return {x, x+s.y1-s.x1};
    }
} ver[MAXN]; int vtot;


int raw[MAXN], tot;

int id, n, m, q; ll ans;

struct {
    #define ls(p) (p<<1)
    #define rs(p) (p<<1|1)
    #define ll(p) tr[p].l
    #define rr(p) tr[p].r
    #define len(p) tr[p].len
    #define cnt(p) tr[p].cnt
    struct node {
        int l, r, len, cnt;
    } tr[MAXN<<2];
    void build(int l, int r, int p=1) {
        ll(p)=l, rr(p)=r; len(p)=cnt(p)=0;
        if (l==r) return;
        int mid=(l+r)>>1; build(l,mid,ls(p)); build(mid+1,r,rs(p));
    }

    void change(int l, int r, int c, int p=1) {
        int cl=ll(p), cr=rr(p);
        if (l<=cl && cr<=r) {
            cnt(p)+=c;
            if (cnt(p)) 
                len(p)=(raw[cr+1]-raw[cl]);
            else 
                len(p)=cl==cr?0:len(ls(p))+len(rs(p));
            return;
        }
        int mid=(cl+cr)>>1;

        if (l<=mid) change(l,r,c,ls(p));
        if (r>mid) change(l,r,c,rs(p));

        if (cnt(p)) 
            len(p)=raw[cr+1]-raw[cl];
        else 
            len(p)=len(ls(p))+len(rs(p));
    }

    int get() {
        return tr[1].len;
    }
} sg;

int query(int x) {
    return lower_bound(raw+1,raw+1+tot,x)-raw;
}

signed main() {
    ios::sync_with_stdio(false);
    cin>>id>>n>>m>>q;
    int op, x1, y1, x2, y2;
    for (int i=1; i<=q; ++i) {
        cin>>op>>x1>>y1>>x2>>y2;
        if (op<=2) {    
            raw[++tot]=y1; a[tot]={x1,y1,y2+1,1};
            raw[++tot]=y2+1; a[tot]={x2+1,y1,y2+1,-1};
            if (op==1) hor[++htot]={y1,x1,x2};
            else ver[++vtot]={x1,y1,y2};
        }
        else {
            s[++stot]={x1,y1,x2,y2}; 
            // ans+=x2-x1+1;
        }
    }
    sort(a+1,a+1+tot); sort(raw+1,raw+1+tot); n=tot; 
    tot=unique(raw+1,raw+1+tot)-(raw+1);
    if (n>1) {
        sg.build(1,tot-1);
        for (int i=1; i<n; ++i) {
            int x=a[i].x, 
            y1=query(a[i].y1), y2=query(a[i].y2)-1, 
            c=a[i].k;
            sg.change(y1,y2,c);
            ans+=(a[i+1].x-a[i].x)*sg.get();
        }
    }
    for (int i=1; i<1<<stot; ++i) {
        int b=-(1<<30), l, r;
        int cur=-1;
        bool flag=true;
        for (int j=0; j<stot; ++j) {
            if ((i>>j)&1) {
                // 抽到了第 j+1 根斜线
                if (b==(-(1<<30))) {
                    b=s[j+1].y1-s[j+1].x1;
                    l=s[j+1].x1, r=s[j+1].x2;
                    cur*=-1;
                }
                else {
                    cur*=-1;
                    if (s[j+1].y1-s[j+1].x1!=b) {
                        flag=false; break;
                    }
                    else {
                        r=min(r,s[j+1].x2);
                        l=max(l,s[j+1].x1);
                    }
                }
            }
        }
        if (flag) {
            ans+=cur*(r-l+1);
        }
    }
    set<point> st;
    for (int i=1; i<=stot; ++i) {
        for (int j=1; j<=htot; ++j) 
            if (hor[j].intersect(s[i])) 
                st.insert(hor[j].cord(s[i]));
        for (int j=1; j<=vtot; ++j) 
            if (ver[j].intersect(s[i])) 
                st.insert(ver[j].cord(s[i]));
    }
    // for (auto i: st) {
    //     cout<<i.x<<' '<<i.y<<'\n';
    // }
    ans-=st.size();
    cout<<ans<<'\n';
}