#include <bits/stdc++.h>

struct Vector {
    int x, y;

    Vector() : x(0), y(0) { ; }
    Vector(int x, int y) : x(x), y(y) { ; }

    Vector operator-(const Vector& other) const {
        return Vector(x - other.x, y - other.y);
    }

    int64_t operator*(const Vector& other) const {
        return int64_t(x) * other.x + int64_t(y) * other.y;
    }
    int64_t operator%(const Vector& other) const {
        return int64_t(x) * other.y - int64_t(y) * other.x;
    }

    bool operator==(const Vector& other) const {
        return x == other.x && y == other.y;
    }
};

struct Line {
    int64_t c;
    Vector n;

    Line() = default;
    Line(Vector a, Vector b) {
        n = Vector((a - b).y, -(a - b).x);
        c = -(n * a);
    }

    int64_t fuck(Vector v) {
        return v * n + c;
    }
};

Vector inter_point(Line a, Line b) {
    int64_t cross = a.n % b.n;

    if (cross == 0) {
        // assert(false);
        return {-1, -1};
    }
    Vector res;
    __int128_t pr1 = (b.c * __int128_t(a.n.y) - a.c * __int128_t(b.n.y));
    __int128_t pr2 = (b.c * __int128_t(a.n.x) - a.c * __int128_t(b.n.x));
    assert(pr1 % cross == 0);
    assert(pr2 % cross == 0);
    res.x = (b.c * __int128_t(a.n.y) - a.c * __int128_t(b.n.y)) / cross;
    res.y = (b.c * __int128_t(a.n.x) - a.c * __int128_t(b.n.x)) / -cross;
    assert(a.fuck(res) == 0);
    assert(b.fuck(res) == 0);
    return res;
}

std::pair<bool, Vector> intersect(Vector a, Vector b, Vector c, Vector d) {
    if (a == b && c == d) {
        return {a == c, c};
    }
    if (a == b || c == d) {
        if (a == b) {
            std::swap(a, c);
            std::swap(b, d);
        }
        if ((a - b) % (c - b) != 0) {
            return {false, {}};
        }
        // if (a== c || b == c){
        //     return {true, c};
        // }
        if ((c - b) * (a - b) >= 0 && (c - a) * (b - a) >= 0) {
            return {true, c};
        }
        return {false, {}};
    }
    int64_t p1 = (a - b) % (c - b);
    int64_t p2 = (a - b) % (d - b);
    int64_t p3 = (c - d) % (a - d);
    int64_t p4 = (c - d) % (b - d);
    bool b1 = p1 == 0 || p2 == 0 || ((p1 > 0) != (p2 > 0));
    bool b2 = p3 == 0 || p4 == 0 || ((p3 > 0) != (p4 > 0));
    bool res = b1 && b2;
    if (res) {
        Vector p = inter_point(Line(a, b), Line(c, d));
        if (Line(a, b).fuck(p) == 0 && Line(c, d).fuck(p) == 0) {
            return {true, p};
        }
    }
    return {false, {}};
}

struct Bit {
    int n;
    std::vector<int> data;

    Bit(int n = 0) : n(n), data(n, 0) { ; }

    void update(int i, int dlt) {
        for (; i < n; i |= i + 1) {
            data[i] += dlt;
        }
    }
    int get_prf(int i) {
        int res = 0;
        for (; i >= 0; i = (i & i + 1) - 1) {
            res += data[i];
        }
        return res;
    }
};

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int group_id;
    int w, h, q;
    std::cin >> group_id >> w >> h >> q;
    std::vector<std::array<int, 5>> input(q);
    for (auto& [a, b, c, d, e] : input) {
        std::cin >> a >> b >> c >> d >> e;
        b--, c--, d--, e--;
    }

    std::map<int, std::vector<std::pair<int, int>>> vert, horz, diag;

    for (auto [tp, x1, y1, x2, y2] : input) {
        assert(x1 <= x2);
        assert(y1 <= y2);
        if (tp == 1) {
            horz[y1].push_back({x1, x2 + 1});
        } else if (tp == 2) {
            vert[x1].push_back({y1, y2 + 1});
        } else {
            diag[x1 - y1].push_back({x1 + y1, x2 + y2 + 2});
        }
    }

    std::vector<std::pair<Vector, Vector>> v_seg, h_seg;
    std::vector<std::pair<Vector, Vector>> d_seg;
    for (auto ptr : std::vector{&vert, &horz, &diag}) {
        std::vector<int> all;
        for (auto [x, vec] : *ptr) {
            all.clear();
            for (auto [l, r] : vec) {
                all.push_back(l);
                all.push_back(r);
            }
            std::sort(all.begin(), all.end());
            all.erase(std::unique(all.begin(), all.end()), all.end());
            std::vector<int> fuck(all.size());
            for (auto [l, r] : vec) {
                l = std::lower_bound(all.begin(), all.end(), l) - all.begin();
                r = std::lower_bound(all.begin(), all.end(), r) - all.begin();
                fuck[l]++, fuck[r]--;
            }
            for (int i = 0, s = 0; i < all.size(); i++) {
                s += fuck[i];
                if (s) {
                    if (ptr == &vert) {
                        v_seg.push_back({Vector{x, all[i]}, Vector{x, all[i + 1] - 1}});
                    } else if (ptr == &horz) {
                        h_seg.push_back({Vector{all[i], x}, Vector{all[i + 1] - 1, x}});
                    } else {
                        int x1 = (x + all[i]) / 2, y1 = (all[i] - x) / 2;
                        int x2 = (x + all[i + 1]) / 2, y2 = (all[i + 1] - x) / 2;
                        d_seg.push_back({Vector{x1, y1}, Vector{x2 - 1, y2 - 1}});
                        Vector dt = d_seg.back().second - d_seg.back().first;
                        assert(dt.x == dt.y);
                    }
                }
            }
        }
    }

    int64_t ans = 0;
    for (auto [a, b] : v_seg) {
        ans += b.y - a.y + 1;
    }
    for (auto [a, b] : h_seg) {
        ans += b.x - a.x + 1;
    }
    for (auto [a, b] : d_seg) {
        ans += b.x - a.x + 1;
    }

    if (1) {
        std::vector<int> all;
        for (auto [a, b] : v_seg) {
            all.push_back(a.y);
            all.push_back(b.y);
        }
        for (auto [a, b] : h_seg) {
            all.push_back(a.y);
            all.push_back(b.y);
        }
        std::sort(all.begin(), all.end());
        all.erase(std::unique(all.begin(), all.end()), all.end());

        Bit bt(all.size());
        std::vector<std::array<int, 4>> events;
        for (auto [a, b] : v_seg) {
            events.push_back({a.x, 1, a.y, b.y});
        }
        for (auto [a, b] : h_seg) {
            assert(a.y == b.y);
            events.push_back({a.x, 0, a.y, -1});
            events.push_back({b.x, 2, a.y, -1});
        }
        std::sort(events.begin(), events.end());

        for (auto [x, tp, y, y2] : events) {
            int it = std::lower_bound(all.begin(), all.end(), y) - all.begin();
            int it2 = std::lower_bound(all.begin(), all.end(), y2) - all.begin();
            if (tp == 0) {
                bt.update(it, +1);
            } else if (tp == 2) {
                bt.update(it, -1);
            } else {
                assert(it2 < all.size());
                ans -= bt.get_prf(it2) - bt.get_prf(it - 1);
            }
        }
    } else {
        for (auto [a, b] : v_seg) {
            for (auto [c, d] : h_seg) {
                ans -= intersect(a, b, c, d).first;
            }
        }
    }
    std::map<std::pair<int, int>, int> map;
    for (auto [a, b] : d_seg) {
        for (auto [c, d] : v_seg) {
            auto [it, p] = intersect(a, b, c, d);
            if (it) {
                ans--;
                map[{p.x, p.y}]++;
            }
        }
        for (auto [c, d] : h_seg) {
            auto [it, p] = intersect(a, b, c, d);
            if (it) {
                ans--;
                map[{p.x, p.y}]++;
            }
        }
    }

    for (auto [a, b] : map) {
        assert(b == 1 || b == 2);
        ans += b > 1;
    }

    std::cout << ans << "\n";

    return 0;
}