/*
	Rozwiązanie zadania "Mieszanie kolorów [B]" (KOL) na Potyczki Algorytmiczne 2020.
	Damian Mazur
*/
#include <stdio.h>

struct operacja
{
	int l;
	int r;
};

const int iloscOperacjiDoSprawdzenia = 8;
int n, m;
operacja* operacjeZ;
operacja* operacjeN;
operacja* operacjeC;
int iloscOperacjiZ = 0;
int iloscOperacjiN = 0;
int iloscOperacjiC = 0;
int operacjaDoSprawdzeniaZ = 0;
int operacjaDoSprawdzeniaN = 0;
int operacjaDoSprawdzeniaC = 0;
int* tablicaKolorow;
const int zolty = 0b001;
const int niebieski = 0b010;
const int czerwony = 0b100;
const int zielony = 0b011;

void dodajZolty(int l, int r)
{
	if (iloscOperacjiZ)
	{
		int poczatkowoSprawdzonaOperacja = operacjaDoSprawdzeniaZ;
		for (int i = 0; i < iloscOperacjiDoSprawdzenia; i++)
		{
			if (l < operacjeZ[operacjaDoSprawdzeniaZ].l)
			{
				if (r > operacjeZ[operacjaDoSprawdzeniaZ].r)
				{
					operacjeZ[operacjaDoSprawdzeniaZ].l = l;
					operacjeZ[operacjaDoSprawdzeniaZ].r = r;
					return;
				}
				else if (r >= operacjeZ[operacjaDoSprawdzeniaZ].l)
				{
					operacjeZ[operacjaDoSprawdzeniaZ].l = l;
					return;
				}
			}
			else if (l <= operacjeZ[operacjaDoSprawdzeniaZ].r)
			{
				if (r > operacjeZ[operacjaDoSprawdzeniaZ].r)
				{
					operacjeZ[operacjaDoSprawdzeniaZ].r = r;
					return;
				}
				else if (r >= operacjeZ[operacjaDoSprawdzeniaZ].l)
				{
					return;
				}
			}
			operacjaDoSprawdzeniaZ++;
			if (operacjaDoSprawdzeniaZ >= iloscOperacjiZ)
			{
				operacjaDoSprawdzeniaZ = 0;
			}
			if (operacjaDoSprawdzeniaZ == poczatkowoSprawdzonaOperacja)
			{
				break;
			}
		}
	}
	operacjeZ[iloscOperacjiZ].l = l;
	operacjeZ[iloscOperacjiZ].r = r;
	iloscOperacjiZ++;
	return;
}

void dodajNiebieski(int l, int r)
{
	if (iloscOperacjiN)
	{
		int poczatkowoSprawdzonaOperacja = operacjaDoSprawdzeniaN;
		for (int i = 0; i < iloscOperacjiDoSprawdzenia; i++)
		{
			if (l < operacjeN[operacjaDoSprawdzeniaN].l)
			{
				if (r > operacjeN[operacjaDoSprawdzeniaN].r)
				{
					operacjeN[operacjaDoSprawdzeniaN].l = l;
					operacjeN[operacjaDoSprawdzeniaN].r = r;
					return;
				}
				else if (r >= operacjeN[operacjaDoSprawdzeniaN].l)
				{
					operacjeN[operacjaDoSprawdzeniaN].l = l;
					return;
				}
			}
			else if (l <= operacjeN[operacjaDoSprawdzeniaN].r)
			{
				if (r > operacjeN[operacjaDoSprawdzeniaN].r)
				{
					operacjeN[operacjaDoSprawdzeniaN].r = r;
					return;
				}
				else if (r >= operacjeN[operacjaDoSprawdzeniaN].l)
				{
					return;
				}
			}
			operacjaDoSprawdzeniaN++;
			if (operacjaDoSprawdzeniaN >= iloscOperacjiN)
			{
				operacjaDoSprawdzeniaN = 0;
			}
			if (operacjaDoSprawdzeniaN == poczatkowoSprawdzonaOperacja)
			{
				break;
			}
		}
	}
	operacjeN[iloscOperacjiN].l = l;
	operacjeN[iloscOperacjiN].r = r;
	iloscOperacjiN++;
	return;
}

void dodajCzerwony(int l, int r)
{
	if (iloscOperacjiC)
	{
		int poczatkowoSprawdzonaOperacja = operacjaDoSprawdzeniaC;
		for (int i = 0; i < iloscOperacjiDoSprawdzenia; i++)
		{
			if (l < operacjeC[operacjaDoSprawdzeniaC].l)
			{
				if (r > operacjeC[operacjaDoSprawdzeniaC].r)
				{
					operacjeC[operacjaDoSprawdzeniaC].l = l;
					operacjeC[operacjaDoSprawdzeniaC].r = r;
					return;
				}
				else if (r >= operacjeC[operacjaDoSprawdzeniaC].l)
				{
					operacjeC[operacjaDoSprawdzeniaC].l = l;
					return;
				}
			}
			else if (l <= operacjeC[operacjaDoSprawdzeniaC].r)
			{
				if (r > operacjeC[operacjaDoSprawdzeniaC].r)
				{
					operacjeC[operacjaDoSprawdzeniaC].r = r;
					return;
				}
				else if (r >= operacjeC[operacjaDoSprawdzeniaC].l)
				{
					return;
				}
			}
			operacjaDoSprawdzeniaC++;
			if (operacjaDoSprawdzeniaC >= iloscOperacjiC)
			{
				operacjaDoSprawdzeniaC = 0;
			}
			if (operacjaDoSprawdzeniaC == poczatkowoSprawdzonaOperacja)
			{
				break;
			}
		}
	}
	operacjeC[iloscOperacjiC].l = l;
	operacjeC[iloscOperacjiC].r = r;
	iloscOperacjiC++;
	return;
}

void wypelnijTabliceKolorow()
{
	for (int i = 0; i < iloscOperacjiZ; i++)
	{
		for (int j = operacjeZ[i].l; j <= operacjeZ[i].r; j++)
		{
			tablicaKolorow[j] |= zolty;
		}
	}
	for (int i = 0; i < iloscOperacjiN; i++)
	{
		for (int j = operacjeN[i].l; j <= operacjeN[i].r; j++)
		{
			tablicaKolorow[j] |= niebieski;
		}
	}
	for (int i = 0; i < iloscOperacjiC; i++)
	{
		for (int j = operacjeC[i].l; j <= operacjeC[i].r; j++)
		{
			tablicaKolorow[j] |= czerwony;
		}
	}
	return;
}

int zliczZielone()
{
	int wynik = 0;
	for (int i = 0; i < n; i++)
	{
		if (tablicaKolorow[i] == zielony)
		{
			wynik++;
		}
	}
	return wynik;
}

int main()
{
	scanf("%d", &n);
	scanf("%d", &m);
	tablicaKolorow = new int[n];
	for (int i = 0; i < n; i++)
	{
		tablicaKolorow[i] = 0;
	}
	operacjeZ = new operacja[m];
	operacjeN = new operacja[m];
	operacjeC = new operacja[m];
	for (int i = 0; i < m; i++)
	{
		int l, r, tryb;
		scanf("%d", &l);
		scanf("%d", &r);
		scanf("%d", &tryb);
		l--;
		r--;
		if (tryb == 1)
		{
			dodajZolty(l, r);
		}
		else if (tryb == 2)
		{
			dodajNiebieski(l, r);
		}
		else if (tryb == 3)
		{
			dodajCzerwony(l, r);
		}
	}
	wypelnijTabliceKolorow();
	printf("%d", zliczZielone());
	return 0;
}