#include<stdio.h>
#include<vector>
#include<string>
#include<iostream>
#include<algorithm>
#include<deque>
#include<set>
using namespace std;

#pragma warning(push)
#pragma warning(disable: 4996)

int D, N, M;

vector<int> zile_lipsit;

struct interval 
{
	int start;
	int sfarsit;
	vector<int> zile_incluse;
	int lungime_zile_incluse;
};

struct less_than_key
{
	inline bool operator() (const interval& struct1, const interval& struct2)
	{
		return (struct1.lungime_zile_incluse > struct2.lungime_zile_incluse);
	}
};

interval intervale[1005];

bool numere[1005];

int zi_lipsa;
int counter = 0;
bool found = false;

int main()
{
	//freopen("permuta.in", "r", stdin);
	//freopen("permuta.out", "w", stdout);

	scanf("%d%d%d", &D, &N, &M);

	for (int i = 0; i < N; ++i)
	{
		scanf("%d", &zi_lipsa);
		zile_lipsit.push_back(zi_lipsa);
		numere[zi_lipsa] = true;
	}

	for (int i = 0; i < M; ++i)
	{
		scanf("%d%d", &intervale[i].start, &intervale[i].sfarsit);
	}

	sort(zile_lipsit.begin(), zile_lipsit.end());

	for (int i = 0; i < M; ++i)
	{
		for (int j = 0; j < N; ++j)
		{
			if (zile_lipsit[j] >= intervale[i].start && zile_lipsit[j] <= intervale[i].sfarsit)
			{
				intervale[i].zile_incluse.push_back(zile_lipsit[j]);
				intervale[i].lungime_zile_incluse = intervale[i].lungime_zile_incluse + 1;
			}
		}
	}

	sort(intervale, intervale + M, less_than_key());

	for (int i = 0; i < M; ++i)
	{
		for (int j = 0; j < intervale[i].lungime_zile_incluse; ++j)
		{
			if (numere[intervale[i].zile_incluse[j]])
			{
				numere[intervale[i].zile_incluse[j]] = false;
				found = true;
			}
		}

		if (found)
		{
			found = false;
			counter++;
		}
	}

	printf("%d\n", counter);

	return 0;
}


#pragma warning(pop)