#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <cassert>
#include <cstdio>
#include <stdexcept>
#include <iterator>
#include <type_traits>

#include <iostream>
#include <stack>
#if defined (_MSC_VER)
#include <io.h>
// code specific to Visual Studio compiler
#else
#include "unistd.h"
#endif
#pragma warning(disable:4146)
using ull = unsigned long long;
using ll = long long;

class Input {
public:
    Input() { bufpos = bufend = buffer; eof = false; }
    bool Eof() { return eof; }
    char Peek() { if (bufpos == bufend) Grab(); return *bufpos; }
    unsigned char UPeek() { return static_cast<unsigned char>(Peek()); }
    void SkipWS();
    template<class T> T Get();
    void operator()() {}
    template<class Arg, class... Args> void operator()(Arg& arg, Args&... args) {
        arg = Get<Arg>();
        operator()(args...);
    }
private:
    static const int BUFSIZE = 1 << 16;
    char buffer[BUFSIZE];
    char* bufpos;
    char* bufend;
    bool eof;
    void Grab();
};

void Input::Grab() {
    if (eof) return;
    bufpos = buffer;
    bufend = buffer + read(0, buffer, BUFSIZE);
    if (bufend == bufpos) { eof = true; *bufpos = 0; }
}

template<> inline char Input::Get<char>() {
    char res = Peek();
    ++bufpos;
    return res;
}

void Input::SkipWS() {
    while (isspace(UPeek())) Get<char>();
}

template<> unsigned Input::Get<unsigned>() {
    SkipWS();
    unsigned x = 0;
    while (isdigit(UPeek())) {
        x = 10u * x + (Get<char>() - '0');
    }
    return x;
}

template<> int Input::Get<int>() {
    SkipWS();
    bool neg = false;
    if (Peek() == '-') { neg = true; Get<char>(); }
    unsigned x = Get<unsigned>();
    if (neg) x = -x;
    return static_cast<int>(x);
}

template<> ull Input::Get<ull>() {
    SkipWS();
    ull x = 0;
    while (isdigit(UPeek())) {
        x = 10ULL * x + (Get<char>() - '0');
    }
    return x;
}

template<> ll Input::Get<ll>() {
    SkipWS();
    bool neg = false;
    if (Peek() == '-') { neg = true; Get<char>(); }
    ull x = Get<ull>();
    if (neg) x = -x;
    return static_cast<ll>(x);
}

template<>
std::string Input::Get<std::string>() {
    SkipWS();
    std::string s;
    while (!Eof() && !isspace(UPeek())) s += Get<char>();
    return s;
}

class Output {
public:
    void Flush();
    Output() :bufpos(buffer), BUFLIMIT(buffer + BUFSIZE - 100) {}
    ~Output() { Flush(); }
    void Put(char c);
    void Put(unsigned x);
    void Put(int x);
    void Put(ull x);
    void Put(ll x);
    void Put(const char* s);
    void Put(const std::string& s);

    void operator()() {}
    template<class Arg, class... Args> void operator()(const Arg& arg, const Args&... args) {
        Put(arg);
        operator()(args...);
    }
private:
    static const int BUFSIZE = 1 << 16;
    char buffer[BUFSIZE];
    char* bufpos;
    char* BUFLIMIT;
};

void Output::Flush() {
    char* p = buffer;
    while (p < bufpos) {
        p += write(1, p, bufpos - p);
    }
    bufpos = buffer;
}

inline void Output::Put(char c) {
    *bufpos = c;
    ++bufpos;
    if (bufpos >= BUFLIMIT) Flush();
}

void Output::Put(unsigned x) {
    char* old = bufpos;
    do {
        *bufpos = char('0' + x % 10u);
        x /= 10u;
        ++bufpos;
    } while (x);
    std::reverse(old, bufpos);
    if (bufpos >= BUFLIMIT) Flush();
}

void Output::Put(int x) {
    if (x < 0) {
        Put('-'); Put(-static_cast<unsigned>(x));
    }
    else {
        Put(static_cast<unsigned>(x));
    }
}

void Output::Put(ull x) {
    char* old = bufpos;
    do {
        *bufpos = char('0' + x % 10u);
        x /= 10u;
        ++bufpos;
    } while (x);
    std::reverse(old, bufpos);
    if (bufpos >= BUFLIMIT) Flush();
}

void Output::Put(ll x) {
    if (x < 0) {
        Put('-'); Put(-static_cast<ull>(x));
    }
    else {
        Put(static_cast<ull>(x));
    }
}

void Output::Put(const char* s) {
    while (*s) Put(*s++);
}

void Output::Put(const std::string& s) {
    for (char c : s) Put(c);
}

Input IN;
Output OUT;

int n, m;
std::vector<std::pair<int, int>> yellow, blue, other;

inline bool overlaps(const std::pair<int, int>& p, int v)
{
	return p.first <= v && v <= p.second;
}
int main()
{
	int l, r, k;
	IN(n, m);
	yellow.reserve(m);
	blue.reserve(m);
	other.reserve(m);

	while(m--)
	{
        IN.SkipWS();
		IN(l, r, k);

		if(k == 1)
		{
			yellow.emplace_back(l, r);
		}
        else if(k == 2)
        {
			blue.emplace_back(l, r);
        }
        else
        {
            other.emplace_back(l, r);
        }
	}
    std::sort(yellow.begin(), yellow.end());
    std::sort(blue.begin(), blue.end());
    std::sort(other.begin(), other.end());
	
	int result = 0;
    auto yellow_it = yellow.begin();
	auto blue_it = blue.begin();
	auto other_it = other.begin();
	
	for(int i = 1; i <= n; ++i)
	{
		while(yellow_it != yellow.end() && !overlaps(*yellow_it, i) && i >= yellow_it->first)
            ++yellow_it;
		while(blue_it != blue.end() && !overlaps(*blue_it, i) && i >= blue_it->first)
            ++blue_it;
		while(other_it != other.end() && !overlaps(*other_it, i) && i >= other_it->first)
            ++other_it;

		if(yellow_it == yellow.end() || blue_it == blue.end())
            break;
		
		if(overlaps(*yellow_it, i) && 
            overlaps(*blue_it, i) && 
            (other_it == other.end() || !overlaps(*other_it, i)))
		{
			result++;
        }
	}
	
    OUT(result);

	return 0;
}