// PotyczkiAlgorytmiczne2019.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <algorithm>
#include <sstream>

//using namespace std;

static int Task2()
{


	return 0;
}

std::vector<std::string> splitString(std::string str, char delimiter) {
	std::vector<std::string> internal;
	std::stringstream ss(str); // Turn the string into a stream.
	std::string tok;

	while (std::getline(ss, tok, delimiter)) {
		internal.push_back(tok);
	}

	return internal;
}

std::vector<int> splitStringToInt(std::string str, char delimiter) {
	std::vector<int> internal;
	std::stringstream ss(str); // Turn the string into a stream.
	std::string tok;

	while (std::getline(ss, tok, delimiter)) {
		internal.push_back(std::stoi(tok));
	}

	return internal;
}


static int Task1C()
{
	//std::ifstream infile("input1_1.txt");

	std::string line;

	std::getline(std::cin, line);
	//std::getline(infile, line);

	unsigned int n = atoi(line.c_str());
	//std::getline(infile, line);
	std::getline(std::cin, line);
	std::vector<std::string> vector = splitString(line, ' ');

	std::sort(vector.begin(), vector.end());

	int count5A, count5B, count5C = 0;
	count5A = std::count(vector.begin(), vector.end(), "5A");
	count5B = std::count(vector.begin(), vector.end(), "5B");
	count5C = std::count(vector.begin(), vector.end(), "5C");

	if (count5A >= 2 && count5B >= 2 && count5C >= 2)
	{
		vector.erase(unique(vector.begin(), vector.end()), vector.end());
		int count = vector.size();
		if (count == 15)
		{
			std::cout << "TAK";
			return 0;
		}
	}
	std::cout << "NIE";
	return 0;
}

static int Task1BNaive()
{
	//std::ifstream infile("input1B.txt");

	std::string line;

	std::getline(std::cin, line);
	//std::getline(infile, line);

	unsigned int n, m = 0;

	std::vector<int> _params = splitStringToInt(line, ' ');
	n = _params[0];
	m = _params[1];

	std::vector<std::string> cans;
	for (int i = 0; i <= n; i++)
		cans.push_back("");

	//while (std::getline(std::cin, line))
		//while (std::getline(infile, line))
	for (int z = 0; z < m; z++)
	{
		std::getline(std::cin, line);
		unsigned int l, r, k = 0;
		std::vector<int> _params = splitStringToInt(line, ' ');
		l = _params[0];
		r = _params[1];
		k = _params[2];
		for (int i = l; i <= r; i++)
		{
			switch (k) {
			case 1:
				cans[i].append("Y");
				break;
			case 2:
				cans[i].append("B");
				break;
			case 3:
				cans[i].append("R");
				break;
			}
		}
	}
	int count = 0;
	for (int i = 0; i <= n; i++)
	{
		int y = 0;
		int b = 0;
		int r = 0;
		std::string str = cans[i];
		for (int j = 0; j < str.size(); j++)
		{
			switch (str[j])
			{
			case 'Y':
				y++;
				break;
			case 'B':
				b++;
				break;
			case 'R':
				r++;
				break;
			}
			if (r > 0)
				break;
		}
		if (r == 0 && y > 0 && b > 0)
			count++;
	}
	std::cout << count;
	return count;
}

struct Interval
{
	int start;
	int end;
	Interval() : start(0), end(0)
	{
	}
	Interval(int s, int e) : start(s), end(e)
	{
	}
};

// Function used in sort  
bool mycomp(Interval a, Interval b)
{
	return (a.start < b.start);
}

std::vector<Interval> mergeIntervals(std::vector<Interval> arr, int n)
{
	// Test if the given set has at least one interval 
	if (n <= 0)
		return arr;

	// Create an empty stack of intervals 
	std::vector<Interval> s;

	// sort the intervals in increasing order of start time 
	std::sort(arr.begin(), arr.end(), mycomp);

	// push the first interval to stack 
	s.push_back(arr[0]);

	// Start from the next interval and merge if necessary 
	for (int i = 1; i < n; i++)
	{
		// get interval from stack top 
		Interval top = s[0];

		// if current interval is not overlapping with stack top, 
		// push it to the stack 
		if (top.end < arr[i].start)
			s.push_back(arr[i]);

		// Otherwise update the ending time of top if ending of current 
		// interval is more 
		else if (top.end < arr[i].end)
		{
			top.end = arr[i].end;
			s.pop_back();
			s.push_back(top);
		}
	}
	return s;
}

// Function to print intersecting intervals 
std::vector<Interval> intersectIntervals(std::vector<Interval> arr1, std::vector<Interval> arr2)
{
	std::vector<Interval> result;
	// i and j pointers for 
	// arr1 and arr2 respectively 
	int i = 0, j = 0;

	// Size of the two lists 
	int n = arr1.size(), m = arr2.size();

	// Loop through all intervals unless 
	// one of the interval gets exhausted 
	while (i < n && j < m) {
		// Left bound for intersecting segment 
		int l = std::max(arr1[i].start, arr2[j].start);

		// Right bound for intersecting segment 
		int r = std::min(arr1[i].end, arr2[j].end);

		// If segment is valid print it 
		if (l < r)
			result.push_back({ l, r });

		// If i-th interval's right 
		// bound is smaller 
		// increment i else 
		// increment j 
		if (arr1[i].end < arr2[j].end)
			i++;
		else
			j++;
	}
	return result;
}
/*
std::vector<Interval> cutIntervals(std::vector<Interval> arrIn1, std::vector<Interval> arrIn2)
{
	std::vector<Interval> result;
	// i and j pointers for
	// arr1 and arr2 respectively
	int i = 0, j = 0;

	// Size of the two lists
	int n = arrIn1.size(), m = arrIn2.size();

	// Loop through all intervals unless
	// one of the interval gets exhausted
	while (i < n && j < m) {
		Interval arr1;
		Interval arr2;
		for (int ii = arrIn1[i][0]; ii <= arrIn1[i][1]; ii++)
		{
			//arr1.push_back(ii);
		}

		for (int ii = arrIn2[j][0]; ii <= arrIn2[j][1]; ii++)
		{
			//arr2.push_back(ii);
		}

		std::vector<int> diff;

		//std::set_difference(arr1.begin(), arr1.end(), arr2.begin(), arr2.end(), std::inserter(diff, diff.begin()));
		//result.push_back({ diff[0], diff[diff.size() - 1] + 1 });

		//if (arrIn1[i][0] < arrIn2[j][0] && arrIn1[i][1] > arrIn2[j][1])
		{
			//result.push_back({ arr1[i][0], arr2[j][0] - 1 });
			//result.push_back({ arr1[j][1 + 1], arr2[i][i] });
			j++;
		}
		else if (arrIn1[i][0] < arrIn2[j][0] && arrIn1[i][1] < arrIn2[j][1])
		{
			//result.push_back({ arr1[i][0], arr2[i][1] });
			i++;
		}
		else if (arrIn1[i][0] > arrIn2[j][0] && arrIn1[i][1] < arrIn2[j][1])
		{
			i++;
		}
		else if (arrIn1[i][0] > arrIn2[j][0] && arrIn1[i][1] > arrIn2[j][1])
		{
			//result.push_back({ arr1[j][1 + 1], arr2[i][i] });
			j++;
		}
	}
	return result;
}*/


static int Task1B()
{
	//std::ifstream infile("input1B_1.txt");
	std::vector<Interval> arr1;
	std::vector<Interval> arr2;
	std::vector<Interval> arr3;

	std::string line;

	std::getline(std::cin, line);
	//std::getline(infile, line);

	unsigned int n, m = 0;

	std::vector<int> _params = splitStringToInt(line, ' ');
	n = _params[0];
	m = _params[1];

	//while (std::getline(std::cin, line))
	for (int z = 0; z < m; z++)
	{
		std::getline(std::cin, line);
		//std::getline(infile, line);
		int l, r, k = 0;
		std::vector<int> _params = splitStringToInt(line, ' ');
		l = _params[0];
		r = _params[1];
		k = _params[2];
		switch (k) {
		case 1:
			arr1.push_back({ l, r });
			break;
		case 2:
			arr2.push_back({ l, r });
			break;
		case 3:
			arr3.push_back({ l, r });
			break;
		}
	}
	//arr1
	int cnt = sizeof(arr1) / sizeof(arr1[0]);
	arr1 = mergeIntervals(arr1, arr1.size());
	//arr2
	arr2 = mergeIntervals(arr2, arr2.size());
	//arr3
	arr3 = mergeIntervals(arr3, arr3.size());

	std::vector<Interval> intersection = intersectIntervals(arr1, arr2);
	//std::vector<std::vector<int>> finalPart = cutIntervals(intersection, arr3);

	int count = 0;

	std::vector<int> result(n + 1);
	for (int i = 0; i < arr3.size(); i++)
	{
		int min = arr3[i].start;
		int max = arr3[i].end;
		for (int ii = min; ii <= max; ii++)
		{
			result[ii] = 100;
			//result.erase(std::remove(result.begin(), result.end(), ii), result.end());
		}

	}
	for (int i = 0; i < intersection.size(); i++)
	{
		int min = intersection[i].start;
		int max = intersection[i].end;
		for (int ii = min; ii <= max; ii++)
		{
			if (result[ii] != 100)
				count++;
			//result.push_back(ii);
		}
	}

	std::cout << count;
	return 0;
}

static int Task1()
{
	return 0;
}

int main()
{
	//Task1BNaive();
	Task1B();
	//Task2();
	return 0;

}