#include <bits/stdc++.h>

//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
//using namespace __gnu_pbds;


#define st first
#define nd second
#define pb push_back
#define popb pop_back
#define mp make_pair
#define all(x) x.begin(),x.end()
#define sortall(x) sort(all(x));
#define deb(x) cout << #x << " = " << x << endl
#define debv(x) cout << #x << ": "; for (int i = 0; i < (x).size(); i++) cout << (x)[i] << ' '; cout << endl
#define PI 3.1415926535897932384626
#define fastio ios_base::sync_with_stdio(false); cin.tie(); cout.tie(); srand(time(NULL)); cout << fixed << setprecision(9)
typedef pair< int ,int >                pii;
typedef pair< long long, long long >    pll;
typedef vector< pii >                   vii;
typedef vector< pll >                   vll;
typedef long long                       ll;
typedef map< int, int >                 mii;
typedef set< pii >                      sii;
typedef set< int >                      si;
typedef vector< int >                   vi;
typedef vector< ll >                    vl;
typedef long double                     ld;
typedef pair< ld, ld >                  pld;
typedef vector< pld >                   vpld;
typedef unsigned long long              ull;
typedef long long                       ll;

//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
//ordered_set t;
//t.insert(val);
//t.find_by_order(i) - returns iterator to the i-th element in set
//t.order_of_key(i) - index of value i

const ll mod = 1e9 + 7;                 /// 1 000 000 007
const ll mod2 = 119 << 23 | 1;          /// 998244353
const ll mod3 = 467093870598391;    /// big prime
int inf = 1e9 + 7;
ll INF = 1e16 + 9;

///tagliatelle here
template<typename T>
class LazyTree{                 ///(0,1,...n-1)
private:
    vector<T> Tree, lazy;
    int leafcount = 1;
public:
    void push(T v){                   ///accumulates lazy values in leaves but they don't matter
        Tree[v * 2] += lazy[v];         ///pushing the lazy value to tree node
        lazy[v * 2] += lazy[v];         ///pushing the lazy indicator to the tree node
        Tree[v * 2 + 1] += lazy[v];
        lazy[v * 2 + 1] += lazy[v];
        lazy[v] = 0;                    ///no actions further postponed for this node
    }

    void rangeupdate(int l, int r, T val, int from = 0, int to = -1, int akt = 1){
        if(to == -1)
            to += leafcount;
        if(l > r)
            return;
        if(from == l && r == to){
            Tree[akt] += val;
            lazy[akt] += val;
        }else if(from <= l && r <= to){
            push(akt);
            int mid = from + (to - from) / 2;
            if(r <= mid)
                rangeupdate(l, r, val, from, mid, 2 * akt);
            else if(mid + 1 <= l)
                rangeupdate(l, r, val, mid + 1, to, 2 * akt + 1);
            else{
                rangeupdate(l, mid, val, from, mid, 2 * akt);
                rangeupdate(mid + 1, r, val, mid + 1, to, 2 * akt + 1);
            }
            Tree[akt] = Tree[akt * 2] + Tree[2 * akt + 1];
        }
    }

    T rangequery(int l, int r, int from = 0, int to = -1, int akt = 1){
        if(to == -1)
            to += leafcount;
        if(l > r)
            return 0;
        if(from == l && r == to){
            return Tree[akt];
        }else if(from <= l && r <= to){
            push(akt);
            int mid = from + (to - from) / 2;
            if(r <= mid)
                return rangequery(l, r, from, mid, 2 * akt);
            else if(mid + 1 <= l)
                return rangequery(l, r, mid + 1, to, 2 * akt + 1);
            else{
                return rangequery(l, mid, from, mid, 2 * akt) + rangequery(mid + 1, r, mid + 1, to, 2 * akt + 1);
            }
        }
        return 0;
    }

    LazyTree(int _n){
        while(leafcount < _n)
            leafcount *= 2;
        Tree.resize(2 * leafcount);
        lazy.resize(2 * leafcount);
        for(int i = 0; i < 2 * leafcount; i++)
            Tree[i] = 0, lazy[i] = 0;
    }

};
///

ll power (ll x, ll y);
ll inv (ll x);
bool isPrime (ll x);
ll gcd (ll x, ll y);

//================================================================================

const int nax = 2e5 + 13;

void prep(){
}

void solve(){
    int n, m;
    cin >> n >> m;
    LazyTree<int> puszki1(n);
    LazyTree<int> puszki2(n);
    LazyTree<int> puszki3(n);
    int l, r, t;
    for(int i = 0; i < m; i++){
        cin >> l >> r >> t;
        if(t == 1){
            puszki1.rangeupdate(l - 1, r - 1, 1);
        }else if(t == 2){
            puszki2.rangeupdate(l - 1, r - 1, 1);
        }else{
            puszki3.rangeupdate(l - 1, r - 1, 1);
        }
    }
    int ile = 0;
    for(int i = 0; i < n; i++){
        if(puszki1.rangequery(i, i) > 0 && puszki2.rangequery(i, i) > 0 && puszki3.rangequery(i, i) == 0){
            ile++;
        }
    }
    cout << ile << endl;
}

int main(){            ///use cin and printf if you wanna see some REAL SPEED
//#ifndef ONLINE_JUDGE
//    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
//#endif
    fastio;
    int T = 1;
    prep();
    //cin >> T;
    for(int i = 1; i <= T; i++){
        //cout << "test number " << i << endl;
        solve();
        //cout << "end" << endl;
    }
    return 0;
}

ll power (ll x, ll y) {
    ll res = 1ll;
    x %= mod;
    if (x == 0)
        return 0;
    while (y > 0) {
        if (y & 1)
            res = (res * x) % mod;
        y = y >> 1ll;
        x = (x * x) % mod;
    }
    return res;
}

bool isPrime (ll x) {
    if (x == 1)
        return false;
    for (ll i = 2ll; i * i <= x; i++) {
        if (x % i == 0)
            return false;
    }
    return true;
}

ll gcd (ll x, ll y) {
    if (!y)
        return x;
    return gcd (y, x % y);
}

/*
    __builtin_popcount
    __builtin_ctz
    __builtin_clz
*/