#include <bits/stdc++.h>
using namespace std;

const int MOD = 998244353;

const int MAXN = 14, MAXM = 510;
int need[MAXN][MAXM];
int nptr[MAXN][MAXM];
vector<array<int, 2>> restr[MAXM];
int64_t dp0[3 << MAXN][MAXN];
int64_t dp1[3 << MAXN][MAXN];

void solve_() {
    int n, m, r;
    cin >> n >> m >> r;
    bool bad = false;
    while (r--) {
        int c, l, r, diff;
        cin >> c >> l >> r >> diff;
        --c;
        if (c == 0) {
            if (diff == 0) bad = true;
            continue;
        }
        if (diff == 0) {
            for (int i = l; i < r; ++i) {
                need[i][c] = true;
            }
        } else {
            --l; --r;
            restr[c].push_back({l, r});
        }
    }
    if (bad) {
        cout << "0\n";
        return;
    }
    for (int c = 0; c < m; ++c) {
        sort(restr[c].begin(), restr[c].end());
        vector<array<int, 2>> st;
        for (auto elem : restr[c]) {
            while (!st.empty() && st.back()[1] >= elem[1]) st.pop_back();
            if (!st.empty() && st.back()[0] == elem[0]) continue;
            st.push_back(elem);
        }
        restr[c] = st;
        for (int i = 0; i < n; ++i) {
            nptr[i][c] = st.size();
        }
        for (int i = (int)st.size() - 1; i >= 0; --i) {
            for (int r = st[i][0] - 1; r >= 0; --r) {
                nptr[r][c] = i;
            }
        }
    }
    dp0[(1 << n) - 1][0] = 1;
    int lsz = 0;
    for (int cell = 0; cell < n * m; ++cell) {
        int r = cell % n;
        int c = cell / n;
        int csz = restr[c].size();
        if (r == 0) {
            for (int mask = 0; mask < (3 << n); ++mask) {
                int val = dp0[mask][lsz];
                if (mask >= (1 << n)) val = 0;
                fill(dp0[mask], dp0[mask] + csz + 1, 0);
                dp0[mask][0] = val;
            }
        }
        if (need[r][c]) {
            for (int mask = 0; mask < (1 << n); ++mask) {
                fill(dp0[mask], dp0[mask] + csz + 1, 0);
            }
        }
        for (int mask = 0; mask < (3 << n); ++mask) {
            for (int ptr = 0; ptr < csz; ++ptr) {
                if (r >= restr[c][ptr][1]) {
                    dp0[mask][ptr] = 0;
                }
            }
        }
        for (int mask = 0; mask < (3 << n); ++mask) {
            fill(dp1[mask], dp1[mask] + csz + 1, 0);
        }

        for (int mask = 0; mask < (3 << n); ++mask) {
            int tp = (mask >> n);
            int to_left = (mask >> r) & 1;
            for (int ptr = 0; ptr <= csz; ++ptr) {
                if (dp0[mask][ptr] == 0) continue;

                auto vert = [&](int nmask) {
                    dp1[nmask][ptr] += dp0[mask][ptr];
                    if (dp1[nmask][ptr] >= MOD) dp1[nmask][ptr] -= MOD;
                };

                auto no_vert = [&](int nmask) {
                    dp1[nmask][nptr[r][c]] += dp0[mask][ptr];
                    if (dp1[nmask][nptr[r][c]] >= MOD) dp1[nmask][nptr[r][c]] -= MOD;
                };

                if (to_left == 0) {
                    if (tp == 0) {
                        int nmask = mask | (1 << n);
                        vert(nmask);
                        nmask |= (1 << r);
                        vert(nmask);
                    } else if (tp == 1) {
                        int nmask = mask;
                        vert(nmask);
                    } else {
                        int nmask = mask;
                        vert(nmask);
                        nmask ^= (2 << n);
                        no_vert(nmask);
                        nmask ^= (1 << r);
                        no_vert(nmask);
                    }
                } else {
                    if (tp == 0) {
                        int nmask = mask;
                        no_vert(nmask);
                        nmask ^= (1 << r);
                        no_vert(nmask);
                        nmask ^= (2 << n);
                        vert(nmask);
                    } else if (tp == 1) {
                        int nmask = mask ^ (1 << r) ^ (1 << n);
                        no_vert(nmask);
                    }
                }
            }
        }
        for (int i = 0; i < (3 << n); ++i) {
            for (int j = 0; j <= csz; ++j) {
                swap(dp0[i][j], dp1[i][j]);
            }
        }
        lsz = restr[c].size();
    }
    int ans = dp0[0][lsz];
    cout << ans << "\n";
}

/// #define MULTITEST

main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int tst = 1;
#ifdef MULTITEST
    cin >> tst;
#endif // MULTITEST
    while (tst--) {
        solve_();
    }
    return 0;
}