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
#include <bits/stdc++.h>

#define all(x) (x).begin(), (x).end()
#define li long long
#define itn int

using namespace std;

inline int nxt(){
	int n;
	scanf("%d", &n);
	return n;
}

void panic() {
	puts("No");
	exit(0);
}

#define next lksjflkgkjsfg
#define prev jkhljsgf

int main(){

	int n = nxt(), m = nxt();
	vector<vector<int>> indices(m);
	int q = nxt();
	vector<int> a(q);
	for (itn i = 0; i < q; i++) {
		int x = nxt() - 1;
		a[i] = x;
		indices[x].push_back(i);
	}
	vector<int> lst(m);
	for (int i = 0; i < m; i++) {
		lst[i] = -i - 1;
	}

	for (itn i = 0; i < m; i++) {
		if (!indices[i].empty()) {
			lst[i] = indices[i].back();
		}
	}
	vector<itn> next(m, -1), prev(m, -1);
	for (int i = 0; i < m; i++) {
		if (i < m - 1) {
			next[i] = i + 1;
		}
		prev[i] = i - 1;
	}

	int cnt = 0;
	for (int i = 0; i < m - 1; i++) {
		if (lst[i] < lst[i + 1]) {
			cnt++;
		}
	}

	vector<char> used(m);
	int index = q - 1;
	vector<int> bound(n, q);
	while (index >= 0 && cnt) {

		int c = a[index];
		used[c] = 1;
		int nx = next[c];
		int pr = prev[c];
		if (nx > -1) {
			if (lst[c] < lst[nx]) {
				cnt--;
			}
			prev[nx] = pr;
		}
		if (pr > -1) {
			if (lst[pr] < lst[c]) {
				cnt--;
			}
			next[pr] = nx;
		}
		if (nx > -1 && pr > -1) {
			if (lst[pr] < lst[nx]) {
				cnt++;
			}
		}

		int i = n - 1;
		for (int j = (int)indices[c].size() - 1; j >= 0; j--) {
			if (i == -1) {
				break;
			}
			if (indices[c][j] < bound[i]) {
				bound[i--] = indices[c][j];
			}
		}
		if (i >= 0) {
			panic();
		}

		while (index >= 0 && used[a[index]]) {
			index--;
		}
	}

	puts("Yes");

	return 0;
}
