Yaroslav has an array that consists of n integers. In one second Yaroslav can swap two neighboring array elements. Now Yaroslav is wondering if he can obtain an array where any two neighboring elements would be distinct in a finite time.

Help Yaroslav.

Input

The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1000) — the array elements.

Output

In the single line print "YES" (without the quotes) if Yaroslav can obtain the array he needs, and "NO" (without the quotes) otherwise.

Examples

Input

1
1


Output

YES


Input

3
1 1 2


Output

YES


Input

4
7 7 7 7


Output

NO

Note

In the first sample the initial array fits well.

In the second sample Yaroslav can get array: 1, 2, 1. He can swap the last and the second last elements to obtain it.

In the third sample Yarosav can't get the array he needs.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.PrintWriter;
import java.util.Arrays;



public class A {



	public static void main(String[]args)throws IOException {
		FastReader sc = new FastReader();
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt();
		int temp = n;
		int []freq = new int[1001];
		while (n-- > 0)
			freq[sc.nextInt()]++;

		int f = Integer.MIN_VALUE;
		for (int i = 1; i < 1001; i++)
			f = Math.max(f, freq[i]);

		out.println(f > ((temp + 2 - 1) / 2) ? "NO" : "YES");
		out.close();
	}




// public static euclidTriplet euclidExtended(int a, int b) {
// 	if (b == 0)
// 		return new euclidTriplet(1, 0, a);

// 	euclidTriplet ans = euclidExtended(b, a % b);

// 	return new euclidTriplet(ans.y, ans.x - (a / b) * ans.y, ans.gcd);
// }


// public static int  gcd(int a, int b) {
// 	if (a == 0)
// 		return b;

// 	return gcd(b % a, a);
// }

}

// class euclidTriplet {
// 	int x, y, gcd;
// 	euclidTriplet(int x, int y, int gcd) {
// 		this.x = x;
// 		this.y = y;
// 		this.gcd = gcd;
// 	}
// }


// class comp implements Comparator<long []> {
// 	public int compare(long [] arr1, long[] arr2) {
// 		if ((2 * arr2[0] + arr2[1]) > (2 * arr1[0] + arr1[1]))
// 			return 1;

// 		else
// 			return -1;
// 	}
// }


class FastReader {

	BufferedReader br;
	StringTokenizer st;

	public FastReader() {
		br = new BufferedReader(new InputStreamReader(System.in));
	}

	String next() {
		while (st == null || !st.hasMoreElements()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException  e) {
				e.printStackTrace();
			}
		}
		return st.nextToken();
	}

	int nextInt() {
		return Integer.parseInt(next());
	}

	int [] nextIntArray(int n) {
		int [] arr = new int[n];
		for (int i = 0; i < n; i++)
			arr[i] = nextInt();

		return arr;

	}


	long nextLong() {
		return Long.parseLong(next());
	}

	long [] nextLongArray(int n) {
		long [] arr = new long[n];
		for (int i = 0; i < n; i++)
			arr[i] = nextLong();

		return arr;

	}

	double nextDouble() {
		return Double.parseDouble(next());
	}

	String nextLine() {
		String str = "";
		try {
			str = br.readLine();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return str;
	}

}