#include <bits/stdc++.h>

/*#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("vpt")
#pragma GCC optimize("rename-registers")
#pragma GCC optimize("move-loop-invariants")
#pragma GCC optimize("unswitch-loops")
#pragma GCC optimize("function-sections")
#pragma GCC optimize("data-sections")
#pragma GCC optimize("branch-target-load-optimize")
#pragma GCC optimize("branch-target-load-optimize2")
#pragma GCC optimize("btr-bb-exclusive")*/

#define mp make_pair
#define ll long long
#define ld long double
#define pb push_back
#define fast_io ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define fs first
#define sc second
#define getfiles ifstream cin("input.txt"); ofstream cout("output.txt");
#define endl '\n'
#define con continue
#define pii pair<int, int>

const int INF = 2000000005;
const ll BIG_INF = 2000000000000000005;
const int mod = 1000000007;
const int P = 31;
const ld PI = 3.141592653589793238462643;

using namespace std;

struct edge {
    int u, v, p, w, rev;
    edge(){
    }
    edge(int U, int V, int P, int C) {
        u = U, v = V, p = P, w = C;
    }
};

int n, q, o = 0, N, ans = 0;
vector<pii> a;

vector<edge> e;
vector< vector<int> > g;
vector<int> p, d;

bool getShortPath() {
    fill(d.begin(), d.end(), INF);
    fill(p.begin(), p.end(), -1);
    d[0] = 0;
    set<pii> q;
    q.insert(mp(d[0], 0));
    while (!q.empty()) {
        int v = q.begin()->sc;
        q.erase(q.begin());
        for (int i = 0; i < g[v].size(); i++) {
            if (e[g[v][i]].p == 0)
                continue;
            if (d[e[g[v][i]].v] > d[v] + e[g[v][i]].w) {
                p[e[g[v][i]].v] = g[v][i];
                q.erase(mp(d[e[g[v][i]].v], e[g[v][i]].v));
                d[e[g[v][i]].v] = d[v] + e[g[v][i]].w;
                q.insert(mp(d[e[g[v][i]].v], e[g[v][i]].v));
            }
        }
    }
    if (d[N] == INF)
        return false;
    return true;
}

signed main() {
    fast_io;

    cin >> n >> q;
    N = 2 * n + 1;
    d.resize(N + 1);
    p.resize(N + 1);

    a.resize(n, mp(-INF, INF));
    while(q--) {
        int t, l, r, v;
        cin >> t >> l >> r >> v;
        l--, r--;
        for (int i = l; i <= r; i++) {
            if (t == 1)
                a[i].fs = max(a[i].fs, v);
            else
                a[i].sc = min(a[i].sc, v);

            if (a[i].fs > a[i].sc) {
                cout << -1;
                return 0;
            }
        }
    }

    g.resize(2 * n + 2);
    for (int i = 1; i <= n; i++) {
        for (int k = 1; k <= n; k++) {
            e.pb(edge(0, i, 1, 2 * k - 1));
            g[0].pb(e.size() - 1);
            e.pb(edge(i, 0, 0, -(2 * k - 1)));
            g[i].pb(e.size() - 1);
            e[e.size() - 1].rev = e.size() - 2;
            e[e.size() - 2].rev = e.size() - 1;
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (!(a[j - 1].fs <= i && a[j - 1].sc >= i))
                continue;
            e.pb(edge(i, n + j, 1, 0));
            g[i].pb(e.size() - 1);
            e.pb(edge(n + j, i, 0, 0));
            g[n + j].pb(e.size() - 1);
            e[e.size() - 1].rev = e.size() - 2;
            e[e.size() - 2].rev = e.size() - 1;
        }
        e.pb(edge(n + i, 2 * n + 1, 1, 0));
        g[n + i].pb(e.size() - 1);
        e.pb(edge(2 * n + 1, n + i, 0, 0));
        g[2 * n + 1].pb(e.size() - 1);
        e[e.size() - 1].rev = e.size() - 2;
        e[e.size() - 2].rev = e.size() - 1;
    }

    while(getShortPath()) {
        int cur = N;
        while (cur != 0) {
            e[p[cur]].p = 0;
            e[e[p[cur]].rev].p = 1;
            ans += e[p[cur]].w;
            cur = e[p[cur]].u;
        }
    }
    cout << ans;

    return 0;
}