You are given an array $a_1, a_2, \ldots, a_n$.

In one operation you can choose two elements $a_i$ and $a_j$ ($i \ne j$) and decrease each of them by one.

You need to check whether it is possible to make all the elements equal to zero or not.


-----Input-----

The first line contains a single integer $n$ ($2 \le n \le 10^5$) — the size of the array.

The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^9$) — the elements of the array.


-----Output-----

Print "YES" if it is possible to make all elements zero, otherwise print "NO".


-----Examples-----
Input
4
1 1 2 2

Output
YES
Input
6
1 2 3 4 5 6

Output
NO


-----Note-----

In the first example, you can make all elements equal to zero in $3$ operations:   Decrease $a_1$ and $a_2$,  Decrease $a_3$ and $a_4$,  Decrease $a_3$ and $a_4$ 

In the second example, one can show that it is impossible to make all elements equal to zero.

Difficulty: MEDIUM
Tags: Mathematics

Greedy algorithms
Skill types: Greedy algorithms

Starter code:

Solutions:
(n, a) = (int(input()), [int(x) for x in input().split()])
res = str('NO') if sum(a) % 2 == 1 or 2 * max(a) > sum(a) else str('YES')
print(res)


n = int(input())
data = list(map(int, input().split()))
sumData = sum(data)
maxData = max(data)
if sumData % 2 == 0 and sumData - maxData >= maxData:
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline
n = int(input())
l = list(map(int, input().split()))
s = sum(l)
if s % 2 == 1:
	print('NO')
elif max(l) > s // 2:
	print('NO')
else:
	print('YES')


n = int(input())
a = [int(x) for x in input().split()]
s = sum(a)
if s % 2 == 1:
	print('NO')
else:
	half = s // 2
	a.sort()
	if a[-1] > half:
		print('NO')
	else:
		print('YES')


n = int(input())
a = list(map(int, input().split()))
if sum(a) % 2:
	print('NO')
else:
	a.sort()
	if sum(a[:n - 1]) - a[-1] < 0:
		print('NO')
	else:
		print('YES')


n = int(input())
a = list(map(int, input().split()))
if sum(a) % 2 == 0 and max(a) <= sum(a) // 2:
	print('YES')
else:
	print('NO')


import sys, os, io

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math, datetime, functools, itertools, operator, bisect, fractions, statistics
from collections import deque, defaultdict, OrderedDict, Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify, _heapify_max, _heappop_max

def main():
	starttime = datetime.datetime.now()
	if os.path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	for _ in range(1):
		n = ri()
		a = ria()
		c = sum(a)
		ans = 'YES'
		for i in a:
			if i > c // 2:
				ans = 'NO'
				break
		if c % 2 == 1:
			ans = 'NO'
		print(ans)
	endtime = datetime.datetime.now()
	time = (endtime - starttime).total_seconds() * 1000
	if os.path.exists('input.txt'):
		print('Time:', time, 'ms')

class FastReader(io.IOBase):
	newlines = 0

	def __init__(self, fd, chunk_size=1024 * 8):
		self._fd = fd
		self._chunk_size = chunk_size
		self.buffer = io.BytesIO()

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self, size=-1):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

class FastWriter(io.IOBase):

	def __init__(self, fd):
		self._fd = fd
		self.buffer = io.BytesIO()
		self.write = self.buffer.write

	def flush(self):
		os.write(self._fd, self.buffer.getvalue())
		(self.buffer.truncate(0), self.buffer.seek(0))

class FastStdin(io.IOBase):

	def __init__(self, fd=0):
		self.buffer = FastReader(fd)
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

class FastStdout(io.IOBase):

	def __init__(self, fd=1):
		self.buffer = FastWriter(fd)
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.flush = self.buffer.flush
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()


n = int(input())
li = [int(i) for i in input().split()]
s = sum(li)
m = max(li)
if s % 2 == 0 and m <= s - m:
	print('YES')
	exit()
print('NO')


n = int(input())
L = sorted(list(map(int, input().split())))
k = sum(L)
if k % 2 or k < 2 * L[-1]:
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
sum = 0
mx = 0
for i in range(n):
	sum += a[i]
	mx = max(a[i], mx)
if sum % 2 == 1 or mx * 2 > sum:
	print('NO')
else:
	print('YES')


def main():
	N = map(int, input().split())
	v = map(int, input().split())
	sum = 0
	biggest = 0
	for i in v:
		sum = sum + i
		biggest = max(biggest, i)
	if sum % 2 == 0 and biggest <= sum - biggest:
		print('YES')
	else:
		print('NO')
main()


from itertools import accumulate

def solveC():
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	if len(a) == 1:
		print(a[0] + k)
	else:
		a.sort()
		a = a[len(a) // 2:]
		b = list(accumulate(a))
		mx = 0
		if a[0] + k <= a[1]:
			mx = a[0] + k
		for i in range(1, len(a) - 1):
			lmax = a[i + 1]
			if lmax * (i + 1) - b[i] - k > i + 1:
				mx = max(mx, (b[i] + k) // (i + 1))
				break
			elif b[i] + k < lmax * (i + 1):
				mx = max(mx, (b[i] + k) // (i + 1))
			else:
				mx = max(mx, lmax)
		else:
			if b[-1] + k >= a[-1] * len(a):
				mx = max(mx, (b[-1] + k) // len(a))
		print(mx)

def solveB():
	input()
	a = list(map(int, input().split()))
	if sum(a) & 1 or max(a) > sum(a) - max(a):
		print('NO')
	else:
		print('YES')
solveB()


l = int(input())
b = [int(item) for item in input().split()]
if sum(b) % 2 == 0 and max(b) <= sum(b) - max(b):
	print('YES')
else:
	print('NO')


import re
from collections import deque
from functools import reduce
from heapq import *
from itertools import permutations
from math import pi
from operator import itemgetter
from operator import mul
from operator import xor
from os import linesep

def fmatr(matrix, lnsep: str=linesep, fieldsep: str=' ') -> str:
	return lnsep.join(map(lambda row: fieldsep.join(map(str, row)), matrix))

def fbool(boolval: int) -> str:
	return ['No', 'Yes'][boolval]

def solve() -> None:
	(n, *a) = map(int, open(0).read().split())
	sm = sum(a)
	mx = max(a)
	ans = sm % 2 == 0 and mx * 2 <= sm
	print(fbool(ans).upper())
solve()


input()
a = list(map(int, input().split()))
print('YNEOS'[sum(a) % 2 or 2 * max(a) > sum(a)::2])


n = int(input())
l = [int(i) for i in input().split()]
sm = 0
for i in l:
	sm += i
if sm & 1:
	print('NO')
	exit()
m = max(l)
if m > sm - m:
	print('NO')
	exit()
print('YES')


n = int(input())
s = [int(x) for x in input().split()]
tot = sum(s)
if tot % 2:
	print('NO')
else:
	s.sort()
	max_val = max(s)
	sum_rest = sum(s) - max_val
	if sum_rest < max_val:
		print('NO')
	else:
		print('YES')


n = int(input())
a = list(map(int, input().split()))
max_a = max(a)
sum_a = sum(a)
if max_a <= sum_a - max_a and sum_a % 2 == 0:
	print('Yes')
else:
	print('NO')


n = int(input())
arr = [int(x) for x in input().split()]
arr.sort()
answer = False
if ~answer:
	sum = 0
	for i in arr:
		sum += i
if sum % 2 == 0 and arr[-1] * 2 <= sum:
	answer = True
print('YES' if answer else 'NO')


n = int(input())
a = list(map(int, input().split()))
a.sort()
cnt = 0
le = 0
s = 0
for e in a:
	if a != le:
		if cnt % 2 == 1:
			s += le
		le = e
		cnt = 1
	else:
		cnt += 1
s += a[-1] * (cnt % 2)
if s % 2 == 0 and a[-1] * 2 <= s:
	print('YES')
else:
	print('NO')


n = int(input())
arr = input().split()
sum = 0
maxim = 0
for i in range(n):
	temp = int(arr[i])
	sum += temp
	maxim = max(maxim, temp)
if sum % 2 == 0 and maxim <= sum / 2:
	print('YES')
else:
	print('NO')


from sys import stdin
stdin.readline

def mp():
	return list(map(int, stdin.readline().strip().split()))

def it():
	return int(stdin.readline().strip())
n = it()
l = mp()
m = max(l)
if n == 2:
	if abs(l[0] - l[1]) != 0:
		print('NO')
	else:
		print('YES')
elif sum(l) & 1:
	print('NO')
elif sum(l) // 2 >= m:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
sa = sum(a)
ma = max(a)
if sa % 2:
	print('NO')
elif ma > sa - ma:
	print('NO')
else:
	print('YES')


n = int(input())
l = list(map(int, input().split()))
s = 0
(M1, M2) = (0, 0)
for x in l:
	if x > M1:
		s += M2
		(M1, M2) = (x, M1)
	elif M2 < x <= M1:
		s += M2
		M2 = x
	else:
		s += x
e = M1 - M2
if e > s:
	print('NO')
elif (s - e) % 2 == 0:
	print('YES')
else:
	print('NO')


def input(f):
	(n,) = map(int, f.readline().split())
	a = list(map(int, f.readline().split()))
	return (n, a)

def solve(n, a):
	max_a = max(a)
	if sum(a) % 2 == 0 and max_a <= sum(a) - max_a:
		return 'YES'
	else:
		return 'NO'
import sys
print(solve(*input(sys.stdin)))


n = int(input())
l = [int(x) for x in input().split()]
index = l.index(max(l))
if sum(l) % 2 == 0 and sum(l[:index]) + sum(l[index + 1:]) >= max(l):
	print('YES')
else:
	print('NO')


L = int(input())
arr = list(map(int, input().split()))
s = 0
m = max(arr)
for i in arr:
	s += i
if s % 2 == 1 or s < 2 * m:
	print('NO')
else:
	print('YES')


import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
from heapq import heappush as hpush
from heapq import heappop as hpop
mod = 10 ** 9 + 7

def ri(flag=0):
	if flag == 0:
		return [int(i) for i in sys.stdin.readline().split()]
	else:
		return int(sys.stdin.readline())
n = ri(1)
a = ri()
a.sort()
take = sum(a) - a[-1]
if sum(a) % 2 == 0 and a[-1] <= take:
	print('YES')
else:
	print('NO')


n = int(input())
a = sorted(list(map(int, input().split())))
if sum(a) % 2 == 0 and a[-1] <= sum(a[0:n - 1]):
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
mx = max(arr)
sm = sum(arr)
if sm - mx < mx or sm % 2 == 1:
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
if sum(a) % 2 == 1:
	print('NO')
	exit()
elif sum(a) - max(a) >= max(a):
	print('YES')
else:
	print('NO')


n = int(input())
S = list(map(int, input().split()))
if sum(S) % 2 != 0:
	print('NO')
elif sum(S) < 2 * max(S):
	print('NO')
else:
	print('YES')


n = map(int, input().split())
arr = list(map(int, input().split()))
sum = 0
maxm = 0
for i in range(len(arr)):
	sum += arr[i]
	maxm = max(maxm, arr[i])
if sum & 1 or sum - maxm < maxm:
	print('NO')
else:
	print('YES')


def cal(l, e, o):
	for i in l:
		if i % 2 == 0:
			e += 1
		else:
			o += 1
	if o % 2 == 0:
		return True
	else:
		return False
n = int(input())
l = list(map(int, input().split()))[:n]
l.sort(reverse=True)
c = 0
e = 0
o = 0
ans = 'NO'
if sum(l) % 2 == 1:
	print('NO')
	exit()
elif max(l) % 2 == 1 and cal(l, e, o) and (sum(l) - max(l) >= max(l)):
	ans = 'YES'
elif max(l) % 2 == 0 and cal(l, e, o) and (sum(l) - max(l) >= max(l)):
	ans = 'YES'
print(ans)


n = int(input())
l = list(map(int, input().split()))
s = sum(l)
n1 = max(l)
if s % 2 == 0 and n1 * 2 <= s:
	print('YES')
else:
	print('NO')


import os
import sys
import math
from io import BytesIO, IOBase
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

def dijkstra(start, distance, path, n):
	visited = [False for _ in range(n)]
	distance[start] = 0
	for i in range(n):
		v = -1
		for j in range(n):
			if not visited[v] and (v == -1 or distance[j] < distance[v]):
				v = j
		if distance[v] == math.inf:
			break
		visited[v] = True
		for edge in adj[v]:
			destination = edge[0]
			weight = edge[1]
			if distance[v] + weight < distance[destination]:
				distance[destination] = distance[v] + weight
				path[destination] = v

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def lcm(a, b):
	return a * b // gcd(a, b)

def ncr(n, r):
	return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def npr(n, r):
	return math.factorial(n) // math.factorial(n - r)

def seive(n):
	primes = [True] * (n + 1)
	ans = []
	for i in range(2, n):
		if not primes[i]:
			continue
		j = 2 * i
		while j <= n:
			primes[j] = False
			j += i
	for p in range(2, n + 1):
		if primes[p]:
			ans += [p]
	return ans

def factors(n):
	factors = []
	x = 1
	while x * x <= n:
		if n % x == 0:
			if n // x == x:
				factors.append(x)
			else:
				factors.append(x)
				factors.append(n // x)
		x += 1
	return factors

def main():
	try:
		n = inp()
		a = inlt()
		s = sum(a)
		m = max(a)
		if s % 2 or 2 * m > s:
			print('NO')
		else:
			print('YES')
	except Exception as e:
		print(e)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


n = int(input())
s = list(map(int, input().split()))
x = sum(s)
if x % 2 == 1:
	print('NO')
else:
	for c in s:
		if c > x - c:
			print('NO')
			return
	print('YES')


n = int(input())
a = []
x = input().split()
for i in range(n):
	a.append(int(x[i]))
sum = 0
for i in a:
	sum += i
if sum % 2 == 0 and max(a) <= sum - max(a):
	print('Yes')
else:
	print('No')


n = int(input())
a = list(map(int, input().split()))
m = max(a)
s = sum(a)
print('NO' if s % 2 or m * 2 > s else 'YES')


from sys import stdin, stdout

def INI():
	return int(stdin.readline())

def INL():
	return [int(_) for _ in stdin.readline().split()]

def INS():
	return stdin.readline()

def MOD():
	return pow(10, 9) + 7

def OPS(ans):
	stdout.write(str(ans) + '\n')

def OPL(ans):
	[stdout.write(str(_) + ' ') for _ in ans]
	stdout.write('\n')
n = INI()
A = INL()
m = max(A)
s = sum(A) - m
if sum(A) % 2 == 0 and m <= s:
	OPS('YES')
else:
	OPS('NO')


n = int(input())
a = sorted(map(int, input().split()))
s = sum(a)
if s % 2 != 0 or max(a) > s // 2:
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
f = 1
s = sum(a)
maxx = max(a)
if s % 2 == 1:
	print('NO')
else:
	s -= maxx
	if s >= maxx:
		print('YES')
	else:
		print('NO')


I = lambda : int(input())
IL = lambda : list(map(int, input().split()))
IF = lambda : list(map(float, input().split()))
n = I()
A = IL()
print('YES' if sum(A) % 2 == 0 and max(A) * 2 <= sum(A) else 'NO')


n = int(input())
b = list(map(int, input().strip().split()))
m = 0
s = 0
can = True
for i in b:
	m = max(m, i)
	s += i
if s % 2:
	can = False
if 2 * m > s:
	can = False
if can:
	print('YES')
else:
	print('NO')


n = int(input())
l = list(map(int, input().split()))
l.sort()
su = sum(l)
tm = sum(l[:n - 1])
if su % 2 == 0 and tm >= l[n - 1]:
	print('YES')
else:
	print('NO')


n = int(input())
inps = [int(x) for x in input().split()]
sum = 0
maxi = 0
for i in range(n):
	sum += inps[i]
	maxi = max(maxi, inps[i])
if sum % 2 == 0 and 2 * maxi <= sum:
	print('YES')
else:
	print('NO')


input()
data = sorted([int(i) for i in input().split()])
print('YES' if data[-1] <= sum(data[:-1]) and (not sum(data) % 2) else 'NO')


input()
a = [int(c) for c in input().split()]

def funct(a):
	a.sort()
	if sum(a) % 2 != 0:
		return 'NO'
	if a[-1] > sum(a[:len(a) - 1]):
		return 'NO'
	return 'YES'
print(funct(a))


n = int(input())
u = list(map(int, input().split()))
s = sum(u)
if s % 2 == 1:
	print('NO')
elif s - max(u) * 2 < 0:
	print('NO')
else:
	print('YES')


n = int(input())
a = input()
A = list(map(int, list(a.split())))
if sum(A) % 2 != 0:
	print('No')
elif max(A) <= sum(A) - max(A):
	print('Yes')
else:
	print('No')


n = int(input())
a = sorted(list(map(int, input().split())))
s = sum(a)
if s % 2 or s - a[-1] < a[-1]:
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
sum = 0
maxx = 0
for i in a:
	sum += i
	maxx = max(i, maxx)
if sum % 2 == 0:
	if sum - maxx < maxx:
		print('NO')
	else:
		print('YES')
else:
	print('NO')


n = int(input())
l = [int(i) for i in input().split(' ')]
sum = 0
oddCount = 0
for i in l:
	sum += i
test = sum % 2 == 0
for i in l:
	if i > sum / 2:
		test = False
		break
if test:
	print('YES')
else:
	print('NO')


n = int(input())
ar = list(map(int, input().split()))
su = sum(ar)
flag = True
if su % 2 != 0:
	flag = False
for i in range(n):
	if su - ar[i] < ar[i]:
		flag = False
if flag:
	print('YES')
else:
	print('NO')


from collections import defaultdict
import heapq
n = int(input())
l = list(map(int, input().split()))
s = sum(l)
if s % 2 == 1:
	print('NO')
else:
	f = 0
	for i in l:
		rem = s - i
		if i > rem:
			f = 1
			break
	if f == 0:
		print('YES')
	else:
		print('NO')


limit = int(input())
elements = input()
parse = elements.split(' ')
arr = []
for i in parse:
	arr.append(int(i))
sum = 0
for i in range(0, limit):
	sum += arr[i]
stop = False
if sum % 2 != 0:
	stop = True
for j in range(0, limit):
	if arr[j] > sum // 2:
		stop = True
		break
if stop:
	print('No')
else:
	print('Yes')


import sys
import math
import bisect

def solve(A):
	n = len(A)
	A.sort()
	if A[-1] > sum(A[:-1]):
		return False
	return sum(A) % 2 == 0

def main():
	n = int(input())
	A = list(map(int, input().split()))
	ans = solve(A)
	if ans:
		print('YES')
	else:
		print('NO')
main()


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
n = int(data())
arr = l()
s = sum(arr)
if s & 1:
	out('NO')
	exit()
for i in range(n):
	if arr[i] > s - arr[i]:
		out('NO')
		exit()
out('YES')


input()
a = sorted(map(int, input().split()))
if sum(a) & 1 or a[-1] > sum(a[:-1]):
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
d = sum(a)
if d % 2 == 1:
	print('NO')
	exit()
for i in a:
	tc = d - i
	if i > tc:
		print('NO')
		exit()
print('YES')


from sys import stdin, stdout
import math
import collections
input = stdin.readline

def print(x='', end='\n'):
	stdout.write(str(x) + end)

def solve():
	n = int(input())
	l = list(map(int, input().split()))
	l.sort()
	ss = sum(l)
	if ss % 2 == 0 and l[-1] <= ss - l[-1]:
		print('YES')
	else:
		print('NO')
tt = 1
for __ in range(tt):
	solve()


from sys import stdin, stdout
from math import gcd, sqrt, inf
from collections import deque
input = stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\n')
L = lambda : list(R())
hg = lambda x, y: (y + x - 1) // x * x
pw = lambda x: 1 if x == 1 else 1 + pw(x // 2)
chk = lambda x: chk(x // 2) if not x % 2 else True if x == 1 else False
M = inf
n = I()
(*a,) = R()
if sum(a) % 2 == 0 and max(a) <= sum(a) - max(a):
	print('YES')
else:
	print('NO')


from math import *
from collections import *
from itertools import *
from functools import *
from random import *

def getl(t=int):
	return [t(x) for x in input().split()]

def get(t=int):
	return t(input())
alphabet = [chr(x) for x in range(ord('a'), ord('z') + 1)]
alnum = lambda x: ord(x) - ord('a')

def main():
	n = get()
	a = getl()
	m = max(a)
	s = sum(a) - m
	if m <= s and (s + m) % 2 == 0:
		print('YES')
	else:
		print('NO')
main()


from collections import defaultdict
n = int(input())
arr = list(map(int, input().split(' ')))
sum_ = 0
for x in arr:
	sum_ += x
print('YES' if sum_ % 2 == 0 and 2 * max(arr) <= sum_ else 'NO')


n = input()
a = list(map(int, input().split()))
maxn = -1
sum = 0
i = 0
while i in range(0, int(n)):
	sum += a[i]
	maxn = max(a[i], maxn)
	i = i + 1
if sum % 2 == 0 and maxn * 2 <= sum:
	print('YES')
else:
	print('NO')


n = int(input())
array = list(map(int, input().split(' ')))
sum = 0
for i in range(n):
	sum += array[i]
if sum % 2 or 2 * max(array) > sum:
	print('NO')
else:
	print('YES')


n = int(input())
a = sorted(map(int, input().split()))
s = sum(a)
m = max(a)
if s % 2:
	print('NO')
elif m * 2 > s:
	print('NO')
else:
	print('YES')


n = int(input())
numbers = [int(x) for x in input().split(' ')]
summation = sum(numbers)
maximum = max(numbers)
if summation % 2 == 0 and maximum <= summation - maximum:
	print('YES')
else:
	print('NO')


(n, a) = (int(input()), list(map(int, input().split())))
if sum(a) % 2 == 1 or max(a) * 2 > sum(a):
	print('NO')
else:
	print('YES')


arraysize = int(input())
insert = input()
insert = insert.split()
numbers = []
for i in range(0, arraysize):
	numbers.append(int(insert[i]))
total = sum(numbers)
maximum = max(numbers)
if maximum <= total - maximum and total % 2 == 0:
	print('YES')
else:
	print('NO')


def solve():
	n = int(input())
	s = list(map(int, input().split()))
	x = sum(s)
	m = max(s)
	if x % 2 == 1 or m > x / 2:
		print('NO')
	else:
		print('YES')
solve()


n = int(input())
lst = list(map(int, input().split()))
if sum(lst) % 2 == 0:
	lst.sort()
	if n == 2:
		if lst[0] == lst[1]:
			print('YES')
		else:
			print('NO')
	elif sum(lst[0:n - 2]) >= lst[-1] - lst[-2]:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


import sys
input = sys.stdin.readline
n = int(input())
A = list(map(int, input().split()))
if sum(A) % 2 == 0 and max(A) <= sum(A) - max(A):
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
sum = 0
for i in arr:
	sum += i
if sum % 2 == 1:
	print('NO')
else:
	m = max(arr)
	t = sum - m
	if t >= m:
		print('YES')
	else:
		print('NO')


a = int(input())
A = list(map(int, input().split()))
m = max(A)
s = sum(A)
if s - m >= m and s % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input())
l = list(map(int, input().split()))
sum = 0
l.sort()
for i in range(n):
	sum += l[i]
s = sum - l[n - 1]
if sum % 2 is 0 and l[n - 1] <= s:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout, exit
n = int(stdin.readline())
a = list(map(int, stdin.readline().split()))
a.sort(reverse=True)
cur = sum(a)
if cur % 2 == 1:
	print('NO')
	exit()
if a[0] > cur - a[0]:
	print('NO')
	exit()
print('YES')


def solve(A):
	A.sort()
	if sum(A) % 2:
		return 'NO'
	elif sum(A[:-1]) < A[-1]:
		return 'NO'
	else:
		return 'YES'
N = int(input())
A = list(map(int, input().split()))
ans = solve(A)
print(ans)


n = int(input())
a = list(map(int, input().split()))
M = max(a)
s = sum(a)
res = 0 if s % 2 == 0 and s - M >= M else 1
print('YNEOS'[res::2])


n = int(input())
a = [int(s) for s in input().split()]
m = max(a)
s = sum(a) - m
if s >= m and s % 2 == m % 2:
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
summ = sum(arr)
if summ % 2 == 0 and summ >= 2 * max(arr):
	print('YES')
else:
	print('NO')


N = int(input())
arr = list(map(int, input().split()))
sum_of_arr = sum(arr)
if sum_of_arr % 2 == 0 and max(arr) <= sum_of_arr // 2:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
n = int(stdin.readline())
a = list(map(int, stdin.readline().split()))
calc = 0
for i in range(0, n):
	calc += a[i]
if calc % 2 == 0 and calc - max(a) >= max(a):
	print('Yes')
else:
	print('NO')


def solve(a, l):
	m_v = max(a)
	s = sum(a)
	if s % 2 == 0 and s - m_v >= m_v:
		return 'YES'
	return 'NO'
n = int(input())
array = list(map(int, input().split()))
array.sort()
print(solve(array, n))


import sys
import math as mt
input = sys.stdin.buffer.readline
t = 1
for __ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	suma = sum(l[:])
	maxi = max(l[:])
	if suma % 2 == 0 and suma - maxi >= maxi:
		print('YES')
	else:
		print('NO')


n = int(input())
a = list(map(int, input().split()))
a.sort()
s = sum(a)
if s % 2 == 0:
	k = max(a)
	if s >= 2 * k:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


n = int(input())
A = list(map(int, input().split()))
s = A[0]
m = A[0]
for i in range(1, n):
	s += A[i]
	m = max(A[i], m)
if s % 2 == 0 and m <= s - m:
	print('YES')
else:
	print('NO')


n = int(input())
l = [int(i) for i in input().split()]
if sum(l) % 2 == 0 and max(l) <= sum(l) - max(l):
	print('YES')
else:
	print('NO')


q = int(input())
w = list(map(int, input().split()))
e = sum(w)
r = max(w)
if e % 2 == 0:
	if r > e - r:
		print('NO')
	elif r <= e - r:
		print('YES')
else:
	print('NO')


from sys import stdin
input = stdin.readline
n = int(input())
a = list(map(int, input().split()))
s = sum(a)
for i in range(n):
	if a[i] > s - a[i]:
		print('NO')
		break
else:
	if s % 2 == 0:
		print('YES')
	else:
		print('NO')


def solve(arr):
	total = 0
	max_so_far = float('-inf')
	for (i, value) in enumerate(arr):
		max_so_far = max(max_so_far, value)
		total += value
	return not (total % 2 != 0 or max_so_far > total // 2)

def main():
	_ = input()
	arr = [int(x) for x in input().strip().split()]
	print('YES' if solve(arr) else 'NO')
main()


n = int(input())
a = [int(i) for i in input().split()]
sum = 0
for i in range(0, len(a)):
	sum = sum + a[i]
d = max(a)
sums = sum - d
if sum % 2 == 0 and d <= sums:
	print('YES')
else:
	print('NO')


class Read:

	@staticmethod
	def int():
		return int(input())

	@staticmethod
	def list(sep=' '):
		return input().split(sep)

	@staticmethod
	def list_int(sep=' '):
		return list(map(int, input().split(sep)))

def solve():
	n = Read.int()
	a = Read.list_int()
	a.sort()
	f = 0
	for i in a:
		f += i
	if f % 2 == 1:
		print('NO')
	elif a[-1] > f - a[-1]:
		print('NO')
	else:
		print('YES')
query_count = 1
for j in range(query_count):
	solve()


R = lambda : map(int, input().split())
n = int(input())
L = sorted(R())
s = sum(L)
if s % 2:
	print('NO')
else:
	print('YNEOS'[s // 2 < L[n - 1]::2])


t = int(input())
numbers = [int(x) for x in input().split()]
s = sum(numbers)
m = max(numbers)
if s % 2 == 0 and s >= 2 * m:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout

class Solve:

	def __init__(self):
		R = stdin.readline
		W = stdout.write
		n = int(input())
		a = [int(x) for x in R().split()]
		a.sort()
		s = sum(a)
		if s % 2 == 0 and s - a[n - 1] >= a[n - 1]:
			W('YES')
		else:
			W('NO')

def main():
	s = Solve()
main()


n = int(input())
w = [int(k) for k in input().split()]
c = sum(w)
if c % 2 == 0 and 2 * max(w) <= c:
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
a.sort()
if sum(a) % 2 == 1:
	print('NO')
elif sum(a) < 2 * a[n - 1]:
	print('NO')
else:
	print('YES')


n = int(input())
li = list(map(int, input().split(' ')))
s = sum(li)
if s % 2 == 1:
	print('NO')
elif len(li) % 2 == 1:
	if max(li) > sum(li) - max(li):
		print('NO')
	else:
		print('YES') if sum(li) >= len(li) + 1 else print('NO')
elif max(li) > sum(li) - max(li):
	print('NO')
else:
	print('YES') if sum(li) >= len(li) else print('NO')


_ = input()
A = [int(x) for x in input().split()]
a = sum(A)
print(['NO', 'YES'][a % 2 == 0 and all([x <= a // 2 for x in A])])


n = int(input())
a = [*map(int, input().split())]
max_elem = max(a)
sum_list = sum(a)
print('YES' if sum_list % 2 == 0 and max_elem <= sum_list - max_elem else 'NO')


n = int(input())
s = input()
l = s.split(' ')
p = 0
l1 = []
for i in l:
	l1.append(int(i))
for i in l1:
	p = p + i
q = max(l1)
if p % 2 == 1 or 2 * q > p:
	print('No')
else:
	print('Yes')


input()
l = list(map(int, input().split()))
print('YNEOS'[sum(l) % 2 or 2 * max(l) > sum(l)::2])


n = int(input())
arreglo = list(map(int, input().split(' ')))
suma = 0
mayor = 0
for i in arreglo:
	suma += i
	mayor = max(i, mayor)
if suma % 2 == 0:
	if suma - mayor >= mayor:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


input()
nums = [int(i) for i in input().split()]
okay = sum(nums) % 2 == 0 and max(nums) * 2 <= sum(nums)
print('YES' if okay else 'NO')


n = int(input())
a = list(map(int, input().split()))
(o, e) = (0, 0)
(q, w) = ([], [])
for i in a:
	if i % 2:
		o += 1
	else:
		e += 1
if o & 1:
	print('NO')
	exit(0)
print('YES' if sum(a) - max(a) >= max(a) else 'NO')


n = int(input())
a = list(map(int, input().split()))
m = max(a)
s = sum(a)
if s % 2 > 0:
	print('NO')
elif m > s - m:
	print('NO')
else:
	q = s // n
	r = s % n
	if n % 2 == 0:
		if r % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif q % 2 == 0:
		if r % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif r % 2 == 1:
		print('YES')
	else:
		print('NO')


def inp(type):
	return list(map(type, input().split()))

def main():
	n = int(input())
	a = inp(int)
	sum = 0
	mx = 0
	for x in a:
		sum = sum + x
		mx = max(mx, x)
	if mx > sum / 2:
		print('NO')
		exit(0)
	if sum % 2 == 0:
		print('YES')
	else:
		print('NO')
main()


n = int(input())
a = list(map(int, input().strip().split()))
s = sum(a)
flag = 1
for i in a:
	if s % 2 == 1:
		flag = 0
	elif s - i < i:
		flag = 0
if flag == 1:
	print('YES')
else:
	print('NO')


n = int(input())
a = [*list(map(int, input().split()))]
sa = sum(a)
ma = max(a)
print('YNEOS'[sa % 2 or ma > sa - ma::2])


import sys
n = int(input())
lis = list(map(int, input().split()))
ans = 0
ans = sum(lis) % 2
if ans == 1:
	print('NO')
else:
	lis.sort()
	if sum(lis[0:n - 1]) >= lis[n - 1]:
		print('YES')
	else:
		print('NO')


from sys import stdin

def iinput():
	return int(stdin.readline())

def minput():
	return map(int, stdin.readline().split())

def linput():
	return list(map(int, stdin.readline().split()))
n = iinput()
a = linput()
a.sort()
print('YES' if sum(a) % 2 == 0 and a[-1] <= sum(a) - a[-1] else 'NO')


n = int(input())
lis = sorted(map(int, input().split()))
s = sum(lis)
if s % 2 == 0 and max(lis) <= s - max(lis):
	print('YES')
else:
	print('NO')


def truncateArray(n, arr):
	sum = 0
	mx = 0
	for i in range(n):
		sum += arr[i]
		mx = max(mx, arr[i])
	return sum % 2 == 0 and mx <= sum / 2
n = int(input())
arr = list(map(int, input().strip().split()))[:n]
if truncateArray(n, arr):
	print('YES')
else:
	print('NO')


from sys import stdin

def ii():
	return int(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def li():
	return list(mi())
n = ii()
a = li()
x = z = 0
m = max(a)
mm = a.index(m)
for i in range(n):
	if a[i] % 2:
		x += 1
	if i != mm and z < m:
		z += a[i]
x = x % 2
if z < m:
	x = 1
print(['YES', 'NO'][x])


n = int(input())
arr = [int(i) for i in input().split()]
sum_arr = sum(arr)
max_arr = max(arr)
if sum_arr % 2 == 1:
	print('NO')
elif max_arr > sum_arr - max_arr:
	print('NO')
else:
	print('YES')


import sys
import bisect as bi
import math
from collections import defaultdict as dd
import heapq
import itertools
import io
import os
input = sys.stdin.readline
import random
mo = 10 ** 9 + 7

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())
for _ in range(1):
	n = inin()
	l = ain()
	l.sort()
	s = sum(l[:n - 1])
	if (s + l[-1]) % 2 or l[-1] > s:
		print('NO')
	else:
		print('YES')


m = int(input())
a = [int(x) for x in input().split(' ')]
a.sort()
if sum(a) % 2 != 0:
	print('NO')
elif sum(a[0:len(a) - 1]) >= a[-1]:
	print('YES')
else:
	print('NO')


n = int(input())
a = []
summ = 0
s = map(int, input().split())
a = list(s)
for i in range(n):
	summ += a[i]
if summ % 2 == 0 and max(a) <= summ - max(a):
	print('YES')
else:
	print('NO')


from collections import deque
n = int(input())
a = list(map(int, input().split()))
a.sort()
if sum(a) % 2 == 0 and sum(a[0:-1]) >= a[-1]:
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(i) for i in input().split()]
s1 = sum(a)
s2 = max(a)
s3 = s1 - s2
if s1 % 2 != 0:
	print('NO')
elif s2 > s3:
	print('NO')
else:
	print('YES')


n = int(input())
a = sorted(map(int, input().split()))
if max(a) > sum(a[:-1]):
	print('NO')
elif sum(a) % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input())
x = list(map(int, input().split()))
if sum(x) % 2 != 0 or 2 * max(x) > sum(x):
	print('NO')
else:
	print('YES')


import sys
input = sys.stdin.readline
n = int(input())
A = [int(i) for i in input().split()]
if sum(A) % 2 == 0 and max(A) * 2 <= sum(A):
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
s = 0
m = 0
for i in a:
	s += i
	if i > m:
		m = i
if s % 2 == 0 and s >= 2 * m:
	print('Yes')
else:
	print('No')


import collections
n = int(input())
a = list(map(int, input().split()))
a.sort()
print('YES' if not sum(a) % 2 and a[-1] <= sum(a) - a[-1] else 'NO')


[n] = [int(w) for w in input().split()]
a = [int(w) for w in input().split()]
t = max(a)
s = sum(a)
r = s % 2 == 0 and s >= 2 * t
print('YES' if r else 'NO')


from collections import *
n = int(input())
l = list(map(int, input().split()))
add = sum(l)
if add % 2 == 0 and max(l) <= add // 2:
	print('YES')
else:
	print('NO')


n = int(input())
l = [int(x) for x in input().split()]
s = sum(l)
a = max(l)
if s % 2 == 1:
	print('NO')
elif a > s // 2:
	print('NO')
else:
	print('YES')


R1 = lambda : list(map(int, input().split()))
R2 = lambda : int(input())
n = R2()
A = R1()
(m, s) = (max(A), sum(A))
if s % 2 == 0 and m <= s - m:
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(x) for x in input().split()]
suma = sum(a)
maximo = max(a)
if suma % 2 != 0 or suma - maximo < maximo:
	print('NO')
else:
	print('YES')


size = int(input())
x = 0
s = 0
maxi = 0
x = input().split(' ')
for i in x:
	t = int(i)
	s += t
	maxi = max(maxi, t)
if s % 2 == 0:
	if 2 * maxi > s:
		print('NO')
	else:
		print('YES')
else:
	print('NO')


input()
ar = list(map(int, input().split()))
is_odd_count_even = sum([1 for i in ar if i % 2 == 1]) % 2 == 0
mx = max(ar)
is_max_smaller_than_sum_of_other_numbers = mx <= sum(ar) - mx
print('YES' if is_odd_count_even and is_max_smaller_than_sum_of_other_numbers else 'NO')


from collections import Counter
n = int(input())
l = [int(x) for x in input().split()]
if sum(l) % 2 != 0:
	print('NO')
else:
	l.sort()
	if sum(l) - l[-1] < l[-1]:
		print('NO')
	else:
		print('YES')


import sys
inf = float('inf')
(mod, MOD) = (1000000007, 998244353)

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
n = int(input())
Arr = get_array()
x = sum(Arr)
if x & 1:
	print('NO')
else:
	flag = 0
	for i in Arr:
		if i > x - i:
			flag = 1
			break
	if flag == 0:
		print('YES')
	else:
		print('NO')


n = int(input())
lista = list(map(int, input().split()))
lista.sort(reverse=True)
if sum(lista) % 2 == 0 and lista[0] <= sum(lista[1:]):
	print('YES')
else:
	print('NO')


n = int(input())
arr = [int(i) for i in input().split()]
arr.sort()
pre_arr = [0] * (n + 1)
for i in range(n - 1, -1, -1):
	pre_arr[i] = pre_arr[i + 1] + arr[i]
if pre_arr[0] % 2 == 0:
	mid = pre_arr[0] // 2
	count = start = 0
	while arr[start] + count <= mid:
		count += arr[start]
		start += 1
	if count == mid:
		print('YES')
	elif start == n - 1:
		print('NO')
	else:
		t1 = count
		t2 = pre_arr[start + 1]
		div = arr[start]
		temp = t2 - t1 + div
		if temp % 2 == 0:
			print('YES')
		else:
			print('NO')
else:
	print('NO')


def f():
	input()
	a = [int(x) for x in input().split()]
	s = sum(a)
	m = max(a)
	if s % 2 == 0 and m <= s / 2:
		return 'YES'
	return 'NO'

def main():
	print(f())
main()


n = int(input())
ls = list(map(int, input().split()))
sums = [0] * n
mins = [0] * n
sums[0] = ls[0]
mins[0] = ls[0]
for i in range(1, n):
	sums[i] = sums[i - 1] + ls[i]
	if ls[i] > sums[i - 1]:
		mins[i] = ls[i] - sums[i - 1]
	elif mins[i - 1] >= ls[i]:
		mins[i] = mins[i - 1] - ls[i]
	elif ls[i] % 2 == sums[i - 1] % 2:
		mins[i] = 0
	else:
		mins[i] = 1
if mins[-1] == 0:
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
max_ele = 0
add = 0
for i in range(n):
	if arr[i] > max_ele:
		max_ele = arr[i]
	add += arr[i]
print('YES' if add % 2 == 0 and max_ele <= add - max_ele else 'NO')


def solve(n, ar):
	ar.sort()
	if sum(ar) % 2 == 1 or sum(ar) < max(ar) * 2:
		print('NO')
	else:
		print('YES')
	return
n = int(input())
ar = list(map(int, input().split()))
solve(n, ar)


from sys import *
n = int(stdin.readline())
a = list(map(int, stdin.readline().split()))
s = sum(a) % 2
if s == 0 and max(a) <= sum(a) - max(a):
	print('YES')
else:
	print('NO')


n = int(input())
xs = [int(x) for x in input().split()]
s = sum(xs)
ma = max(xs)
print('YES' if s % 2 == 0 and ma * 2 <= s else 'NO')


n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
maxa = a[0]
summa = 0
for i in range(1, n):
	summa += a[i]
if (summa + maxa) % 2 or summa < maxa:
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
s = sum(a)
for i in range(n):
	if a[i] > s - a[i]:
		print('NO')
		break
else:
	print('YNEOS'[s & 1::2])


a = int(input())
c = list(map(int, input().split()))
flag = 0
b = sum(c)
if b % 2 == 0:
	for i in c:
		if i > b // 2:
			print('NO')
			flag = 1
			break
	if flag == 0:
		print('YES')
else:
	print('NO')


n = int(input())
ar = list(map(int, input().split()))[:n]
s = sum(ar)
t = max(ar)
if s % 2 or t > s - t:
	print('NO')
else:
	print('YES')


input()
a = (*map(int, input().split()),)
s = sum(a)
print('YNEOS'[s % 2 or any((x > s // 2 for x in a))::2])


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import Counter
import heapq
from collections import Counter
n = int(input())
arr = list(map(int, input().split()))
cnt = 0
arr.sort()
s = sum(arr)
if s % 2 == 0 and arr[-1] <= sum(arr[:n - 1]):
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(x) for x in input().split()]
total = sum(a)
if total % 2:
	print('NO')
else:
	req = total // 2
	sub_total = 0
	ind = 0
	a.sort()
	for i in range(len(a)):
		sub_total += a[i]
		if sub_total >= req:
			ind = i
			break
	if ind != len(a) - 1:
		print('YES')
	else:
		print('NO')


n = int(input())
a = []
s = map(int, input().split())
a = list(s)
sm = 0
mx = 0
for i in range(n):
	x = a[i]
	sm += x
	mx = max(x, mx)
if sm % 2 or mx > sm / 2:
	print('NO')
else:
	print('YES')


n = int(input())
arr = list(map(int, input().split()))
arr.sort()
sm = sum(arr)
if arr[-1] * 2 <= sm and sm % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input())
s = [int(x) for x in input().split()]
tot = sum(s)
if tot % 2:
	print('NO')
else:
	s.sort()
	cur = n - 1
	i = n - 2
	while i >= 0:
		if s[cur] >= s[i]:
			s[cur] -= s[i]
			s[i] = 0
			i -= 1
		else:
			s[cur] = 0
			s[i] -= s[cur]
			cur = i
	if s[cur]:
		print('NO')
	else:
		print('YES')


a = input()
b = list(map(int, input().split()))
maxa = -1
sum = 0
i = 0
while i in range(0, int(a)):
	sum += b[i]
	maxa = max(b[i], maxa)
	i = i + 1
if sum % 2 == 0 and maxa * 2 <= sum:
	print('YES')
else:
	print('NO')


n = int(input())
l = list(map(int, input().split()))
if sum(l) % 2 == 1:
	print('No')
elif max(l) <= sum(l) // 2:
	print('YES')
else:
	print('NO')


import sys
import math
import operator as op
from functools import reduce

def read_line():
	return sys.stdin.readline()[:-1]

def read_int():
	return int(sys.stdin.readline())

def read_int_line():
	return [int(v) for v in sys.stdin.readline().split()]

def read_float_line():
	return [float(v) for v in sys.stdin.readline().split()]

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer / denom
t = 1
for i in range(t):
	n = read_int()
	a = read_int_line()
	a.sort()
	su = sum(a)
	sl = su - a[-1]
	if su & 1 == 0 and sl >= a[-1]:
		print('YES')
	else:
		print('NO')


n = int(input())
S = list(map(int, input().split()))
m = max(S)
s = sum(S)
if s % 2 == 1:
	print('NO')
elif m > s - m:
	print('NO')
else:
	print('YES')


import math
skipnum = input('')
arr = list(map(int, input().split()))

def compute():
	nums = arr
	if sum(nums) % 2 == 0 and max(nums) <= sum(nums) - max(nums):
		print('YES')
	else:
		print('NO')
compute()


n = int(input())
a = [int(x) for x in input().strip().split()]
sume = sum(a)
maxx = max(a)
if maxx <= sume - maxx and sume % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
a.sort()
p = [0, 0]
temp = 0
for v in a:
	v += temp
	add = v // 2
	temp = v % 2
print('YES' if temp == 0 and sum(a[:n - 1]) >= a[-1] else 'NO')


p = int(input())
a = sorted(list(map(int, input().split())))
if sum(a) % 2 == 0 and 2 * max(a) <= sum(a):
	print('Yes')
else:
	print('No')


size = int(input())
numbers = list(map(int, input().split()))
total = sum(numbers)
largest = max(numbers)
if total % 2 == 0 and largest <= total - largest:
	print('YES')
else:
	print('NO')


input()
arr = input().split()
newarr = [int(i) for i in arr]
sum = 0
for i in newarr:
	sum += i
if max(newarr) > int(sum / 2):
	print('NO')
	exit()
print('YES') if sum % 2 == 0 else print('NO')


n = int(input())
a = list(map(int, input().split()))
sum = 0
if n == 2:
	if a[0] != a[1]:
		print('NO')
		exit(0)
a = sorted(a)
for i in range(n - 1):
	sum += a[i]
if sum < a[n - 1]:
	print('NO')
	exit(0)
sum += a[n - 1]
if sum % 2 == 0:
	print('YES')
	exit(0)
print('NO')


from math import *
from collections import *

def getl(t=int):
	return [t(x) for x in input().split()]

def get(t=int):
	return t(input())
n = get()
a = getl()
a.sort()
s = 0
for i in a:
	s += i
s -= a[n - 1]
if a[n - 1] <= s and (s + a[n - 1]) % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
a.sort()
sm = 0
for i in range(n - 1):
	sm += a[i]
if sm % 2 == a[n - 1] % 2 and sm >= a[n - 1]:
	print('YES')
else:
	print('NO')


n = int(input())
heights = list(map(int, input().split()))
summa = 0
heights.sort()
for h in heights:
	summa += h
if summa % 2 == 1:
	print('NO')
else:
	maxValue = heights[len(heights) - 1]
	if maxValue > summa - maxValue:
		print('NO')
	else:
		print('YES')


n = int(input())
x = list(map(int, input().split()))
(s, m) = (sum(x), max(x))
if s % 2 == 0 and s - m >= m:
	print('YES')
else:
	print('NO')


n = int(input())
ar = list(map(int, input().split()))
s = sum(ar)
if n == 2:
	if ar[0] == ar[1]:
		print('YES')
	else:
		print('NO')
	exit()
if s % 2 == 0:
	ar.sort()
	s /= 2
	if ar[n - 1] == s:
		print('YES')
		exit()
	if ar[n - 1] > s:
		print('NO')
		exit()
	else:
		print('YES')
else:
	print('NO')


def mp():
	return map(int, input().split())
n = int(input())
a = list(mp())
i = a.index(max(a))
s = sum(a[:i] + a[i + 1:])
if max(a) <= s and sum(a) % 2 == 0:
	print('YES')
else:
	print('NO')


import sys
import math
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
ans = 0
res = 0
for x in a:
	res += x
	if x > ans:
		ans = x
if res % 2 == 0 and ans <= res - ans:
	print('YES')
else:
	print('NO')


def rint():
	return int(input())

def rints():
	return list(map(int, input().split()))
n = rint()
a = rints()
ma = max(a)
su = sum(a)
print('NO' if su % 2 == 1 or ma > su // 2 else 'YES')


n = int(input())
a = list(map(int, input().split()))
s = sum(a)
if not s & 1 and max(a) <= s - max(a):
	print('YES')
else:
	print('NO')


import math
from decimal import *
import random
import sys
n = int(input())
arr = list(map(int, input().split()))
ok = True
sm = sum(arr)
odd = 0
for i in range(n):
	if arr[i] % 2 == 1:
		odd += 1
	if sm - arr[i] < arr[i]:
		ok = False
if odd % 2 == 1:
	ok = False
if ok:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
from collections import Counter
import math

def rsingle_int():
	return int(stdin.readline().rstrip())

def rmult_int():
	return [int(x) for x in stdin.readline().rstrip().split()]

def rmult_str():
	return stdin.readline().rstrip().split()

def r_str():
	return stdin.readline().rstrip()

def rsingle_char():
	return stdin.read(1)

def main():
	n = rsingle_int()
	a = rmult_int()
	possible = True
	sum = 0
	for i in range(n):
		sum += a[i]
	if sum % 2 == 0:
		for i in range(n):
			if a[i] > sum - a[i]:
				possible = False
				break
	else:
		possible = False
	if not possible:
		print('NO')
	else:
		print('YES')
main()


n = int(input())
a = [int(i) for i in input().split()]
s = sum(a)
if s % 2 == 0:
	if max(a) > s // 2:
		print('NO')
	else:
		print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
s = sum(arr)
arr.sort()
if s % 2 != 0:
	print('NO')
else:
	last = arr[-1]
	s = s - last
	if last <= s:
		print('YES')
	else:
		print('NO')


from bisect import insort, bisect_right, bisect_left
from sys import stdout, stdin, setrecursionlimit
from heapq import heappush, heappop, heapify
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from string import *
from queue import *
from math import *
from re import *
from os import *

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = read(self._fd, max(fstat(self._fd).st_size, 8192))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = read(self._fd, max(fstat(self._fd).st_size, 8192))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))
(graph, mod, szzz) = ({}, 10 ** 9 + 7, lambda : sorted(zzz()))

def getStr():
	return input()

def getInt():
	return int(input())

def listStr():
	return list(input())

def getStrs():
	return input().split()

def isInt(s):
	return '0' <= s[0] <= '9'

def input():
	return stdin.readline().strip()

def zzz():
	return [int(i) for i in input().split()]

def output(answer, end='\n'):
	stdout.write(str(answer) + end)

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def getPrimes(N=10 ** 5):
	SN = int(sqrt(N))
	sieve = [i for i in range(N + 1)]
	sieve[1] = 0
	for i in sieve:
		if i > SN:
			break
		if i == 0:
			continue
		for j in range(2 * i, N + 1, i):
			sieve[j] = 0
	prime = [i for i in range(N + 1) if sieve[i] != 0]
	return prime

def primeFactor(n, prime=getPrimes()):
	lst = []
	mx = int(sqrt(n)) + 1
	for i in prime:
		if i > mx:
			break
		while n % i == 0:
			lst.append(i)
			n //= i
	if n > 1:
		lst.append(n)
	return lst
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
n = getInt()
arr = szzz()
s = sum(arr)
s -= arr[-1]
print('Yes' if s >= arr[-1] and s + arr[-1] & 1 == 0 else 'No')


n = int(input())
mass = list(map(int, input().split()))
if sum(mass) % 2 == 1:
	print('NO')
elif 2 * max(mass) <= sum(mass):
	print('YES')
else:
	print('NO')


x = int(input())
s = list(map(int, input().split()))
mx = max(s)
sm = sum(s)
if sm % 2 == 1 or mx > sm - mx:
	print('NO')
else:
	print('YES')


import sys
import math
input = sys.stdin.readline
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
import heapq
infinite = float('inf')
n = int(input())
l = RI()
s = sum(l)
if s % 2 == 1:
	print('NO')
else:
	l.sort()
	s = sum(l[0:n - 1])
	if l[n - 1] > s:
		print('NO')
	else:
		print('YES')


n = int(input())
a = list(map(int, input().split()))
s = sum(a)
if s % 2 != 0:
	print('NO')
else:
	for e in a:
		if e > s - e:
			print('NO')
			break
	else:
		print('YES')


def fastio():
	import sys
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import log2, ceil
from bisect import bisect_right as br, bisect_left as bl
from collections import Counter as C
(n,) = I()
l = I()
k = sum(l)
m = max(l)
if k % 2 == 0 and m <= k - m:
	print('YES')
else:
	print('NO')


import os
import sys
import math
import itertools
from io import BytesIO, IOBase
import os.path
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
mod = 10 ** 9 + 7
pi = 3.141592653589793

def i1():
	return int(sys.stdin.readline())

def sf():
	return sys.stdin.readline()

def mi():
	return map(int, sys.stdin.readline().split())

def arr():
	return list(map(int, sys.stdin.readline().split()))

def pf(ans):
	return sys.stdout.write(str(ans) + '\n')

def gcd(a, b):
	if a == 0:
		return b
	elif b == 0:
		return a
	if a > b:
		return gcd(a % b, b)
	else:
		return gcd(a, b % a)

def lcm(a, b):
	return a * b // gcd(a, b)
if os.path.exists('input_file.txt'):
	sys.stdin = open('input_file.txt', 'r')
	sys.stdout = open('output_file.txt', 'w')

def SOE(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = False
	prime[1] = False
	return prime

def solve():
	n = i1()
	a = arr()
	s = sum(a)
	if s % 2 != 0:
		return 0
	elif max(a) <= s // 2:
		return 1
	else:
		return 0
tc = 1
for t in range(tc):
	if solve():
		print('YES')
	else:
		print('NO')


n = int(input())
ints = input().split(' ')
ints = [int(i) for i in ints]

def solve(n, ints):
	summ = 0
	for i in range(len(ints)):
		summ += ints[i]
	if summ % 2 != 0:
		print('NO')
		return None
	for i in range(n):
		if ints[i] > summ // 2:
			print('NO')
			return None
	print('YES')
solve(n, ints)


n = int(input())
lst = input().split(' ')
lst = [int(i) for i in lst]
total = sum(lst)
max_num = max(lst)
if total % 2 != 0:
	print('NO')
elif max_num > total // 2:
	print('NO')
else:
	print('YES')


q = int(input())
a = list(map(int, input().strip().split()))
d = 0
e = q
f = sum(a) - max(a)
if sum(a) % 2 == 0 and max(a) <= f:
	print('YES')
else:
	print('NO')


n = int(input())
l1 = list(map(int, input().split()))
s = sum(l1)
m = max(l1)
if s & 1 != 0 or m > s - m:
	print('NO')
else:
	print('YES')


n = int(input())
A = [int(x) for x in input().split()]
mx = max(A)
if mx <= sum(A) - mx and sum(A) % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input())
raw_int = input().split()
int_val = [int(x) for x in raw_int]
sum = 0
max_val = max(int_val)
for i in range(n):
	sum = sum + int_val[i]
if sum % 2 == 0 and sum - max_val >= max_val:
	print('YES')
else:
	print('NO')


a = input()
b = list(map(int, input().split()))
k = 0
b = sorted(b)
r = 0
c = 0
while b[-1] > r:
	if c == len(b) - 1:
		print('NO')
		exit()
	r += b[c]
	c += 1
for i in b:
	if i % 2 == 1:
		k += 1
if k % 2 == 1:
	print('NO')
else:
	print('YES')


n = int(input())
arr = [int(s) for s in input().split()]
s = sum(arr)
if s % 2 == 0 and max(arr) * 2 <= s:
	print('YES')
else:
	print('NO')


n = int(input())
ai = list(map(int, input().split()))
num = sum(ai)
if num % 2 == 0:
	if sum(ai) < 2 * max(ai):
		print('NO')
	else:
		print('YES')
else:
	print('NO')


input()
l = list(map(int, input().split()))
q = sum(l)
if q % 2 != 0:
	print('NO')
else:
	max = 0
	for i in l:
		if i > max:
			max = i
	if max > q // 2:
		print('NO')
	else:
		print('YES')


from math import *
n = int(input())
a = [int(x) for x in input().split()]
if n == 2:
	if a[0] == a[1]:
		print('YES')
	else:
		print('NO')
elif sum(a) % 2 != 0:
	print('NO')
elif sum(a) - max(a) >= max(a):
	print('YES')
else:
	print('NO')


import sys, math
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())
import collections as col
import math

def solve():
	N = getInt()
	A = getInts()
	s = sum(A)
	if s % 2 == 1:
		return 'NO'
	m = max(A)
	return 'NO' if m > s / 2 else 'YES'
print(solve())


n = int(input())
s = list(map(int, input().split()))
res = sum(s)
if res % 2 != 0:
	print('NO')
else:
	res = res / 2
	for i in s:
		if i > res:
			print('NO')
			break
	else:
		print('YES')


n = int(input())
A = [int(i) for i in input().split()]
ans = 0
s = sum(A)
m = max(A)
if s % 2 != 0 or m > s - m:
	print('NO')
else:
	print('YES')


input()
arr = list(map(int, input().split()))
sm = sum(arr)
if sm % 2 == 0 and max(arr) <= sm - max(arr):
	print('YES')
else:
	print('NO')


n = int(input())
assert 2 <= n <= 100000
li = list(map(int, input().split()))
su = sum(li)
if su % 2 == 0:
	for item in li:
		if su < item << 1:
			print('NO')
			break
	else:
		print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000)

def getN():
	return int(input())

def getList():
	return list(map(int, input().split()))
import math
from bisect import bisect_left
n = getN()
nums = getList()
if sum(nums) % 2 == 1:
	print('NO')
	return
if max(nums) * 2 > sum(nums):
	print('NO')
	return
print('YES')


num = int(input())
inp1 = input()
nums = inp1.split()
for i in range(num):
	nums[i] = int(nums[i])
count = sum(nums)
sorted(nums)
if count % 2 == 1:
	print('NO')
elif max(nums) <= count - max(nums):
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline
n = int(input())
lis = list(map(int, input().split()))
s = sum(lis)
m = max(lis)
if s % 2 == 0 and m <= s - m:
	print('YES')
else:
	print('NO')


n = int(input())
array = list(map(int, input().split()))
m = array[0]
s = 0
for i in array:
	s += i
	if i > m:
		m = i
if s % 2 == 1:
	print('NO')
elif m > s // 2:
	print('NO')
else:
	print('YES')


lent = int(input())
mass = list(map(int, input().split()))
maxx = -1
summ = 0
for j in range(lent):
	i = mass[j]
	maxx = max(maxx, i)
	summ += i
if summ % 2 == 0 and 2 * maxx <= summ:
	print('YES')
else:
	print('NO')


arsz = int(input())
arr = [int(j) for j in input().split()]
l = len(arr)
s = 0
s1 = 0
m = 0
for e in arr:
	s = s + e
	m = max(e, m)
arr1 = arr[:]
arr1.remove(m)
for e in arr1:
	s1 = s1 + e
if s & 1 or m * 2 > s:
	print('NO')
else:
	print('YES')


import os
import sys
from io import BytesIO, IOBase
import math
from decimal import *
getcontext().prec = 25
MOD = pow(10, 9) + 7
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def binary_search(data, val, le):
	test = le
	if val >= data[-1]:
		return [test - 1, test - 1]
	elif val <= data[0]:
		return [0, 0]
	high_index = test - 1
	low_index = 0
	while high_index > low_index:
		index = (high_index + low_index) // 2
		sub = data[index]
		if data[low_index] == val:
			return [low_index, low_index]
		elif sub == val:
			return [index, index]
		elif data[high_index] == val:
			return [high_index, high_index]
		elif sub > val:
			if high_index == index:
				return sorted([high_index, low_index])
			high_index = index
		else:
			if low_index == index:
				return sorted([high_index, low_index])
			low_index = index
	return sorted([high_index, low_index])
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
n = int(input())
l = list(map(int, input().split(' ')))
l.sort()
a = sum(l)
if a % 2:
	print('NO')
elif a - l[-1] < l[-1]:
	print('NO')
else:
	print('YES')


n = int(input())
s = list(map(int, input().split()))
sum1 = 0
for i in range(len(s)):
	sum1 += s[i]
if sum1 % 2 == 1:
	print('NO')
else:
	flag = False
	for i in range(len(s)):
		if sum1 - s[i] < s[i]:
			flag = True
			print('NO')
			break
	if flag == False:
		print('YES')


from os import path
import sys
from functools import cmp_to_key as ctk
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def solve():
	n = ii()
	a = li()
	f = 1
	if sum(a) & 1:
		f = 0
	s = sum(a) - max(a)
	if s < max(a):
		f = 0
	print('YES' if f else 'NO')
solve()


import sys
from math import *
from collections import Counter as cc, defaultdict as df

def counter(l):
	return dict(cc(l))

def lcm(a, b):
	return int(a * b / gcd(a, b))

def input():
	return sys.stdin.readline().strip()

def ini():
	return int(input())

def inp():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))
n = ini()
l = li()
if sum(l) & 1 or max(l) > sum(l) - max(l):
	print('NO')
else:
	print('YES')


_ = int(input())
a = list(map(int, input().split()))
s = 0
_max = -1
for ai in a:
	if ai > _max:
		_max = ai
	s += ai
if s / 2 < _max:
	print('NO')
elif s % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input().strip())
numbers = list(map(int, input().strip().split()))
numbers.sort()
s = 0
for k in range(0, len(numbers) - 1):
	s = s + numbers[k]
if s >= numbers[-1] and (s + numbers[-1]) % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input())
lis = list(map(int, input().split()))
lis.sort()
length = len(lis)
if sum(lis) % 2 != 0:
	print('NO')
elif sum(lis) - lis[-1] < lis[-1]:
	print('NO')
else:
	print('YES')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = 1
	rr = []
	for _ in range(t):
		n = I()
		a = LI()
		s = sum(a)
		m = max(a)
		rr.append(YES(s % 2 == 0 and s // 2 >= m))
	return JA(rr, '\n')
print(main())


for _ in range(1):
	n = int(input())
	a = list(map(int, input().split()))
	maxP = max(a)
	total = sum(a)
	if maxP << 1 > total or total & 1:
		print('NO')
	else:
		print('YES')


n = int(input())
arr = list(map(int, input().split()))
s = sum(arr)
if s & 1:
	print('NO')
else:
	m = max(arr)
	if m <= s - m:
		print('YES')
	else:
		print('NO')


n = int(input())
array = list(map(int, input().split()))
s = sum(array)
array.sort()
if s % 2 == 1:
	print('NO')
	exit(0)
if n == 2 and array[0] != array[1]:
	print('NO')
	exit(0)
for i in range(n):
	if array[i] > s - array[i]:
		print('NO')
		exit(0)
else:
	print('YES')


t = int(input())
numeros = [int(x) for x in input().split()]
if len(numeros) == 2:
	if numeros[0] == numeros[1]:
		print('YES')
	else:
		print('NO')
else:
	suma = 0
	for i in range(0, t):
		suma += numeros[i]
	if suma % 2 == 0 and 2 * max(numeros) <= suma:
		print('YES')
	else:
		print('NO')


n = input()
A = list(map(int, input().strip().split(' ')))
total = sum(A)
total2 = total - max(A)
if total % 2 == 0 and total2 >= max(A):
	print('YES')
else:
	print('NO')


_ = input()
numbers = list(map(int, input().split()))
print('YES') if sum(numbers) % 2 == 0 and max(numbers) <= sum(numbers) / 2 else print('NO')


n = int(input())
inp = input()
a = [int(ele) for ele in inp.split()]
a.sort()
count = 0
for ele in a:
	if ele % 2 != 0:
		count += 1
if sum(a[:n - 1]) < a[-1]:
	print('NO')
elif count % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input())
a = []
b = input()
a = b.split(' ')
for i in range(n):
	a[i] = int(a[i])
sum = 0
for num in a:
	sum = sum + num
max = max(a)
sum1 = sum - max
if sum1 >= max and sum % 2 == 0:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
import heapq
n = int(stdin.readline())
l = list(map(int, stdin.readline().split()))
l.sort()
s = sum(l)
a = l[-1]
if s % 2 == 0 and a <= s - a:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split(' ')))
s = 0
for i in a:
	s += i
if s % 2 == 1:
	print('NO')
else:
	for i in a:
		if i > s // 2:
			print('NO')
			exit()
	print('YES')


import sys
import math
from collections import deque, defaultdict
from string import ascii_letters
letters = ascii_letters[:26]
ONLINE_JUDGE = 0
if any(['--local' in i for i in sys.argv]) and (not ONLINE_JUDGE):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
n = int(input())
arr = list(sorted(map(int, input().split())))
if sum(arr) % 2 == 0 and sum(arr[:-1]) >= arr[-1]:
	print('YES')
else:
	print('NO')


n = int(input())
l = list(map(int, input().split()))
l.sort()
pref = [0] * (n + 1)
pref[1] = l[0]
for i in range(2, n + 1):
	pref[i] = pref[i - 1] + l[i - 1]
ok = 1
for i in range(n, 0, -1):
	if l[i - 1] > pref[n] - l[i - 1]:
		ok = 0
if pref[n] % 2 == 1:
	ok = 0
if ok:
	print('YES')
else:
	print('NO')


import heapq
n = int(input())
arr = list(map(int, input().split()))
arr.sort()
largest = arr[-1]
total = sum(arr)
others = total - arr[-1]
if total % 2 == 0 and largest <= others:
	print('YES')
else:
	print('NO')


def ii():
	return int(input())

def lmii():
	return list(map(int, input().split()))
n = ii()
r = lmii()
r.sort()
if sum(r) % 2 == 0:
	if 2 * r[n - 1] <= sum(r):
		print('YES')
	else:
		print('NO')
else:
	print('NO')


_ = int(input())
L = list(map(int, input().split()))
s = sum(L)
if s % 2 == 0 and 2 * max(L) <= s:
	print('Yes')
else:
	print('No')


input()
a = (*map(int, input().split()),)
s = sum(a)
print('YNEOS'[s % 2 or 2 * max(a) > s::2])


import os
import sys

def Valid(v):
	s = sum(v)
	mx = max(v)
	if s % 2 == 1:
		return False
	if mx * 2 > s:
		return False
	return True
n = int(input())
v = list(map(int, input().strip().split()))
if Valid(v):
	print('YES')
else:
	print('NO')


x = int(input())
c = input().split()
for i in range(len(c)):
	c[i] = int(c[i])
if sum(c) % 2 == 0 and max(c) <= sum(c) - max(c):
	print('YES')
else:
	print('NO')


import heapq

def do():
	n = int(input())
	nums = [int(c) for c in input().split(' ')]
	total = sum(nums)
	if total % 2:
		return 'NO'
	m = max(nums)
	if total - m < m:
		return 'NO'
	return 'YES'
print(do())


l = int(input())
r = [int(x) for x in input().split()]
if sum(r) % 2 == 0 and 2 * max(r) <= sum(r):
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(x) for x in input().split()]
b = max(a)
c = sum(a) - b
if (c + b) % 2 == 0 and c >= b:
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(i) for i in input().split()]
a = sorted(a)
if sum(a) % 2 == 0 and a[-1] <= sum(a[:n - 1]):
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
s = sum(a)
k = True
if s % 2 == 1:
	k = False
for i in range(n):
	if a[i] > s // 2:
		k = False
if k:
	print('YES')
else:
	print('NO')


n = input()
numbers = [int(i) for i in input().split()]
sum = 0
for i in numbers:
	sum += i
if sum % 2 == 1:
	print('NO')
elif max(numbers) > sum / 2:
	print('NO')
else:
	print('YES')


n = int(input())
s = int()
a = list(map(int, input().split()))
mx = int()
for i in range(n):
	s += a[i]
	mx = max(a[i], mx)
if s % 2 == 1 or mx * 2 > s:
	print('No')
else:
	print('Yes')


n = int(input())
a = input().split()
sum1 = 0
max1 = 0
for i in range(n):
	sum1 += int(a[i])
	if int(a[i]) > max1:
		max1 = int(a[i])
if sum1 % 2 == 0 and max1 <= sum1 // 2:
	print('YES')
else:
	print('NO')


n = int(input())
arr = [int(x) for x in input().split()]
c = 0
s = 0
arr = sorted(arr)
for x in arr:
	s += x
if s % 2 == 1:
	print('NO')
elif s % 2 == 0 and s - arr[-1] >= arr[-1]:
	print('YES')
else:
	print('NO')


x = input()
y = list(map(int, input().strip().split()))
if sum(y) % 2 == 0:
	p = max(y)
	q = sum(y) - max(y)
	if p > q:
		print('NO')
	else:
		print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split(' ')))
s = sum(a)
f = 0
for i in a:
	if i > s - i:
		f = 1
		break
if f or s & 1:
	print('No')
else:
	print('Yes')


def soln() -> None:

	def logic() -> None:
		n = int(input())
		arr = [int(x) for x in input().split()]
		s = sum(arr)
		m = max(arr)
		if s % 2 == 1 or m > s - m:
			print('NO')
		else:
			print('YES')
	logic()
soln()


n = int(input())
a = list(map(int, input().split()))
a.sort()
m = 0
sum = 0
ans = 0
for i in range(n):
	m = max(m, a[i])
	sum += a[i]
	ans += a[i] % 2
if ans % 2 == 0 and m <= sum - m:
	print('YES')
else:
	print('NO')


import math

def check(k, h, c):
	return ((k + 1) * h + k * c) / (2 * k + 1)

def main():
	n = int(input())
	a = list(map(int, input().split()))
	add = sum(a)
	a.sort()
	if add % 2 == 0 and sum(a[:-1]) >= a[-1]:
		print('YES')
	else:
		print('NO')
	return
main()


n = int(input())
A = list(map(int, input().split()))
A = sorted(A)
if sum(A) % 2 == 1 or A[-1] > sum(A[:-1]):
	print('NO')
else:
	print('YES')


n = int(input())
a = list(map(int, input().split()))
s = 0
for i in a:
	s += i
if s - max(a) * 2 < 0:
	print('NO')
elif s % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))

def solve(a):
	res = sum(a)
	if res % 2 == 1:
		return 'NO'
	if max(a) > res // 2:
		return 'NO'
	return 'YES'
print(solve(a))


def zero_array(lst):
	(s, m) = (sum(lst), max(lst))
	if s % 2 == 1 or s < 2 * m:
		return 'NO'
	return 'YES'
n = int(input())
a = [int(i) for i in input().split()]
print(zero_array(a))


input()
a = (*map(int, input().split()),)
s = sum(a)
print(['YES', 'NO'][s % 2 or 2 * max(a) > s])


input()
array = list(map(int, input().split()))
total_sum = sum(array)
if total_sum % 2 == 0 and (not any([x > total_sum / 2 for x in array])):
	print('YES')
else:
	print('NO')


input()
(*a, b) = sorted(map(int, input().split()))
if (sum(a) + b) % 2 != 0 or sum(a) < b:
	print('NO')
else:
	print('YES')


n = int(input())
x = input()
y = x.split()
z = [int(d) for d in y]
m = max(z)
if sum(z) % 2 == 0 and sum(z) >= 2 * m:
	print('YES')
else:
	print('NO')


n = int(input())
A = list(map(int, input().split()))
M = max(A)
if M * 2 <= sum(A) and sum(A) % 2 == 0:
	print('YES')
else:
	print('NO')


input()
List = list(map(int, input().split()))
mx = 0
summ = 0
for x in List:
	if x > mx:
		mx = x
	summ += x
if summ % 2 == 0 and summ - mx >= mx:
	print('YES')
else:
	print('NO')


n = int(input())
a = [int(x) for x in input().split()]
a.sort()
if sum(a) % 2 == 0 and sum(a[:len(a) - 1]) >= a[len(a) - 1]:
	print('YES')
else:
	print('NO')


n = int(input())
arr = list(map(int, input().split()))
if sum(arr) % 2 != 0:
	print('NO')
else:
	arr.sort()
	i = n - 1
	while i > 0 and arr[i] == arr[i - 1]:
		i -= 1
	if i == 0 or sum(arr[:i]) >= arr[n - 1]:
		print('Yes')
	else:
		print('No')


import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
n = Int()
a = array()
ans = 'YES'
if sum(a) % 2 or max(a) * 2 > sum(a):
	ans = 'NO'
print(ans)


def func():
	n = int(input())
	li = list(map(int, input().split(' ')))
	ans = 0
	for i in range(n):
		ans += li[i]
	for i in range(n):
		if not li[i] <= ans - li[i]:
			print('NO')
			return
	if ans % 2 == 0:
		print('YES')
	else:
		print('NO')
func()


import sys
from collections import defaultdict

def main():
	n = int(input())
	a = list(map(int, input().split()))
	m = max(a)
	s = sum(a)
	s1 = s - m
	print('YES' if s % 2 == 0 and m <= s1 else 'NO')
main()


import math
import sys
import collections

def getdict(n):
	d = {}
	if type(n) is list:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))
n = ii()
d = li()
s = sum(d)
print('NO') if s % 2 or s - max(d) < max(d) else print('YES')


n = int(input())
a = sorted(map(int, input().split()))
if sum(a) % 2 != 0 or sum(a) - a[-1] < a[-1]:
	print('NO')
else:
	print('YES')


n = input()
l = list(map(int, input().split()))
l.sort()
if sum(l) % 2 != 0 or l[-1] > sum(l[:len(l) - 1]):
	print('NO')
else:
	print('YES')


import math
import bisect
import copy
from collections import defaultdict
from collections import OrderedDict
n = int(input())
ar = list(map(int, input().split()))
p = max(ar)
if sum(ar) % 2 == 0 and sum(ar) - p >= p:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
N = int(input())
arr = [int(x) for x in stdin.readline().split()]
if sum(arr) % 2 == 1:
	print('NO')
	quit()
m = max(arr)
s = sum(arr)
if m > s - m:
	print('NO')
else:
	print('YES')


size = int(input())
arr = list(map(int, input().split()))
can = True
s = sum(arr)
if s % 2 == 1:
	can = False
else:
	mx = max(arr)
	if s - mx < mx:
		can = False
if can:
	print('YES')
else:
	print('NO')


import sys, re, math
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from heapq import heappush, heappop, heapify, nlargest, nsmallest

def STR():
	return list(input())

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST():
	return list(map(int, input().split()))

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def sortListWithIndex(listOfTuples, idx):
	return sorted(listOfTuples, key=lambda x: x[idx])

def sortDictWithVal(passedDic):
	temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
	toret = {}
	for tup in temp:
		toret[tup[0]] = tup[1]
	return toret

def sortDictWithKey(passedDic):
	return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
n = INT()
a = LIST()
a = sorted(a)[::-1]
if a[0] <= sum(a[1:]) and sum(a) % 2 == 0:
	print('YES')
else:
	print('NO')


n = int(input())
l = list(map(int, input().split()))
a = sum(l)
b = max(l)
if a % 2 != 0:
	print('NO')
elif b > a - b:
	print('NO')
else:
	print('YES')


size_of_array = input()
array = list(map(int, input().split()))
sum_sum = sum(array)
max_max = max(array)
if not sum_sum % 2:
	if sum_sum - max_max >= max_max:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


N = int(input())
data = list(map(int, input().split()))
m = max(data)
if sum(data) % 2 == 0 and m <= sum(data) - m:
	print('YES')
else:
	print('NO')


def answer(n, A):
	s = sum(A)
	if s % 2 == 0:
		if max(A) <= s - max(A):
			return 'YES'
		else:
			return 'NO'
	else:
		return 'NO'
n = int(input())
arr = list(map(int, input().split()))
print(answer(n, arr))


n = int(input())
Y = 0
p = input().rstrip().split(' ')
p.sort(key=int)
for i in range(0, len(p)):
	Y += int(p[i])
if Y % 2 == 0:
	if Y - int(p[len(p) - 1]) >= int(p[len(p) - 1]):
		print('YES')
	else:
		print('NO')
else:
	print('NO')


n = int(input())
line = input()
num = [int(i) for i in line.split(' ')]
(cnt, mx) = (0, 0)
for i in num:
	cnt += i
	mx = max(i, mx)
if cnt % 2 == 0 and 2 * mx <= cnt:
	print('YES')
else:
	print('NO')


n = int(input())
l = input().split()
li = [int(i) for i in l]
x = sum(li)
z = max(li)
if x % 2 or z > x - z:
	print('NO')
else:
	print('YES')


import sys
n = int(sys.stdin.readline().strip())
a = list(map(int, sys.stdin.readline().strip().split()))
v = True
if 2 * max(a) > sum(a):
	v = False
if sum(a) % 2 == 1:
	v = False
if v == True:
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
sum = 0
ma = 0
for i in range(n):
	sum += a[i]
	ma = max(a[i], ma)
if sum % 2 == 0 and ma <= sum / 2:
	print('YES')
else:
	print('NO')


n = int(input())
A = list(map(int, input().split()))
A.sort()
sum = 0
for i in A:
	sum += i
if sum % 2 == 0 and sum - A[-1] >= A[-1]:
	print('YES')
else:
	print('NO')


n = int(input())
A = list(map(int, input().split()))
suma = sum(A)
if suma % 2 == 1:
	print('NO')
elif max(A) > suma - max(A):
	print('NO')
else:
	print('YES')


n = input()
n = int(n)
w = input().split()
w = [int(i) for i in w]
s = sum(w)
x = max(w)
if s % 2 == 0 and x <= s // 2:
	print('YES')
else:
	print('NO')


import math
from collections import deque, defaultdict
from sys import stdin, stdout
input = stdin.readline
listin = lambda : list(map(int, input().split()))
mapin = lambda : map(int, input().split())
n = int(input())
a = listin()
s = sum(a)
if s % 2:
	print('NO')
else:
	for i in a:
		if i > s // 2:
			print('NO')
			exit()
	print('YES')


n = int(input())
a = [int(u) for u in input().split()]
t = sum(a) % 2 == 0
m = max(a)
v = 2 * m <= sum(a)
if t and v:
	print('YES')
else:
	print('NO')


n = int(input())
k = list(map(int, input().split()))
m = max(k)
if m > sum(k) - m or sum(k) % 2 == 1:
	print('NO')
else:
	print('YES')


from collections import Counter, defaultdict, deque
import heapq as hq
from itertools import count, islice
import math
import sys
input = sys.stdin.readline
tt = int(input())
arr = [int(x) for x in input().split()]
s = sum(arr)
m = max(arr)
print('YES' if s % 2 == 0 and m <= s - m else 'NO')


x = int(input())
a = list(map(int, input().split()))
c = sum(a)
d = max(a)
if d <= c // 2 and x > 1 and (c % 2 == 0):
	print('YES')
else:
	print('NO')


n = int(input())
sum_all = 0
sum_except = 0
max_a = 0
all_a = input().split()
for a in all_a:
	a = int(a)
	sum_all += a
	if a > max_a:
		sum_except += max_a
		max_a = a
	else:
		sum_except += a
if sum_all % 2 == 0 and max_a <= sum_except:
	print('YES')
else:
	print('NO')


k = int(input())
list1 = list(map(int, input().split()))
if sum(list1) % 2 != 0 or max(list1) > sum(list1) - max(list1):
	print('NO')
else:
	print('YES')


n = int(input())
y = list(map(int, input().split()))
even = 0
odd = 0
for i in y:
	if i % 2 == 0:
		even += 1
	else:
		odd += 1
y = sorted(y)
x = sum(y[:-1])
if x >= y[-1]:
	x = x + y[-1]
	if x % 2 == 0:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


n = int(input())
A = list(map(int, input().split()))
M = max(A)
if M * 2 > sum(A) or sum(A) % 2 == 1:
	print('NO')
else:
	print('YES')


import sys, math, statistics as ss, collections as cc
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
a.sort()
if 2 * a[-1] <= sum(a) and sum(a) % 2 == 0:
	print('YES')
else:
	print('NO')


n = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
s = sum(l)
flag = 'YES'
if s % 2 == 1:
	flag = 'NO'
else:
	t = s - l[-1]
	if t < l[-1]:
		flag = 'NO'
print(flag)


N = int(input())
List = [int(x) for x in input().split()]
List.sort()
Max = List[-1]
Sum = sum(List)
if Sum - Max < Max or Sum & 1:
	print('NO')
else:
	print('YES')


case = int(input())
num = map(int, input().split())
num_list = list(num)
sum = 0
sort_num = sorted(num_list)
for i in range(case):
	sum = sum + num_list[i]
if sum % 2 == 1:
	print('NO')
elif sort_num[-1] > sum - sort_num[-1]:
	print('NO')
else:
	print('YES')


import os
import sys, math
from io import BytesIO, IOBase

def main():
	t = 1
	for case in range(t):
		n = int(input())
		l = list(map(int, input().split()))
		if max(l) <= sum(l) - max(l) and sum(l) % 2 == 0:
			print('YES')
		else:
			print('NO')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import math
length = int(input())
elements = [int(x) for x in input().split(' ')]
sumcount = sum(elements)
if sumcount % 2 == 1:
	print('NO')
elif max(elements) > sumcount / 2:
	print('NO')
else:
	print('YES')


n = int(input())
l = list(map(int, input().split(' ')))
s = sum(l)
s1 = max(l)
s2 = s - s1
if s % 2 != 0:
	print('NO')
elif s1 > s2:
	print('NO')
else:
	print('YES')


n = int(input())
array = input().split()
s = 0
maxval = 0
for x in array:
	s += int(x)
	if int(x) > maxval:
		maxval = int(x)
if s % 2 == 0 and maxval * 2 <= s:
	print('YES')
else:
	print('NO')


N = int(input())
a = [int(i) for i in input().split()]
if sum(a) % 2 == 0 and max(a) <= sum(a) // 2:
	print('YES')
else:
	print('NO')


def check(l):
	s = sum(l)
	for i in l:
		if s - i < i:
			return 'NO'
	if s % 2:
		return 'NO'
	else:
		return 'YES'
n = int(input())
l = list(map(int, input().split()))
print(check(l))


n = int(input())
data = input().split(' ')
numbers = []
total = 0
for i in data:
	a = int(i)
	numbers.append(a)
	total += a
max_number = max(numbers)
if total % 2 != 0 or max_number > total / 2:
	print('NO')
else:
	print('YES')


n = int(input())
arr = list(map(int, input().split()))
if sum(arr) % 2 == 1:
	print('NO')
	exit()
t = sum(arr) // 2
for i in arr:
	if t < i:
		print('NO')
		exit()
print('YES')


def user99():
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	bad = s % 2 == 1
	for i in a:
		if i > s / 2:
			bad = True
	print('NO' if bad else 'YES')
user99()


from statistics import mode
from collections import Counter
n = int(input(''))
a = [int(x) for x in str(input('')).split(' ')]
maximum = -1
for i in range(0, n):
	if a[i] > maximum:
		maximum = a[i]
if sum(a) % 2 == 0 and sum(a) - maximum >= maximum:
	print('YES')
else:
	print('NO')


n = int(input())
l = [*map(int, input().split())]
s = sum(l)
m = max(l)
print('NO' if s & 1 or m > s // 2 else 'YES')


def main():
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	if s % 2 == 1:
		print('NO')
		return
	s = s // 2
	for x in a:
		if x > s:
			print('NO')
			return
	print('YES')
	return
main()


n = int(input())
arreglo = list(map(int, input().split(' ')))
suma = sum(arreglo)
mayor = max(arreglo)
if suma % 2 == 0:
	if suma - mayor >= mayor:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


n = int(input())
numbers = list(map(int, input().split()))
numbers.sort(reverse=True)
sumaTotal = sum(numbers)
sumaTmp = sum(numbers[1:])
maximum = numbers[0]
if sumaTotal % 2 != 0 or numbers[0] > sumaTmp:
	print('NO')
else:
	print('YES')


def main():
	n = input()
	val = [int(v) for v in input().split()]
	sum_v = sum(val)
	max_v = max(val)
	if sum_v % 2 != 0 or max_v > sum_v - max_v:
		print('NO')
	else:
		print('YES')
main()


import math

def parse_nums(string: str):
	list_of_nums = list(map(int, string.split(' ')))
	return list_of_nums

def check_sum(list_of_nums: list):
	if sum(list_of_nums) % 2 > 0:
		return False
	return True

def sort_nums(list_of_nums: list):
	return sorted(list_of_nums)

def pop_and_sub(list_of_sorted_nums: list):
	big_value = list_of_sorted_nums.pop()
	while big_value > 0:
		if len(list_of_sorted_nums):
			big_value -= list_of_sorted_nums.pop()
		else:
			print('NO')
			list_of_sorted_nums.append(big_value)
			return list_of_sorted_nums
	if big_value < 0:
		list_of_sorted_nums.insert(0, -big_value)
	if len(list_of_sorted_nums) == 1:
		print('NO')
		return list_of_sorted_nums
	if len(list_of_sorted_nums) > 0:
		pop_and_sub(list_of_sorted_nums)
	return list_of_sorted_nums

def pop_and_sub2(list_of_sorted_nums: list):
	big_value = list_of_sorted_nums.pop()
	ss = big_value / len(list_of_sorted_nums)
	return 0

def compute(string):
	part_1 = parse_nums(string)
	if not check_sum(part_1):
		print('NO')
		return
	part_2 = sort_nums(part_1)
	if part_2[-1] > sum(part_2[:-1]):
		print('NO')
	else:
		print('YES')
a = input()
numbers = input()
compute(numbers)


def process(A, n):
	a = sum(A)
	b = max(A)
	if a % 2 == 0 and b <= a - b:
		print('YES')
	else:
		print('NO')
n = int(input())
A = [int(x) for x in input().split()]
process(A, n)


n = int(input())
k = list(map(lambda x: int(x), input().split()))
if sum(k) % 2 == 0 and max(k) * 2 <= sum(k):
	print('YES')
else:
	print('NO')


import sys
import math
n = int(input())
c = int(0)
a = list(map(int, input().split()))
maxx = 0
for i in range(n):
	c += a[i]
	maxx = max(maxx, a[i])
if maxx <= c - maxx:
	if c % 2:
		print('NO')
	else:
		print('YES')
else:
	print('NO')


from sys import stdin, stdout

def solve(inp, out):
	n = int(inp())
	a = list(map(int, inp().split()))
	ans = 'NO'
	p = sum(a)
	if p % 2 == 0:
		if p >= 2 * max(a):
			ans = 'YES'
	out(ans)

def main():
	inp = stdin.readline
	out = stdout.write
	t = 0
	if t == 0:
		test = 1
	else:
		test = int(inp())
	for _ in range(test):
		solve(inp, out)
main()


n = int(input())
mx = 0
arr = [int(x) for x in input().split()]
arr_sum = sum(arr)
for i in range(0, n):
	mx = max(mx, arr[i])
if arr_sum % 2 == 0 and arr_sum - mx >= mx:
	print('YES')
else:
	print('NO')


MOD = 1000000007
MOD2 = 998244353
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
n = ii()
l = il()
print('NO' if sum(l) % 2 or max(l) > sum(l) - max(l) else 'YES')


input()
data = [int(i) for i in input().split()]
sm = sum(data)
if sm % 2 == 0 and 2 * max(data) <= sm:
	print('YES')
else:
	print('NO')


from sys import stdin
n = int(stdin.readline().strip())
s = list(map(int, stdin.readline().strip().split()))
s.sort(reverse=True)
if sum(s) % 2 == 0 and s[0] <= sum(s[1:]):
	print('YES')
else:
	print('NO')


n = int(input())
l1 = list(map(int, input().split()))
sum1 = sum(l1)
if sum1 % 2 == 0:
	l1.sort()
	sum2 = sum(l1[0:n - 1])
	if l1[n - 1] <= sum2:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


T = int(input())
var = 1
sum = 0
l = list(map(int, input().split()))
for i in range(T):
	sum += l[i]
	if l[i] > var:
		var = l[i]
if var * 2 > sum or sum % 2 != 0:
	print('NO')
else:
	print('YES')


size = int(input())
array = list(map(int, input().split()))

def test(array, size):
	ar_sum = sum(array)
	if ar_sum % 2 != 0:
		return False
	list_sums = [int(0) for i in range(size)]
	for x in range(size):
		list_sums[x] = ar_sum - array[x]
		if array[x] > list_sums[x]:
			return False
	return True
if test(array, size):
	print('YES')
else:
	print('NO')


import math
import cmath
import sys
import string
import heapq
import bisect
import copy
from queue import Queue, PriorityQueue, LifoQueue
from collections import Counter, deque
from itertools import permutations, combinations
from functools import cmp_to_key, reduce
t = int(input())
a = list(map(int, input().strip().split()))
sum = 0
for i in a:
	sum += i
if sum % 2 != 0:
	print('NO')
	sys.exit()
elif 2 * max(a) > sum:
	print('NO')
	sys.exit()
print('YES')


n = int(input())
a = list(map(int, input().split()))
if sum(a) % 2:
	print('NO')
else:
	a.sort()
	if max(a) > sum(a) - max(a):
		print('NO')
	else:
		print('YES')


n = int(input())
a = list(map(int, input().split()))
s = 0
for i in a:
	s += i
if s % 2 == 1:
	print('NO')
else:
	mx = max(a)
	ost = s - mx
	if ost >= mx:
		print('YES')
	else:
		print('NO')


input()
(*a,) = map(int, input().split())
s = sum(a)
if s >= 2 * max(a) and (not s % 2):
	print('YES')
	exit()
print('NO')


n = eval(input())
tmp = input()
listx = tmp.split(' ')
for i in range(n):
	listx[i] = int(listx[i])
listx = sorted(listx)
slistx = sum(listx)
if slistx % 2 != 0:
	print('NO')
elif listx[-1] > slistx // 2:
	print('NO')
else:
	print('YES')


n = int(input())
ln = [int(i) for i in input().split(' ')]
s = 0
m = 0
for i in ln:
	s += i
	m = max(m, i)
if s % 2 == 1:
	print('NO')
elif m <= s / 2:
	print('YES')
else:
	print('NO')


import atexit
import io
import sys

def foo(lst1):
	max_int = lst1.index(max(lst1))
	flag = True
	sum = 0
	for (i, j) in enumerate(lst1):
		if i == max_int:
			continue
		sum += j
	if max(lst1) <= sum:
		return True
	else:
		return False
R = lambda : map(int, input().split())
n = int(input())
lst1 = list(R())
if sum(lst1) % 2 == 0 and foo(lst1):
	print('YES')
else:
	print('NO')


from sys import stdin
n = stdin.readline()
arr = list((int(i) for i in stdin.readline().split()))
horse = 1
total = 0
high = -1
for i in arr:
	if i % 2 == 1:
		horse *= -1
	total += i
	if i > high:
		high = i
if horse == 1:
	if total >= 2 * high:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


import sys

def bravado():
	y = input()
	x = sys.stdin.readline()
	A = list(map(int, x.split()))
	x = sum(A)
	if sum(A) % 2 == 1:
		print('NO')
		return
	mid_val = x / 2
	flag = 'YES'
	for i in A:
		if i > mid_val:
			flag = 'NO'
	print(flag)
bravado()


n = int(input())
total = 0
lis = [int(x) for x in input().split()]
total = sum(lis)
max = 0
max_index = -1
for (i, num) in enumerate(lis):
	if num >= max:
		max = num
		max_index = i
del lis[max_index]
if total % 2 == 0 and max <= sum(lis):
	print('YES')
else:
	print('NO')


n = int(input())
a = list(map(int, input().split()))
sumA = sum(a)
TWins = False
for elem in a:
	if elem > sumA // 2:
		TWins = True
		break
if TWins or sumA % 2 != 0:
	print('No')
else:
	print('yes')


from sys import stdin

def main():
	n = int(stdin.readline())
	m = list(map(int, stdin.readline().split()))
	total = sum(m)
	if total % 2:
		print('NO')
	else:
		aux = max(m)
		total -= aux
		if total >= aux:
			print('YES')
		else:
			print('NO')
main()


n = int(input())
k = list(map(int, input().split()))
if sum(k) % 2 == 1 or 2 * max(k) > sum(k):
	print('No')
else:
	print('Yes')


n = int(input())
x = input().split()
for i in range(0, n):
	x[i] = int(x[i])
total = 0
for i in x:
	total += i
if total % 2 == 1:
	print('NO')
else:
	x.sort(reverse=True)
	if x[0] <= total - x[0]:
		print('YES')
	else:
		print('NO')


n = int(input())
sum = 0
mas = [int(i) for i in input().split()]
for i in mas:
	sum += i
for i in mas:
	if i > sum // 2:
		sum = 1
		break
if sum % 2 == 0:
	print('YES')
else:
	print('NO')


t = int(input())
a = [int(i) for i in input().split()]
m = max(a)
s = sum(a)
print(['YES', 'NO'][s % 2 == 1 or m > s / 2])


import sys
input = lambda : sys.stdin.readline().strip('\r\n')
n = int(input())
a = list(map(int, input().split()))
maxi = max(a)
asum = sum(a)
if asum % 2 == 0 and asum - maxi >= maxi:
	print('YES')
else:
	print('NO')


def solve():
	n = int(input())
	arr = [int(x) for x in input().split(' ')]
	total = sum(arr)
	if total % 2 == 1 or max(arr) * 2 > total:
		print('NO')
	else:
		print('YES')
solve()


n = int(input())
a = [int(x) for x in input().split()]
total = sum(a)
if total % 2:
	print('NO')
else:
	z = max(a)
	if max(a) > total // 2:
		print('NO')
	else:
		print('YES')


import sys
input = sys.stdin.readline
n = int(input())
data = list(map(int, input().split()))
if sum(data) % 2 != 0:
	print('NO')
elif max(data) * 2 > sum(data):
	print('NO')
else:
	print('YES')


input()
array = list(map(int, input().split()))
total_sum = sum(array)
if total_sum % 2 == 0 and max(array) <= total_sum / 2:
	print('YES')
else:
	print('NO')


t = int(input())
x = [int(q) for q in input().split()]
w = sorted(x)
if sum(x) % 2 == 0 and 2 * max(x) <= sum(x):
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
a.sort()
pf_sum = [a[0]]
for i in range(1, n):
	pf_sum.append(pf_sum[-1] + a[i])
if pf_sum[-1] % 2:
	print('NO')
	sys.exit()
elif pf_sum[-1] > 2 * pf_sum[-2]:
	print('NO')
	sys.exit()
else:
	print('YES')


n = int(input())
a = sorted(map(int, input().split()))
if sum(a) % 2 or sum(a[:-1]) < a[-1]:
	print('NO')
	exit()
print('YES')


n = int(input())
a = list(map(int, input().split()))
k = sum(a)
if k % 2 == 1 or 2 * max(a) > k:
	print('no')
else:
	print('yes')


def solve(a, n):
	sm = sum(a)
	mx = max(a)
	if sm % 2 == 1 or sm < 2 * mx:
		return 'NO'
	return 'YES'
n = int(input())
a = list(map(int, input().split()))
print(solve(a, n))


t = int(input())
l = [int(num) for num in input().split()]
sum1 = 0
max1 = 0
for i in range(0, t):
	sum1 += l[i]
	if max1 < l[i]:
		max1 = l[i]
if sum1 % 2 == 0:
	if max1 <= sum1 - max1:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


def main():
	import sys
	input = sys.stdin.readline
	n = int(input())
	arr = list(map(int, input().split()))
	ma = max(arr)
	s = sum(arr)
	if ma * 2 > s or s & 1:
		print('NO')
	else:
		print('YES')
	return 0
main()


n = int(input())
sum = 0
max = 0
A = input().split()
for i in range(n):
	if int(A[i]) > max:
		max = int(A[i])
	sum += int(A[i])
if sum % 2 == 1 or max > sum // 2:
	print('NO')
else:
	print('YES')


nb_elements = int(input())
elems = [int(x) for x in input().split()]
sums = sum(elems)
maxs = max(elems)
if not sums & 1 and maxs <= sums - maxs:
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline

def solve():
	n = int(input())
	L = list(map(int, input().split()))
	if max(L) <= sum(L) - max(L) and sum(L) % 2 == 0:
		print('YES')
	else:
		print('NO')
solve()


n = int(input())
l = [int(x) for x in input().split()]
s = sum(l)
l.sort()
if s % 2 == 0 and s - l[n - 1] >= l[n - 1]:
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.buffer.readline

def prog():
	n = int(input())
	nums = list(map(int, input().split()))
	total = 0
	for num in nums:
		total += num
	if 0 == total % 2:
		fail = False
		for num in nums:
			if 2 * num > total:
				fail = True
				break
		if fail:
			print('NO')
		else:
			print('YES')
	else:
		print('NO')
prog()


import math
import time
from collections import defaultdict, deque
from sys import stdin, stdout
from bisect import bisect_left, bisect_right, bisect
n = int(input())
a = list(map(int, stdin.readline().split()))
temp = sum(a)
if temp % 2 == 0:
	a.sort()
	if a[-1] + a[-1] > temp:
		print('NO')
	else:
		print('YES')
else:
	print('NO')