#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)

// если модуль подается на вход, убрать все <> и раскомментировать нужные строки
using uint = unsigned int;
using ull = unsigned long long;
template <uint MD> struct ModInt {
    using M = ModInt;
    // static int MD;
    uint v;
    ModInt(ll _v = 0) { set_v(uint(_v % MD + MD)); }
    M& set_v(uint _v) {
        v = (_v < MD) ? _v : _v - MD;
        return *this;
    }
    explicit operator bool() const { return v != 0; }
    M operator-() const { return M() - *this; }
    M operator+(const M& r) const { return M().set_v(v + r.v); }
    M operator-(const M& r) const { return M().set_v(v + MD - r.v); }
    M operator*(const M& r) const { return M().set_v(uint((ull)v * r.v % MD)); }
    M operator/(const M& r) const { return *this * r.inv(); }
    M& operator+=(const M& r) { return *this = *this + r; }
    M& operator-=(const M& r) { return *this = *this - r; }
    M& operator*=(const M& r) { return *this = *this * r; }
    M& operator/=(const M& r) { return *this = *this / r; }
    bool operator==(const M& r) const { return v == r.v; }
    bool operator!=(const M& r) const { return v != r.v; }
    M inv() const;
    friend istream& operator>>(istream& is, M& r) { ll x; is >> x; r = M(x); return is; }
    friend ostream& operator<<(ostream& os, const M& r) { return os << r.v; }
};

template<uint MD>
ModInt<MD> pow(ModInt<MD> x, ll n) {
    ModInt<MD> r = 1;
    while (n) {
        if (n & 1) r *= x;
        x *= x;
        n >>= 1;
    }
    return r;
}

template<uint MD>
ModInt<MD> ModInt<MD>::inv() const { return pow(*this, MD - 2); }
// or copy egcd and {return egcd(MD, v, 1).second;}

// if MD is from input
// this line is necessary, read later as you wish
// int ModInt::MD;

const int MOD = 998'244'353;
using Mint = ModInt<MOD>;
// using Mint = double;

const int MS = (1 << 14) + 239;
const int M = 510;

Mint dp[2][MS];

int n, m, r;
vector<tuple<int, int, int>> info[M];

vector<tuple<int, int, int>> go;

vector<int> df[MS];

void gen() {
    for (int mask = 0; mask < (1 << (n - 1)); mask++) {
        vector<int> pos;
        pos.emplace_back(0);
        for (int i = 0; i < n - 1; i++) {
            if ((mask >> i) & 1) {
                pos.emplace_back(i + 1);
            }
        }
        pos.emplace_back(n);
        df[mask] = pos;
        for (int sub = 0; sub < (1 << ((int)pos.size() - 1)); sub++) {
            bool ok = true;
            for (int x = 0; x < (int)pos.size() - 1; x++) {
                if ((sub >> x) & 1) {
                    if (pos[x + 1] - pos[x] == 1) {
                        ok = false;
                        break;
                    }
                }
            }
            if (!ok) {
                continue;
            }
            int m1 = 0;
            int m2 = 0;
            for (int x = 0; x < (int)pos.size() - 1; x++) {
                if ((sub >> x) & 1) {
                    m1 ^= (1 << pos[x]);
                    m2 ^= (1 << (pos[x + 1] - 1));
                } else {
                    m2 ^= (1 << pos[x]);
                    m1 ^= (1 << (pos[x + 1] - 1));
                }
            }
            go.emplace_back(m1, m2, mask);
        }
    }
}

bool good[MS];

void solve() {
    cin >> n >> m >> r;
    for (int i = 0; i < r; i++) {
        int c, x, y, d;
        cin >> c >> x >> y >> d;
        c--, x--, y--;
        info[c].emplace_back(x, y, d);
    }
    gen();
    /*for (const auto& t : go) {
        cerr << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << "\n";
    }*/
    for (const auto& t : info[0]) {
        if (get<2>(t) == 0) {
            cout << "0\n";
            return;
        }
    }
    memset(dp, 0, sizeof(dp));
    dp[0][(1 << n) - 1] = 1;
    for (int c = 1; c < m; c++) {
        for (int i = 0; i < n; i++) {
            for (int mask = (1 << n) - 1; mask >= 0; mask--) {
                if (((mask >> i) & 1) == 0) {
                    dp[1 - (c & 1)][mask] += dp[1 - (c & 1)][mask ^ (1 << i)];
                }
            }
        }
        memset(dp[c & 1], 0, sizeof(dp[c & 1]));
        for (int mask = 0; mask < (1 << (n - 1)); mask++) {
            good[mask] = true;
            for (const auto& t : info[c]) {
                int loc1 = upper_bound(df[mask].begin(), df[mask].end(), get<0>(t)) - df[mask].begin();
                int loc2 = upper_bound(df[mask].begin(), df[mask].end(), get<1>(t)) - df[mask].begin();
                if ((int)(loc1 != loc2) != get<2>(t)) {
                    good[mask] = false;
                    //cerr << c << " " << mask << "\n";
                    break;
                }
            }
        }
        for (const auto& [m1, m2, mask] : go) {
            if (good[mask]) {
                dp[c & 1][m2] += dp[1 - (c & 1)][m1];
            }
        }
    }
    Mint ans = 0;
    for (int mask = 0; mask < (1 << n); mask++) {
        ans += dp[(m - 1) & 1][mask];
    }
    cout << ans << "\n";
}

int test(int n) {
    int tot = 0;
    for (int mask = 0; mask < (1 << (n - 1)); mask++) {
        int last = 0;
        int cnt = 0;
        for (int i = 0; i < n - 1; i++) {
            if ((mask >> i) & 1) {
                cnt += (i + 1 - last > 1);
                last = i + 1;
            }
        }
        cnt += n - last > 1;
        tot += (1 << cnt);
    }
    return tot;
}

int main() {
#ifdef ONPC
    freopen("input", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    /*for (int n = 1; n <= 14; n++) {
        cout << n << " " << test(n) << "\n";
    }
    return 0;*/

    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}