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.
'''
Github: https://github.com/Devansh3712
'''

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

# <fast I/O>
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)
# </fast I/O>

# <template>
mod = (10**9)+7
pi = 3.14159265358979323846264338327950


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


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


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


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


def pf(ans):  # print(x)
    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)


# </template>
# <testcases>
if(os.path.exists('input_file.txt')):
    sys.stdin = open("input_file.txt", "r")
    sys.stdout = open("output_file.txt", "w")
# </testcases>



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
    else:
        if max(a)<=(s//2):return 1
        else:return 0

    

    

# <solution>
tc = 1
# p=SOE(1000002)
for t in range(tc):
    if solve():print("YES")
    else:print("NO")
# <solution>


