You are given an array a_1, a_2, …, a_n.

In one operation you can choose two elements a_i and a_j (i ≠ 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 ≤ n ≤ 10^5) — the size of the array.

The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 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.
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, k = map(int, input().split(" "))
# l = list(map(int, input().split(" ")))

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