There are N arrays. The length of each array is M and initially each array contains integers (1，2，...，M) in this order.

Mr. Takahashi has decided to perform Q operations on those N arrays. For the i-th (1≤i≤Q) time, he performs the following operation.

* Choose an arbitrary array from the N arrays and move the integer a_i (1≤a_i≤M) to the front of that array. For example, after performing the operation on a_i=2 and the array (5，4，3，2，1), this array becomes (2，5，4，3，1).



Mr. Takahashi wants to make N arrays exactly the same after performing the Q operations. Determine if it is possible or not.

Constraints

* 2≤N≤10^5
* 2≤M≤10^5
* 1≤Q≤10^5
* 1≤a_i≤M

Input

The input is given from Standard Input in the following format:


N M
Q
a_1 a_2 ... a_Q


Output

Print `Yes` if it is possible to make N arrays exactly the same after performing the Q operations. Otherwise, print `No`.

Examples

Input

2 2
3
2 1 2


Output

Yes


Input

3 2
3
2 1 2


Output

No


Input

2 3
3
3 2 1


Output

Yes


Input

3 3
6
1 2 2 3 3 3


Output

No
//ProblemE.cpp

#include <iostream>

static std::istream & ip = std::cin;
static std::ostream & op = std::cout;

#if OJ_MYPC
#include <ojio.h>
#endif

#ifndef OPENOJIO
#define OPENOJIO
#endif

#if 1 || DEFINE
/***************************************************************/
typedef unsigned long long u64;
typedef long long s64;

typedef unsigned uint;

#define ABS(x) ((x) > 0 ? (x) : -(x))

#define MIN(x, y) ((x) < (y) ? (x) : (y))
#define MAX(x, y) ((x) > (y) ? (x) : (y))

#define MIN3(x, y, z) MIN(x, MIN(y, z))
#define MAX3(x, y, z) MAX(x, MAX(y, z))

#define FillZero(arr) memset(arr, 0, sizeof(arr));

/***************************************************************/
#endif //1 || DEFINE

#include <string>
#include <vector>
#include <map>
#include <set>
#include <bitset>
#include <queue>
#include <stack>
#include <utility>
#include <algorithm>
#include <iomanip>
#include <cstring>
#include <cmath>
#include <cstdio>

//001
//op << setfill('0') << setw(3) << setiosflags(ios::right) << 1;

//op << fixed << setprecision(20);

using namespace std;

//ProblemE.cpp

#define MAXN 100010
#define MAXM 100010
#define MAXQ 100010

int main(int argc, char* argv[])
{
	OPENOJIO;

	int n, m, q;
	static int a[MAXQ];

	ip >> n >> m >> q;
	for (int i = 1; i <= q; ++i) ip >> a[i];

	static bool used[MAXM];
	for (int i = 1; i <= m; ++i) used[i] = false;

	int last[MAXM];
	int ilast = 1;

	for (int i = q; i >= 1; --i) {
		if (used[a[i]])
			continue;

		last[ilast++] = a[i];
		used[a[i]] = true;
	}

	for (int i = 1; i <= m; ++i) {
		if (used[i])
			continue;

		last[ilast++] = i;
	}

	int mii[MAXM];
	for (int i = 1; i <= m; ++i)
		mii[last[i]] = i;

	static int cl[MAXM];
	for (int i = 1; i <= m; ++i)
		cl[i] = 0;
	cl[0] = n;

	for (int i = q; i >= 1; --i) {
		int index = mii[a[i]];

		if (cl[index - 1] > 0) {
			--cl[index - 1];
			++cl[index];
		}
	}

	bool rst = true;
	for (int i = 0; i < m; ++i) {
		if (cl[i] == 0) continue;
		for (int j = i + 1; j < m; ++j) {
			if (last[j] > last[j + 1]) {
				rst = false;
				break;
			}
		}
		break;
	}

	op << (rst ? "Yes" : "No") << endl;
	return 0;
}
/***************************************************************/
