#include <iostream>
#include <cmath>
#include <vector>
#include <time.h>
#include <map>
#include <set>
#include <deque>
#include <cstdio>
#include <cstdlib>
#include <unordered_map>
#include <bitset>
#include <algorithm>
#include <string>
#include <fstream>
#include <assert.h>
#include <list>
#include <cstring>
using namespace std;

namespace fastinput
{
	/** Interface */

	inline int readChar();
	template <class T = int> inline T readInt();
	template <class T> inline void writeInt(T x, char end = 0);
	inline void writeChar(int x);
	inline void writeWord(const char *s);

	/** Read */

	static const int buf_size = 16384;

	inline int getChar() {
		static char buf[buf_size];
		static int len = 0, pos = 0;
		if (pos == len)
			pos = 0, len = fread(buf, 1, buf_size, stdin);
		if (pos == len)
			return -1;
		return buf[pos++];
	}

	inline int readChar() {
		int c = getChar();
		while (c <= 32)
			c = getChar();
		return c;
	}

	template <class T>
	inline T readInt() {
		int s = 1, c = readChar();
		T x = 0;
		if (c == '-')
			s = -1, c = getChar();
		while ('0' <= c && c <= '9')
			x = x * 10 + c - '0', c = getChar();
		return s == 1 ? x : -x;
	}

	/** Write */

	static int write_pos = 0;
	static char write_buf[buf_size];

	inline void writeChar(int x) {
		if (write_pos == buf_size)
			fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
		write_buf[write_pos++] = x;
	}

	template <class T>
	inline void writeInt(T x, char end) {
		if (x < 0)
			writeChar('-'), x = -x;

		char s[24];
		int n = 0;
		while (x || !n)
			s[n++] = (char)('0' + x % 10), x /= 10;
		while (n--)
			writeChar(s[n]);
		if (end)
			writeChar(end);
	}

	inline void writeWord(const char *s) {
		while (*s)
			writeChar(*s++);
	}

	struct Flusher {
		~Flusher() {
			if (write_pos)
				fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
		}
	} flusher;
}

using namespace fastinput;

const int N = 1e5;
const int SIZE = 317;
vector <int> g[N];
vector <int> rb;
vector <int> lb;
int answer[N];

struct Event
{
	int l, r;
	int id;
	int block;
};

Event Moes[N];

bool operator <(const Event &a, const Event &b)
{
	if (a.block != b.block)
		return a.block < b.block;
	else
		if (a.block & 1)
			return a.r < b.r;
		else
			return a.r > b.r;
}

struct Ev
{
	int type;
	int u, v;
};

vector <Ev> DCP;
vector <int> answers;

int parent[N];
int rnk[N];
vector <pair <int, int*>> stack;
int cursize = 0;
int edges = 0;

int getparent(int v)
{
	if (parent[v] == v)
		return v;
	return getparent(parent[v]);
}

void unite(int a, int b)
{
	a = getparent(a);
	b = getparent(b);
	if (a == b)
		return;
	if (rnk[a] < rnk[b])
		swap(a, b);
	if (rnk[a] == rnk[b])
	{
		stack.push_back({ rnk[a], &rnk[a] });
		++rnk[a];
	}
	stack.push_back({ parent[b], &parent[b] });
	parent[b] = a;
	stack.push_back({ edges, &edges });
	++edges;
}

void cur(int l, int r)
{
	if (l == r)
	{
		if (DCP[l].type == 0)
			answers.push_back(edges);
		return;
	}
	int mid = (l + r) / 2;
	int keepsize = stack.size();
	for (int i = mid + 1; i <= r; ++i)
		if (DCP[i].type == -1 && lb[i] < l)
		{
			unite(DCP[i].u, DCP[i].v);
		}
	cur(l, mid);
	while (stack.size() > keepsize)
	{
		pair <int, int*> top = stack.back();
		stack.pop_back();
		*top.second = top.first;
	}
	for (int i = l; i <= mid; ++i)
		if (DCP[i].type == 1 && rb[i] > r)
			unite(DCP[i].u, DCP[i].v);
	cur(mid + 1, r);
	while (stack.size() > keepsize)
	{
		pair <int, int*> top = stack.back();
		stack.pop_back();
		*top.second = top.first;
	}
}

int cnt[2];

int main()
{
	int n = readInt();
	for (int i = 0; i < n; ++i)
	{
		int x = readInt();
		cnt[x % 2]++;
	}
	if (cnt[1] % 2 == 1)
		cout << "NO";
	else
	{
		cnt[0] += cnt[1] / 2;
		cout << "YES";

	}
	return 0;
}

Measured memory_bytes: 2560