#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()

const int MOD = 998244353;

int add(int a, int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}

const int MAXNM = 15 * 510 + 100;
vector<array<int, 2>> cond[MAXNM];
int can[MAXNM];

const int MAXN = 15;

int dp[1 << MAXN][MAXN], dp1[1 << MAXN][MAXN];

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    fill(can, can + MAXNM, 1);

    int n, m, cnd;
    cin >> n >> m >> cnd;
    for (int i = 0; i < cnd; ++i) {
        int c, x, y, d;
        cin >> c >> x >> y >> d;
        --c;
        if (d == 0) {
            if (c == 0) {
                cout << "0\n";
                return 0;
            }
            for (int i = x; i < y; ++i) {
                can[c * n + i] = 0;
            }
        } else {
            if (c == 0) {
                continue;
            }
            cond[c].push_back({x, y});
        }
    }

    for (int i = 1; i < m; ++i) {
        sort(cond[i].begin(), cond[i].end(), [](array<int, 2> a, array<int, 2> b) {
            if (a[0] == b[0]) return a[1] > b[1];
            return a[0] < b[0];
        });
        vector<array<int, 2>> seg;
        for (int t = 0; t < (int)cond[i].size(); ++t) {
            bool f = true;
            for (int q = 0; q < (int)cond[i].size(); ++q) {
                if (t == q) continue;
                if (cond[i][q] == cond[i][t] && q < t) {
                    f = false;
                }
                if (cond[i][q] == cond[i][t]) continue;
                if (cond[i][q][0] >= cond[i][t][0] && cond[i][q][1] <= cond[i][t][1]) {
                    f = false;
                }
            }
            if (f) {
                seg.push_back(cond[i][t]);
            }
        }
        cond[i] = seg;
    }

    dp[(1 << n) - 1][0] = 1;
    int c = 0, r = n - 1;
    int condl = 0, condr = 0;
    for (int i = n - 1; i < n * m - 1; ++i) {
        ++r;
        if (r == n) {
            r = 0;
            ++c;
            condl = condr = 0;
        }
        while (condl < (int)cond[c].size() && cond[c][condl][1] <= r) ++condl;
        while (condr < (int)cond[c].size() && cond[c][condr][0] <= r) ++condr;

        /// vector<vector<int>> dp1((1 << (n + 1)), vector<int>(cond[c].size() + 1, 0));
        for (int i = 0; i < (1 << (n + 1)); ++i) {
            fill(dp1[i], dp1[i] + cond[c].size() + 1, 0);
        }

        if (r == 0) {
            for (int mask = 0; mask < (1 << n); ++mask) {
                if (mask & 1) {
                    dp1[mask][0] += dp[mask][cond[c - 1].size()];
                }
                dp1[mask | 1 | (1 << n)][0] += dp[mask][cond[c - 1].size()];
            }
            for (int i = 0; i < 2 * (1 << n); ++i) {
                dp1[i][0] %= MOD;
            }
            /// dp = move(dp1);
            for (int i = 0; i < (1 << (n + 1)); ++i) {
                memcpy(dp[i], dp1[i], sizeof(int) * (cond[c].size() + 1));
            }
            continue;
        }
        for (int mask = 0; mask < (1 << n); ++mask) {
            int m1 = mask;
            if (!(mask & (1 << r))) {
                m1 ^= (1 << r);
            }
            for (int i = condl; i <= condr; ++i) {
                if (dp[mask][i] == 0) continue;
                if (mask & (1 << (r - 1))) {
                    dp1[m1 ^ (1 << (r - 1))][i] += dp[mask][i];
                }
                if (!can[c * n + r]) continue;
                int j = condr;
                if (mask & (1 << r)) {
                    dp1[m1][j] += dp[mask][i];
                    /// cerr << m1 << " " << j << " " << dp1[m1][j] << endl;
                }
                dp1[m1 + (1 << n)][j] += dp[mask][i];
            }
        }
        for (int mask = (1 << n); mask < 2 * (1 << n); ++mask) {
            int m0 = mask;
            if (mask & (1 << r)) {
                m0 ^= (1 << r);
            }
            for (int i = condl; i <= condr; ++i) {
                if (dp[mask][i] == 0) continue;
                dp1[m0][i] += dp[mask][i];
                if (mask & (1 << r)) {
                    dp1[m0 - (1 << n)][i] += dp[mask][i];
                }
            }
        }
        /// dp = move(dp1);
        for (int i = 0; i < (1 << (n + 1)); ++i) {
            memcpy(dp[i], dp1[i], sizeof(int) * (cond[c].size() + 1));
        }
    }
    int ans = 0;
    for (int mask = 0; mask < (1 << n); ++mask) {
        ans = add(ans, dp[mask][cond[m - 1].size()] % MOD);
    }
    cout << ans << "\n";
    return 0;
}