Dawid has four bags of candies. The $i$-th of them contains $a_i$ candies. Also, Dawid has two friends. He wants to give each bag to one of his two friends. Is it possible to distribute the bags in such a way that each friend receives the same amount of candies in total?

Note, that you can't keep bags for yourself or throw them away, each bag should be given to one of the friends.


-----Input-----

The only line contains four integers $a_1$, $a_2$, $a_3$ and $a_4$ ($1 \leq a_i \leq 100$) — the numbers of candies in each bag.


-----Output-----

Output YES if it's possible to give the bags to Dawid's friends so that both friends receive the same amount of candies, or NO otherwise. Each character can be printed in any case (either uppercase or lowercase).


-----Examples-----
Input
1 7 11 5

Output
YES

Input
7 3 2 5

Output
NO



-----Note-----

In the first sample test, Dawid can give the first and the third bag to the first friend, and the second and the fourth bag to the second friend. This way, each friend will receive $12$ candies.

In the second sample test, it's impossible to distribute the bags.

Source: codeforces | Difficulty: EASY
Tags: Implementation

Complete search


Solutions:
(a1, a2, a3, a4) = list(map(int, input().split()))
if a1 + a2 == a3 + a4:
	print('YES')
elif a1 + a3 == a2 + a4:
	print('YES')
elif a1 + a4 == a2 + a3:
	print('YES')
elif a1 == a2 + a3 + a4:
	print('YES')
elif a2 == a1 + a3 + a4:
	print('YES')
elif a3 == a2 + a1 + a4:
	print('YES')
elif a4 == a2 + a3 + a1:
	print('YES')
else:
	print('NO')


arr = list(map(int, input().split()))
arr.sort()
if arr[3] == arr[0] + arr[1] + arr[2]:
	print('YES')
elif arr[0] + arr[3] == arr[1] + arr[2]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
sum1 = a[0] + a[1] + a[2] + a[3]
if sum1 % 2 != 0:
	print('NO')
elif a[0] + a[1] == a[2] + a[3]:
	print('YES')
elif a[0] + a[2] == a[1] + a[3]:
	print('YES')
elif a[0] + a[3] == a[1] + a[2]:
	print('YES')
elif a[0] == sum1 // 2:
	print('YES')
elif a[1] == sum1 // 2:
	print('YES')
elif a[2] == sum1 // 2:
	print('YES')
elif a[3] == sum1 // 2:
	print('YES')
else:
	print('NO')


a = [int(a) for a in input().split()]
a.sort()
if a[0] + a[3] == a[2] + a[1] or a[0] + a[1] + a[2] == a[3]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a.sort()
t1 = a[0] + a[3]
t2 = a[0] + a[1] + a[2]
y1 = a[1] + a[2]
if t1 == y1 or t2 == a[3]:
	print('YES')
else:
	print('NO')


l = list(map(int, input().split()))
l.sort()
x1 = l[3]
x2 = l[0] + l[1] + l[2]
y1 = l[3] + l[0]
y2 = l[1] + l[2]
if x1 == x2:
	print('YES')
elif y1 == y2:
	print('YES')
else:
	print('NO')


(a, b, c, d) = list(map(int, input().split()))
if a + b == c + d or a + c == b + d or a + d == b + c:
	print('YES')
elif a == b + c + d or b == a + c + d or c == a + b + d or (d == a + b + c):
	print('YES')
else:
	print('NO')


def main():
	a = tuple(map(int, input().split()))
	n = sum(a)
	if n % 2 == 1:
		print('no')
		return
	n = int(n / 2)
	for s in a:
		if s == n:
			print('yes')
			return
	for i in range(3):
		for j in range(i + 1, 4):
			if a[i] + a[j] == n:
				print('yes')
				return
	print('no')
main()


n = list(map(int, input().split()))
n.sort()
if n[0] + n[1] + n[2] == n[3] or n[0] + n[3] == n[2] + n[1]:
	print('YES')
else:
	print('NO')


arr = sorted([int(i) for i in input().split()])
print('YES' if arr[3] + arr[0] == arr[2] + arr[1] or arr[0] + arr[1] + arr[2] == arr[3] else 'NO')


arr = list(map(int, input().split()))
sm = sum(arr)
possible = False
for i in range(3):
	for j in range(i + 1, 4):
		if 2 * arr[i] == sm or 2 * arr[j] == sm:
			possible = True
			break
		if 2 * (arr[i] + arr[j]) == sm:
			possible = True
			break
print('YES' if possible else 'NO')


(a, b, c, d) = sorted(map(int, input().split()))
if d + a == b + c or d - b == c + a:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split(' '))
s = a + b + c + d
if s % 2:
	print('NO')
	exit(0)
s //= 2
if s in (a, b, c, d, a + b, a + c, a + d, b + c, b + d, d + c):
	print('YES')
	exit(0)
print('NO')


(a, b, c, d) = map(int, input().split())
x = 0
if a + b == c + d or a + c == b + d or a + d == b + c or (a + b + c == d) or (a + c + d == b) or (b + c + d == a) or (a + b + d == c):
	print('YES')
else:
	print('NO')


l = [*map(int, input().split())]
l.sort()
if l[0] + l[3] == l[1] + l[2] or l[3] == l[0] + l[1] + l[2]:
	print('YES')
else:
	print('NO')


number = sorted([int(x) for x in input().split()])
if number[0] + number[1] + number[2] == number[3] or number[0] + number[3] == number[1] + number[2]:
	print('YES')
else:
	print('NO')


import os
import sys
from io import BytesIO, IOBase
from itertools import permutations

def solution(a, b, c, d):
	if sum([a, b, c, d]) & 1 == 1:
		write('NO')
		return
	for per in permutations([a, b, c, d]):
		if per[0] == sum(per[1:]) or sum(per[:2]) == sum(per[2:]):
			write('YES')
			return
	write('NO')

def main():
	(a, b, c, d) = r_array()
	solution(a, b, c, d)
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def write(*args, end='\n'):
	for x in args:
		sys.stdout.write(str(x) + ' ')
	sys.stdout.write(end)

def r_array():
	return [int(x) for x in input().split()]

def r_int():
	return int(input())

def w_array(arr):
	for x in arr:
		write(x, end=' ')
	write()
main()


l = [int(n) for n in input().split()]
(s, l2) = (sum(l), list())
for i in range(4):
	for j in range(i + 1, 4):
		l2.append(l[i] + l[j])
l.extend(l2)
for n in l:
	if s - n == n:
		print('Yes')
		break
else:
	print('No')


import math
n = list(map(int, input().split()))
s = sum(n)
c = 0
if s % 2 != 0:
	print('NO')
else:
	for i in range(0, len(n)):
		if n[i] == s - n[i]:
			c += 1
			break
	for i in range(len(n)):
		for j in range(len(n)):
			if n[i] + n[j] == s // 2 and i != j:
				c += 1
				break
	if c > 0:
		print('YES')
	else:
		print('NO')


(a, b, c, d) = [int(x) for x in input().split()]
if a + b == c + d or a + c == b + d or a + d == b + c or (a == b + c + d) or (b == a + d + c) or (c == a + b + d) or (d == a + b + c):
	print('YES')
else:
	print('NO')


l = list(map(int, input().split()))
if sum(l) % 2 != 0:
	print('no')
	exit()
su = sum(l) // 2
if su in l:
	print('yes')
	exit()
for i in range(4):
	for j in range(4):
		if i != j and l[i] + l[j] == su:
			print('yes')
			exit()
print('no')


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


a = list(map(int, input().split()))
s1 = a[0] + a[1]
p1 = a[2] + a[3]
s2 = a[0] + a[2]
p2 = a[1] + a[3]
s3 = a[0] + a[3]
p3 = a[1] + a[2]
s4 = a[0] + a[1] + a[2]
p4 = a[3]
s5 = a[0] + a[2] + a[3]
p5 = a[1]
s6 = a[0] + a[1] + a[3]
p6 = a[2]
s7 = a[1] + a[2] + a[3]
p7 = a[0]
if s1 == p1 or s2 == p2 or s3 == p3 or (s4 == p4) or (s5 == p5) or (s6 == p6) or (s7 == p7):
	print('YES')
else:
	print('NO')


n = [*map(int, input().split())]
sum = sum(n)
if sum % 2 != 0:
	print('NO')
	exit()
mid = sum // 2
if n[0] + n[1] == mid or n[0] + n[2] == mid or n[0] + n[3] == mid or (n[2] + n[1] == mid) or (n[3] + n[1] == mid) or (n[2] + n[3] == mid) or (mid in n):
	print('YES')
	exit()
print('NO')


bags = [int(x) for x in input().split(' ')]
bags.sort()
if bags[0] + bags[3] == sum(bags[1:3]) or sum(bags[0:3]) == bags[3]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a = sorted(a)
s = sum(a)
for i in range(1 << 4):
	s1 = 0
	for j in range(4):
		if i & 1 << j:
			s1 += a[j]
	if s1 == s - s1:
		print('YES')
		exit()
print('NO')


a = list(map(int, input().split()))
a = sorted(a)
if a[0] + a[3] == a[1] + a[2] or a[0] + a[1] + a[2] == a[3]:
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = map(int, input().split(' '))
l = []
l.append(a1)
l.append(a2)
l.append(a3)
l.append(a4)
l.sort()
if l[0] + l[3] == l[1] + l[2] or l[0] + l[1] + l[2] == l[3]:
	print('YES')
else:
	print('NO')


a = [int(i) for i in input().split()]
a.sort(reverse=True)
if a[0] == a[1] + a[2] + a[3]:
	print('YES')
	exit()
elif a[0] + a[1] == a[2] + a[3]:
	print('YES')
	exit()
elif a[0] + a[1] + a[2] == a[3]:
	print('YES')
	exit()
elif a[0] + a[3] == a[2] + a[1]:
	print('YES')
	exit()
else:
	print('NO')


c = [int(x) for x in input().split()]
if sum(c) % 2 == 1:
	print('NO')
else:
	half = sum(c) // 2
	if c[0] == half or c[1] == half or c[2] == half or (c[3] == half):
		print('YES')
	elif c[0] + c[1] == half or c[0] + c[2] == half or c[0] + c[3] == half or (c[1] + c[2] == half) or (c[1] + c[3] == half) or (c[2] + c[3] == half):
		print('YES')
	else:
		print('NO')


l = [int(i) for i in input().split(' ')]
l.sort()
if sum(l) % 2 != 0:
	print('NO')
elif sum(l[:3]) == l[3]:
	print('YES')
elif l[0] + l[3] == l[1] + l[2]:
	print('YES')
else:
	print('NO')


m = list(map(int, input().split()))[:4]
if m[0] + m[1] == m[2] + m[3] or m[0] + m[2] == m[1] + m[3] or m[0] + m[3] == m[1] + m[2] or (m[0] + m[1] + m[2] == m[3]) or (m[0] + m[1] + m[3] == m[2]) or (m[3] + m[1] + m[2] == m[0]) or (m[0] + m[3] + m[2] == m[1]):
	print('YES')
else:
	print('NO')


from itertools import combinations
li = [int(x) for x in input().split()]
suma = sum(li)
if any((2 * x == suma for x in li)):
	print('YES')
else:
	for par in combinations(li, 2):
		if 2 * sum(par) == suma:
			print('YES')
			break
	else:
		print('NO')


from itertools import combinations as combi
p = sorted(map(int, input().split()))
print(['NO', 'YES'][sum(p) % 2 == 0 and sum(p) // 2 in list(map(sum, combi(p, 2))) + list(map(sum, combi(p, 3)))])


(a, b, c, d) = map(int, input().split())
count = a + b + c + d
if count % 2 == 0 and (a + b == c + d or a + c == b + d or a + d == c + b or (a + b + c == d) or (a + c + d == b) or (a + b + d == c) or (b + c + d == a)):
	print('YES')
else:
	print('NO')


def process(n, a):
	for i in range(16):
		ii = i
		x = 0
		y = 0
		for j in range(n):
			if ii % 2 == 0:
				x += a[j]
			else:
				y += a[j]
			ii //= 2
		if x == y:
			return True
	return False
n = 4
a = [int(x) for x in input().split()]
res = process(n, a)
print('YES' if res else 'NO')


(a, b, c, d) = sorted(map(int, input().split()))
count = 0
if d == a + b + c:
	print('YES')
	count = 1
if a + d == c + b:
	print('YES')
	count = 1
if count == 0:
	print('NO')


li = [int(i) for i in input().split()]
a = li[0]
b = li[1]
c = li[2]
d = li[3]
if a + b == c + d or a + c == b + d or a + d == b + c or (a + b + c == d) or (a + b + d == c) or (a + c + d == b) or (b + c + d == a):
	print('YES')
else:
	print('NO')


vals = [*map(int, input().split())]
vals.sort()
for val in range(16):
	sub = []
	for i in range(val):
		if val & 1 << i:
			sub.append(vals[i])
	if sum(vals) - sum(sub) == sum(sub):
		print('YES')
		exit(0)
print('NO')


a = list(map(int, input().strip().split()))
a.sort()
b = a[0] + a[1]
c = a[2] + a[3]
d = a[0] + a[3]
e = a[1] + a[2]
f = a[0] + a[1] + a[2]
if b == c or d == e or f == a[3]:
	print('YES')
else:
	print('NO')


x = [int(n) for n in input().split()]
s = sum(x)
if s & 1:
	print('NO')
else:
	s1 = s // 2
	if s1 in x:
		print('YES')
	elif s1 not in x:
		f = 0
		for i in range(3):
			for j in range(i + 1, 4):
				if s1 == x[i] + x[j]:
					f = 1
		for i in x:
			if s - i == s1:
				f = 1
		if f:
			print('YES')
		else:
			print('NO')


(a, b, c, d) = list((int(x) for x in input().split()))
if a == b + c + d:
	print('YES')
elif b == a + c + d:
	print('YES')
elif c == a + b + d:
	print('YES')
elif d == a + b + c:
	print('YES')
elif a + b == c + d:
	print('YES')
elif a + c == b + d:
	print('YES')
elif a + d == b + c:
	print('YES')
else:
	print('NO')


total_bags = 4
bags = list(map(int, input().split()))
count = 0
result = 0
for i in range(0, total_bags):
	count = bags[i] + count
if count % 2 == 0:
	for i in range(0, total_bags):
		if bags[i] == count / 2:
			result = 1
	for j in range(1, total_bags):
		if bags[0] + bags[j] == count / 2:
			result = 1
			break
	if result == 0:
		for k in range(2, total_bags):
			if bags[0] + bags[1] + bags[k] == count / 2:
				result = 1
				break
			if bags[0] + bags[2] + bags[3] == count / 2:
				result = 1
				break
else:
	result = 0
if result == 1:
	print('YES')
else:
	print('NO')


a = [int(s) for s in input().split()]
su = sum(a)

def rec(num, s):
	if s > su // 2:
		return
	if s == su // 2:
		print('YES')
		exit(0)
	if s < su // 2:
		for i in range(num, 4):
			rec(i + 1, s + a[i])
if su % 2 != 0:
	print('NO')
else:
	rec(0, 0)
	print('NO')


(a1, a2, a3, a4) = map(int, input().split())
for a in range(-1, 2, 2):
	for b in range(-1, 2, 2):
		for c in range(-1, 2, 2):
			for d in range(-1, 2, 2):
				if a * a1 + b * a2 + c * a3 + d * a4 == 0:
					print('Yes')
					exit()
print('No')


from itertools import permutations

def find_combination(nums_list):
	if max(nums_list) > sum(nums_list) / 2:
		return 'no'
	elif max(nums_list) == sum(nums_list) / 2:
		return 'yes'
	else:
		out = list(permutations(nums_list))
		for perm in out:
			if perm[0] + perm[1] == perm[2] + perm[3]:
				return 'yes'
		else:
			return 'no'
nums_list = [int(x) for x in input().split()]
print(find_combination(nums_list))


a = list(map(int, input().split()))
a1 = a[0] + a[1]
b1 = a[2] + a[3]
a2 = a[0] + a[2]
b2 = a[1] + a[3]
a3 = a[0] + a[3]
b3 = a[1] + a[2]
if a1 == b1 or a2 == b2 or a3 == b3 or (a[0] == a[1] + a[2] + a[3]) or (a[1] == a[0] + a[2] + a[3]) or (a[2] == a[0] + a[1] + a[3]) or (a[3] == a[0] + a[1] + a[2]):
	print('YES')
else:
	print('NO')


(n, m, k, l) = sorted(map(int, input().split()))
print(['NO', 'YES'][n + l == m + k or n + m + k == l])


n = list(map(int, input().split()))
n.sort(reverse=True)
if n[0] == n[1] + n[2] + n[3]:
	print('YES')
elif n[0] + n[3] == n[1] + n[2]:
	print('YES')
else:
	print('NO')


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
t = 1
for tt in range(t):
	(a, b, c, d) = map(int, sys.stdin.readline().split(' '))
	s = a + b + c + d
	if s % 2 == 0:
		v = s // 2
		if a == v or b == v or c == v or (d == v):
			print('YES')
		elif a + b == v or a + c == v or a + d == v:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


l = list(map(int, input().split()))
if sum(l) % 2 != 0:
	print('No')
else:
	l.sort()
	if l[0] + l[3] == l[1] + l[2] or l[0] + l[1] + l[2] == l[3]:
		print('Yes')
	else:
		print('No')


n = list(map(int, input().split()))
n = sorted(n)
if (n[3] + n[0] != n[1] + n[2] and n[3] + n[1] != n[2] + n[0]) and 2 * n[3] != sum(n):
	print('NO')
else:
	print('YES')


a = list(map(int, input().split(' ')))
if max(a) + min(a) == sum(a) - max(a) - min(a) or max(a) == sum(a) - max(a):
	print('YES')
else:
	print('NO')


l = list(map(int, input().split()))
if l[0] + l[1] == l[2] + l[3]:
	print('YES')
elif l[0] + l[2] == l[1] + l[3]:
	print('YES')
elif l[0] + l[3] == l[1] + l[2]:
	print('YES')
elif l[0] + l[1] + l[2] == l[3]:
	print('YES')
elif l[0] + l[1] + l[3] == l[2]:
	print('YES')
elif l[0] + l[3] + l[2] == l[1]:
	print('YES')
elif l[3] + l[1] + l[2] == l[0]:
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = sorted((int(i) for i in input().split()))
if a1 + a4 == a2 + a3 or a1 + a2 + a3 == a4:
	print('YES')
else:
	print('NO')


(a, b, c, d) = sorted(map(int, input().split()))
print('YNEOS'[a + d != b + c and a + b + c != d::2])


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())
a = ri()
a.sort()
if a[0] + a[1] + a[2] == a[3] or a[0] + a[-1] == a[1] + a[2] or a[0] + a[1] == a[2] + a[3] or (a[0] + a[2] == a[1] + a[3]):
	print('YES')
else:
	print('NO')


s = list(map(int, input().split()))
p = sum(s)
if s[0] == p - s[0] or s[1] == p - s[1] or s[2] == p - s[2] or (s[3] == p - s[3]):
	print('YES')
elif sum(s[0:2]) == sum(s[2:4]) or s[0] + s[2] == s[1] + s[3] or s[0] + s[3] == s[1] + s[2]:
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = map(int, input().split())
if a1 + a2 == a3 + a4:
	print('yes')
elif a1 + a3 == a2 + a4:
	print('yes')
elif a1 + a4 == a2 + a3:
	print('yes')
elif a1 + a2 + a3 == a4:
	print('yes')
elif a1 + a3 + a4 == a2:
	print('yes')
elif a2 + a3 + a4 == a1:
	print('yes')
elif a1 + a2 + a4 == a3:
	print('yes')
else:
	print('no')


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


bags = [*map(int, input().split())]
resp = 'NO'
sumB = sum(bags)
if bags[0] == sumB - bags[0]:
	resp = 'YES'
elif bags[1] == sumB - bags[1]:
	resp = 'YES'
elif bags[2] == sumB - bags[2]:
	resp = 'YES'
elif bags[3] == sumB - bags[3]:
	resp = 'YES'
elif bags[0] + bags[1] == sumB - bags[0] - bags[1]:
	resp = 'YES'
elif bags[0] + bags[2] == sumB - bags[0] - bags[2]:
	resp = 'YES'
elif bags[0] + bags[3] == sumB - bags[0] - bags[3]:
	resp = 'YES'
print(resp)


(a, b, c, d) = map(int, input().split())
if (a + b + c + d) % 2 == 1:
	print('NO')
else:
	t = (a + b + c + d) // 2
	if a == t or b == t or c == t or (d == t) or (a + b == t) or (a + c == t) or (a + d == t) or (b + c == t) or (c + d == t) or (b + d == t):
		print('YES')
	else:
		print('NO')


(a1, a2, a3, a4) = sorted(map(int, input().split()))
print('YES' if a1 + a4 == a2 + a3 or a1 + a2 + a3 == a4 else 'NO')


list1 = sorted(list(map(int, input().split(' '))))
sum1 = sum(list1)
if list1[-1] == list1[0] + list1[1] + list1[2] or list1[0] + list1[-1] == list1[1] + list1[2]:
	print('YES')
else:
	print('NO')


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


from itertools import combinations
p = sorted(map(int, input().split()))
t = [list(map(sum, combinations(p, 2))), list(map(sum, combinations(p, 3)))]
print('YES') if len(set(t[0])) % 2 == 1 or p[-1] in t[1] else print('NO')


(n1, n2, n3, n4) = input().split()
(n1, n2, n3, n4) = (int(n1), int(n2), int(n3), int(n4))

def getForOne(n1, n2, n3, n4):
	if n1 == n2 + n3 + n4:
		return True
	elif n2 == n1 + n3 + n4:
		return True
	elif n3 == n1 + n2 + n4:
		return True
	elif n4 == n1 + n2 + n3:
		return True
	return False

def getForTwo(n1, n2, n3, n4):
	if n1 + n2 == n3 + n4:
		return True
	elif n1 + n3 == n2 + n4:
		return True
	elif n1 + n4 == n2 + n3:
		return True
	return False

def getYesOrNo(n1, n2, n3, n4):
	if getForOne(n1, n2, n3, n4) or getForTwo(n1, n2, n3, n4):
		return 'YES'
	return 'NO'
print(getYesOrNo(n1, n2, n3, n4))


a = list(map(int, input().split()))
sum1 = 0
a.sort()
if a[0] + a[len(a) - 1] == a[1] + a[2] or sum(a[:len(a) - 1]) == a[len(a) - 1]:
	print('YES')
else:
	print('NO')


def solve(arr):
	arr.sort()
	if 2 * arr[-1] == sum(arr):
		return 'YES'
	elif 2 * (arr[0] + arr[-1]) == sum(arr):
		return 'YES'
	else:
		return 'NO'

def main():
	arr = list(map(int, input().strip().split()))
	print(solve(arr))
main()


line = input()
(a, b, c, d) = map(int, line.split(' '))
if a + b == c + d or a + c == b + d or a + b + c == d or (b + c + d == a) or (c + d + a == b) or (d + a + b == c) or (a + d == b + c):
	print('yes')
else:
	print('no')


(a1, a2, a3, a4) = [int(x) for x in input().split(' ')]
x = sum((a1, a2, a3, a4)) / 2
if a1 + a2 + a3 == x or a1 + a2 + a4 == x or a1 + a3 + a4 == x or (a2 + a3 + a4 == x) or (a1 + a2 == x) or (a1 + a3 == x) or (a1 + a4 == x) or (a2 + a3 == x) or (a2 + a4 == x) or (a3 + a4 == x):
	print('YES')
else:
	print('NO')


import sys
from operator import itemgetter
from fractions import gcd
from math import ceil, floor, sqrt
from copy import deepcopy
from collections import Counter, deque
import heapq
from functools import reduce
sys.setrecursionlimit(200000)
input = sys.stdin.readline

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

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

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

def fi():
	return float(input())

def mfi():
	return map(float, input().rstrip().split())

def lmfi():
	return list(map(float, input().rstrip().split()))

def li():
	return list(input().rstrip())

def debug(*args, sep=' ', end='\n'):
	print('debug:', *args, file=sys.stderr, sep=sep, end=end) if not __debug__ else None

def exit(*arg):
	print(*arg)
	return

def main():
	a = lmi()
	a.sort()
	if a[0] + a[3] == a[1] + a[2] or a[3] == a[0] + a[1] + a[2]:
		print('YES')
	else:
		print('NO')

def __starting_point():
	if not __debug__:
		import doctest
		doctest.testmod()
	main()
__starting_point()


items = list(map(int, input().split()))

def powerSet(items):
	N = len(items)
	for i in range(2 ** N):
		combo = []
		for j in range(N):
			if (i >> j) % 2 == 1:
				combo.append(items[j])
		yield combo
tot = sum(items)
ans = 'NO'
for i in powerSet(items):
	if tot - sum(i) == tot / 2 and tot is not 0:
		ans = 'YES'
print(ans)


from bisect import *
from collections import *
from itertools import *
import functools
import sys
import math
from decimal import *
from copy import *
from heapq import *
getcontext().prec = 30
MAX = sys.maxsize
MAXN = 10 ** 6 + 1
MOD = 10 ** 9 + 7
spf = [i for i in range(MAXN)]

def sieve():
	for i in range(2, MAXN, 2):
		spf[i] = 2
	for i in range(3, int(MAXN ** 0.5) + 1):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def mhd(a, b):
	return abs(a[0] - b[0]) + abs(b[1] - a[1])

def charIN(x=' '):
	return sys.stdin.readline().strip().split(x)

def arrIN(x=' '):
	return list(map(int, sys.stdin.readline().strip().split(x)))

def eld(x, y):
	a = y[0] - x[0]
	b = x[1] - y[1]
	return (a * a + b * b) ** 0.5

def lgcd(a):
	g = a[0]
	for i in range(1, len(a)):
		g = math.gcd(g, a[i])
	return g

def ms(a):
	msf = -MAX
	meh = 0
	st = en = be = 0
	for i in range(len(a)):
		meh += a[i]
		if msf < meh:
			msf = meh
			st = be
			en = i
		if meh < 0:
			meh = 0
			be = i + 1
	return (msf, st, en)

def ncr(n, r):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % MOD
		den = den * (i + 1) % MOD
	return num * pow(den, MOD - 2, MOD) % MOD

def flush():
	return sys.stdout.flush()
a = arrIN()
c1 = combinations(a, 1)
c2 = combinations(a, 2)
for i in c1:
	x = sum(a)
	if x % 2:
		print('NO')
		exit(0)
	if sum(i) == x - sum(i):
		print('YES')
		exit(0)
for i in c2:
	x = sum(a)
	if x % 2:
		print('NO')
		exit(0)
	if sum(i) == x - sum(i):
		print('YES')
		exit(0)
print('NO')


ii = lambda : int(input())
kk = lambda : map(int, input().split())
ll = lambda : list(kk())
ls = ll()
for i in range(16):
	if sum((ls[j] for j in range(4) if 1 << j & i)) == sum((ls[j] for j in range(4) if not 1 << j & i)):
		print('YES')
		exit()
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

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):
		(a, b, c, d) = ria()
		ans = 'NO'
		for i in range(2):
			for j in range(2):
				for k in range(2):
					for l in range(2):
						f = 0
						s = 0
						if i == 0:
							f += a
						else:
							s += a
						if j == 0:
							f += b
						else:
							s += b
						if k == 0:
							f += c
						else:
							s += c
						if l == 0:
							f += d
						else:
							s += d
						if f == s:
							ans = 'YES'
		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()


candies = []
(a, b, c, d) = map(int, input().split())
candies.append(a)
candies.append(b)
candies.append(c)
candies.append(d)
min = candies[0]
max = 0
for i in range(0, 4, 1):
	if candies[i] > max:
		max = candies[i]
candies.remove(max)
for i in range(0, 3, 1):
	if candies[i] < min:
		min = candies[i]
candies.remove(min)
if max + min - (candies[0] + candies[1]) == 0 or max - min - (candies[0] + candies[1]) == 0:
	print('Yes')
elif max + min - (candies[0] + candies[1]) != 0 or max - min - (candies[0] + candies[1]) != 0:
	print('No')


(a1, a2, a3, a4) = list(map(int, input().split()))
if (a1 + a2 + a3 + a4) % 2 != 0:
	print('NO')
else:
	p = (a1 + a2 + a3 + a4) // 2
	if a1 + a2 == p or a1 + a3 == p or a1 + a4 == p or (a2 + a3 == p) or (a2 + a4 == p) or (a3 + a4 == p) or (a1 == p) or (a2 == p) or (a3 == p) or (a4 == p):
		print('YES')
	else:
		print('NO')


line = input()
answer = 'NO'
(a, b, c, d) = map(int, line.split(' '))
if a == b + c + d or b == a + c + d or c == a + b + d or (d == a + b + c) or (a + b == c + d) or (a + c == b + d) or (a + d == b + c):
	answer = 'YES'
else:
	()
print(answer)


lst = list(map(int, input().split()))
for i in range(15):
	sum1 = 0
	sum2 = 0
	for j in range(4):
		if 1 << j & i > 0:
			sum1 += lst[j]
		else:
			sum2 += lst[j]
	if sum2 == sum1:
		print('YES')
		break
else:
	print('NO')


bags = [int(k) for k in input().split()]
bags.sort()
if bags[3] == sum(bags[:3]):
	print('YES')
elif bags[0] + bags[3] == bags[1] + bags[2]:
	print('YES')
else:
	print('NO')


def isSubsetSum(arr, n, sum):
	if sum == 0:
		return True
	if n == 0 and sum != 0:
		return False
	if arr[n - 1] > sum:
		return isSubsetSum(arr, n - 1, sum)
	return isSubsetSum(arr, n - 1, sum) or isSubsetSum(arr, n - 1, sum - arr[n - 1])
ar = [int(x) for x in input().strip().split()]
s = sum(ar)
if s % 2 != 0:
	print('NO')
elif isSubsetSum(ar, 4, s // 2):
	print('YES')
else:
	print('NO')


arr = list(map(int, input().split()))

def findPartition(arr, n):
	sum = 0
	(i, j) = (0, 0)
	for i in range(n):
		sum += arr[i]
	if sum % 2 != 0:
		return False
	part = [[True for i in range(n + 1)] for j in range(sum // 2 + 1)]
	for i in range(0, n + 1):
		part[0][i] = True
	for i in range(1, sum // 2 + 1):
		part[i][0] = False
	for i in range(1, sum // 2 + 1):
		for j in range(1, n + 1):
			part[i][j] = part[i][j - 1]
			if i >= arr[j - 1]:
				part[i][j] = part[i][j] or part[i - arr[j - 1]][j - 1]
	return part[sum // 2][n]
n = len(arr)
if findPartition(arr, n) == True:
	print('YES')
else:
	print('NO')


def sort(lst):
	i = 1
	while i < len(lst):
		temp = lst[i]
		j = i - 1
		while j >= 0 and temp < lst[j]:
			lst[j + 1] = lst[j]
			j -= 1
		lst[j + 1] = temp
		i += 1
	return lst
lst = list(map(int, input().split()))
lst = sort(lst)
if lst[0] + lst[1] + lst[2] == lst[3]:
	print('YES')
elif lst[0] + lst[3] == lst[1] + lst[2]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a = sorted(a, reverse=True)
flag = 0
if a[0] == sum(a[1:]):
	flag = 1
elif a[0] + a[-1] == a[2] + a[1]:
	flag = 1
if flag:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split(' '))
pa = a + b + c + d
if pa % 2 != 0:
	print('NO')
elif a + b == c + d or a + c == b + d or a + d == b + c:
	print('YES')
elif a + b + c == d or a + b + d == c or b + c + d == a or (a + c + d == b):
	print('YES')
else:
	print('NO')


(a, b, c, d) = input().split(' ')
a = int(a)
b = int(b)
c = int(c)
d = int(d)
k = a + b + c + d
t = k / 2
t = int(t)
p = max(a, b, c, d)

def main():
	if t == a + b or t == a + c or t == a + d:
		print('YES')
	elif p == a + b + c or p == a + b + d or p == a + c + d or (p == b + c + d):
		print('YES')
	else:
		print('NO')
if k % 2 == 0:
	main()
elif k % 2 != 0:
	print('NO')


(a, b, c, d) = [int(x) for x in input().split()]
if (a + b + c + d) % 2 == 0:
	if a + b == c + d:
		print('YES')
	elif a + c == b + d:
		print('YES')
	elif a + d == b + c:
		print('YES')
	elif a + b + c == d:
		print('YES')
	elif b + c + d == a:
		print('YES')
	elif a + c + d == b:
		print('YES')
	elif a + b + d == c:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


a = list(map(int, input().split()))
n = len(a)
total = sum(a)
flag = False

def subsequences(arr, ind, sub):
	if ind < 0:
		if sum(sub) == total - sum(sub):
			global flag
			flag = True
	else:
		subsequences(arr, ind - 1, sub + [arr[ind]])
		subsequences(arr, ind - 1, sub)
subsequences(a, n - 1, [])
if flag:
	print('YES')
else:
	print('NO')


def solve():
	bags = list(map(int, input().split()))
	tot = sum(bags)
	flag = False
	for i in range(4):
		if bags[i] * 2 == tot:
			flag = True
		for j in range(i + 1, 4):
			if 2 * (bags[i] + bags[j]) == tot:
				flag = True
	print('NO' if not flag else 'YES')
solve()


a = list(map(int, input().split()))
t = []
c = 0
for i in range(len(a)):
	for j in range(i + 1, len(a)):
		t.append(a[i] + a[j])
	t.append(sum(a) - a[i])
if sum(a) % 2 == 0:
	if sum(a) // 2 in t:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


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


from itertools import combinations as cb
c = list(map(int, input().split()))
cc = sum(c)
ans = 'NO'
for g in cb(c, 2):
	if sum(g) == cc // 2:
		ans = 'YES'
for k in c:
	if k == cc // 2:
		ans = 'YES'
if cc & 1:
	ans = 'NO'
print(ans)


s = list(map(int, input().split()))
s.sort()
s = s[::-1]
if s[0] == sum(s[1:]) or s[0] + s[-1] == sum(s[1:-1]):
	print('YES')
else:
	print('NO')


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
l = map(int, stdin.readline().rstrip().split())
l = sorted(l)
if l[0] + l[-1] == l[1] + l[2]:
	print('YES')
elif l[-1] == l[0] + l[1] + l[2]:
	print('YES')
else:
	print('NO')


from math import *
from sys import *
from heapq import *
from collections import defaultdict
import os, sys
from io import IOBase, BytesIO
M = 10 ** 9 + 7

def pow(a, b):
	res = 1
	while b > 0:
		if b & 1:
			res *= a
		a *= a
		b >>= 1
	return res

def powmod(a, b, m):
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a *= a
		b >>= 1
	return res

def inv(a, m):
	return powmod(a, m - 2, m)

def alldivisors(n):
	list = []
	arr = []
	for i in range(1, int(sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				arr += [i]
			else:
				arr += [i]
				list.append(n // i)
	arr += list[::-1]
	return arr

def primefactorisation(n):
	potentional_p = 3
	itog_list = defaultdict(int)
	if n % 2 == 0:
		itog_list[2] = 0
	while n % 2 == 0:
		n = n // 2
		itog_list[2] += 1
	while n - 1:
		if potentional_p > n ** 0.5:
			itog_list[n] += 1
			return itog_list
		while n % potentional_p == 0:
			n = n // potentional_p
			itog_list[potentional_p] += 1
		potentional_p += 2
	return itog_list

def main():
	a = list(map(int, input().split()))
	a.sort()
	if a[0] + a[3] == a[1] + a[2] or a[0] + a[1] + a[2] == a[3]:
		print('YES')
	else:
		print('NO')
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.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()


inp = list(map(int, input().split()))
inp.sort()
print('Yes' if (inp[3] + inp[0] == inp[1] + inp[2]) | (inp[3] - inp[2] == inp[1] + inp[0]) else 'No')


(x, y, z, t) = input().split()
(a, b, c, d) = (int(x), int(y), int(z), int(t))
if a + b == c + d or a + c == b + d or a + d == b + c:
	print('YES')
elif a + b + c == d or a + b + d == c or a + c + d == b or (b + c + d == a):
	print('YES')
else:
	print('NO')


x = input()
x = x.split()
x = [int(i) for i in x]
if max(x) + min(x) == sum(x) - max(x) - min(x) or max(x) == sum(x) - max(x):
	print('YES')
else:
	print('NO')


line = input()
num_list = [int(n) for n in line.split()]
num_list.sort()
if num_list[0] + num_list[-1] == num_list[1] + num_list[-2]:
	print('YES')
elif num_list[0] + num_list[1] + num_list[2] == num_list[-1]:
	print('YES')
else:
	print('NO')


x = []
y = 0
x = input().split()
y = 0
for t in range(len(x)):
	x[t] = int(x[t])
for g in x:
	y = y + g
if y % 2 != 0:
	print('NO')
	exit()
if x[0] + x[1] == y / 2 or x[1] + x[2] == y / 2 or x[2] + x[3] == y / 2 or (x[0] + x[3] == y / 2) or (x[0] + x[2] == y / 2) or (x[1] + x[3] == y / 2):
	print('YES')
	exit()
if x[0] + x[1] + x[2] == x[3] or x[0] + x[1] + x[3] == x[2] or x[1] + x[2] + x[3] == x[0] or (x[0] + x[2] + x[3] == x[1]):
	print('YES')
	exit()
print('NO')


a = list(map(int, input().split()))
s = 0
for i in a:
	s += i
flag = 0
for i in range(len(a)):
	for j in range(i + 1, len(a)):
		if a[i] + a[j] == s - a[i] - a[j]:
			print('YES')
			flag = 1
			break
	if flag == 1:
		break
if flag == 0:
	a.sort()
	if a[0] + a[1] + a[2] == a[3]:
		print('YES')
	else:
		print('NO')


def main():
	values = list(map(int, input().split()))
	total = sum(values)
	values = sorted(values)
	if total % 2 is 1:
		print('NO')
	elif values[0] + values[3] is values[1] + values[2]:
		print('YES')
	elif values[3] == values[1] + values[2] + values[0]:
		print('YES')
	else:
		print('NO')
main()


def func(a):
	if len(a) < 4 or len(a) > 4:
		return
	a.sort()
	if a[0] + a[3] == a[1] + a[2]:
		print('YES')
		return
	if a[0] + a[1] + a[2] == a[3]:
		print('YES')
		return
	else:
		print('NO')
		return
a = input()
a = a.split(' ')
a = [int(a[i]) for i in range(len(a))]
func(a)


(a, b, c, d) = list(map(int, input().strip().split()[:4]))
s = a + b + c + d
if s % 2 != 0:
	print('NO')
elif a + b == c + d:
	print('YES')
elif a + d == b + c:
	print('YES')
elif a + c == b + d:
	print('YES')
elif a == b + c + d:
	print('YES')
elif b == a + c + d:
	print('YES')
elif c == a + b + d:
	print('YES')
elif d == a + b + c:
	print('YES')
else:
	print('NO')


num = [int(k) for k in input().split(' ')]
(a, b, c, d) = (num[0], num[1], num[2], num[3])
if a + b == c + d or a + c == b + d or a + d == b + c or (2 * max(a, b, c, d) == a + b + c + d):
	print('YES')
else:
	print('NO')


from sys import stdin
input = lambda : stdin.readline()
ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(map(int, input().split()))
(a, b, c, d) = mi()
res = 'NO'
if a + b == c + d or a + c == b + d or a + d == b + c or (a + b + c == d) or (a + b + d == c) or (d + b + c == a) or (a + c + d == b):
	res = 'YES'
print(res)


(a, b, c, d) = list(map(int, input().split()))
f = 0
if a + b == c + d:
	f = 1
elif a + c == b + d:
	f = 1
elif a + d == b + c:
	f = 1
elif a == b + c + d:
	f = 1
elif b == a + c + d:
	f = 1
elif c == a + b + d:
	f = 1
elif d == a + b + c:
	f = 1
if f == 1:
	print('YES')
else:
	print('NO')


a_list = list(map(int, input().split()))
for i in range(1 << 4):
	f = 0
	s = 0
	if i & 1 == 1:
		f += a_list[3]
	else:
		s += a_list[3]
	if i >> 1 & 1 == 1:
		f += a_list[2]
	else:
		s += a_list[2]
	if i >> 2 & 1 == 1:
		f += a_list[1]
	else:
		s += a_list[1]
	if i >> 3 & 1 == 1:
		f += a_list[0]
	else:
		s += a_list[0]
	if s == f:
		print('YES')
		exit()
print('NO')


l = list(map(int, input().split()))
l.sort(reverse=True)
c1 = 0
c2 = 0
if len(l) % 2 == 0:
	for i in l:
		if c1 < c2 or c1 == c2:
			c1 = c1 + i
		elif c1 > c2:
			c2 = c2 + i
	if c1 == c2:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
total = a + b + c + d
if total % 2:
	print('NO')
else:
	total = total // 2
	if total in [a, b, c, d] or total in [a + b, a + c, a + d, b + c, b + d, c + d]:
		print('YES')
	else:
		print('NO')


(a, b, c, d) = map(int, input().split())
posbl = [a + b == c + d, a + c == b + d, a + d == b + c, a == b + c + d, b == a + c + d, c == a + b + d, d == a + b + c]
if sum(posbl) > 0:
	print('YES')
else:
	print('NO')


MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import *
l = I()
s = sum(l)
ans = 'NO'
l.sort()
if 2 * l[-1] == s:
	ans = 'YES'
for i in range(4):
	for j in range(4):
		if i == j:
			continue
		if 2 * (l[i] + l[j]) == s:
			ans = 'YES'
print(ans)


ai = list(map(int, input().split()))
ai.sort()
if ai[-1] == sum(ai[:3]) or ai[-1] + ai[0] == ai[1] + ai[2]:
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = map(int, input().split())
s = a1 + a2 + a3 + a4
if s & 1:
	print('NO')
elif a1 + a2 == a3 + a4:
	print('YES')
elif a1 + a3 == a2 + a4:
	print('YES')
elif a1 + a4 == a2 + a3:
	print('YES')
elif a1 == a2 + a3 + a4:
	print('YES')
elif a2 == a1 + a3 + a4:
	print('YES')
elif a3 == a1 + a2 + a4:
	print('YES')
elif a4 == a1 + a2 + a3:
	print('YES')
else:
	print('NO')


import sys
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())
(a1, a2, a3, a4) = invr()
if a1 + a2 == a3 + a4 or a1 + a3 == a2 + a4 or a1 + a4 == a2 + a3:
	print('YES')
elif a1 == a2 + a3 + a4 or a2 == a1 + a3 + a4 or a3 == a1 + a2 + a4 or (a4 == a1 + a2 + a3):
	print('YES')
else:
	print('NO')


A = list(map(int, input().split()))
print('YES' if sum(A) / 2 in A or sum(A) / 2 - A[0] in A[1:] else 'NO')


mod = 10 ** 9 + 7
from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl
from bisect import bisect_right as br
import itertools
import collections
import math
import heapq
from random import randint as rn

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

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

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

def sin():
	return input()

def inin():
	return int(input())

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def main():
	l = ain()
	l.sort()
	if l[0] + l[3] == l[1] + l[2] or l[3] == l[1] + l[2] + l[0]:
		print('YES')
	else:
		print('NO')
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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()


input_lines = input()
ai = map(int, input_lines.replace('\n', '').split(' '))
sorted_ai = sorted(ai)
if sorted_ai[0] + sorted_ai[3] == sorted_ai[1] + sorted_ai[2]:
	print('YES')
elif sorted_ai[0] + sorted_ai[2] == sorted_ai[1] + sorted_ai[3]:
	print('YES')
elif sorted_ai[0] + sorted_ai[1] + sorted_ai[2] == sorted_ai[3]:
	print('YES')
else:
	print('NO')


a = sorted(map(int, input().split()))
s = sum(a)
if s % 2:
	print('NO')
elif s // 2 in (a[0] + a[1], a[0] + a[2], a[0] + a[3], a[0] + a[1] + a[2]):
	print('YES')
else:
	print('NO')


arr = [int(s) for s in input().split(' ')]
arr.sort()
if arr[0] + arr[3] == arr[1] + arr[2] or arr[0] + arr[1] + arr[2] == arr[3]:
	print('Yes')
else:
	print('No')


l = list(map(int, input().split()))
l.sort()
s1 = l[1] + l[2]
s2 = l[0] + l[3]
s3 = l[0] + l[1] + l[2]
if s1 == s2:
	print('YES')
elif s3 == l[3]:
	print('YES')
else:
	print('NO')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
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 main():
	t = 1
	rr = []
	for _ in range(t):
		a = LI()
		s = sum(a)
		t = s / 2
		f = False
		for i in range(4):
			if a[i] == t:
				f = True
				break
			for j in range(i + 1, 4):
				if a[i] + a[j] == t:
					f = True
					break
		rr.append(IF(f, 'YES', 'NO'))
	return JA(rr, '\n')
print(main())


def check(bags):
	bags = [int(val) for val in bags.split()]
	bags = sorted(bags)
	if bags[0] + bags[2] == bags[1] + bags[-1]:
		return 'YES'
	elif bags[0] + bags[-1] == bags[1] + bags[2]:
		return 'Yes'
	elif bags[-1] == bags[0] + bags[1] + bags[2]:
		return 'Yes'
	else:
		return 'NO'
bags = input()
print(check(bags))


(a1, a2, a3, a4) = map(int, input().split())
m = max(a1, a2, a3, a4)
if a1 + a2 == a3 + a4 or a1 + a3 == a2 + a4 or a1 + a4 == a2 + a3 or (m == a1 + a2 + a3) or (m == a2 + a3 + a4) or (m == a1 + a3 + a4) or (m == a1 + a2 + a4):
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
lis = []
lis.append(a)
lis.append(b)
lis.append(c)
lis.append(d)
lis.sort()
if lis[0] + lis[3] == lis[1] + lis[2] or lis[3] == lis[1] + lis[2] + lis[0]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a = sorted(a)
s = sum(a)
if s % 2:
	print('NO')
	exit()
if s // 2 in (a[-1], a[0] + a[-1]):
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
s = a + b + c + d
m = max(a, b, c, d) + min(a, b, c, d)
n = max(a, b, c, d)
print('YES' if 2 * m == s or n == s - n else 'NO')


import sys
input = lambda : sys.stdin.readline().strip()
ls = list(map(int, input().split()))
ls.sort()
if ls[0] + ls[1] + ls[3] == ls[2] or ls[0] + ls[3] == ls[1] + ls[2] or ls[0] + ls[1] + ls[2] == ls[3]:
	print('YES')
else:
	print('NO')


L = list(map(int, input().split()))
L.sort()
if (L[0] + L[-1]) * 2 == sum(L) or L[-1] * 2 == sum(L):
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = map(int, input().split())
s = a1 + a2 + a3 + a4
if s % 2 != 0:
	print('NO')
elif a1 + a2 == a3 + a4 or a1 + a3 == a2 + a4 or a2 + a3 == a1 + a4 or (a2 + a4 == a1 + a3):
	print('YES')
elif a1 == a2 + a3 + a4 or a2 == a1 + a3 + a4 or a3 == a1 + a2 + a4 or (a4 == a1 + a2 + a3):
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
fl = 0
for i in range(16):
	x1 = 0
	x2 = 0
	for j in range(4):
		if i >> j & 1:
			x1 += a[j]
		else:
			x2 += a[j]
	if x1 == x2:
		fl = 1
if fl:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
for i in range(2 ** 4):
	s1 = 0
	s2 = 0
	for j in range(4):
		if i >> j & 1:
			s1 += a[j]
		else:
			s2 += a[j]
	if s1 == s2:
		print('YES')
		break
	elif i == 2 ** 4 - 1:
		print('NO')


stdin = lambda type_='int', sep=' ': list(map(eval(type_), input().split(sep)))
bags = sorted(list(map(int, input().split(' '))))
total = sum(bags) / 2
print('YES' if bags[3] == total or bags[3] + bags[0] == total or bags[3] + bags[1] == total or (bags[3] + bags[2] == total) else 'NO')


(a1, a2, a3, a4) = map(int, input().split(' '))
x = [a1, a2, a3, a4]
x = sorted(x)
if x[0] + x[-1] == x[1] + x[2]:
	print('YES')
elif x[0] + x[2] + x[1] == x[3]:
	print('YES')
else:
	print('NO')


import math
from collections import *
import sys
from functools import reduce

def get_ints():
	return map(int, input().strip().split())

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0)
li = sorted(get_list())
print('YES' if li[0] + li[3] == li[1] + li[2] or li[3] == li[0] + li[1] + li[2] else 'NO')


class bag:

	def __init__(self, bag):
		self.bag = bag

	def result(self):
		bag = self.bag
		t = sum(bag)
		for i in range(3):
			for j in range(i + 1, 4):
				s = (bag[i] + bag[j]) * 2
				if s == t:
					return 'YES'
		for i in range(4):
			s = t - bag[i]
			if bag[i] == s:
				return 'YES'
		else:
			return 'NO'
bags = [int(x) for x in input().split()]
q = bag(bags)
print(q.result())


bags = [int(x) for x in input().split()]
res = 'NO'
if bags[0] == bags[1] + bags[2] + bags[3] or bags[1] == bags[0] + bags[2] + bags[3] or bags[2] == bags[1] + bags[0] + bags[3] or (bags[3] == bags[1] + bags[2] + bags[0]):
	res = 'YES'
elif bags[0] + bags[1] == bags[2] + bags[3] or bags[0] + bags[2] == bags[1] + bags[3] or bags[0] + bags[3] == bags[2] + bags[1]:
	res = 'YES'
print(res)


n = list(map(int, input().split()))
n.sort()
s1 = 0
s2 = 0
s1 += n.pop()
s2 += n.pop()
if s1 > s2:
	s2 += n.pop()
else:
	s1 += n.pop()
if s1 > s2:
	s2 += n.pop()
else:
	s1 += n.pop()
if s1 == s2:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
i = 0
if (a + b + c + d) % 2 != 0:
	print('no')
elif a == b + c + d or b == a + c + d or c == a + b + d or (d == a + b + c) or (a + b == c + d) or (a + c == b + d) or (b + c == a + d) or (a + d == b + c):
	print('yes')
else:
	print('NO')


list1 = list(map(int, input().split()))
sums = sum(list1)
flag1 = True
if sums % 2 == 1:
	print('NO')
	flag1 = False
else:
	for i in range(4):
		flag = True
		if list1[i] == sums / 2:
			flag1
			print('YES')
			flag1 = False
			break
		else:
			for j in range(i + 1, 4):
				if list1[i] + list1[j] == sums / 2:
					print('YES')
					flag = False
					flag1 = False
					break
			if flag == False:
				break
if flag1 == True:
	print('NO')


(u, v, w, x) = map(int, input().split())
if u + v == w + x:
	print('YES')
elif u + w == v + x:
	print('YES')
elif u + x == v + w:
	print('YES')
elif u == v + w + x:
	print('YES')
elif v == u + w + x:
	print('YES')
elif w == u + v + x:
	print('YES')
elif x == u + v + w:
	print('YES')
else:
	print('NO')


l = [int(x) for x in input().split()]
l.sort()
if sum(l[:-1]) == l[-1] or l[0] + l[-1] == l[1] + l[2]:
	print('YES')
else:
	print('NO')


import os, sys, math
import collections
if os.path.exists('testing'):
	name = os.path.basename(__file__)
	if name.endswith('.py'):
		name = name[:-3]
	src = open(name + '.in.txt', encoding='utf8')
	input = src.readline
(a, b, c, d) = map(int, input().strip().split())

def solve(a, b, c, d):
	total = a + b + c + d
	if total & 1:
		return False
	array = [a, b, c, d]

	def check(index, temporary_sum):
		if temporary_sum == total // 2:
			return True
		if index == len(array) or temporary_sum > total // 2:
			return False
		if check(index + 1, temporary_sum):
			return True
		if check(index + 1, temporary_sum + array[index]):
			return True
		return False
	return check(0, 0)
res = solve(a, b, c, d)
print('YES' if res else 'NO')


(a, b, c, d) = map(int, input().split())
x = (a + b + c + d) / 2
if a + b == x:
	print('Yes')
elif a + c == x:
	print('Yes')
elif a + d == x:
	print('Yes')
elif a == x or b == x or c == x or (d == x):
	print('Yes')
else:
	print('No')


s = list(map(int, input().split()))
total = sum(s)
ok = False
i = 0
while i < 4 and (not ok):
	for j in range(i, 4):
		temp = s[i] + s[j]
		if i == j:
			temp -= s[i]
		rest = total - temp
		if temp == rest:
			ok = True
			break
	i += 1
if ok:
	print('YES')
else:
	print('NO')


b = list(map(int, input().split()))
b.sort()
k = sum(b)
f = 0
if k == 2 * b[-1]:
	f = 1
elif b[-1] + b[0] == b[1] + b[2]:
	f = 1
if f == 1:
	print('YES')
else:
	print('NO')


from itertools import permutations
a = list(map(int, input().split()))
for (x, y) in ((b[:i], b[i:]) for b in permutations(a) for i in range(1, 3)):
	if sum(x) == sum(y):
		print('YES')
		break
else:
	print('NO')


a = list(map(int, input().split()))
b = sorted(a)
if b[0] + b[-1] == b[1] + b[2]:
	print('YES')
elif b[0] + b[1] + b[2] == b[-1]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
b = sum(a)
if b % 2 != 0:
	print('NO')
	exit(0)
else:
	c = b // 2
	a.sort()
	sum_1 = 0
	for i in range(len(a)):
		sum_1 = 0
		for j in range(i, len(a)):
			sum_1 += a[j]
			if sum_1 == c:
				print('YES')
				exit(0)
	print('NO')


abcd = input().split()
a = int(abcd[0])
b = int(abcd[1])
c = int(abcd[2])
d = int(abcd[3])
if a + b == c + d or a + c == b + d or a + d == b + c or (a + b + c == d) or (b + c + d == a) or (c + d + a == b) or (d + a + b == c):
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = map(int, input().split())
c = max(a1, a2, a3, a4)
p = min(a1, a2, a3, a4)
l = [a1, a2, a3, a4]
l.remove(c)
l.remove(p)
if p + c == l[0] + l[1]:
	print('YES')
elif c == p + l[0] + l[1]:
	print('YES')
else:
	print('NO')


(a, b, c, d) = list(map(int, input().split()))
sum = a + b + c + d
if sum % 2 == 1:
	print('NO')
elif sum // 2 - a in [b, c, d] or sum // 2 in [a, b, c, d]:
	print('YES')
else:
	print('NO')


nums = sorted(list(map(int, input().split())))
print('yes' if nums[0] + nums[3] == nums[1] + nums[2] or nums[0] + nums[1] + nums[2] == nums[3] else 'no')


(w, x, y, z) = map(int, input().split())
if w + x == y + z:
	print('YES')
elif w + y == x + z:
	print('YES')
elif w + z == x + y:
	print('YES')
elif w == x + y + z:
	print('YES')
elif x == w + y + z:
	print('YES')
elif y == x + w + z:
	print('YES')
elif z == x + y + w:
	print('YES')
else:
	print('NO')


def main():
	candies = sorted([int(i) for i in input().split()])
	if candies[-1] == sum(candies[:3]):
		print('YES')
	elif candies[0] + candies[-1] == sum(candies[1:3]):
		print('YES')
	else:
		print('NO')
main()


def helper(arr, n, start, lsum, rsum):
	if start == n:
		return lsum == rsum
	return helper(arr, n, start + 1, lsum + arr[start], rsum) or helper(arr, n, start + 1, lsum, rsum + arr[start])

def splitArray(arr, n):
	return helper(arr, n, 0, 0, 0)
lis = list(map(int, input().split()))
if splitArray(lis, len(lis)):
	print('YES')
else:
	print('NO')


bags = sorted(list(map(int, input().split())))
if bags[3] == bags[2] + bags[1] + bags[0]:
	print('YES')
elif bags[3] + bags[2] == bags[1] + bags[0]:
	print('YES')
elif bags[3] + bags[0] == bags[1] + bags[2]:
	print('YES')
elif bags[3] + bags[1] == bags[2] + bags[0]:
	print('YES')
else:
	print('NO')


import sys
a = [int(x) for x in input().split()]
suma = sum(a)
if suma % 2 == 0:
	hsuma = int(suma / 2)
	a.sort(reverse=True)
	cursum = hsuma
	for i in range(len(a)):
		if a[i] <= hsuma:
			hsuma -= a[i]
			a[i] -= a[i]
	if hsuma != 0:
		print('NO')
		sys.exit(0)
	print('YES')
else:
	print('NO')


n = input().split()
for i in range(4):
	n[i] = int(n[i])
if n[0] + n[1] == n[2] + n[3]:
	print('YES')
elif n[0] + n[2] == n[1] + n[3]:
	print('YES')
elif n[0] + n[3] == n[2] + n[1]:
	print('YES')
elif n[0] == n[2] + n[1] + n[3]:
	print('YES')
elif n[1] == n[2] + n[0] + n[3]:
	print('YES')
elif n[2] == n[0] + n[1] + n[3]:
	print('YES')
elif n[3] == n[0] + n[1] + n[2]:
	print('YES')
else:
	print('NO')


n = list(map(int, input().split()))
n.append(0)
n.append(0)
n.append(0)
n.append(0)
n.append(0)
f = False
for i in range(len(n)):
	for j in range(len(n)):
		if i == j:
			continue
		for i1 in range(len(n)):
			if i == j or i == i1 or j == i1:
				continue
			for j1 in range(len(n)):
				if i == j or i == i1 or j == i1 or (i == j1) or (j == j1) or (i1 == j1):
					continue
				s = sum([n[i], n[j], n[i1], n[j1]])
				if s == sum(n) - s:
					f = True
if f:
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = map(int, input().split())
A = [a1, a2, a3, a4]
k = (a1 + a2 + a3 + a4) // 2
i = 0
t = 0
if (a1 + a2 + a3 + a4) % 2 == 1:
	t = 0
else:
	a = max(a1, max(a2, max(a3, a4)))
	if a == k:
		t = 1
	else:
		while i < 3 and t == 0:
			for j in range(i + 1, 4):
				if A[j] + A[i] == k:
					t = 1
			i = i + 1
if t == 0:
	r = 'NO'
else:
	r = 'YES'
print(r)


import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce
sys.setrecursionlimit(4100000)
INF = 1 << 60
MOD = 10 ** 9 + 7
(a, b, c, d) = map(int, input().split())
for i in range(2):
	for j in range(2):
		for k in range(2):
			for l in range(2):
				total1 = 0
				total2 = 0
				if i == 1:
					total1 += a
				else:
					total2 += a
				if j == 1:
					total1 += b
				else:
					total2 += b
				if k == 1:
					total1 += c
				else:
					total2 += c
				if l == 1:
					total1 += d
				else:
					total2 += d
				if total1 == total2:
					print('YES')
					sys.exit()
print('NO')


candies = [int(x) for x in input().split()]

def distribute(candies):
	total = sum(candies)
	if total % 2 != 0:
		return False
	target = total // 2
	for x in candies:
		if x == target:
			return True
	for i in range(len(candies)):
		for j in range(i + 1, len(candies)):
			if candies[i] + candies[j] == target:
				return True
	return False
val = distribute(candies)
if val:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
count = 0
if a + b == c + d:
	count += 1
elif a + c == b + d:
	count += 1
elif a + d == b + c:
	count += 1
elif a == b + c + d:
	count += 1
elif b == a + c + d:
	count += 1
elif c == a + b + d:
	count += 1
elif d == a + b + c:
	count += 1
if count >= 1:
	print('YES')
else:
	print('NO')


a = input()
nums = [int(n) for n in a.split()]
a = nums[0]
b = nums[1]
c = nums[2]
d = nums[3]
if a + b == c + d:
	print('YES')
elif a + c == b + d:
	print('YES')
elif a + d == b + c:
	print('YES')
elif a == b + c + d:
	print('YES')
elif b == a + c + d:
	print('YES')
elif c == a + b + d:
	print('YES')
elif d == a + b + c:
	print('YES')
else:
	print('NO')


(b1, b2, b3, b4) = map(int, input().split(' '))
all_candies = b1 + b2 + b3 + b4
each_share = all_candies // 2
if all_candies % 2 == 0:
	if each_share in [b1, b2, b3, b4] and all_candies - each_share == each_share:
		print('YES')
	elif each_share in [b1 + b2, b1 + b3, b1 + b4, b2 + b3]:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


(a, b, c, d) = [int(i) for i in input().split()]
possible = False
if a + b == c + d:
	possible = True
if a + c == b + d:
	possible = True
if a + d == b + c:
	possible = True
if a == b + c + d:
	possible = True
if b == a + c + d:
	possible = True
if c == a + b + d:
	possible = True
if d == a + b + c:
	possible = True
if possible:
	print('YES')
else:
	print('NO')


from itertools import *
a = list(map(int, input().split()))
print('NYOE S'[sum(a) / 2 in [sum(x) for x in permutations(a + [0], 3)]::2])


a = list(map(int, input().split()))
a.sort()
if sum(a) % 2 != 0:
	print('NO')
else:
	s = 0
	f = 0
	for i in range(4):
		s = 0
		s += a[i]
		for j in range(4):
			if i != j and s < sum(a) // 2:
				s += a[j]
			if s == sum(a) // 2:
				print('YES')
				f = 1
				break
		if f == 1:
			break
	if f == 0:
		print('NO')


import sys
import math
input = sys.stdin.readline
b = list(map(int, input().split()))
b.sort()
x = 0
y = 0
x += b[-1]
y += b[-2]
y += b[-3]
if x < y:
	x += b[-4]
else:
	y += b[-4]
if x == y:
	print('YES')
else:
	print('NO')


nums = list(map(int, input().split()))
nums.sort(reverse=True)
if nums[0] == nums[1] + nums[2] + nums[3] or nums[0] + nums[3] == nums[1] + nums[2]:
	print('YES')
else:
	print('NO')


numbers = list(map(int, input().split()))
x = numbers[0]
y = numbers[1]
z = numbers[2]
t = numbers[3]
if x + y == z + t or x + t == y + z or z + x == t + y or (x == y + z + t) or (y == x + z + t) or (z == x + y + t) or (t == x + y + z):
	print('YES')
else:
	print('NO')


def is_possible(a):
	a.sort()
	return 'YES' if a[0] + a[3] == a[1] + a[2] or a[0] + a[1] + a[2] == a[3] else 'NO'
print(is_possible(list(map(int, input().split()))))


from itertools import combinations
(a, b, c, d) = map(int, input().split())
if a + b == c + d or a + c == b + d or a + d == b + c or (a == b + c + d) or (b == a + c + d) or (c == a + b + d) or (d == a + b + c):
	print('YES')
else:
	print('NO')


l = [int(i) for i in input().split()]
x = l[0]
y = l[1]
z = l[2]
w = l[3]
if x + y == z + w or x + z == y + w or x + w == y + z or (x + y + z == w) or (x + z + w == y) or (x + y + w == z) or (y + z + w == x):
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
maxV = max(a, b, c, d)
minV = min(a, b, c, d)
if 2 * maxV - (a + b + c + d) == 0:
	print('YES')
elif 2 * (maxV + minV) - (a + b + c + d) == 0:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
x = sum(a)
flag = 0
if x % 2 != 0:
	print('NO')
else:
	for i in range(len(a)):
		s = a[i]
		for j in range(len(a)):
			if s == x // 2 and i != j:
				flag += 1
				break
			elif i != j:
				s += a[j]
		if flag == 1:
			break
	if flag == 1:
		print('YES')
	else:
		print('NO')


from collections import defaultdict as DD
from bisect import bisect_left as BL
from bisect import bisect_right as BR
from itertools import combinations as IC
from itertools import permutations as IP
from random import randint as RI
import sys
MOD = pow(10, 9) + 7

def IN(f=0):
	if f == 0:
		return [int(i) for i in sys.stdin.readline().split()]
	else:
		return int(sys.stdin.readline())
a = IN()
s = sum(a)
f = 0
for k in range(1, 5):
	for i in IC(a, k):
		if sum(i) == s / 2:
			f = 1
			break
if f == 0:
	print('NO')
else:
	print('YES')


x = list(map(int, input().split()))
if x[0] + x[1] == x[2] + x[3] or x[0] + x[2] == x[1] + x[3] or x[0] + x[3] == x[1] + x[2] or (x[0] + x[1] + x[2] == x[3]) or (x[0] + x[1] + x[3] == x[2]) or (x[0] + x[2] + x[3] == x[1]) or (x[1] + x[2] + x[3] == x[0]):
	print('YES')
else:
	print('NO')


def bag_of_candies(l):
	l.sort(reverse=True)
	if l[0] + l[3] == l[1] + l[2]:
		return 1
	elif l[0] == l[1] + l[2] + l[3]:
		return 1
	else:
		return 0

def main():
	l = list(map(int, input().split(' ')))
	response = bag_of_candies(l)
	if response == 1:
		print('YES')
	else:
		print('NO')
main()


def solve(n):
	n = sorted(n)
	if n[0] + n[3] == n[1] + n[2] or n[0] + n[1] == n[3] + n[2] or n[0] + n[2] == n[1] + n[3]:
		return 'YES'
	elif n[0] + n[3] + n[1] == n[2] or n[0] + n[2] + n[1] == n[3] or n[0] + n[3] + n[2] == n[1] or (n[2] + n[3] + n[1] == n[0]):
		return 'YES'
	return 'NO'
n = list(map(int, input().split()))
print(solve(n))


(a1, a2, a3, a4) = map(int, input().split())

def solve(a1, a2, a3, a4):
	if a1 + a2 + a3 + a4 == 0:
		print('YES')
	elif a1 + a2 + a3 - a4 == 0:
		print('YES')
	elif a1 + a2 - a3 + a4 == 0:
		print('YES')
	elif a1 - a2 + a3 + a4 == 0:
		print('YES')
	elif -a1 + a2 + a3 + a4 == 0:
		print('YES')
	elif a1 + a2 - a3 - a4 == 0:
		print('YES')
	elif a1 - a2 + a3 - a4 == 0:
		print('YES')
	elif -a1 + a2 + a3 - a4 == 0:
		print('YES')
	elif a1 - a2 - a3 + a4 == 0:
		print('YES')
	elif -a1 + a2 - a3 + a4 == 0:
		print('YES')
	elif -a1 - a2 + a3 + a4 == 0:
		print('YES')
	elif a1 - a2 - a3 - a4 == 0:
		print('YES')
	elif -a1 - a2 + a3 - a4 == 0:
		print('YES')
	elif -a1 + a2 - a3 - a4 == 0:
		print('YES')
	elif a1 + a2 + a3 - a4 == 0:
		print('YES')
	elif -a1 - a2 - a3 - a4 == 0:
		print('YES')
	else:
		print('NO')
solve(a1, a2, a3, a4)


from sys import stdin, stdout
import math
values = [int(x) for x in stdin.readline().strip().split()]
flag = False
newvalues = sorted(values)
(a, b, c, d) = newvalues
if a + b == c + d:
	flag = True
if a + c == b + d:
	flag = True
if a + d == b + c:
	flag = True
if d == a + b + c:
	flag = True
if flag:
	stdout.write('YES')
	stdout.write('\n')
else:
	stdout.write('NO')
	stdout.write('\n')


num_arr = list(map(int, input().split()))
count = 'NO'
for i in range(1, 4):
	num_arr2 = num_arr[1:].copy()
	del num_arr2[i - 1]
	if num_arr[0] + num_arr[i] == sum(num_arr2):
		count = 'YES'
		break
if count == 'NO':
	for i in range(4):
		num_arr2 = num_arr.copy()
		del num_arr2[i]
		if num_arr[i] == sum(num_arr2):
			count = 'YES'
			break
print(count)


line = input()
l = line.split()
arr = []
arr.append(int(l[0]))
arr.append(int(l[1]))
arr.append(int(l[2]))
arr.append(int(l[3]))
arr.sort()
a = arr[0]
b = arr[1]
c = arr[2]
d = arr[3]
if a + b + c == d or a + b == c + d or a + d == b + c:
	print('YES')
else:
	print('NO')


import math
import itertools
import collections

def getdict(n):
	d = {}
	if type(n) is list or type(n) is str:
		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()))

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

def wr(arr):
	return ' '.join(map(str, arr))

def revn(n):
	return int(str(n)[::-1])

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True
a = sorted(li())
print('YES') if a[0] + a[3] == a[1] + a[2] or sum(a[:3]) == a[3] else print('NO')


def selections(n):
	if n == 1:
		return [[True], [False]]
	return [[True] + x for x in selections(n - 1)] + [[False] + x for x in selections(n - 1)]

def main():
	candles = list(map(int, input().split(' ')))
	s = selections(4)
	for select in s:
		x = sum([candles[i] for i in range(4) if select[i]])
		y = sum([candles[i] for i in range(4) if not select[i]])
		if x == y:
			print('YES')
			break
	else:
		print('NO')
main()


from sys import stdin
a = list(map(int, stdin.readline().split()))
ans = 'NO'

def recur(i, b1, b2):
	global ans
	if i == 4:
		if b1 == b2:
			ans = 'YES'
	else:
		recur(i + 1, b1 + a[i], b2)
		recur(i + 1, b1, b2 + a[i])
recur(0, 0, 0)
print(ans)


candy = list(map(int, input().split()))
hap = sum(candy)
pos = False
for i in range(4):
	if candy[i] == hap / 2:
		pos = True
for i in range(3):
	for j in range(i + 1, 4):
		if candy[i] + candy[j] == hap / 2:
			pos = True
for i in range(2):
	for j in range(i + 1, 3):
		for k in range(j + 1, 4):
			if candy[i] + candy[j] + candy[k] == hap / 2:
				pos = True
if pos:
	print('YES')
else:
	print('NO')


def solve(nums):
	nums.sort()
	biggest = nums[3]
	smallest = nums[0]
	if biggest + smallest == nums[1] + nums[2] or biggest == smallest + nums[1] + nums[2]:
		print('YES')
	else:
		print('NO')
	return
(a1, a2, a3, a4) = input().split()
(a1, a2, a3, a4) = (int(a1), int(a2), int(a3), int(a4))
solve([a1, a2, a3, a4])


(a, b, c, d) = map(int, input().split())
total = a + b + c + d
if total % 2 != 0:
	print('NO')
elif a + b == total // 2:
	print('YES')
elif a + c == total // 2:
	print('YES')
elif a + d == total // 2:
	print('YES')
elif a + b + c == total // 2:
	print('YES')
elif a + b + d == total // 2:
	print('YES')
elif a + c + d == total // 2:
	print('YES')
elif b + c == total // 2:
	print('YES')
elif b + d == total // 2:
	print('YES')
elif b + c + d == total // 2:
	print('YES')
elif c + d == total // 2:
	print('YES')
else:
	print('NO')


b = list(map(int, input().split()))
b.sort()
if b[-1] == b[0] + b[1] + b[2]:
	print('YES')
elif b[-1] + b[0] == b[1] + b[2]:
	print('YES')
else:
	print('NO')


a = [int(x) for x in input().split()]
a = sorted(a)
if a[0] + a[1] + a[2] == a[3]:
	print('YES')
elif a[0] + a[3] == a[1] + a[2]:
	print('YES')
else:
	print('NO')


l = [int(x) for x in input().split()]
mi = min(l)
ma = max(l)
del l[l.index(mi)]
del l[l.index(ma)]
if l[0] + l[1] == ma + mi or ma == mi + l[0] + l[1]:
	print('YES')
else:
	print('NO')


(a, b, c, d) = sorted(map(int, input().rstrip().split()))
if a + b + c == d:
	print('YES')
elif a + d == b + c:
	print('YES')
elif d + b == a + c:
	print('YES')
elif c + d == a + b:
	print('YES')
else:
	print('NO')


l = [int(x) for x in input().split()]
if l[0] == l[1] + l[2] + l[3]:
	print('YES')
elif l[1] == l[0] + l[2] + l[3]:
	print('YES')
elif l[2] == l[1] + l[0] + l[3]:
	print('YES')
elif l[3] == l[0] + l[1] + l[2]:
	print('YES')
elif l[0] + l[1] == l[2] + l[3]:
	print('YES')
elif l[0] + l[2] == l[1] + l[3]:
	print('YES')
elif l[0] + l[3] == l[2] + l[1]:
	print('YES')
else:
	print('NO')


(x1, x2, x3, x4) = map(int, input().split())
if x1 + x2 == x3 + x4:
	print('YES')
elif x1 + x3 == x2 + x4:
	print('YES')
elif x1 + x4 == x2 + x3:
	print('YES')
elif x1 == x2 + x3 + x4:
	print('YES')
elif x2 == x1 + x3 + x4:
	print('YES')
elif x3 == x1 + x2 + x4:
	print('YES')
elif x4 == x1 + x2 + x3:
	print('YES')
else:
	print('NO')


inp = list(map(int, input().split()))
a = inp[0]
b = inp[1]
c = inp[2]
d = inp[3]
inp.sort()
k = sum(inp)
if k % 2 == 1:
	print('NO')
else:
	m = max(inp)
	if m > k // 2:
		print('NO')
	elif m == k // 2:
		print('YES')
	elif m + inp[1] == k // 2:
		print('YES')
	elif m + inp[0] == k // 2:
		print('YES')
	else:
		print('NO')


bags = list(map(int, input().split()))
bags.sort()
print(['NO', 'YES'][bags[0] + bags[3] == bags[1] + bags[2] or bags[0] + bags[1] + bags[2] == bags[3]])


ls = list(map(int, input().split()))
m = sum(ls)
ls.sort()
if m % 2 == 0:
	if ls[3] == m / 2:
		print('YES')
	else:
		condition = False
		for i in range(3):
			if ls[3] + ls[i] == m / 2:
				condition = True
			else:
				continue
		if condition == True:
			print('YES')
		else:
			print('NO')
else:
	print('NO')


import sys
from collections import defaultdict as dc
from collections import Counter
from bisect import bisect_right
import math
(a, b, c, d) = map(int, input().split())
if a + b == c + d or a + c == b + d or a + d == b + c or (a + b + c == d) or (a + c + d == b) or (a + b + d == c) or (b + c + d == a):
	print('YES')
else:
	print('NO')


def solve(a):
	for i in range(1 << 4):
		x = format(i, f'0{4}b')
		(k, w) = (0, 0)
		for (p, j) in enumerate(x):
			if j == '1':
				k += a[p]
			else:
				w += a[p]
		else:
			if k == w:
				return 'YES'
	return 'NO'

def main():
	a = list(map(int, input().split()))
	print(solve(a))
main()


import itertools
import sys
for l in sys.stdin:
	inputs = [int(i) for i in l.split(' ')]
	for perm in list(itertools.permutations(range(4))):
		inputs_perm = [inputs[i] for i in perm]
		for i in range(4):
			if sum(inputs_perm[:i]) == sum(inputs_perm[i:]):
				print('YES')
				exit(0)
	break
print('NO')


(b1, b2, b3, b4) = map(int, input().split())
ans = 'NO'
if b1 + b2 == b3 + b4:
	ans = 'YES'
elif b1 + b3 == b2 + b4:
	ans = 'YES'
elif b1 + b4 == b3 + b2:
	ans = 'YES'
elif b1 + b2 + b3 == b4:
	ans = 'YES'
elif b1 + b2 + b4 == b3:
	ans = 'YES'
elif b1 + b4 + b3 == b2:
	ans = 'YES'
elif b4 + b2 + b3 == b1:
	ans = 'YES'
print(ans)


import sys
import itertools as it

def main():
	a = list(map(int, sys.stdin.readline().split()))
	m = sum(a)
	if m % 2 == 0:
		m = m // 2
		for i in range(1, 4):
			for val in it.combinations(a, i):
				s = 0
				for x in val:
					s += x
					if s == m:
						print('YES')
						exit()
	print('NO')
main()


def check_possible(nums):
	nums.sort()
	smallest = nums[0]
	biggest = nums[3]
	return biggest == nums[0] + nums[1] + nums[2] or biggest + smallest == nums[1] + nums[2]
(a, b, c, d) = input().split()
(a, b, c, d) = (int(a), int(b), int(c), int(d))
if check_possible([a, b, c, d]):
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
if len(a) > 0:
	a.sort()
	count1 = a.pop()
	count2 = 0
	while len(a) > 0:
		if count1 > count2:
			count2 += a.pop()
		else:
			count1 += a.pop()
	if count1 == count2:
		print('YES')
	else:
		print('NO')
else:
	print('YES')


import sys
line = input()
(sac1, sac2, sac3, sac4) = map(int, line.split(' '))
if sac1 + sac2 == sac3 + sac4 or sac1 + sac3 == sac2 + sac4 or sac2 + sac3 == sac1 + sac4 or (sac1 + sac2 + sac3 == sac4) or (sac1 + sac2 + sac4 == sac3) or (sac1 + sac3 + sac4 == sac2) or (sac2 + sac3 + sac4 == sac1):
	print('YES')
else:
	print('NO')


try:
	l = []
	(a, b, c, d) = map(int, input().split())
	l.append(a)
	l.append(b)
	l.append(c)
	l.append(d)
	if (a + b + c + d) % 2 == 0:
		l.sort()
		last = l.pop()
		sum1 = sum(l)
		if last == sum1:
			print('YES')
		else:
			l.append(last)
			if l[0] + l[3] == l[1] + l[2]:
				print('YES')
			elif l[1] + l[3] == l[0] + l[2]:
				print('YES')
			else:
				print('NO')
	else:
		print('NO')
except:
	print(a, b, x, y)


l = list(map(int, input().split()))
if sum(l) % 2 != 0:
	print('NO')
else:
	l.sort()
	a = l[0] + l[-1]
	b = l[-1]
	c = l[1] + l[2]
	if a == c:
		print('YES')
	elif b == l[0] + c:
		print('YES')
	else:
		print('NO')


(a, b, c, d) = map(int, input().split())
e = a + b + c + d
l = 0
if e % 2 != 0:
	l = 0
else:
	if a + b == c + d:
		l = 1
	if a + c == b + d:
		l = 1
	if a + d == b + c:
		l = 1
	if a + b + c == d:
		l = 1
	if a + b + d == c:
		l = 1
	if a + c + d == b:
		l = 1
	if b + c + d == a:
		l = 1
if l == 1:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
flag = False
for i in range(2):
	for j in range(2):
		for k in range(2):
			for l in range(2):
				a_ = 0
				b_ = 0
				for (i, v) in enumerate([i, j, k, l]):
					if v % 3 == 0:
						a_ += a[i]
					else:
						b_ += a[i]
				if a_ == b_:
					flag = True
if flag:
	print('YES')
else:
	print('NO')


candy = list(map(int, input().split(' ')))
candy.sort()
if (candy[0] + candy[-1]) * 2 == sum(candy) or candy[-1] * 2 == sum(candy):
	print('Yes')
else:
	print('No')


from itertools import chain, combinations
a = list(map(int, input().strip().split()))
sm = sum(a)
pset = list([i for i in chain.from_iterable((combinations(a, r) for r in range(len(a) + 1))) if 2 <= len(i) <= 3])
for elem in pset:
	if 2 * sum(elem) == sm:
		print('YES')
		break
else:
	print('NO')


bags = input().split()
num = (int(bags[0]) + int(bags[1]) + int(bags[2]) + int(bags[3])) / 2
can_divide = False
for i in range(4):
	if int(bags[i]) == num:
		print('YES')
		can_divide = True
if not can_divide:
	if int(bags[0]) + int(bags[1]) == int(bags[2]) + int(bags[3]):
		print('YES')
	elif int(bags[0]) + int(bags[2]) == int(bags[1]) + int(bags[3]):
		print('YES')
	elif int(bags[0]) + int(bags[3]) == int(bags[1]) + int(bags[2]):
		print('YES')
	else:
		print('NO')


from collections import defaultdict as dc
import sys
import math

def inp():
	p = sys.stdin.readline()
	return p
a = list(map(int, inp().split()))
a.sort()
(x, y, z, k) = a
if x + y + z == k or x + z == y + k or z + y == x + k:
	print('YES')
else:
	print('NO')


from itertools import permutations
a = list(map(int, input().split()))
a = list(sorted(a))
l = a[-1]
r = a[-2]
if l + a[0] == r + a[1]:
	print('YES')
elif l + a[1] == r + a[0]:
	print('YES')
elif l == a[1] + a[0] + r:
	print('YES')
else:
	print('NO')


class Solution:

	def __init__(self):
		self.__a = [int(x) for x in input().split()]

	def solve_and_print(self):
		candies_1st_friend = candies_2nd_friend = 0
		total_candies = sum((x for x in self.__a))
		for i in range(1 << self.__a.__len__()):
			candies_1st_friend = sum((self.__a[j] for j in range(self.__a.__len__()) if i & 1 << j))
			candies_2nd_friend = total_candies - candies_1st_friend
			if candies_1st_friend == candies_2nd_friend:
				break
		print('YES' if candies_1st_friend == candies_2nd_friend else 'NO')
Solution().solve_and_print()


(a, b, c, d) = map(int, input().split(' '))
if a + b == c + d:
	print('Yes')
elif a + c == b + d:
	print('YES')
elif a + d == b + c:
	print('YES')
elif a == b + c + d:
	print('YES')
elif b == a + c + d:
	print('YES')
elif c == a + b + d:
	print('YES')
elif d == a + b + c:
	print('YES')
else:
	print('NO')


from sys import stdin
(a, b, c, d) = map(int, stdin.readline().strip().split())
s = [a, b, c, d]
n = a + b + c + d
m = n // 2
dp = [False for i in range(1000)]
dp[0] = True
for j in s:
	for i in range(999, -1, -1):
		if dp[i]:
			dp[i + j] = True
if dp[m] == True and n % 2 == 0:
	print('YES')
else:
	print('NO')


li = list(map(int, input().split(' ')))
count = 0
a = li[0]
b = li[1]
c = li[2]
d = li[3]
if a < 1 or b < 1 or c < 1 or (d < 1):
	print('NO')
elif a > 100 or b > 100 or c > 100 or (d > 100):
	print('NO')
elif a + b == c + d or a + c == b + d or a + d == b + c or (a + b + c == d) or (b + c + d == a) or (a + b + d == c) or (a + c + d == b):
	print('YES')
else:
	print('NO')


def resolve():
	bags_in = input('')
	bags = list(map(int, bags_in.split()))
	friend1 = []
	for (i, candie1) in enumerate(bags):
		friend2 = bags.copy()
		others = bags[i:].copy()
		others.remove(candie1)
		friend1.append(candie1)
		friend2.remove(candie1)
		for (j, candie2) in enumerate(others):
			others2 = others[j:].copy()
			others2.remove(candie2)
			friend1.append(candie2)
			friend2.remove(candie2)
			for candie3 in others2:
				friend1.append(candie3)
				friend2.remove(candie3)
				if sum(friend1) == sum(friend2):
					return True
				friend1.remove(candie3)
				friend2.append(candie3)
			if sum(friend1) == sum(friend2):
				return True
			friend1.remove(candie2)
			friend2.append(candie2)
		if sum(friend1) == sum(friend2):
			return True
		friend1.remove(candie1)
		friend2.append(candie1)
	return False
if resolve():
	print('YES')
else:
	print('NO')


lst = list(map(int, input().split()))
toto = sum(lst)
lst.sort()
if toto % 2 == 0:
	if lst[3] == toto // 2:
		print('YES')
	elif lst[3] + lst[0] == toto // 2:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


a = sorted(map(int, input().split()))
if a[0] + a[1] + a[2] == a[3] or sum(a[0:2]) == sum(a[2:]) or a[0] + a[2] == a[1] + a[3] or (a[0] + a[3] == a[1] + a[2]):
	print('Yes')
else:
	print('NO')


for i in range(1):
	a = list(map(int, input().split()))
	a.sort()
	if a[0] + a[3] == a[1] + a[2] or a[3] == sum(a) - a[3]:
		print('YES')
	else:
		print('NO')


def main():
	A = list(map(int, input().split()))
	A.sort(reverse=True)
	s = sum(A)
	if s % 2:
		return 'NO'
	if A[0] == s // 2:
		return 'YES'
	for a in A[1:]:
		if A[0] + a == s // 2:
			return 'YES'
	return 'NO'
print(main())


lst = [int(i) for i in input().split()]
lst.sort()
if lst[0] + lst[3] == lst[1] + lst[2] or lst[0] + lst[2] + lst[1] == lst[3]:
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = map(int, input().split())
p = a1 + a2 + a3 + a4
l = []
l.append(a1)
l.append(a2)
l.append(a3)
l.append(a4)
l.sort()
q = max(l)
if p % 2 == 0:
	w = p // 2
	if w == a1 or w == a4 or w == a3 or (w == a2):
		print('YES')
	elif a1 + a2 == w or a1 + a3 == w or a1 + a4 == w:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


import itertools

def solver(a):
	pass
b = input()
b = [int(_) for _ in b.split()]
x = [''.join(seq) for seq in itertools.product('01', repeat=4)]
z = False
for i in x:
	asum = 0
	bsum = 0
	for j in range(4):
		if i[j] == '0':
			asum += b[j]
		else:
			bsum += b[j]
	if asum == bsum:
		z = True
if z is True:
	print('YES')
else:
	print('NO')


t = list(map(int, input().split()))
t.sort()
if t[0] + t[-1] == sum(t) - (t[0] + t[-1]):
	print('YES')
elif t[-1] == sum(t) - t[-1]:
	print('YES')
else:
	print('NO')


a = [int(s) for s in input().split(' ')]
if 2 * (max(a) + min(a)) == sum(a) or 2 * max(a) == sum(a):
	print('YES')
else:
	print('NO')


arr = [int(arr) for arr in input().split()][:4]
if arr[0] + arr[2] == arr[1] + arr[3]:
	print('YES')
elif arr[0] + arr[1] == arr[2] + arr[3]:
	print('YES')
elif arr[0] + arr[3] == arr[1] + arr[2]:
	print('YES')
elif arr[0] == arr[1] + arr[2] + arr[3]:
	print('YES')
elif arr[1] == arr[0] + arr[2] + arr[3]:
	print('YES')
elif arr[2] == arr[1] + arr[0] + arr[3]:
	print('YES')
elif arr[3] == arr[1] + arr[2] + arr[0]:
	print('YES')
else:
	print('NO')


def main():
	a = []
	a = [int(x) for x in input().split()]
	for i in range(len(a)):
		if sum(a) - a[i] == a[i]:
			print('YES')
			return
		for j in range(len(a)):
			if j != i:
				s = a[i] + a[j]
				if sum(a) - s == s:
					print('YES')
					return
	print('NO')
	return
main()


import itertools
import sys

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

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

def rln(n):
	l = [None] * n
	for i in range(n):
		l[i] = int(rl())
	return l

def solve(t):
	for e in t:
		if e[0] + e[1] == e[2] + e[3] or e[0] == e[1] + e[2] + e[3]:
			return True
	return False
tab = rn()
t = itertools.permutations(tab)
print('YES' if solve(t) else 'NO')


l = list(map(int, input().split()))
flag = True
flag2 = True
if sum(l) % 2 != 0:
	print('NO')
else:
	div = sum(l) / 2
	onethrees = []
	twotwos = []
	for i in range(0, 4):
		if sum(l[i:i]) + sum(l[0:i] + l[i + 1:]) == div:
			flag = False
			print('YES')
			break
	if flag:
		for i in range(0, 4):
			for j in range(i + 1, 4):
				if l[i] + l[j] == div:
					print('YES')
					flag2 = False
					break
			if not flag2:
				break
	if flag and flag2:
		print('NO')


res = 'NO'
a = list(map(int, input().split()))
t = sum(a) / 2
for i in range(2):
	if a[i] == t:
		res = 'YES'
		break
	for j in range(i + 1, 3):
		if a[i] + a[j] == t:
			res = 'YES'
			break
		for k in range(j + 1, 4):
			if a[i] + a[j] + a[k] == t:
				res = 'YES'
				break
print(res)


nums = [int(x) for x in input().split()]
nums = sorted(nums)
if nums[0] + nums[3] == nums[1] + nums[2] or nums[3] == nums[0] + nums[1] + nums[2]:
	print('yes')
else:
	print('no')


import sys
import math
from functools import reduce
import bisect

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

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

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

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

def index(a, x):
	i = bisect.bisect_left(a, x)
	if i != len(a) and a[i] == x:
		return -1
	return i
(a, b, c, d) = getNM()
check = False
for i in [a, b, c, d]:
	if sum([a, b, c, d]) - i == i:
		check = True
		break
if a + b == c + d or a + c == d + b or a + d == c + b or check:
	print('YES')
else:
	print('NO')


def solve():
	m = [int(s) for s in input().split()]
	u = False
	for i in range(2):
		for j in range(2):
			for k in range(2):
				for l in range(2):
					s = 0
					if i:
						s += m[0]
					if j:
						s += m[1]
					if k:
						s += m[2]
					if l:
						s += m[3]
					if s == sum(m) - s:
						u = True
	if u:
		print('YES')
	else:
		print('NO')
solve()


def solution(listInput):
	if listInput[0] + listInput[1] == listInput[2] + listInput[3] or listInput[0] + listInput[2] == listInput[1] + listInput[3] or listInput[0] + listInput[3] == listInput[1] + listInput[2]:
		print('YES')
	elif listInput[0] + listInput[1] + listInput[2] == listInput[3] or listInput[2] + listInput[3] + listInput[0] == listInput[1] or listInput[1] + listInput[2] + listInput[3] == listInput[0] or (listInput[1] + listInput[0] + listInput[3] == listInput[2]):
		print('YES')
	else:
		print('NO')

def main():
	nNumsLine = list(map(int, input().split()))
	solution(nNumsLine)
main()


import itertools as it
a = list(map(int, input().split()))
summ = sum(a)
if summ % 2 != 0:
	print('NO')
else:
	b = False
	for r in range(1, 5):
		if b:
			print('YES')
			break
		for p in it.combinations(a, r):
			if sum(p) == summ // 2:
				b = True
				break
	else:
		print('NO')


vet = list(map(int, input().split()))
opa = sum(vet)
if opa % 2 == 1:
	print('NO')
	exit()
else:
	for i in range(4):
		soma = vet[i]
		if soma == opa - soma:
			print('YES')
			exit()
		for j in range(i + 1, 4):
			if vet[i] + vet[j] == opa - (vet[i] + vet[j]):
				print('YES')
				exit()
			soma += vet[j]
			if soma == opa - soma:
				print('YES')
				exit()
print('NO')


arr = [0] * 4
arr = input().split()
a = int(arr[0])
b = int(arr[1])
c = int(arr[2])
d = int(arr[3])
fifa = True
for r in range(1):
	if a + b == c + d:
		fifa = False
		print('YES')
		break
	if a + c == b + d:
		fifa = False
		print('YES')
		break
	if a + d == b + c:
		fifa = False
		print('YES')
		break
	if a == b + c + d:
		fifa = False
		print('YES')
		break
	if b == c + d + a:
		fifa = False
		print('YES')
		break
	if c == a + b + d:
		fifa = False
		print('YES')
		break
	if d == a + b + c:
		fifa = False
		print('YES')
		break
if fifa == True:
	print('NO')


def particion(lista):
	if lista[0] + lista[1] + lista[2] == lista[3]:
		return True
	elif lista[0] + lista[1] == lista[2] + lista[3]:
		return True
	elif lista[0] == lista[1] + lista[2] + lista[3]:
		return True
	elif lista[0] + lista[2] == lista[1] + lista[3]:
		return True
	else:
		return False

def main():
	lista = list(map(int, input().split()))
	i = 0
	verdadero = False
	while verdadero == False and i < 4:
		if particion(lista):
			verdadero = True
		else:
			a = lista[0]
			lista.pop(0)
			lista.append(a)
			i += 1
	if verdadero:
		print('YES')
	else:
		print('NO')
main()


def getones(a, b, c, d, n):
	s = ('0000' + str(bin(n)[2:]))[-4:]
	ans = a * int(s[0]) + b * int(s[1]) + c * int(s[2]) + d * int(s[3])
	return ans * 2 == a + b + c + d
(a, b, c, d) = map(int, input().split())
getones(a, b, c, d, 3)
flag = 1
for i in range(16):
	if getones(a, b, c, d, i):
		print('YES')
		flag = 0
		break
if flag:
	print('NO')


input_list = list(map(int, input().split(' ')))
if len(input_list) != 4:
	print('NO')
else:
	sum_input = sum(input_list)
	max_input = max(input_list)
	min_input = min(input_list)
	if sum_input == (max_input + min_input) * 2 or sum_input == max_input * 2:
		print('YES')
	else:
		print('NO')


def main():
	nums = list(map(int, input().split()))
	total = sum(nums)
	if total % 2 == 1:
		print('NO')
		return
	for i in range(len(nums) - 1):
		for j in range(i + 1, len(nums)):
			if nums[i] + nums[j] == total // 2:
				print('YES')
				return
	for num in nums:
		if num == total // 2:
			print('YES')
			return
	print('NO')
main()


import sys
import math
import bisect

def main():
	A = list(map(int, input().split()))
	n = len(A)
	ans = False
	for i in range(2 ** n):
		val = 0
		for j in range(n):
			if i & 1 << j:
				val += A[j]
		if val * 2 == sum(A):
			ans = True
	if ans:
		print('YES')
	else:
		print('NO')
main()


value = input().split()
(a1, a2, a3, a4) = value
a1 = int(a1)
a2 = int(a2)
a3 = int(a3)
a4 = int(a4)
l = [a1, a2, a3, a4]
l.sort()
max = l[3]
min = l[0]
next_to_min = l[1]
prev_to_max = l[2]
if min + max == next_to_min + prev_to_max or min + next_to_min + prev_to_max == max:
	print('YES')
else:
	print('NO')


import sys
a = [int(x) for x in input().split(' ')]
jam = a[0] + a[1] + a[2] + a[3]
k = 0
for i in range(4):
	l = 0
	if a[i] == jam - a[i]:
		l = 1
		break
	for j in range(4):
		if a[i] + a[j] == jam / 2:
			l = 1
if l == 1:
	print('YES')
else:
	print('NO')


from collections import defaultdict

def backtrack(states, a, idx):
	if idx == 4:
		sum_dict = defaultdict(int)
		for (state, ea) in zip(states, a):
			sum_dict[state] += ea
		return sum_dict[True] == sum_dict[False]
	states[idx] = True
	if backtrack(states, a, idx + 1):
		return True
	states[idx] = False
	return backtrack(states, a, idx + 1)

def solve(a):
	a = sorted(a)
	return backtrack([False] * 4, a, 0)
assert solve([1, 7, 11, 5])
assert not solve([7, 3, 2, 5])
assert solve([3, 14, 36, 53])
a = list(map(int, input().split()))
print('YES' if solve(a) else 'NO')


A = list(map(int, input().split()))

def check(a):
	a.sort()
	s = sum(a)
	if a[0] + a[3] == a[2] + a[1]:
		return 'YES'
	for i in range(len(a)):
		if a[i] == s - a[i]:
			return 'YES'
	return 'NO'
print(check(A))


arr = list(map(int, input().split()))
arr.sort()
x = sum(arr)
if x % 2 == 0:
	x = x // 2
	a = x - arr[-1]
	if a in arr[:3] or a == 0:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


(a, b, c, d) = [int(i) for i in input().split()]
if a == max(a, b, c, d):
	(a, d) = (d, a)
elif b == max(a, b, c, d):
	(b, d) = (d, b)
elif c == max(a, b, c, d):
	(c, d) = (d, c)
if b == min(a, b, c, d):
	(b, a) = (a, b)
elif c == min(a, b, c, d):
	(c, a) = (a, c)
elif d == min(a, b, c, d):
	(d, a) = (a, d)
if d == a + b + c:
	print('YES')
elif a + d == b + c:
	print('YES')
else:
	print('NO')


import random
nums = list(map(int, input().split()))
cond = False
for i in range(1000):
	x = random.choice([1, 2, 3, 4])
	M = nums[:]
	sum1 = 0
	sum2 = 0
	for i in range(x):
		k = random.choice(M)
		M.remove(k)
		sum1 += k
	if sum1 == sum(M):
		print('YES')
		cond = True
		break
if cond == False:
	print('NO')


l = list(map(int, input().split()))
S = sum(l)
cnt = 0
for i in range(1, 4):
	S1 = l[0] + l[i]
	if S1 == S - S1:
		cnt += 1
		break
for i in range(4):
	if l[i] == S - l[i]:
		cnt += 1
		break
if cnt > 0:
	print('YES')
else:
	print('NO')


arr = list(map(int, input().split()))
a = arr[0]
b = arr[1]
c = arr[2]
d = arr[3]
if a + b == c + d:
	print('YES')
elif a + d == b + c:
	print('YES')
elif a + c == b + d:
	print('YES')
elif a == b + c + d:
	print('YES')
elif b == a + d + c:
	print('YES')
elif c == a + b + d:
	print('YES')
elif d == a + b + c:
	print('YES')
else:
	print('NO')


from itertools import combinations
ls = list(map(int, input().split()))
combo = list(combinations(ls, 2))
combo2 = list(combinations(ls, 3))
combo1 = list(combinations(ls, 1))
combo += combo2
combo += combo1
ans = 'NO'
for i in range(len(combo)):
	for j in range(i + 1, len(combo)):
		if sum(combo[i]) == sum(combo[j]):
			if sum(combo[i]) + sum(combo[j]) == sum(ls):
				ans = 'YES'
				break
print(ans)


(a, b, c, d) = input().strip().split(' ')
(a, b, c, d) = [int(a), int(b), int(c), int(d)]
s = [a, b, c, d]
s.sort()
if s[0] + s[3] == s[1] + s[2] or s[3] == s[0] + s[1] + s[2]:
	print('YES')
else:
	print('No')


l = [int(i) for i in input().split()]
l.sort()
if l[0] + l[-1] == l[1] + l[2] or l[-1] == l[0] + l[1] + l[2]:
	print('YES')
else:
	print('NO')


candies = input().split()
c1 = int(candies[0])
c2 = int(candies[1])
c3 = int(candies[2])
c4 = int(candies[3])
sum1 = c1 + c2
sum2 = c1 + c3
sum3 = c1 + c4
sum4 = c2 + c3
sum5 = c2 + c4
sum6 = c3 + c4
suma = c1 + c2 + c3
sumb = c1 + c2 + c4
sumc = c1 + c3 + c4
sumd = c2 + c3 + c4
if sum1 == sum6 or sum2 == sum5 or sum3 == sum4 or (suma == c4) or (sumb == c3) or (sumc == c2) or (sumd == c1):
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
ma = max(a)
a.remove(ma)
flag = 0
if ma == sum(a):
	print('YES')
	flag = 1
mi = min(a)
a.remove(mi)
if mi + ma == sum(a):
	print('YES')
	flag = 1
if flag == 0:
	print('NO')


import sys
import heapq
import math
from collections import defaultdict as dd
l = [int(i) for i in input().split()]
l.sort()
if l[0] + l[-1] == l[1] + l[2] or l[0] + l[1] + l[2] == l[3]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
for i in range(4):
	for j in range(4):
		if i != j:
			if a[i] + a[j] == sum(a) - a[i] - a[j]:
				print('YES')
				exit()
for i in range(4):
	for j in range(4):
		for k in range(4):
			if i != k and j != k and (j != i):
				if a[i] + a[j] + a[k] == sum(a) - a[i] - a[j] - a[k]:
					print('YES')
					exit()
print('NO')


x = [int(y) for y in input().split()]
s = []
count = 0
if x[0] + x[1] + x[2] == x[3]:
	count = 1
elif x[0] + x[1] + x[3] == x[2]:
	count = 1
elif x[0] + x[2] + x[3] == x[1]:
	count = 1
elif x[1] + x[2] + x[3] == x[0]:
	count = 1
elif x[0] + x[1] == sum(x) - (x[0] + x[1]):
	count = 1
elif x[0] + x[2] == sum(x) - (x[0] + x[2]):
	count = 1
elif x[0] + x[3] == sum(x) - (x[0] + x[3]):
	count = 1
elif x[1] + x[2] == sum(x) - (x[2] + x[1]):
	count = 1
elif x[1] + x[3] == sum(x) - (x[3] + x[1]):
	count = 1
elif x[2] + x[3] == sum(x) - (x[2] + x[3]):
	count = 1
else:
	count = 0
if count == 0:
	print('NO')
else:
	print('YES')


def solution(a):
	a.sort()
	st = []
	total = sum(a)
	cur = 0
	for i in a:
		cur += i
		st.append(i)
		while st and sum(st) * 2 > total:
			cur -= st.pop(0)
		if sum(st) == total / 2:
			return 'YES'
	return 'NO'
a = [int(i) for i in input().split()]
print(solution(a))


from sys import stdin
bags = [int(x) for x in stdin.readline().split()]
res = 'NO'
total_candies = sum(bags)
for i in range(0, 4):
	if bags[i] * 2 == total_candies:
		res = 'YES'
		break
for i in range(0, 3):
	for j in range(i + 1, 4):
		if (bags[i] + bags[j]) * 2 == total_candies:
			res = 'YES'
			break
print(res)


candies = map(int, input().split(' '))
candies = sorted(candies)
if candies[0] + candies[3] == candies[1] + candies[2] or candies[0] + candies[1] + candies[2] == candies[3]:
	print('YES')
else:
	print('NO')


from collections import defaultdict as dd
from collections import Counter as ccd
from itertools import permutations as pp
from itertools import combinations as cc
from random import randint as rd
from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq as hq
from math import gcd
mod = pow(10, 9) + 7

def inp(flag=0):
	if flag == 0:
		return list(map(int, input().strip().split(' ')))
	else:
		return int(input())

def canPartition(nums):
	if len(nums) < 2:
		return False
	total = sum(nums)
	if total & 1:
		return False
	(target, memo) = (total // 2, {})
	return dfs(tuple(nums), target, memo)

def dfs(nums, target, memo):
	if not nums:
		return False
	if nums in memo:
		return memo[nums]
	s = sum(nums)
	if s == target:
		memo[nums] = True
		return True
	if s < target:
		memo[nums] = False
		return False
	for i in range(len(nums)):
		_nums = list(nums)
		n = _nums.pop(i)
		if dfs(tuple(_nums), target, memo):
			memo[nums] = True
			return True
	memo[nums] = False
	return False
l = inp()
if canPartition(l):
	print('YES')
else:
	print('NO')


while True:
	try:
		candy = list(map(int, input().split()))
	except EOFError:
		break
	except ValueError:
		break
	if candy == [] or sum(candy) % 2 != 0:
		print('NO')
	else:
		target = sum(candy) // 2
		dp = [0] * (target + 1)
		dp[0] = True
		for can in candy:
			for j in range(target, 0, -1):
				if j >= can:
					dp[j] = dp[j] or dp[j - can]
		if dp[target]:
			print('YES')
		else:
			print('NO')


(a, b, c, d) = map(int, input().split())
x1 = [a, b, c, d, a + b, b + c, c + d, d + a, a + c, b + d, a + b + c, b + c + d, c + d + a, d + a + b]
f = int((a + b + c + d) / 2)
c1 = x1.count(f)
if c1 < 2 or (a + b + c + d) % 2 != 0:
	print('NO')
elif c1 >= 2:
	print('YES')


arr = [int(x) for x in input().split()]
first = 0
second = 0
arr.sort()
while len(arr) > 0:
	greatest = arr.pop()
	if first > second:
		second += greatest
	else:
		first += greatest
print('YES' if first == second else 'NO')


a = list(map(int, input().split()))
a.sort()
k = sum(a) / 2
f = False
for i in range(3):
	if f:
		break
	for j in range(i + 1, 4):
		if a[i] + a[j] == k:
			print('YES')
			f = True
			break
else:
	if a[0] + a[1] + a[2] == a[3]:
		print('YES')
	else:
		print('NO')


import sys
n = list(map(int, input().split()))
sumi = sum(n)
for i in range(4):
	for j in range(i + 1, i + 4):
		for k in range(i + 1, j):
			if sumi - (n[i] + n[j % 4] + n[k % 4]) == n[i] + n[j % 4] + n[k % 4] or sumi - (n[i] + n[j % 4]) == n[i] + n[j % 4]:
				print('YES')
				sys.exit()
print('NO')


def solve(cand_list):
	tot = sum(cand_list)
	rem = tot % 2
	if rem != 0:
		return 'NO'
	div = tot // 2

	def calc(idx, cur_sum) -> bool:
		if idx >= len(cand_list):
			return False
		if cur_sum == div:
			return True
		return calc(idx + 1, cur_sum) or calc(idx + 1, cur_sum + cand_list[idx])
	if calc(0, 0):
		return 'YES'
	else:
		return 'NO'
read = input()
candles = [int(r) for r in read.split(' ')]
print(solve(candles))


def comp(l):
	s = sum(l)
	if s % 2 != 0:
		return False
	else:
		s = s // 2
	for i in range(4):
		if l[i] == s:
			return True
		for j in range(4):
			if i != j and l[i] + l[j] == s:
				return True
	return False
l = list(map(int, input().split()))
res = comp(l)
if res:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a.sort()
res = a[0] + a[3] == a[1] + a[2]
res2 = sum(a[:3]) == a[3]
fin = res or res2
print('YNEOS'[not fin::2])


a = [int(j) for j in input().split()]
a.sort()
if a[3] == a[0] + a[1] + a[2]:
	print('yes')
elif a[3] + a[0] == a[1] + a[2] or a[3] + a[1] == a[0] + a[2] or a[3] + a[2] == a[0] + a[1]:
	print('yes')
else:
	print('no')


a = list(map(int, input().split()))
b = sorted(a)
a1 = []
a2 = []
i = len(b) - 3
a1.append(b[len(b) - 1])
a2.append(b[len(b) - 2])
while i >= 0:
	if sum(a1) > sum(a2):
		a2.append(b[i])
	else:
		a1.append(b[i])
	i = i - 1
if sum(a1) == sum(a2):
	print('YES')
else:
	print('NO')


mylist = []
(a, b, c, d) = input().split()
a = int(a)
b = int(b)
c = int(c)
d = int(d)
mylist.extend([a, b, c, d])
maximum = max(mylist)
minimum = min(mylist)
suming = maximum + minimum
difference = sum(mylist) - suming
mylist.remove(maximum)
if difference == suming or sum(mylist) == maximum:
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = map(int, input().split())
summ = a1 + a2 + a3 + a4
if summ % 2 == 1:
	print('NO')
elif 2 * a1 == summ or 2 * a2 == summ or 2 * a3 == summ or (2 * a4 == summ) or (2 * (a1 + a2) == summ) or (2 * (a1 + a3) == summ) or (2 * (a1 + a4) == summ) or (2 * (a2 + a3) == summ) or (2 * (a2 + a4) == summ) or (2 * (a3 + a4) == summ):
	print('YES')
else:
	print('NO')


arr = [int(x) for x in input().split()]
if arr[0] + arr[1] == arr[2] + arr[3] or arr[0] + arr[2] == arr[1] + arr[3] or arr[0] + arr[3] == arr[1] + arr[2] or (arr[0] + arr[1] + arr[2] == arr[3]) or (arr[1] + arr[2] + arr[3] == arr[0]) or (arr[2] + arr[3] + arr[0] == arr[1]) or (arr[3] + arr[0] + arr[1] == arr[2]):
	print('YES')
else:
	print('NO')


arr = list(map(int, input().rstrip().split()))
candy = sorted(arr)
if candy[0] + candy[3] == candy[1] + candy[2] or candy[0] + candy[1] + candy[2] == candy[3]:
	print('YES')
else:
	print('NO')


from sys import stdin
input = stdin.readline
(a1, a2, a3, a4) = map(int, input().split())
if a1 + a2 == a3 + a4:
	print('YES')
elif a1 + a3 == a2 + a4:
	print('YES')
elif a1 + a4 == a2 + a3:
	print('YES')
elif a1 == a4 + a2 + a3:
	print('YES')
elif a2 == a4 + a1 + a3:
	print('YES')
elif a3 == a4 + a2 + a1:
	print('YES')
elif a4 == a1 + a2 + a3:
	print('YES')
else:
	print('NO')


(x, y, z, t) = input().split()
a = [0] * 4
(a[0], a[1], a[2], a[3]) = (int(x), int(y), int(z), int(t))
s = a[0] + a[1] + a[2] + a[3]
g = False
for i in range(0, 3):
	if g == True:
		break
	for j in range(i + 1, 4):
		if s - a[i] - a[j] == a[i] + a[j]:
			g = True
			print('YES')
			break
if g == False:
	if a[0] + a[1] + a[2] == a[3] or a[0] + a[1] + a[3] == a[2] or a[0] + a[3] + a[2] == a[1] or (a[3] + a[1] + a[2] == a[0]):
		g = True
		print('YES')
if g == False:
	print('NO')


(a, b, c, d) = map(int, input().split())
tot = a + b + c + d
if tot % 2 == 1:
	print('NO')
	return
tot //= 2
if tot == a + b or tot == a + c or tot == a + d or (tot == a) or (tot == b) or (tot == c) or (tot == d):
	print('YES')
else:
	print('NO')


def Ans(a, b, c, d):
	judge = 0
	if a == b + c + d or b == a + c + d:
		judge = 1
		return judge
	if c == a + b + d or d == a + b + c:
		judge = 1
		return judge
	if a + b == c + d or a + c == b + d or a + d == b + c:
		judge = 1
		return judge
	return judge
(a, b, c, d) = map(int, input().split())
j = Ans(a, b, c, d)
if j == 1:
	print('YES')
else:
	print('NO')


arr = [i for i in map(int, input().split())]
sum = 0
result = 'NO'
temp = 0
for i in arr:
	sum += i
for i in range(0, 3):
	if arr[i] == sum / 2:
		result = 'YES'
		break
	for j in range(i + 1, 4):
		if arr[i] + arr[j] == sum / 2 or arr[j] == sum / 2:
			result = 'YES'
			break
print(result)


A = list(map(int, input().split()))
A.sort()
if sum(A) % 2 == 1:
	a = False
elif A[0] + A[3] == sum(A) // 2 and A[1] + A[2] == sum(A) // 2:
	a = True
elif A[3] == sum(A) // 2:
	a = True
else:
	a = False
if a:
	print('YES')
else:
	print('NO')


a = [*map(int, input().split())]
a.sort()
if a[0] + a[3] == a[1] + a[2]:
	print('Yes')
elif a[0] + a[1] + a[2] == a[3]:
	print('Yes')
else:
	print('No')


def main(s):
	xs = [int(x) for x in s.split()]
	xs.sort()
	if xs[0] + xs[3] == xs[1] + xs[2]:
		return 'YES'
	elif xs[0] == xs[1] + xs[2] + xs[3]:
		return 'YES'
	elif xs[3] == xs[1] + xs[2] + xs[0]:
		return 'YES'
	else:
		return 'NO'
s = input()
res = main(s)
print(res)

def test1():
	assert main('1 7 11 5') == 'YES'

def test2():
	assert main('7 3 2 5') == 'NO'

def test3():
	assert main('1 2 3 6') == 'NO'

def test_min():
	assert main('1 1 1 1') == 'YES'

def test_max():
	assert main('100 100 100 100') == 'YES'


(x, y, z, w) = map(int, input().split())
ans = False
if x + y == z + w:
	ans = True
elif x + z == y + w:
	ans = True
elif x + w == y + z:
	ans = True
elif x == y + w + z:
	ans = True
elif y == x + w + z:
	ans = True
elif z == y + x + w:
	ans = True
elif w == y + x + z:
	ans = True
if ans:
	print('YES')
else:
	print('NO')


from itertools import combinations
arr = list(map(int, input().split()))
ans = 'NO'
s = sum(arr)
for i in range(2, 4):
	brr = list(combinations(arr, i))
	brr = [sum(i) for i in brr]
	for j in brr:
		if s - j == j:
			ans = 'YES'
print(ans)


inp = list(map(int, input().split()))
_max = max(inp)
_min = min(inp)
_sum = sum(inp)
if _max == _sum - _max:
	print('YES')
elif _min + _max == _sum - _min - _max:
	print('YES')
else:
	print('NO')


lst = list(map(int, input().rstrip().split()))

def evaluate(lst):
	v = sum(lst)
	if v % 2 != 0:
		return 'NO'
	v = v // 2
	if lst[0] + lst[1] == v:
		return 'YES'
	if lst[0] + lst[2] == v:
		return 'YES'
	if lst[0] + lst[3] == v:
		return 'YES'
	if lst[0] == v:
		return 'YES'
	if lst[1] == v:
		return 'YES'
	if lst[2] == v:
		return 'YES'
	if lst[3] == v:
		return 'YES'
	return 'NO'
print(evaluate(lst))


import sys
a = sorted([int(x) for x in sys.stdin.readline().split()])
sys.stdout.write('YES' if a[0] + a[3] == a[1] + a[2] or a[0] + a[1] + a[2] == a[3] else 'NO')


l = [int(i) for i in input().split()]
tot = sum(l)
for i in range(16):
	curr = []
	for j in range(4):
		if i & 1 << j:
			curr.append(l[j])
	if sum(curr) == tot - sum(curr):
		print('YES')
		exit()
print('NO')


(a1, a2, a3, a4) = map(int, input().split())
boo = False
arr = [a1, a2, a3, a4]
if a1 == a2 + a3 + a4 or a2 == a1 + a3 + a4 or a3 == a1 + a2 + a4 or (a4 == a1 + a2 + a3) or (a1 + a2 == a3 + a4) or (a1 + a3 == a2 + a4) or (a1 + a4 == a2 + a3):
	boo = True
if boo:
	print('YES')
else:
	print('NO')


mas = list(map(int, input().split(' ')))
mas.sort(reverse=True)
if len(mas) == 1:
	print('NO')
else:
	(f, s) = (mas[0], mas[1])
	for i in range(2, len(mas)):
		if s < f:
			s += mas[i]
		elif f <= s:
			f += mas[i]
	if f == s:
		print('YES')
	else:
		print('NO')


a = list(map(int, input().split()))
a.sort()
f1 = 0
f2 = 0
l = len(a)
if l == 1:
	print('NO')
else:
	for i in range(len(a) - 1, -1, -1):
		if f1 >= f2:
			f2 = f2 + a[i]
		else:
			f1 += a[i]
	if f1 == f2:
		print('YES')
	else:
		print('NO')


A = [int(i) for i in input().split()]
t = sum(A)
flg = False
for i in range(1, 4):
	if (A[0] + A[i]) * 2 == t:
		flg = True
for i in range(4):
	if A[i] * 2 == t:
		flg = True
print('YES' if flg == True else 'NO')


import bisect
import os
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate

def primeFactors(n):
	prime = set()
	while n % 2 == 0:
		prime.add(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			prime.add(i)
			n = n // i
	if n > 2:
		prime.add(n)
	return list(prime)

def getFactors(n):
	factors = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				factors.append(i)
			else:
				factors.append(i)
				factors.append(n // i)
		i = i + 1
	return factors

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

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

def sort_dict(key_value):
	return sorted(key_value.items(), key=lambda kv: (kv[1], kv[0]))

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

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

def string_list():
	return list(input())

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def binaryToDecimal(n):
	return int(n, 2)

def solve():
	arr = list_input()
	arr.sort()
	if arr[0] + arr[3] == arr[1] + arr[2] or arr[0] + arr[1] + arr[2] == arr[3]:
		print('YES')
		return
	print('NO')
t = 1
for _ in range(t):
	solve()


from sys import stdin
from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi

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

def fi():
	return float(stdin.readline())

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

def fmi():
	return map(float, stdin.readline().split())

def li():
	return [x for x in mi()]

def si():
	return stdin.readline()
a = li()
print('YES' if 2 * (max(a) + min(a)) == sum(a) or 2 * max(a) == sum(a) else 'NO')


a = list(map(int, input().split()))
b = max(a)
c = a.index(b)
if a[0] + a[1] == a[2] + a[3]:
	print('YES')
elif a[0] + a[2] == a[1] + a[3]:
	print('YES')
elif a[0] + a[3] == a[1] + a[2]:
	print('YES')
elif sum(a) == 2 * a[c]:
	print('YES')
else:
	print('NO')


l = list(map(int, input().split()))
a1 = l[0]
a2 = l[1]
a3 = l[2]
a4 = l[3]
flag = 0
for i in range(4):
	if l[i] == sum(l) - l[i]:
		print('YES')
		flag = -1
		break
if flag != -1:
	if a1 + a2 == a3 + a4:
		print('YES')
	elif a1 + a3 == a2 + a4:
		print('YES')
	elif a1 + a4 == a2 + a3:
		print('YES')
	else:
		print('NO')


(a, b, c, d) = map(int, input().split())

def equalable(a, b, c, d):
	if a == b + c + d:
		return 'YES'
	if b == a + c + d:
		return 'YES'
	if c == b + a + d:
		return 'YES'
	if d == b + c + a:
		return 'YES'
	if a + b == c + d:
		return 'YES'
	if a + c == b + d:
		return 'YES'
	if a + d == b + c:
		return 'YES'
	return 'NO'
print(equalable(a, b, c, d))


arr = list(map(int, input().split()))
s = sum(arr)
if s % 2 != 0:
	print('NO')
else:
	c = 0
	a = set(arr)
	if s // 2 in a:
		c += 1
	else:
		for i in range(3):
			for j in range(i + 1, 4):
				if arr[i] + arr[j] == s // 2:
					c += 1
					break
	if c == 0:
		print('NO')
	else:
		print('YES')


a = [i for i in map(int, input().split())]
a.sort()
total = sum(a)
flag = True
if total % 2 == 1:
	print('NO')
else:
	total2 = total // 2
	if a[3] == total2 or a[3] + a[0] == total2 or a[2] + a[1] == total2 or (a[2] + a[1] + a[0] == total2):
		flag = False
	if flag:
		print('NO')
	else:
		print('YES')


lst = sorted(list(map(int, input().split())))
high = lst[3]
low = lst[0]
oth = lst[1] + lst[2]
if high == low + oth or high + low == oth:
	print('YES')
else:
	print('NO')


(e, f, g, h) = map(int, input().split())
a = []
a.append(e)
a.append(f)
a.append(g)
a.append(h)
a.sort()
sum1 = a[1] + a[2]
if a[3] - sum1 == a[0]:
	sum1 = sum1 + a[0]
	sum2 = a[3]
else:
	sum2 = a[0] + a[3]
if sum1 == sum2:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
print('NYOE S'[a + b == c + d or a + c == b + d or a + d == b + c or (sum([a, b, c, d]) / 2 in [a, b, c, d])::2])


(a1, a2, a3, a4) = map(int, input().split())
w = [a1, a2, a3, a4]
w.sort()
if abs(a1 - a2) == abs(a3 - a4) or abs(a1 - a3) == abs(a2 - a4) or w.pop() == sum(w):
	print('YES')
else:
	print('NO')


(a, b, c, d) = list(map(int, input().split()))
arr = [a, b, c, d]
for i in range(2):
	for j in range(2):
		for z in range(2):
			for k in range(2):
				cnt = 0
				for l in range(4):
					q = [i, j, z, k][l]
					if q:
						cnt += arr[l]
					else:
						cnt -= arr[l]
				if cnt == 0:
					print('YES')
					return
print('NO')


import sys

def main():

	def input():
		return sys.stdin.readline()[:-1]
	a = sorted(list(map(int, input().split())))
	t = sum(a)
	for k in range(16):
		S = []
		for l in range(4):
			if 1 & k >> l == 1:
				S.append(a[l])
		if 2 * sum(S) == t:
			print('YES')
			exit(0)
	print('NO')
main()


(q, p, r, x) = map(int, input().split())
s = q + p + r + x
if q + p == r + x:
	print('YES')
elif q + r == p + x:
	print('YES')
elif q + x == p + r:
	print('YES')
elif q == s - q:
	print('YES')
elif p == s - p:
	print('YES')
elif r == s - r:
	print('YES')
elif x == s - x:
	print('YES')
else:
	print('NO')


l = list(map(int, input().split()))
if sum(l) - l[0] - l[1] == l[0] + l[1]:
	print('YES')
	exit()
if sum(l) - l[1] - l[2] == l[1] + l[2]:
	print('YES')
	exit()
if sum(l) - l[2] - l[3] == l[2] + l[3]:
	print('YES')
	exit()
if sum(l) - l[3] - l[0] == l[3] + l[0]:
	print('YES')
	exit()
if sum(l) - l[2] - l[0] == l[2] + l[0]:
	print('YES')
	exit()
if sum(l) - l[3] - l[1] == l[3] + l[1]:
	print('YES')
	exit()
if sum(l) - l[3] == l[3]:
	print('YES')
	exit()
if sum(l) - l[2] == l[2]:
	print('YES')
	exit()
if sum(l) - l[0] == l[0]:
	print('YES')
	exit()
if sum(l) - l[1] == l[1]:
	print('YES')
	exit()
else:
	print('NO')


(a1, a2, a3, a4) = map(int, input().split())
a = [a1, a2, a3, a4]
a.sort()
t = sum(a)
if t % 2 == 1:
	print('NO')
else:
	temp = t // 2
	if temp in a:
		print('YES')
	elif a[0] + a[3] == a[1] + a[2]:
		print('YES')
	else:
		print('NO')


l = list()
s = 0
while True:
	x = input('')
	l = x.split(' ')
	if len(l) == 4:
		break
l = x.split(' ')
for i in range(len(l)):
	l[i] = int(l[i])
for i in l:
	s += i
if s % 2 == 0:
	if l[0] == s / 2:
		print('yes')
	elif l[0] + l[1] == s / 2:
		print('yes')
	elif l[0] + l[2] == s / 2:
		print('yes')
	elif l[0] + l[3] == s / 2:
		print('yes')
	elif l[0] + l[1] + l[2] == s / 2:
		print('yes')
	elif l[0] + l[1] + l[3] == s / 2:
		print('yes')
	elif l[0] + l[3] + l[2] == s / 2:
		print('yes')
	else:
		print('no')
else:
	print('no')


(a1, a2, a3, a4) = map(int, input().split())
res = False
for i1 in range(2):
	for i2 in range(2):
		for i3 in range(2):
			for i4 in range(2):
				if (i1 * a1 + i2 * a2 + i3 * a3 + i4 * a4) * 2 == a1 + a2 + a3 + a4:
					res = True
if res:
	print('YES')
else:
	print('NO')


import sys
r = lambda : sys.stdin.readline().rstrip()

def go(a):
	tot = sum(a)
	if tot % 2 == 1:
		return 'NO'
	tgt = tot // 2
	for i in range(4):
		if a[i] == tgt:
			return 'YES'
		for j in range(4):
			if i == j:
				continue
			if a[i] + a[j] == tgt:
				return 'YES'
	return 'NO'
a = list(map(int, r().split()))
print(go(a))


import math
n = list(map(int, input().split()))
z = math.fmod(sum(n), 2)
if z == 0:
	a = int(sum(n) / 2)
	b = int(sum(n) / 2)
	n = sorted(n)
	for i in reversed(range(len(n))):
		if a >= n[i]:
			a = a - n[i]
		else:
			b = b - n[i]
	if a == 0 and b == 0:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


(a1, a2, a3, a4) = [int(c) for c in input().split()]
if a1 + a2 == a3 + a4:
	print('YES')
elif a2 + a3 == a1 + a4:
	print('YES')
elif a1 + a3 == a2 + a4:
	print('YES')
elif a1 + a4 == a3 + a2:
	print('YES')
elif a1 == a4 + a3 + a2:
	print('YES')
elif a2 == a1 + a3 + a4:
	print('YES')
elif a3 == a1 + a4 + a2:
	print('YES')
elif a4 == a1 + a3 + a2:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
if a[0] + a[1] == a[2] + a[3] or a[0] + a[2] == a[1] + a[3] or a[0] + a[3] == a[2] + a[1] or (a[1] + a[2] + a[0] == a[3]) or (a[0] + a[2] + a[3] == a[1]) or (a[1] + a[2] + a[3] == a[0]) or (a[1] + a[0] + a[3] == a[2]):
	print('yes')
else:
	print('NO')


def yeah(s, n, ss):
	if ss == 0:
		return True
	if n == 0 and ss != 0:
		return False
	if s[n - 1] > ss:
		return yeah(s, n - 1, ss)
	return yeah(s, n - 1, ss) or yeah(s, n - 1, ss - s[n - 1])
s = [int(i) for i in input().split()]
if sum(s) % 2 == 1:
	print('NO')
elif yeah(s, 4, sum(s) // 2):
	print('YES')
else:
	print('NO')


(x, y, a, b) = map(int, input().split())
if x + y == a + b or x + a == y + b or x + b == y + a or (x + y + a == b) or (x + a + b == y) or (x + b + y == a) or (y + a + b == x):
	print('YES')
else:
	print('NO')


a = list(map(int, input().split(' ')))
b = sum(a) / 2
if b in a or a[0] + a[1] == b or a[0] + a[2] == b or (a[0] + a[3] == b):
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
result = 'NO'
if a[0] + a[1] == a[2] + a[3]:
	result = 'YES'
elif a[0] + a[2] == a[1] + a[3]:
	result = 'YES'
elif a[0] + a[3] == a[1] + a[2]:
	result = 'YES'
elif a[0] + a[1] + a[2] == a[3]:
	result = 'YES'
elif a[1] + a[2] + a[3] == a[0]:
	result = 'YES'
elif a[0] + a[2] + a[3] == a[1]:
	result = 'YES'
elif a[0] + a[1] + a[3] == a[2]:
	result = 'YES'
print(result)


import sys
(a1, a2, a3, a4) = map(int, sys.stdin.readline().split())
if (a1 + a2 + a3 + a4) % 2 != 0:
	print('NO')
elif a1 + a2 == a3 + a4 or a1 + a3 == a2 + a4 or a1 + a4 == a2 + a3 or (a1 == a4 + a2 + a3) or (a2 == a1 + a3 + a4) or (a3 == a1 + a2 + a4) or (a4 == a1 + a2 + a3):
	print('YES')
else:
	print('NO')


a = [int(x) for x in input().split()]
half = sum(a) / 2
if half != int(half):
	print('NO')
	exit()
for x in range(0, 4):
	if a[x] > half:
		print('NO')
		exit()
	if a[x] == half:
		print('YES')
		exit()
for x in range(1, 4):
	if a[0] + a[x] == half:
		print('YES')
		exit()
for x in range(2, 4):
	if a[1] + a[x] == half:
		print('YES')
		exit()
if a[2] + a[3] == half:
	print('YES')
	exit()
print('NO')


from itertools import combinations

def dawid_bag_candy(arr):
	int_arr = []
	for i in arr:
		int_arr.append(int(i))
	arr = int_arr
	total = sum(arr)
	if total % 2 == 1:
		return 'NO'
	for i in range(1, 4):
		for num in set(list(combinations(arr, i))):
			if sum(num) == total // 2:
				return 'YES'
	return 'NO'
bag_candy_arr = input().split(' ')
print(dawid_bag_candy(bag_candy_arr))


import sys
(a, b, c, d) = sorted(list(map(int, input().split())))
if a + b == c + d or a + c == b + d or a + d == b + c or (a == b + c + d) or (b == a + c + d) or (d == a + b + c):
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
m = (a + b + c + d) / 2
if a + b == m or a + c == m or a + d == m or (a == m) or (b == m) or (c == m) or (d == m):
	print('YES')
else:
	print('NO')


n = 4
a = list(map(int, input().strip().split()))
a.sort()
(sum, ans) = (0, 0)
ans = a[3]
n = 2
while n >= 0:
	if ans > sum:
		sum += a[n]
		n -= 1
	else:
		ans += a[n]
		n -= 1
if ans == sum:
	print('YES')
else:
	print('NO')


arr = [int(j) for j in input().split()]
arr.sort()
if arr[0] + arr[3] == arr[1] + arr[2] or arr[3] == arr[1] + arr[0] + arr[2]:
	print('YES')
else:
	print('NO')


bags = list(map(int, input().split()))
bags.sort()
cnt1 = cnt2 = 0
i = 3
while i >= 0:
	if cnt1 > cnt2:
		cnt2 += bags[i]
	else:
		cnt1 += bags[i]
	i -= 1
if cnt1 == cnt2:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
asum = a[0] + a[1] + a[2] + a[3]
b = []
b.append(a[0] + a[1])
b.append(a[0] + a[2])
b.append(a[0] + a[3])
b.append(a[1] + a[2])
b.append(a[1] + a[3])
b.append(a[2] + a[3])
b.append(b[0] + a[2])
b.append(b[1] + a[3])
b.append(b[2] + a[1])
b.append(b[3] + a[3])
c = 0
for i in b:
	if i * 2 == asum:
		print('YES')
		c = 1
		break
if c == 0:
	print('NO')


ar = list(map(int, input().strip().split(' ')))
ar.sort()
if ar[0] + ar[3] == ar[1] + ar[2]:
	print('YES')
elif ar[3] == ar[0] + ar[1] + ar[2]:
	print('YES')
else:
	print('NO')


Numofcandies = input()
candy = Numofcandies.split(' ')
for x in range(0, 4):
	candy[x] = int(candy[x])
total = candy[0] + candy[1] + candy[2] + candy[3]
counter = 0
for a in candy:
	if total - a == a:
		counter = counter + 1
for b in range(0, 4):
	for c in range(0, 4):
		if b == c:
			break
		elif candy[b] + candy[c] == total - candy[b] - candy[c]:
			counter = counter + 1
if counter:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
mx = max(a, b, c, d)
rest = a + b + c + d - mx
if a + b == c + d:
	print('YES')
elif a + c == b + d:
	print('YES')
elif a + d == b + c:
	print('YES')
elif mx == rest:
	print('YES')
else:
	print('NO')


import math
ll = list(map(int, input().split()))
l = sorted(ll)
a = l[0]
b = l[1]
c = l[2]
d = l[3]
if a + c == b + d or a + b + c == d or a + b == c + d or (a + d == b + c):
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = input().split()
(a1, a2, a3, a4) = [int(a1), int(a2), int(a3), int(a4)]
b = []
b.append(a1)
b.append(a2)
b.append(a3)
b.append(a4)
sum = a1 + a2 + a3 + a4
if sum % 2 == 0:
	b.sort()
	x = sum / 2 - b[0]
	if b[3] == b[0] + b[1] + b[2]:
		print('YES')
	elif x == b[3]:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


l = list(map(int, input().split()))
a = [l[0] + l[1], l[2] + l[3]]
b = [l[0] + l[3], l[2] + l[1]]
c = [l[0] + l[2], l[3] + l[1]]
p = [l[0] + l[1] + l[2], l[3]]
q = [l[0] + l[3] + l[1], l[2]]
r = [l[0] + l[2] + l[3], l[1]]
s = [l[1] + l[2] + l[3], l[0]]
sa = set(a)
sb = set(b)
sc = set(c)
sp = set(p)
sq = set(q)
sr = set(r)
ss = set(s)
if len(sa) == 1 or len(sb) == 1 or len(sc) == 1 or (len(sp) == 1) or (len(sq) == 1) or (len(sr) == 1) or (len(ss) == 1):
	print('YES')
else:
	print('NO')


List = list(map(int, input().split()))
max_value = max(List)
min_value = min(List)
s1 = max_value + min_value
List.remove(max_value)
s2 = sum(List)
List.remove(min_value)
s3 = sum(List)
if max_value == s2 or s1 == s3:
	print('YES')
else:
	print('NO')


numbers = input().split()
counter = 0
for i in range(len(numbers)):
	numbers[i] = int(numbers[i])
a1a2 = numbers[0] + numbers[1]
a3a4 = numbers[2] + numbers[3]
if a1a2 == a3a4:
	counter += 1
a1a2 = numbers[0] + numbers[2]
a3a4 = numbers[1] + numbers[3]
if a1a2 == a3a4:
	counter += 1
a1a2 = numbers[0] + numbers[3]
a3a4 = numbers[1] + numbers[2]
if a1a2 == a3a4:
	counter += 1
a1a2 = numbers[0] + numbers[1] + numbers[2]
a3a4 = numbers[3]
if a1a2 == a3a4:
	counter += 1
a1a2 = numbers[0]
a3a4 = numbers[3] + numbers[1] + numbers[2]
if a1a2 == a3a4:
	counter += 1
a1a2 = numbers[0] + numbers[1] + numbers[3]
a3a4 = numbers[2]
if a1a2 == a3a4:
	counter += 1
a1a2 = numbers[0] + numbers[2] + numbers[3]
a3a4 = numbers[1]
if a1a2 == a3a4:
	counter += 1
if counter > 0:
	print('YES')
else:
	print('NO')


a = input().split()
a = list(map(int, a))
for i in range(4):
	for j in range(i, 4):
		if a[i] > a[j]:
			tmp = a[i]
			a[i] = a[j]
			a[j] = tmp
if a[3] + a[0] == a[1] + a[2] or a[3] == a[1] + a[0] + a[2]:
	print('YES')
else:
	print('NO')


import itertools

def main():
	data = [int(v) for v in input().split()]
	for k in itertools.permutations(data):
		for j in range(4):
			if sum(k[0:j]) == sum(k[j:]):
				print('YES')
				return
	print('NO')
main()


inp = input().split()
a = int(inp[0])
b = int(inp[1])
c = int(inp[2])
d = int(inp[3])
arr = []
arr.append(a)
arr.append(b)
arr.append(c)
arr.append(d)
arr.sort()
flag = 0
if arr[0] + arr[1] == arr[2] + arr[3] or arr[1] + arr[2] == arr[0] + arr[3] or arr[0] + arr[1] + arr[2] == arr[3]:
	flag = 1
else:
	flag = 0
if flag == 1:
	print('YES')
else:
	print('NO')


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

def splitable(a):
	conds = [sum(a[:2]) == sum(a[2:]), sum(a[::2]) == sum(a[1::2]), a[0] + a[3] == a[1] + a[2]]
	conds.append(a[0] == sum(a[1:]))
	conds.append(a[1] == a[0] + a[2] + a[3])
	conds.append(a[2] == a[0] + a[1] + a[3])
	conds.append(a[3] == a[0] + a[1] + a[2])
	return any(conds)
if splitable(a):
	print('YES')
else:
	print('NO')


(a, b, c, d) = input().strip().split()
a = int(a)
b = int(b)
c = int(c)
d = int(d)
if a + b == c + d or a + c == b + d or a + d == c + b or (a + b + c == d) or (a + b + d == c) or (a + c + d == b) or (a + b + c + d == 0) or (b + c + d == a):
	print('YES')
else:
	print('No')


h = list(map(int, input().split()))
p = len(h)
if h[0] + h[2] == h[1] + h[3] or h[0] + h[1] == h[2] + h[3] or h[0] + h[3] == h[1] + h[2] or (h[0] + h[1] + h[2] == h[3]) or (h[0] + h[3] + h[2] == h[1]) or (h[0] + h[1] + h[3] == h[2]) or (h[3] + h[1] + h[2] == h[0]):
	print('YES')
else:
	print('NO')


from sys import stdin

def main():
	input = lambda : stdin.readline()[:-1]
	A = list(map(int, input().split()))
	sum_ = sum(A)
	for i in range(1, 4):
		if A[0] * 2 == sum_ or A[i] * 2 == sum_ or (A[0] + A[i]) * 2 == sum_:
			print('YES')
			return
	print('NO')
main()


b = [int(b) for b in input().split()]
b.sort()
if b[3] == b[0] + b[1] + b[2]:
	print('YES')
elif b[1] + b[2] == b[0] + b[3]:
	print('YES')
else:
	print('NO')


import sys
import os
from io import IOBase, BytesIO

def main():
	arr = get_array()
	arr.sort()
	if arr[0] + arr[1] + arr[2] == arr[3]:
		print('YES')
		return
	if arr[0] + arr[-1] == arr[1] + arr[2]:
		print('YES')
		return
	if arr[0] + arr[3] == arr[2] + arr[1]:
		print('YES')
		return
	print('NO')
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		py2 = round(0.5)
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2 == 1:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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))

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

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

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


val = list(map(int, input().split(' ')))
val.sort()
temp = []
if sum(val) % 2 == 0:
	for i in range(len(val) // 2):
		temp.append(val[i] + val[len(val) - i - 1])
	if len(set(temp)) == 1 or val[0] + val[1] + val[2] == val[3]:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


l = list(map(int, input().split()))
f = 0
if l[0] + l[1] == l[2] + l[3]:
	f = 1
elif l[0] + l[2] == l[1] + l[3]:
	f = 1
elif l[0] + l[3] == l[1] + l[2]:
	f = 1
elif l[1] + l[3] == l[0] + l[2]:
	f = 1
elif l[0] + l[1] + l[2] == l[3]:
	f = 1
elif l[0] + l[2] + l[3] == l[1]:
	f = 1
elif l[3] + l[1] + l[2] == l[0]:
	f = 1
elif l[0] + l[1] + l[3] == l[2]:
	f = 1
if f == 1:
	print('yes')
else:
	print('no')


l = sorted(list(map(int, input().split())))
p = sum(l)
if p % 2 == 0:
	if p - l[-1] == p // 2 or p - l[-1] - l[0] == p // 2:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


def fun(arr):
	if sum(arr) % 2 != 0:
		return 'NO'
	arr = sorted(arr)
	if arr[3] + arr[0] == arr[1] + arr[2] or arr[3] == arr[0] + arr[1] + arr[2]:
		return 'YES'
	return 'No'
arr = list(map(int, input().split(' ')))
print(fun(arr))


s = input()
list = s.split()
for i in range(4):
	list[i] = int(list[i])
list.sort()
if list[0] + list[3] == list[2] + list[1] or list[0] + list[1] + list[2] == list[3]:
	print('YES')
else:
	print('NO')


n = input().split(' ')
for i in range(len(n)):
	n[i] = int(n[i])
for i in range(len(n)):
	for j in range(i + 1, len(n)):
		if n[i] > n[j]:
			swap = n[i]
			n[i] = n[j]
			n[j] = swap
cek1 = n[0] + n[1] + n[2]
cek2 = n[0] + n[3]
cek3 = n[1] + n[2]
if cek1 == n[3]:
	print('YES')
elif cek2 == cek3:
	print('YES')
else:
	print('NO')


import random

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

def get_int():
	return int(input())
(a, b, c, d) = sorted(get_many_ints())
if d == a + b + c or a + d == b + c or d + b == a + c:
	print('YES')
else:
	print('NO')


candies = sorted([int(i) for i in input().split()])
print('YES' if candies[0] + candies[3] == candies[1] + candies[2] or sum(candies) == 2 * max(candies) else 'NO')


def fun(a, b, c, d):
	if a + b == c + d or a + c == b + d or a + d == b + c or (b + c == a + d):
		return 'YES'
	elif a + b + c == d or b + c + d == a or a + c + d == b or (a + b + d == c):
		return 'YES'
	else:
		return 'NO'
(a, b, c, d) = map(int, input().split(' '))
print(fun(a, b, c, d))


(a, b, c, d) = input().split(' ')
(a, b, c, d) = (int(a), int(b), int(c), int(d))
count = 0
if (a + b + c + d) % 2 == 0:
	if a + b == c + d:
		count = count + 1
	if a + c == b + d:
		count = count + 1
	if a + d == b + c:
		count = count + 1
	if a + b + c == d:
		count = count + 1
	if a + c + d == b:
		count = count + 1
	if a + b + d == c:
		count = count + 1
	if d + b + c == a:
		count = count + 1
if count:
	print('YES')
else:
	print('NO')


mas = list(map(int, input().split()))
mas = sorted(mas)
i = 0
sum1 = 0
while i <= len(mas) - 1:
	sum1 = sum1 + mas[i]
	i += 1
if sum1 % 2 != 0:
	print('NO')
else:
	i = sum1 / 2
	x = i - mas[3]
	if x == 0:
		print('YES')
	elif x == mas[0]:
		print('YES')
	else:
		print('NO')


def gns():
	return list(map(int, input().split()))
ns = gns()
sm = sum(ns)
if sm % 2 == 1:
	print('NO')
	quit()
st = set()
st.add(0)
for c in ns:
	for x in set(st):
		st.add(x + c)
m = sm // 2
if m in st:
	print('YES')
else:
	print('NO')


(a, b, c, d) = [int(x) for x in input().split()]
tot = a + b + c + d
works = False
for subset in [a, b, c, d, a + b, a + c, a + d, b + c, b + d, c + d]:
	if subset == tot - subset:
		works = True
print('YES' if works else 'NO')


(w, x, y, z) = list(map(int, input().split()))
if w == x + y + z or x == w + y + z or y == w + x + z or (z == w + y + x) or (x + y == w + z) or (x + z == y + w) or (x + w == y + z):
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a.sort()
r = a.pop()
if sum(a) == r:
	print('YES')
else:
	a.append(r)
	if a[len(a) - 1] + a[len(a) - 3] == a[len(a) - 2] + a[0]:
		print('YES')
	elif a[len(a) - 1] + a[len(a) - 4] == a[len(a) - 2] + a[len(a) - 3]:
		print('YES')
	else:
		print('NO')


def answer():
	a = [int(x) for x in input().split()]
	if sum(a) % 2:
		return 'NO'
	else:
		i = 0
		while i < len(a):
			if a[i] == sum(a) / 2:
				return 'YES'
			i += 1
		(i, j) = (0, 0)
		while i < len(a):
			if j == i:
				j += 1
			while j < len(a):
				if sum([a[i], a[j]]) == sum(a) / 2:
					return 'YES'
				j += 1
			i += 1
			j = i
	return 'NO'
print(answer())


(a, b, c, d) = map(int, str(*open(0)).split())
print('NYOE S'[a + b == c + d or a + c == b + d or a + d == b + c or (sum([a, b, c, d]) / 2 in [a, b, c, d])::2])


candices = [int(x) for x in input().split()]
total_candices = sum(candices)
if total_candices % 2 == 0:
	candices_needed = total_candices / 2
	if max(candices) == candices_needed or max(candices) + min(candices) == candices_needed:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


a = list(map(int, input().split()))
s = 0
for i in a:
	s += i
if s % 2 == 0:
	c = s // 2
	t = 0
	f = 0
	n = len(a)
	a.sort()
	for i in range(0, n):
		t = 0
		for j in range(i, n):
			t += a[j]
			if t == c:
				f = 1
				break
		if f == 1:
			break
	if f == 1:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


arr = list(map(int, input().split(' ')[:4]))
arr.sort()
if arr[0] + arr[3] == arr[1] + arr[2] or arr[3] - arr[0] == arr[2] + arr[1]:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
ch = 0
if a + b == c + d:
	ch = 1
elif a + c == b + d:
	ch = 1
elif a + d == b + c:
	ch = 1
elif a + b + c == d or b == a + c + d or c == a + b + d or (a == d + b + c):
	ch = 1
if ch == 1:
	print('YES')
else:
	print('NO')


def to_int(s):
	for i in range(len(s)):
		s[i] = int(s[i])
	return s
s = to_int(input().split(' '))
s = sorted(s)
if s[0] + s[3] == s[1] + s[2] or s[0] + s[1] + s[2] == s[3]:
	print('YES')
else:
	print('NO')


f = 0
(a1, a2, a3, a4) = map(int, input().split())
if a1 + a2 == a3 + a4:
	f = 1
elif a1 + a3 == a2 + a4:
	f = 1
elif a1 + a4 == a2 + a3:
	f = 1
elif a1 + a2 + a3 == a4:
	f = 1
elif a1 + a2 + a4 == a3:
	f = 1
elif a1 + a3 + a4 == a2:
	f = 1
elif a2 + a3 + a4 == a1:
	f = 1
if f == 1:
	print('YES')
else:
	print('NO')


a = [int(x) for x in input().split()]
s = sum(a)
if s % 2 > 0:
	print('NO')
else:
	s /= 2
	if s in a or a[0] + a[1] == s or a[0] + a[2] == s or (a[1] + a[2] == s):
		print('YES')
	else:
		print('NO')


nlist = list(map(int, input().split()))
if nlist[0] + nlist[1] == nlist[2] + nlist[3]:
	print('Yes')
elif nlist[0] + nlist[2] == nlist[1] + nlist[3]:
	print('Yes')
elif nlist[0] + nlist[3] == nlist[1] + nlist[2]:
	print('Yes')
elif nlist[0] == nlist[1] + nlist[2] + nlist[3]:
	print('Yes')
elif nlist[1] == nlist[0] + nlist[2] + nlist[3]:
	print('Yes')
elif nlist[2] == nlist[0] + nlist[1] + nlist[3]:
	print('Yes')
elif nlist[3] == nlist[0] + nlist[1] + nlist[2]:
	print('Yes')
else:
	print('No')


a = list(map(int, input().split()))
many = a.pop(a.index(max(a)))
small = a.pop(a.index(min(a)))
f2 = sum(a)
if many + small == f2 or many == f2 + small:
	print('YES')
else:
	print('NO')


bags = list(map(int, input().split(' ')))
bags.sort()
if sum(bags[0:3]) == bags[-1] or bags[0] + bags[-1] == sum(bags[1:3]):
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
(x, y) = (0, 0)
a.sort(reverse=1)
for i in a:
	if x < y:
		x += i
	else:
		y += i
if x == y:
	print('YES')
else:
	print('NO')


import itertools

def f():
	d = [int(i) for i in str.split(input())]
	for i in range(1, 4):
		l = list(itertools.combinations(range(4), i))
		for ll in l:
			(a, b) = [0, 0]
			a = sum([d[i] for i in range(4) if i in ll])
			b = sum([d[i] for i in range(4) if i not in ll])
			if a == b:
				print('YES')
				return
	print('NO')
f()


ar = list(map(int, input().split()))
su = sum(ar)
if su % 2 != 0:
	print('NO')
else:
	ans = [ar[0] + ar[1], ar[1] + ar[2], ar[2] + ar[3], ar[0] + ar[3], ar[0] + ar[2], ar[1] + ar[3], ar[0] + ar[1] + ar[2], ar[1] + ar[2] + ar[3], ar[0] + ar[2] + ar[3], ar[0] + ar[1] + ar[3]]
	if su // 2 in ans:
		print('YES')
	else:
		print('NO')


l = list(map(int, input().split()))
(m1, m2) = (max(l), min(l))
l.remove(m1)
l.remove(m2)
if m1 + m2 == sum(l):
	print('YES')
elif m1 == sum(l) + m2:
	print('YES')
else:
	print('NO')


m = input().split()
a = int(m[0])
b = int(m[1])
c = int(m[2])
d = int(m[3])
n = [1, 3, 4, 5]
n[0] = a
n[1] = b
n[2] = c
n[3] = d
n.sort()
x = n[0] + n[3]
y = n[1] + n[2]
z = x + y - n[3]
if x == y or z == n[3]:
	print('YES')
else:
	print('NO')


import sys

def main():
	arr = [int(x) for x in sys.stdin.readline().split(' ')]
	arr.sort()
	if arr[-1] + arr[0] == arr[1] + arr[2]:
		return 'YES'
	if sum(arr[:-1]) == arr[-1]:
		return 'YES'
	return 'NO'
print(main())


def possible(a):
	for i in range(2 ** len(a)):
		x = 0
		for b in a:
			if i % 2:
				x += b
			i //= 2
		if x == sum(a) - x:
			return True
	return False
print('YES' if possible(list(map(int, input().split()))) else 'NO')


import sys

def main():
	a = [int(x) for x in sys.stdin.readline().rstrip().split()]
	a.sort()
	k = sum(a)
	if k % 2 == 1:
		print('NO')
		return
	k /= 2
	if a[3] == k:
		print('YES')
		return
	i = 0
	j = 3
	while i < j:
		if a[i] + a[j] == k:
			print('YES')
			return
		elif a[i] + a[j] > k:
			j -= 1
		else:
			i += 1
	print('NO')
	return
main()


list1 = list(map(int, input().split()))
sum1 = sum(list1)
flag = 0
if sum1 % 2 == 0:
	if sum1 // 2 in list1:
		flag = 1
	for i in range(0, 4):
		for j in range(i + 1, 4):
			if list1[i] + list1[j] == sum1 // 2:
				flag = 1
	if list1[0] + list1[1] + list1[2] == sum1 // 2:
		flag = 1
	if list1[3] + list1[1] + list1[2] == sum1 // 2:
		flag = 1
	if flag == 1:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


a = list(map(int, input().split()))
a.sort()
z = []
z.append((a[0] + a[3], a[1] + a[2]))
z.append((a[0] + a[1] + a[2], a[3]))
z.append((a[0] + a[1], a[2] + a[3]))
flag = 0
for i in z:
	if i[0] == i[1]:
		flag = 1
		break
if flag == 1:
	print('YES')
else:
	print('NO')


a = sorted(list(map(int, input().split())), reverse=True)
f1 = a[0] + a[3]
f2 = a[1] + a[2]
if f1 == f2:
	print('YES')
elif a[0] == a[1] + a[2] + a[3]:
	print('YES')
else:
	print('NO')


from itertools import *
a = [int(x) for x in input().split()]
x = [sum(h) for h in [a[:i] + a[i + 1:] for i in range(4)]]
y = []
if any([a[i] == x[i] for i in range(4)]):
	print('YES')
	exit()
if any([a[0] + a[1] == a[2] + a[3], a[0] + a[2] == a[1] + a[3], a[0] + a[3] == a[1] + a[2], a[1] + a[2] == a[0] + a[3], a[1] + a[3] == a[0] + a[2], a[2] + a[3] == a[0] + a[1]]):
	print('YES')
	exit()
print('NO')


a = list(map(int, input().split()))
flag = 0
sum2 = sum(a)
for i in range(len(a)):
	sum3 = a[i]
	s1 = sum2
	s1 -= sum3
	if sum3 == s1:
		flag = 1
		break
	for j in range(i + 1, len(a)):
		sum1 = a[i]
		sum1 += a[j]
		s = sum2
		s -= sum1
		if sum1 == s:
			flag = 1
			break
	if flag == 1:
		break
if flag == 1:
	print('YES')
else:
	print('NO')


v = [int(x) for x in input().split()]
v.sort()
if v[0] + v[3] == v[1] + v[2] or v[3] == v[0] + v[1] + v[2]:
	print('YES')
else:
	print('NO')


a = sorted([int(i) for i in input().split()], reverse=True)
b = 0
c = 0
for i in range(len(a)):
	if c > b:
		b += a[i]
	else:
		c += a[i]
if b == c:
	print('YES')
else:
	print('NO')


def swap(arr, i, j):
	temp = arr[i]
	arr[i] = arr[j]
	arr[j] = temp
a = input().split()
for i in range(4):
	a[i] = int(a[i])
for i in range(3):
	for j in range(3):
		if a[j] > a[j + 1]:
			swap(a, j, j + 1)
b = a[0] + a[3]
c = a[2] + a[1]
d = a[0] + a[1] + a[2]
if b == c or d == a[3]:
	print('YES')
else:
	print('NO')


x = list(map(int, input().split()))
flag = 0
if 2 * max(x) == sum(x):
	print('YES')
else:
	for i in range(4):
		for j in range(4):
			if 2 * (x[i] + x[j]) == sum(x) and i != j:
				print('YES')
				flag = 1
				break
			if i == 3 and j == 3:
				print('NO')
		if flag == 1:
			break


import sys
from collections import defaultdict
from itertools import combinations
from itertools import permutations
input = lambda : sys.stdin.readline().rstrip()

def write(*args, sep=' '):
	for i in args:
		sys.stdout.write('{}'.format(i) + sep)
INF = float('inf')
MOD = int(1000000000.0 + 7)
arr = list(map(int, input().split()))
s = sum(arr)
for i in range(1, 5):
	for j in combinations(arr, i):
		if sum(j) == s - sum(j):
			print('YES')
			exit()
print('NO')


print((lambda rec, a: 'YES' if rec(rec, a, 0, 0) else 'NO')(lambda self_fn, a, i, cur_sum: cur_sum == 0 if i == 4 else self_fn(self_fn, a, i + 1, cur_sum + a[i]) or self_fn(self_fn, a, i + 1, cur_sum - a[i]), tuple((int(i) for i in input().split()))))


def canEqualBags():
	firstBag = numbers[0] + numbers[3]
	secondBag = numbers[1] + numbers[2]
	if firstBag == secondBag:
		return True
	elif numbers[0] + numbers[1] + numbers[2] == numbers[3]:
		return True
	return False
numbers = input().split()
for i in range(0, len(numbers)):
	numbers[i] = int(numbers[i])
numbers.sort()
if canEqualBags():
	print('YES')
else:
	print('NO')


from itertools import permutations
for i in list(permutations([int(i) for i in input().split()])):
	if sum(i[:1]) == sum(i[1:]) or sum(i[:2]) == sum(i[2:]) or sum(i[:3]) == sum(i[3:]):
		print('YES')
		exit(0)
print('NO')


x = list(input().split(' '))
x[0] = int(x[0])
x[1] = int(x[1])
x[2] = int(x[2])
x[3] = int(x[3])
x.sort()
if x[0] + x[2] == x[1] + x[3]:
	print('YES')
elif x[0] + x[3] == x[1] + x[2]:
	print('YES')
elif x[0] + x[1] + x[2] == x[3]:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
l = [a, b, c, d]
l.sort()
if l[3] + l[0] == l[2] + l[1]:
	print('YES')
elif l[3] == l[0] + l[2] + l[1]:
	print('YES')
else:
	print('NO')


k = list(map(int, input().split()))
s = max(k)
k.remove(s)
if s == sum(k):
	print('YES')
else:
	m = min(k)
	k.remove(m)
	if s + m == sum(k):
		print('YES')
	else:
		print('NO')


(a1, a2, a3, a4) = map(int, input().split())
a = [a1, a2, a3, a4]
temp = 0
tot = 0
for i in range(0, len(a)):
	tot += a[i]
for i in range(0, len(a)):
	if tot - a[i] == a[i]:
		temp = 1
for i in range(0, len(a)):
	for j in range(i + 1, len(a)):
		if tot - a[i] - a[j] == a[i] + a[j]:
			temp = 1
if temp == 1:
	print('YES')
else:
	print('NO')


(a, b, c, d) = list(map(int, input().split()))
print('YES' if any([a + b == c + d, a + c == b + d, a + d == c + b, a == b + c + d, b == a + c + d, c == a + b + d, d == a + b + c]) else 'NO')


s = map(int, input().split())
s = list(s)
x = sum(s)
if x % 2 != 0:
	print('NO')
else:
	a = max(s)
	s.remove(a)
	if a == x / 2:
		print('YES')
	else:
		d = False
		for i in range(3):
			if s[i] + a == x / 2:
				print('YES')
				d = True
				break
			else:
				continue
		if d == False:
			print('NO')


a = str(input()).split(' ')
d1 = []
d2 = []
q = [0]
for i in range(4):
	q.append(int(a[i]))
if q[1] == q[2] + q[3] + q[4]:
	print('YES')
elif q[2] == q[1] + q[3] + q[4]:
	print('YES')
elif q[3] == q[2] + q[1] + q[4]:
	print('YES')
elif q[4] == q[2] + q[3] + q[1]:
	print('YES')
elif q[1] + q[2] == q[3] + q[4]:
	print('YES')
elif q[3] + q[1] == q[2] + q[4]:
	print('YES')
elif q[1] + q[4] == q[3] + q[2]:
	print('YES')
else:
	print('NO')


def part(arr, p, s):
	if s == 0:
		return True
	if s != 0 and p < 0:
		return False
	if arr[p] > s:
		return part(arr, p - 1, s)
	if arr[p] <= s:
		return part(arr, p - 1, s - arr[p]) or part(arr, p - 1, s)
ans = list(map(int, input().split()))
sa = sum(ans)
if sa % 2 == 0 and part(ans, len(ans) - 1, sa // 2):
	print('YES')
else:
	print('NO')


n = list(map(int, input().split()))
n.sort()
s = n[3]
while True:
	if s == sum([n[0], n[1], n[2]]):
		print('YES')
		break
	elif s + n[0] == sum([n[1], n[2]]):
		print('YES')
		break
	else:
		print('NO')
		break


(a1, a2, a3, a4) = list(map(int, input().strip().split()))
X = [[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [1, 0, 0, 1], [0, 0, 1, 0], [1, 0, 1, 0], [0, 0, 1, 1], [1, 0, 1, 1], [0, 1, 0, 0], [1, 1, 0, 0], [0, 1, 0, 1], [1, 1, 0, 1], [0, 1, 1, 0], [1, 1, 1, 0], [0, 1, 1, 1], [1, 1, 1, 1]]
flag = 1
for B in X:
	if a1 * B[0] + a2 * B[1] + a3 * B[2] + a4 * B[3] == a1 * (1 - B[0]) + a2 * (1 - B[1]) + a3 * (1 - B[2]) + a4 * (1 - B[3]):
		print('YES')
		flag = 0
		break
if flag:
	print('NO')


import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
L = list(map(int, input().split()))
half = sum(L) / 2
cand = set([0])
for l in L:
	tmp = set()
	for c in cand:
		tmp.add(c + l)
		tmp.add(c)
	cand = tmp
ans = 'NO'
for c in cand:
	if c == half:
		ans = 'YES'
		break
print(ans)


lst = list(map(int, input().split()))
if lst[0] + lst[1] == lst[2] + lst[3] or lst[0] + lst[2] == lst[1] + lst[3] or lst[0] + lst[3] == lst[1] + lst[2]:
	print('YES')
elif lst[0] == lst[1] + lst[2] + lst[3] or lst[1] == lst[0] + lst[2] + lst[3] or lst[2] == lst[0] + lst[1] + lst[3] or (lst[3] == lst[0] + lst[2] + lst[1]):
	print('Yes')
else:
	print('NO')


x = list(map(int, input().split()))
(a, b, c, d) = x
s = sum(x) / 2
if s in (a, b, c, d, a + b, a + c, a + d):
	print('YES')
else:
	print('NO')


arr = [int(x) for x in input().split()]
arr.sort(reverse=True)
f = 0
if arr[0] == arr[1] + arr[2] + arr[3]:
	f = 1
elif arr[0] + arr[3] == arr[1] + arr[2]:
	f = 1
print('YES') if f == 1 else print('NO')


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_strList_from_str = lambda : list(sys.stdin.readline().strip())
get_int = lambda : int(sys.stdin.readline().strip())
pt = lambda x: sys.stdout.write(str(x))
lst = get_list()
s = sum(lst)
(a, b, c, d) = lst
if a == s - a or b == s - b or c == s - c or (d == s - d):
	print('YES')
elif a + b == c + d or a + c == b + d or a + d == b + c:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(lambda x: int(x), input().split())
step1 = [0]
step2 = []
step3 = []
step4 = []
step5 = []
for x in step1:
	step2.append(x + a)
	step2.append(x - a)
for x in step2:
	step3.append(x + b)
	step3.append(x - b)
for x in step3:
	step4.append(x + c)
	step4.append(x - c)
for x in step4:
	step5.append(x + d)
	step5.append(x - d)
print('YES' if 0 in step5 else 'NO')


candies = list(map(int, input().split()))
cmb = [[0, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [0, 0, 1, 1], [0, 1, 0, 0], [0, 1, 0, 1], [0, 1, 1, 0], [0, 1, 1, 1], [1, 0, 0, 0], [1, 0, 0, 1], [1, 0, 1, 0], [1, 0, 1, 1], [1, 1, 0, 0], [1, 1, 0, 1], [1, 1, 1, 0], [1, 1, 1, 1]]
for c in cmb:
	(f, s) = (0, 0)
	for i in range(4):
		if c[i] == 0:
			f += candies[i]
		else:
			s += candies[i]
	if f == s:
		break
if f == s:
	print('YES')
else:
	print('NO')


ele = list(map(int, input().rstrip().split()))
if ele[0] + ele[1] == ele[2] + ele[3]:
	print('Yes')
elif ele[1] + ele[2] == ele[0] + ele[3]:
	print('Yes')
elif ele[3] + ele[1] == ele[0] + ele[2]:
	print('Yes')
elif ele[0] + ele[1] + ele[2] == ele[3]:
	print('Yes')
elif ele[1] + ele[2] + ele[3] == ele[0]:
	print('Yes')
elif ele[2] + ele[3] + ele[0] == ele[1]:
	print('Yes')
elif ele[0] + ele[1] + ele[3] == ele[2]:
	print('Yes')
else:
	print('No')


import sys
input = sys.stdin.readline
(a, b, c, d) = map(int, input().split())
A = [a, b, c, d, a + b, b + c, c + d, a + c, b + d, a + d]
ok = False
S = a + b + c + d
for p in A:
	if S - p == p:
		ok = True
print('YES' if ok else 'NO')


l = list(map(int, input().split()))
sum1 = l[0] + l[1] + l[2] + l[3]
flag = 0
x = l[0]
y = l[1]
z = l[2]
w = l[3]
if x == y + z + w:
	print('YES')
elif y == x + z + w:
	print('YES')
elif z == x + y + w:
	print('YES')
elif w == x + y + z:
	print('YES')
elif x + y == z + w:
	print('YES')
elif x + z == y + w:
	print('YES')
elif x + w == y + z:
	print('YES')
else:
	print('NO')


import sys
import itertools
import math
import collections
from collections import Counter

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 sieve(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] = prime[1] = False
	r = [p for p in range(n + 1) if prime[p]]
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

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()))

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

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return collections.defaultdict(int)
t = li()
s = sum(t)
for i in range(4):
	for j in range(4):
		if i != j and t[i] + t[j] == s - (t[i] + t[j]):
			exit(print('YES'))
for i in range(4):
	if t[i] == s - t[i]:
		exit(print('YES'))
print('NO')


bags = sorted(list(map(int, input().split(' '))))
possible = False
if sum(bags[:3]) == bags[3] or bags[1] + bags[2] == bags[0] + bags[3]:
	possible = True
print('YES' if possible else 'NO')


l = list(map(int, input().split()))
for i in range(16):
	(cur1, cur2) = (0, 0)
	for j in range(4):
		if i & 1 << j == 0:
			cur1 += l[j]
		else:
			cur2 += l[j]
	if cur1 == cur2:
		print('YES')
		quit()
print('NO')


from itertools import permutations
a = list(map(int, input().split()))
for i in permutations(a):
	if i[0] == sum(i[1:]) or sum(i[:2]) == sum(i[2:]):
		print('YES')
		break
else:
	print('NO')


a = sorted(map(int, input().split()))
s = sum(a)
print('YNEOS'[s % 2 or s // 2 not in [sum(a[:3]), sum(a[1:3])]::2])


a = list(map(int, input().split()))
s = sum(a)
if s % 2:
	print('NO')
elif s // 2 in a:
	print('YES')
elif s // 2 in (a[-1] + a[i] for i in range(3)):
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline
a = [int(i) for i in input().split()]
if a[0] == a[1] + a[2] + a[3]:
	print('YES')
	exit()
elif a[1] == a[0] + a[2] + a[3]:
	print('YES')
	exit()
elif a[2] == a[0] + a[1] + a[3]:
	print('YES')
	exit()
elif a[3] == a[0] + a[1] + a[2]:
	print('YES')
	exit()
elif a[0] + a[1] == a[2] + a[3]:
	print('YES')
	exit()
elif a[0] + a[2] == a[1] + a[3]:
	print('YES')
	exit()
elif a[0] + a[3] == a[1] + a[2]:
	print('YES')
	exit()
else:
	print('NO')


x = [*map(int, input().split())]
x = sorted(x)
if x[0] + x[3] == x[1] + x[2]:
	print('YES')
elif x[3] == x[0] + x[1] + x[2]:
	print('YES')
else:
	print('NO')


(w, x, y, z) = map(int, input().split())
flag = 0
sum = w + x + y + z
if w == sum / 2:
	flag = 1
if x == sum / 2:
	flag = 1
if y == sum / 2:
	flag = 1
if z == sum / 2:
	flag = 1
if w + x == sum / 2:
	flag = 1
if w + y == sum / 2:
	flag = 1
if w + z == sum / 2:
	flag = 1
if flag == 1:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a.sort()
p = a[1] + a[2]
d = abs(p - a[3])
if a[0] == d:
	print('YES')
else:
	print('NO')


from math import *
from cmath import *
from itertools import *
from decimal import *
from fractions import *
from sys import *
for _ in range(1):
	a = [int(x) for x in input().split()]
	a.sort()
	print(['NO', 'YES'][a[0] + a[3] == a[1] + a[2] or a[3] == a[0] + a[1] + a[2]])


(b1, b2, b3, b4) = map(int, input().split(' '))
all_candies = b1 + b2 + b3 + b4
each_share = all_candies // 2
candies = sorted([b1, b2, b3, b4])
if all_candies % 2 == 0:
	if each_share in [b1, b2, b3, b4] and all_candies - each_share == each_share:
		print('YES')
	elif candies[0] + candies[3] == candies[1] + candies[2]:
		print('YES')
	else:
		print('NO')
else:
	print('NO')


l = list(map(int, input().split()))[:4]
g = sorted(l)
d = g[0] + g[3]
e = g[1] + g[2]
if d == e or g[0] + g[1] + g[2] == g[3]:
	print('yes')
else:
	print('no')


inn = input().split()
num = []
for i in inn:
	num.append(int(i))
num.sort()
if num[0] + num[3] == num[1] + num[2]:
	print('YES')
elif num[0] + num[1] + num[2] == num[3]:
	print('YES')
else:
	print('NO')


p = [int(x) for x in input().split()]
s = sum(p)
can = False
for i in range(8):
	t = 0
	for j in range(4):
		if i & 1 << j > 0:
			t += p[j]
	if s == 2 * t:
		can = True
		break
print('YES' if can else 'NO')


from itertools import combinations
l = [*map(int, input().split())]
print('Yes' if any((2 * sum(c) == sum(l) for x in [1, 2] for c in combinations(l, x))) else 'No')


def brut(s, i):
	if s == sum(lis) - s:
		return 1
	if i == 4:
		return 0
	return max(brut(s, i + 1), brut(s + lis[i], i + 1))
lis = list(map(int, input().split()))
if brut(0, 0) == 1:
	print('YES')
else:
	print('NO')


value = [int(num) for num in input().split()]
value.sort()
if value[0] + value[1] + value[2] == value[3] or value[0] + value[3] == value[1] + value[2]:
	print('YES')
else:
	print('NO')


(x, y, z, t) = input().split()
a = [int(x), int(y), int(z), int(t)]
S = a[0] + a[1] + a[2] + a[3]
found = False
for i in range(len(a) - 1):
	if found:
		break
	for j in range(i + 1, len(a)):
		if a[i] + a[j] == S - a[i] - a[j]:
			found = True
			break
if a[0] + a[1] + a[2] == a[3] or a[0] + a[1] + a[3] == a[2] or a[0] + a[3] + a[2] == a[1] or (a[3] + a[1] + a[2] == a[0]):
	found = True
if found:
	print('YES')
else:
	print('NO')


arr = sorted([int(x) for x in input().split(' ')])

def func2(s):
	for i in range(4):
		for j in range(i + 1, 4):
			if arr[i] + arr[j] == s:
				return 1
	return 0
if sum(arr) & 1:
	print('NO')
else:
	s = sum(arr) // 2
	if func2(s) or s in arr:
		print('YES')
	else:
		print('NO')


arr = list(map(int, input().split()))
arr.sort()
aa = arr[0] + arr[3]
bb = arr[1] + arr[2]
a1 = arr[0] + arr[2]
b1 = arr[1] + arr[3]
aae = arr[0] + arr[1]
bee = arr[2] + arr[3]
if sum(arr) % 2 == 1:
	print('NO')
	exit()
xx = arr[0] + arr[1] + arr[2]
if aa == bb or a1 == b1 or aae == bee or (xx == arr[3]):
	print('YES')
else:
	print('NO')


a = list(map(int, input('').split(' ')))
t = sum(a)
b = ['0001', '0010', '0011', '0100', '0101', '0110', '0111']
res = False
for s in b:
	su = 0
	for i in range(4):
		if s[i] == '1':
			su = su + a[i]
	if su == t / 2:
		res = True
		break
if res:
	print('YES')
else:
	print('NO')


from sys import stdin
nums = [int(x) for x in stdin.readline().split()]
for i in range(2 ** 4):
	l = 0
	r = 0
	b = bin(i)[2:]
	if len(b) < 4:
		b = '0' * (4 - len(b)) + b
	for j in range(len(b)):
		if b[j] == '0':
			l += nums[j]
		else:
			r += nums[j]
	if l == r:
		print('YES')
		quit()
print('NO')


import sys
input = sys.stdin.readline

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

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

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

def getStr():
	return input().strip()

def addDictList(d, key, val):
	if key not in d:
		d[key] = []
	d[key].append(val)

def addDictInt(d, key, val):
	if key not in d:
		d[key] = 0
	d[key] = val

def addDictCount(d, key):
	if key not in d:
		d[key] = 0
	d[key] += 1

def addDictSum(d, key, val):
	if key not in d:
		d[key] = 0
	d[key] += val
a = getList()
a.sort(reverse=True)
s1 = a[0]
s2 = a[1]
for i in range(2, len(a)):
	if s1 < s2:
		s1 += a[i]
	else:
		s2 += a[i]
if s1 == s2:
	print('yes')
else:
	print('no')


List = [int(x) for x in input().split()]
List.sort()
if List[0] + List[3] == List[1] + List[2]:
	print('Yes')
elif List[0] + List[1] + List[2] == List[3]:
	print('Yes')
else:
	print('No')


def main():
	a = list(map(int, input().split()))
	k = sum(a)
	if k % 2 != 0:
		print('NO')
		return
	k = k // 2
	for i in range(4):
		for j in range(4):
			if i != j:
				if a[i] + a[j] == k:
					b = [0, 1, 2, 3]
					b.remove(i)
					b.remove(j)
					if a[b[0]] + a[b[1]] == k:
						print('YES')
						return
	for i in range(4):
		if a[i] == k:
			print('YES')
			return
	print('NO')
	return
main()


def can_split(numbers):
	numbers.sort()
	return numbers[0] + numbers[3] == numbers[1] + numbers[2] or numbers[0] + numbers[1] + numbers[2] == numbers[3]
numbers = list(map(int, input().split()))
print('YES' if can_split(numbers) else 'NO')


def f():
	(a, b, c, d) = map(int, input().split())
	ab = a + b
	ac = a + c
	ad = a + d
	bc = b + c
	bd = b + d
	cd = c + d
	bcd = b + c + d
	acd = a + c + d
	abd = a + b + d
	abc = a + b + c
	ar = [a, b, c, d, ab, ac, ad, bc, bd, cd, bcd, acd, abd, abc]
	for k in range(len(ar)):
		if a + b + c + d - ar[k] == ar[k]:
			return True
	return False
if f():
	print('YES')
else:
	print('NO')


s = 0
l = []
(n1, n2, n3, n4) = map(int, input().split())
l = [n1, n2, n3, n4]
if n1 + n2 == n3 + n4 or n1 + n3 == n2 + n4 or n1 + n4 == n2 + n3 or (n2 + n3 == n1 + n4) or (n1 + n2 + n3 == n4) or (n1 == n2 + n3 + n4) or (n2 == n1 + n3 + n4) or (n3 == n1 + n2 + n4):
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = map(int, input().split())
a = [a1, a2, a3, a4]
b = [a1, a2, a3, a4]
max1 = max(a)
a.remove(max1)
if sum(a) == max1:
	print('YES')
elif sum(a) < max1:
	print('NO')
else:
	b.sort()
	if b[0] + b[-1] == b[1] + b[2]:
		print('YES')
	else:
		print('NO')


(a1, a2, a3, a4) = map(int, input().split())
q = a1 + a2 + a3 + a4
if q % 2 != 0:
	print('NO')
else:
	q = q // 2
	if max(a1, a2, a3, a4) + min(a1, a2, a3, a4) == q or max(a1, a2, a3, a4) == q:
		print('YES')
	else:
		print('NO')


import sys
A = list(map(int, input().split()))
s = sum(A)
if s % 2 != 0:
	print('NO')
	sys.exit()
half = s // 2
if half in A:
	print('YES')
	sys.exit()
A.sort()
if A[0] + A[3] == A[1] + A[2]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a.sort()
h = 0.5 * sum(a)
if a[3] == h or a[3] + a[1] == h or a[3] + a[0] == h or (a[3] + a[2] == h):
	print('YES')
else:
	print('NO')


(a, b, c, d) = list(map(int, input().rstrip().split()))
out = False
if a + b == c + d or a + c == b + d or a + d == b + c:
	out = True
elif a == b + c + d or b == a + c + d or c == b + a + d or (d == b + c + a):
	out = True
if out:
	print('YES')
else:
	print('NO')


sacks = list(map(int, input().split()))
length = len(sacks)
one = 0
two = 0
state = ''
for i in range(length):
	one = sacks[i]
	two = sum(sacks[:i]) + sum(sacks[i + 1:])
	if one == two:
		state = 'true'
		print('Yes')
		break
if state != 'true':
	for i in range(length):
		for j in range(length):
			if i != j:
				buff = []
				for el in sacks:
					buff.append(el)
				one = sacks[i] + sacks[j]
				l = buff[j]
				buff.pop(i)
				buff.pop(buff.index(l))
				two = sum(buff)
				if one == two:
					state = 'true'
					print('Yes')
					break
		if state == 'true':
			break
if state != 'true':
	print('No')


a = list(map(int, input().split()))
s = sum(a)
d = s // 2
if s % 2 == 0 and (a[0] == d or a[1] == d or a[2] == d or (a[3] == d) or (a[0] + a[1] == d) or (a[0] + a[2] == d) or (a[0] + a[3] == d)):
	print('YES')
else:
	print('NO')


o = list(map(int, input().rstrip().split()))
o.sort()
s = sum(o)
if s % 2 != 0:
	print('NO')
else:
	g = o[0] + o[1] + o[2]
	if g == o[3]:
		print('YES')
	else:
		s = s / 2
		a = o[0] + o[1]
		b = o[0] + o[2]
		c = o[0] + o[3]
		if a == s or b == s:
			print('YES')
		elif c == s:
			print('YES')
		else:
			print('NO')


q = input().split()
a = int(q[0])
if a < 1 or a > 100:
	raise SystemExit
b = int(q[1])
if b < 1 or b > 100:
	raise SystemExit
c = int(q[2])
if c < 1 or c > 100:
	raise SystemExit
d = int(q[3])
if d < 1 or d > 100:
	raise SystemExit
if a == b + c + d:
	print('YES')
elif b == a + c + d:
	print('YES')
elif c == a + b + d:
	print('YES')
elif d == b + c + a:
	print('YES')
elif a + b == c + d:
	print('YES')
elif a + c == b + d:
	print('YES')
elif a + d == b + c:
	print('YES')
else:
	print('NO')


l = [int(x) for x in input().split()]
l.sort()
s1 = l[0] + l[-1]
s2 = l[1] + l[2]
s3 = l[0] + l[1] + l[2]
s4 = l[-1]
if s1 == s2:
	print('YES')
elif s3 == s4:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
if a == b + c + d or b == a + c + d or c == b + a + d or (d == b + c + a) or (a + b == c + d) or (a + c == b + d) or (a + d == c + b):
	print('Yes')
else:
	print('No')


A = list(map(int, input().split()))
s = sum(A)
flag = 0
for i in range(4):
	if A[i] == s - A[i]:
		flag = 1
		break
	if i == 3:
		break
	for j in range(i + 1, 4):
		if A[i] + A[j] == s - (A[i] + A[j]):
			flag = 1
			break
if flag == 1:
	print('YES')
else:
	print('NO')


l = list(input().split())
l = [int(i) for i in l]
if sum(l) - (min(l) + max(l)) == min(l) + max(l) or sum(l) - max(l) == max(l):
	print('YES')
else:
	print('NO')


(a, b, c, d) = [int(_) for _ in input().split()]
sum = (a + b + c + d) / 2
if a + b == sum or a + c == sum or a + d == sum or (b + c == sum) or (b + d == sum) or (c + d == sum) or (a == sum) or (b == sum) or (c == sum) or (d == sum):
	print('YES')
else:
	print('NO')


a = [int(i) for i in input().split()]
total = sum(a)
for i in range(1, 4):
	if 2 * (a[0] + a[i]) == total:
		print('YES')
		break
else:
	if 2 * max(a) == total:
		print('YES')
	else:
		print('NO')


def main():
	n = int(input())
	arr = [int(i) for i in input().split(' ')]
	arr_sum = sum(arr)
	zeros = len([i for i in arr if i == 0])
	if -1 * arr_sum == zeros:
		print(zeros + 1)
		return
	print(max(0, zeros))

def possible(arr):
	halfsum = sum(arr) // 2
	if halfsum in arr:
		return True
	for i in range(0, 4):
		for j in range(i + 1, 4):
			if arr[i] + arr[j] == halfsum:
				return True
	return False
arr = [int(i) for i in input().split(' ')]
if sum(arr) % 2 != 0:
	print('NO')
elif possible(arr):
	print('YES')
else:
	print('NO')


p = list(map(int, input().split()))
mx = max(p)
if mx == sum(p) - mx or mx + min(p) == sum(p) - (mx + min(p)):
	print('YES')
else:
	print('NO')


(a, b, c, d) = list(map(int, input().split()))
s = [a, b, c, d]
su = sum(s)
if a + b == c + d or a + c == b + d or a + d == b + c or (su - a == a) or (su - b == b) or (su - c == c) or (su - d == d):
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
arr = [int(i) for i in stdin.readline().split()]
total = sum(arr)
ans = 'NO'
for i in arr:
	if i == total - i:
		ans = 'YES'
		break
for j in range(1, len(arr)):
	if arr[0] + arr[j] == total - (arr[0] + arr[j]):
		ans = 'YES'
		break
print(ans)


def candies(ls):
	ls.sort()
	t1 = ls[0] + ls[3]
	t2 = ls[1] + ls[2]
	t3 = ls[0] + ls[1] + ls[2]
	if t1 == t2 or t3 == ls[3]:
		return 'YES'
	else:
		return 'NO'
ls = [int(i) for i in input().split()]
print(candies(ls), end=' ')


(a, b, c, d) = [int(i) for i in input().split()]
if not (a + b + c + d) % 2:
	k = (a + b + c + d) // 2
	if a + b == k or a + c == k or a + d == k or (a == k) or (b == k) or (c == k) or (d == k):
		print('YES')
	else:
		print('NO')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
l = [[a, b + c + d], [b, a + c + d], [c, d + a + b], [d, a + b + c], [a + b, c + d], [b + c, d + a], [a + c, b + d], [a + d, b + c]]
f = 0
for i in l:
	if i[0] == i[1]:
		print('YES')
		f = 1
		break
if f == 0:
	print('NO')


a = sorted([int(i) for i in input().split()], reverse=True)
if a[0] == a[1] + a[2] + a[3] or a[0] + a[3] == a[1] + a[2] or a[0] + a[3] == a[1] + a[2]:
	print('YES')
else:
	print('NO')


def subsets(s):
	if len(s) == 0:
		yield []
	else:
		for sx in subsets(s[1:]):
			yield sx
			yield (s[:1] + sx)
a = list(map(int, input().split()))
for x in subsets(a):
	if sum(a) == 2 * sum(x):
		print('YES')
		exit(0)
print('NO')


bags = list(map(int, input().split()))
bags.sort(reverse=True)
friend1 = 0
friend2 = 0
for bag in bags:
	if friend1 > friend2:
		friend2 += bag
	else:
		friend1 += bag
if friend1 == friend2:
	print('YES')
else:
	print('NO')


nums = list(map(int, input().split()))

def splitEq(nums):
	total = sum(nums)
	if total % 2:
		return 'NO'
	total //= 2
	dp = [True] + [False] * total
	for num in nums:
		for j in range(num, total + 1)[::-1]:
			dp[j] = dp[j] or dp[j - num]
	return 'YES' if dp[total] else 'NO'
print(splitEq(nums))


def main():
	(a1, a2, a3, a4) = map(int, input().split())
	if a1 + a2 == a3 + a4 or a1 + a3 == a2 + a4 or a1 + a4 == a2 + a3:
		print('YES')
	elif a1 == a2 + a3 + a4 or a2 == a1 + a3 + a4 or a3 == a1 + a2 + a4 or (a4 == a1 + a2 + a3):
		print('YES')
	else:
		print('NO')
main()


k = 0
a = input().split()
if int(a[0]) > int(a[1]):
	max = int(a[0])
else:
	max = int(a[1])
if int(a[2]) > max:
	max = int(a[2])
if int(a[3]) > max:
	max = int(a[3])
if max == int(a[0]) + int(a[1]) + int(a[2]) + int(a[3]) - max:
	k += 1
if (int(a[0]) + int(a[1]) + int(a[2]) + int(a[3])) % 2 == 0:
	f = (int(a[0]) + int(a[1]) + int(a[2]) + int(a[3])) // 2
	if int(a[0]) + int(a[1]) == f or int(a[0]) + int(a[2]) == f or int(a[0]) + int(a[3]) == f or (int(a[1]) + int(a[2]) == f) or (int(a[1]) + int(a[3]) == f) or (int(a[2]) + int(a[3]) == f):
		k += 1
if k == 0:
	print('NO')
else:
	print('YES')


l = [int(x) for x in input().split()]
s = l[0] + l[1] + l[2] + l[3]
for i in range(4):
	for j in range(i + 1, 4):
		if l[i] + l[j] == s - (l[i] + l[j]):
			print('YES')
			quit()
for i in range(4):
	for j in range(i + 1, 4):
		for k in range(j + 1, 4):
			if l[i] + l[j] + l[k] == s - (l[i] + l[j] + l[k]):
				print('YES')
				quit()
print('NO')


bags = list(map(int, input().split()))
if min(bags) + max(bags) == sum(bags) / 2 or max(bags) == sum(bags) / 2:
	print('YES')
else:
	print('NO')


v = [int(x) for x in input().split()]
if sum(v) % 2 == 1:
	print('NO')
elif (v[0] + v[1] == v[2] + v[3]) | (v[0] + v[2] == v[1] + v[3]) | (v[0] + v[3] == v[1] + v[2]):
	print('YES')
elif (v[0] == v[1] + v[2] + v[3]) | (v[1] == v[0] + v[2] + v[3]) | (v[2] == v[1] + v[0] + v[3]) | (v[3] == v[1] + v[2] + v[0]):
	print('YES')
else:
	print('NO')


arr = list(map(int, input().split()))
s = sum(arr)
if s % 2 != 0:
	print('NO')
else:
	s >>= 1
	arr.sort(reverse=True)
	for i in arr:
		if s >= i:
			s -= i
		if s == 0:
			break
	if s == 0:
		print('YES')
	else:
		print('NO')


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 main():
	a = li()
	if sum(a) % 2 == 0:
		a.sort()
		f = 0
		if a[2] + a[1] == a[3] + a[0]:
			f = 1
		if a[0] + a[1] + a[2] == a[3]:
			f = 1
		if f == 1:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')
main()


q = lambda : map(int, input().split())
qi = lambda : int(input())
qs = lambda : input().split()
a = sorted(list(q()))
if a[0] + a[-1] == a[1] + a[2] or a[0] + a[1] + a[2] == a[3]:
	print('YES')
else:
	print('NO')


def isFair(arr):
	arr = sorted(arr)
	VS = [(1, 1), (1, 2), (1, 3), (2, 2)]
	A = arr[0] + arr[-1]
	B = arr[1] + arr[-2]
	if A == B:
		return True
	for i in arr:
		A = sum(arr) - i
		if A == i:
			return True
	return False
IN = input().split(' ')
LS = list()
for el in IN:
	LS.append(int(el))
if isFair(LS):
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a.sort()
maxi = a[3]
if a[0] + a[1] + a[2] == maxi:
	print('YES')
elif a[0] + a[1] + a[2] < maxi:
	print('NO')
elif a[1] + a[2] == maxi + a[0]:
	print('YES')
elif a[1] + a[2] < maxi + a[0]:
	print('NO')
elif a[2] == maxi + a[0] + a[1]:
	print('YES')
elif a[2] < maxi + a[0] + a[1]:
	print('NO')


(a1, a2, a3, a4) = list(map(int, input().split()))
sa = a1 + a2 + a3 + a4
if a1 + a2 == a3 + a4 or a1 + a3 == a2 + a4 or a1 + a4 == a2 + a3 or (a1 == sa - a1) or (a2 == sa - a2) or (a3 == sa - a3) or (a4 == sa - a4):
	print('YES')
else:
	print('NO')


presents = sorted([int(elem) for elem in input().split()])
(first, second) = (0, 0)
for i in range(len(presents) - 1, -1, -1):
	if first > second:
		second += presents[i]
	else:
		first += presents[i]
if first == second:
	print('YES')
else:
	print('NO')


li = list(map(int, input().split()))
if li[0] + li[1] == li[2] + li[3] or li[0] + li[3] == li[2] + li[1]:
	print('YES')
elif li[0] + li[2] == li[1] + li[3] or li[0] + li[1] + li[2] == li[3] or li[1] + li[2] + li[3] == li[0] or (li[0] + li[1] + li[3] == li[2]) or (li[0] + li[2] + li[3] == li[1]):
	print('YES')
else:
	print('NO')


l = list(map(int, input().split()))
total = sum(l)
ans = False
if total % 2 == 0:
	f = total // 2
	for i in range(1, 4):
		if l[0] + l[i] == f or l[i] == f or l[0] == f:
			ans = True
			print('YES')
			break
	if ans == False:
		print('NO')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
e = a + b + c + d
if e % 2 == 0:
	f = e / 2
	if a + b == f or a + c == f or a + d == f or (b + c == f) or (b + d == f) or (c + d == f) or (a == f) or (b == f) or (c == f) or (d == f) or (a + b + c == f) or (a + b + d == f) or (a + c + d == f) or (b + c + d == f):
		print('YES')
	else:
		print('NO')
else:
	print('NO')


(p, q, r, s) = list(map(int, input().strip().split()))
a = p + q + r + s
if a % 2 != 0:
	print('NO')
elif p + q == r + s:
	print('YES')
elif p + s == q + r:
	print('YES')
elif p + r == q + s:
	print('YES')
elif p == q + r + s:
	print('YES')
elif q == p + r + s:
	print('YES')
elif r == p + q + s:
	print('YES')
elif s == p + q + r:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a.sort(reverse=True)
l = 0
r = 0
for i in range(len(a)):
	if r >= l:
		l += a[i]
	else:
		r += a[i]
if l == r:
	print('YES')
else:
	print('NO')


(a, b, c, d) = [int(i) for i in input().split()]
s = a + b + c + d
pos = 0
A = [a, b, c, d]
for i in range(16):
	c = 0
	for j in range(4):
		if i & 1 << j:
			c += A[j]
	if s - c == c:
		pos = 1
if pos:
	print('YES')
else:
	print('NO')


a = input()
a = a.split()
a = [int(i) for i in a]
flag = 0
a.sort()
for _ in range(1):
	if a[0] + a[1] == a[2] + a[3]:
		flag = 1
		break
	if a[0] + a[2] == a[1] + a[3]:
		flag = 1
		break
	if a[0] + a[3] == a[2] + a[1]:
		flag = 1
		break
	if a[0] + a[1] + a[2] == a[3]:
		flag = 1
		break
if flag == 0:
	print('NO')
else:
	print('YES')


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

def check(arr, sum):
	if len(arr) == 1:
		return sum == arr[0]
	return check(arr[1:], sum - arr[0]) or check(arr[1:], sum)
print('YES' if check(arr, sum(arr) / 2) else 'NO')


a = [*map(int, input().split())]
a.sort()
if sum(a) % 2:
	print('NO')
elif sum(a) / 2 in a:
	print('YES')
else:
	for i in a[1:]:
		if a[0] + i == sum(a) / 2:
			print('YES')
			exit()
	print('NO')


l = list(map(int, input().split()))

def posl(i, r):
	if i == 4:
		a1 = 0
		a2 = 0
		for i2 in range(4):
			if r[i2] == 1:
				a1 += l[i2]
			else:
				a2 += l[i2]
		if a1 == a2:
			print('YES')
			exit()
	else:
		for i2 in range(2):
			r[i] = i2
			posl(i + 1, r)
posl(0, [0, 0, 0, 0])
print('NO')


def findPartition(arr, n):
	sum = 0
	(i, j) = (0, 0)
	for i in range(n):
		sum += arr[i]
	if sum % 2 != 0:
		return 0
	part = [[True for i in range(n + 1)] for j in range(sum // 2 + 1)]
	for i in range(0, n + 1):
		part[0][i] = True
	for i in range(1, sum // 2 + 1):
		part[i][0] = False
	for i in range(1, sum // 2 + 1):
		for j in range(1, n + 1):
			part[i][j] = part[i][j - 1]
			if i >= arr[j - 1]:
				part[i][j] = part[i][j] or part[i - arr[j - 1]][j - 1]
	return part[sum // 2][n]
a = input().split()
arr = [0, 0, 0, 0]
arr[0] = int(a[0])
arr[1] = int(a[1])
arr[2] = int(a[2])
arr[3] = int(a[3])
n = len(arr)
if findPartition(arr, n) == True:
	print('Yes')
else:
	print('No')


import math, sys
from collections import Counter, defaultdict
from sys import stdin, stdout
lili = lambda : list(map(int, sys.stdin.readlines()))
li = lambda : list(map(int, input().split()))
a = li()
a.sort()
if a[0] + a[3] == a[1] + a[2]:
	print('YES')
elif a[0] + a[2] == a[1] + a[3]:
	print('YES')
elif a[3] == a[2] + a[1] + a[0]:
	print('YES')
else:
	print('NO')


numlist = list(map(int, input().strip().split()))
midnum = sum(numlist) / 2
if sum(numlist) % 2 == 1:
	print('NO')
elif numlist[0] + numlist[1] == sum(numlist) / 2 and numlist[2] + numlist[3] == sum(numlist) / 2:
	print('YES')
elif numlist[0] + numlist[2] == sum(numlist) / 2 and numlist[1] + numlist[3] == sum(numlist) / 2:
	print('YES')
elif numlist[0] + numlist[3] == sum(numlist) / 2 and numlist[1] + numlist[2] == sum(numlist) / 2:
	print('YES')
elif numlist[0] + numlist[1] + numlist[2] == numlist[3]:
	print('YES')
elif numlist[0] + numlist[2] + numlist[3] == numlist[1]:
	print('YES')
elif numlist[1] + numlist[2] + numlist[3] == numlist[0]:
	print('YES')
elif numlist[1] + numlist[0] + numlist[3] == numlist[2]:
	print('YES')
else:
	print('NO')


s = 0
(x1, x2, x3, x4) = sorted(list(map(int, input().split())))
if x1 + x4 == x2 + x3 or x4 == x1 + x2 + x3:
	print('YES')
else:
	print('NO')


from itertools import combinations
arr = list(map(int, input().split()))
s = sum(arr)
flag = False
for i in combinations(range(4), 1):
	if arr[i[0]] == s / 2:
		flag = True
for i in combinations(range(4), 2):
	if arr[i[0]] + arr[i[1]] == s / 2:
		flag = True
if flag == True:
	print('YES')
else:
	print('NO')


arr = list(map(int, input().split()))
rez = sum(arr)
if rez % 2:
	print('NO')
elif rez // 2 in arr:
	print('YES')
elif arr[0] + arr[1] == rez // 2 or arr[0] + arr[2] == rez // 2 or arr[0] + arr[3] == rez // 2:
	print('YES')
else:
	print('NO')


l = list(map(int, input().split()))
a = max(l)
b = min(l)
(c, d) = (0, 0)
l.remove(a)
l.remove(b)
(c, d) = l
flag = 0
if a + b == c + d:
	print('YES')
	flag = 9
elif a == b + c + d:
	print('YES')
else:
	print('NO')


import math
from decimal import Decimal
import heapq

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def dva():
	(n, m) = map(int, input().split())
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	return (n, m, b)

def eratosthenes(n):
	sieve = list(range(n + 1))
	for i in sieve:
		if i > 1:
			for j in range(i + i, len(sieve), i):
				sieve[j] = 0
	return sorted(set(sieve))

def lol(lst, k):
	k = k % len(lst)
	ret = [0] * len(lst)
	for i in range(len(lst)):
		if i + k < len(lst) and i + k >= 0:
			ret[i] = lst[i + k]
		if i + k >= len(lst):
			ret[i] = lst[i + k - len(lst)]
		if i + k < 0:
			ret[i] = lst[i + k + len(lst)]
	return ret

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)

def Factor(n):
	Ans = []
	d = 2
	while d * d <= n:
		if n % d == 0:
			Ans.append(d)
			n //= d
		else:
			d += 1
	if n > 1:
		Ans.append(n)
	return Ans
a = list(map(int, input().split()))
a.sort()
d1 = a[0] + a[3]
d2 = a[1] + a[2]
a1 = a[0] + a[1] + a[2]
if d1 == d2 or a1 == a[3]:
	print('YES')
else:
	print('NO')


import sys
import itertools
data = list(map(int, input().split()))
sorted_data = sorted(data)
posible_idx = list(itertools.permutations([0, 1, 2, 3], 4))
posible_arrays = [[sorted_data[i] for i in idx] for idx in posible_idx]

def compare_sum(d):
	for i in [1, 2, 3]:
		if sum(d[i:]) == sum(d[:i]):
			return 'YES'
		else:
			continue

def main():
	for a in posible_arrays:
		if compare_sum(a) == 'YES':
			print('YES')
			return
	print('NO')
	return
main()


a = [0] * 4
(a[0], a[1], a[2], a[3]) = map(int, input().split())
count = 0
maxi = 0
if max(a) > sum(a) / 2:
	count = 0
elif max(a) == sum(a) / 2:
	count = 1
elif a[0] + a[1] == a[2] + a[3]:
	count = 1
elif a[0] + a[2] == a[1] + a[3]:
	count = 1
elif a[0] + a[3] == a[1] + a[2]:
	count = 1
if count > 0:
	print('YES')
else:
	print('NO')


def main():
	arr = [int(i) for i in input().split()]
	arr = sorted(arr)
	s = sum(arr)
	if s % 2 != 0:
		print('NO')
		return
	else:
		for i in range(4):
			if arr[i] == int(s / 2):
				print('YES')
				return
		for i in range(0, 3):
			if arr[i] + arr[i + 1] == int(s / 2):
				print('YES')
				return
		for i in range(0, 2):
			if arr[i] + arr[i + 1] + arr[i + 2] == int(s / 2):
				print('YES')
				return
		print('NO')
		return
main()


X = sorted(list(map(int, input().split())))
Avg = sum(X) / 2
if X[-1] == Avg or X[-1] + X[0] == Avg:
	print('YES')
	exit()
print('NO')


t = [int(x) for x in input().split()]
total = sum(t) / 2
if total == t[0] or total == t[1] or total == t[2] or (total == t[3]) or (total == t[0] + t[3]) or (total == t[0] + t[2]) or (total == t[0] + t[1]):
	print('YES')
else:
	print('NO')


l = input().split()
li = [int(i) for i in l]
z = sum(li)
poss = 0
for i in range(1 << 4):
	sumi = 0
	for j in range(4):
		if i & 1 << j:
			sumi += li[j]
	if sumi * 2 == z:
		poss = 1
		break
if poss:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
x = [[a + b + c, d], [a + b + d, c], [a + c + d, b], [b + c + d, a], [a + b, c + d], [a + c, b + d], [a + d, c + b]]

def Check(x):
	for i in x:
		if i[0] == i[1]:
			return True
	return False
if Check(x):
	print('YES')
else:
	print('NO')


(a, s, d, f) = map(int, input().split())
if a + s == d + f or a + f == s + d or a + d == s + f or (a + s + d == f) or (a + d + f == s) or (a + s + f == d) or (s + d + f == a):
	print('YES')
else:
	print('NO')


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
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 [int(x) for x in sys.stdin.readline().split()]

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

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

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

def S():
	return input()

def main():
	(a, b, c, d) = LI()
	for i in range(2):
		for j in range(2):
			for k in range(2):
				for m in range(2):
					x = y = 0
					if i % 2 == 0:
						x += a
					else:
						y += a
					if j % 2 == 0:
						x += b
					else:
						y += b
					if k % 2 == 0:
						x += c
					else:
						y += c
					if m % 2 == 0:
						x += d
					else:
						y += d
					if x == y:
						return 'YES'
	return 'NO'
print(main())


import math

def main():
	(a1, a2, a3, a4) = tuple([int(x) for x in input().split()])
	sum = a1 + a2 + a3 + a4
	a = [a1, a2, a3, a4]
	for mask in range(16):
		t = 0
		for digit in range(4):
			if mask & 1 << digit != 0:
				t += a[digit]
		if t * 2 == sum:
			return 'YES'
	return 'NO'
print(main())


def candies(arr):
	val1 = max(arr)
	arr.remove(val1)
	if sum(arr) == val1:
		return True
	val1 += min(arr)
	arr.remove(min(arr))
	val2 = sum(arr)
	return val1 == val2
x = list(map(int, input().rstrip().split()))
if candies(x):
	print('YES')
else:
	print('NO')


def binary_plus():
	k = 0
	if binary[0] == 1:
		binary[0] = 0
		while k != -1:
			k += 1
			if binary[k] == 1:
				binary[k] = 0
			else:
				binary[k] = 1
				k = -1
	else:
		binary[0] = 1
x = list(map(int, input().split()))
binary = [0 for i in range(len(x))]
for i in range(2 ** len(x) - 1):
	n1 = 0
	n2 = 0
	for j in range(len(x)):
		if binary[j] == 0:
			n1 = n1 + x[j]
		else:
			n2 = n2 + x[j]
	binary_plus()
	if n2 == n1:
		print('YES')
		exit()
print('NO')


import sys, atexit
from io import BytesIO
inp = BytesIO(sys.stdin.buffer.read())
input = lambda : inp.readline().decode('ascii')
buf = BytesIO()
atexit.register(lambda : sys.__stdout__.buffer.write(buf.getvalue()))
l = list(map(int, input().split()))
l.sort()
if l[0] + l[3] == l[1] + l[2] or l[0] + l[1] + l[2] == l[3]:
	print('YES')
else:
	print('NO')


arr = list(map(int, input().split()))
arr.sort()
acum = 0
for i in range(len(arr)):
	acum += arr[i]
res = False
acum2 = 0
for j in range(len(arr)):
	acum2 += arr[j]
	if acum2 == acum / 2:
		res = True
	elif acum2 > acum / 2:
		for k in range(len(arr)):
			if arr[k] == acum2 - acum / 2:
				res = True
if res:
	print('YES')
else:
	print('NO')


alist = input().split()
sumofa = 0
for i in range(len(alist)):
	alist[i] = int(alist[i])
	sumofa = sumofa + alist[i]
true = 0
for x in range(len(alist)):
	if alist[x] == sumofa / 2:
		print('YES')
		break
else:
	for i in range(1, 4):
		if alist[0] + alist[i] == sumofa / 2:
			true = 1
	if true == 1:
		print('YES')
	else:
		print('NO')


(m, n, o, p) = map(int, input().split())
if m + n == o + p:
	print('YES')
elif m + o == n + p:
	print('YES')
elif m + p == n + o:
	print('YES')
elif m == n + o + p:
	print('YES')
elif n == m + o + p:
	print('YES')
elif o == n + m + p:
	print('YES')
elif p == n + o + m:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
if a == b + c + d:
	print('YES')
	exit()
if b == a + c + d:
	print('YES')
	exit()
if c == a + b + d:
	print('YES')
	exit()
if d == a + b + c:
	print('YES')
	exit()
if a + b == c + d:
	print('YES')
	exit()
if a + c == b + d:
	print('YES')
	exit()
if a + d == b + c:
	print('YES')
	exit()
print('NO')


try:
	l = list(map(int, input().split()))
	l.sort
	(a, b, c, d) = (l[0], l[1], l[2], l[3])
	if a + b == c + d:
		print('YES')
	elif a + c == b + d:
		print('YES')
	elif a + d == b + c:
		print('YES')
	elif a + b + c == d:
		print('YES')
	elif a + b + d == c:
		print('YES')
	elif a + d + c == b:
		print('YES')
	elif d + b + c == a:
		print('YES')
	else:
		print('NO')
except:
	pass


bags = list(map(int, input().split(' ')))
if bags[0] == bags[2] + bags[3] + bags[1] or bags[1] == bags[0] + bags[3] + bags[2] or bags[3] == bags[2] + bags[1] + bags[0] or (bags[2] == bags[0] + bags[3] + bags[1]):
	print('yes')
elif bags[0] + bags[1] == bags[2] + bags[3] or bags[0] + bags[2] == bags[1] + bags[3] or bags[0] + bags[3] == bags[2] + bags[1]:
	print('yes')
else:
	print('no')


L = [int(i) for i in input().split()]
answ_b = False
for i in range(1, 4):
	N1 = L[0] + L[i]
	if L[1] + L[2] + L[3] == L[0]:
		answ_b = True
	if i == 1:
		N2 = L[2] + L[3]
		if N1 + L[3] == L[2]:
			answ_b = True
		if N1 + L[2] == L[3]:
			answ_b = True
	if i == 2:
		N2 = L[1] + L[3]
		if N1 + L[1] == L[3]:
			answ_b = True
		if N1 + L[3] == L[1]:
			answ_b = True
	if i == 3:
		N2 = L[2] + L[1]
		if N1 + L[1] == L[2]:
			answ_b = True
		if N1 + L[2] == L[1]:
			answ_b = True
	if N1 == N2:
		answ_b = True
if answ_b:
	print('YES')
else:
	print('NO')


l = [int(i) for i in input().split()]
from collections import *
import itertools
f = 0
c1 = Counter(l)
for i in range(1, 4):
	for j in itertools.combinations(l, i):
		c2 = Counter(list(j))
		diff = c1 - c2
		if sum(list(j)) == sum(list(diff.elements())):
			f = 1
if f:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
k = max(a, b, c, d)
z = min(a, b, c, d)
if k + z == a + b + c + d - k - z:
	print('YES')
elif k == a + b + c + d - k:
	print('YES')
else:
	print('NO')


arr = sorted(list(map(int, input().split())))
print('YES' if sum(arr) % 2 == 0 and (sum(arr) // 2 == arr[0] + arr[-1] or arr[-1] == sum(arr[:-1])) else 'NO')


def check(ip):
	if sum(ip) - max(ip) < max(ip):
		return 0
	elif sum(ip) - max(ip) == max(ip):
		return 1
	elif (sum(ip) - 2 * max(ip)) % 2 != 0:
		return 0
	elif (sum(ip) - 2 * max(ip)) / 2 in ip:
		return 1
	else:
		return 0
	return 1
ip = list(input().split(' '))
ip = list(map(int, ip))
if check(ip) == 1:
	print('YES')
else:
	print('NO')


inp = input()
inp = inp.split(' ')
candies = []
for current_candy in inp:
	candies.append(int(current_candy))
c1 = candies[0]
c2 = candies[1]
c3 = candies[2]
c4 = candies[3]
if c1 + c2 == c3 + c4 or c1 + c3 == c2 + c4 or c1 + c4 == c2 + c3 or (c1 == c2 + c3 + c4) or (c2 == c1 + c3 + c4) or (c3 == c1 + c2 + c4) or (c4 == c1 + c2 + c3):
	print('YES')
else:
	print('NO')


mod = 1000000007
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())
(a, b, c, d) = sorted(f())
if a + b + c == d or b + c == a + d or a + b == c + d:
	print('YES')
else:
	print('NO')


t = list(input().split())
t = list(map(int, t))

def func():
	for i in range(4):
		if t[i] == sum(t[:i] + t[i + 1:]):
			return 'yes'
	for i in range(1, 4):
		a1 = t[0] + t[i]
		a2 = 0
		for j in range(1, 4):
			if j != i:
				a2 += t[j]
		if a1 == a2:
			return 'yes'
	return 'NO'
print(func())


import itertools
A = list(map(int, input().split()))
for l in [1, 2]:
	if sum(A) / 2 in [sum(t) for t in itertools.combinations(A, l)]:
		print('YES')
		break
else:
	print('NO')


l = list(map(int, input().split()))
s = sum(l)
t = 0
for i in range(4):
	if t == 1:
		break
	w = s - l[i]
	if w == l[i]:
		t += 1
	for j in range(4):
		if t == 1:
			break
		if i != j:
			r = l[i] + l[j]
			y = s - r
			if r == y and t == 0:
				t += 1
				break
if t == 0:
	print('NO')
else:
	print('YES')


bags = list(map(int, input().split()))
bags.append(0)
bags.sort()
if sum(bags) % 2 != 0:
	print('NO')
else:
	ans = sum(bags) // 2
	ans = ans - bags[len(bags) - 1]
	if ans in bags:
		print('YES')
	else:
		print('NO')


A = [int(i) for i in input().split()]
all_sum = sum(A)
for j in range(1, len(A)):
	a = A[0] + A[j]
	if all_sum - a == a:
		print('YES')
		break
	elif all_sum - A[0] == A[0] or all_sum - A[1] == A[1] or all_sum - A[2] == A[2] or (all_sum - A[3] == A[3]):
		print('YES')
		break
else:
	print('NO')


from __future__ import division, print_function
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from fractions import Fraction
import math

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

def si():
	return str(input())

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

def li():
	return list(mi())

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

def fsi():
	return str(stdin.readline())

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

def fli():
	return list(fmi())
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
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)
from collections import defaultdict

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y, z) = mi()
		if x not in d:
			d[x] = [[z, y]]
		else:
			d[x].append([z, y])
		if y not in d:
			d[y] = [[z, x]]
		else:
			d[y].append([z, x])
	return d

def gr2(n):
	d = defaultdict(list)
	for i in range(n):
		(x, y) = mi()
		d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s

def find_all(a_str, sub):
	start = 0
	while True:
		start = a_str.find(sub, start)
		if start == -1:
			return
		yield start
		start += len(sub)

def SieveOfEratosthenes(n, isPrime):
	isPrime[0] = isPrime[1] = False
	for i in range(2, n + 1):
		isPrime[i] = True
	p = 2
	while p * p <= n:
		if isPrime[p] == True:
			i = p * p
			while i <= n:
				isPrime[i] = False
				i += p
		p += 1
	return isPrime
l = li()
s = sum(l)
for i in range(4):
	if s - l[i] == l[i]:
		print('YES')
		exit()
if l[0] + l[1] == l[2] + l[3]:
	print('YES')
elif l[0] + l[2] == l[1] + l[3]:
	print('YES')
elif l[0] + l[3] == l[2] + l[1]:
	print('YES')
elif l[2] + l[1] == l[0] + l[3]:
	print('YES')
elif l[3] + l[1] == l[0] + l[2]:
	print('YES')
else:
	print('NO')


import sys
a = list(map(int, sys.stdin.readline().strip().split()))
print('YES' if (min(a) + max(a)) * 2 == sum(a) or max(a) * 2 == sum(a) else 'NO')


import math
import sys
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 list(map(int, input().split()))
a = invr()
b = [a[0] + a[1] == a[2] + a[3], a[0] + a[2] == a[1] + a[3], a[0] + a[3] == a[1] + a[2], a[0] + a[1] + a[2] == a[3], a[0] + a[1] + a[3] == a[2], a[0] + a[2] + a[3] == a[1], a[1] + a[2] + a[3] == a[0]]
if True in b:
	print('YES')
else:
	print('NO')


A = input().split()
suma = 0
for i in range(0, 4):
	suma += int(A[i])
for i in range(0, 16):
	cur = 0
	for j in range(0, 4):
		if i >> j & 1 == 1:
			cur += int(A[j])
	if cur == suma - cur:
		print('YES')
		exit(0)
print('NO')


tab = list(map(int, input().split()))
tab.sort()
(a, b, c, d) = tab
if a + d == b + c or d == b + c + a:
	print('YES')
else:
	print('NO')


(first, second, third, fourth) = map(int, input().split())
if first + second == third + fourth or first + third == second + fourth or first + fourth == second + third or (first + second + third == fourth) or (second + third + fourth == first) or (first + third + fourth == second) or (first + second + fourth == third):
	print('YES')
else:
	print('NO')


a = list(map(int, input().split(' ')))
nb1 = a[0]
nb2 = a[1]
nb3 = a[2]
nb4 = a[3]
if nb1 + nb2 == nb3 + nb4:
	print('YES')
	exit()
if nb1 + nb3 == nb2 + nb4:
	print('YES')
	exit()
if nb1 + nb4 == nb2 + nb3:
	print('YES')
	exit()
if nb1 == nb2 + nb3 + nb4:
	print('YES')
	exit()
if nb2 == nb1 + nb3 + nb4:
	print('YES')
	exit()
if nb3 == nb1 + nb2 + nb4:
	print('YES')
	exit()
if nb4 == nb1 + nb3 + nb2:
	print('YES')
	exit()
else:
	print('NO')


l1 = list(map(int, input().split()))
l1.sort(reverse=True)
if sum(l1[1:4]) == l1[0]:
	print('YES')
elif l1[3] + l1[0] == l1[1] + l1[2]:
	print('YES')
else:
	print('NO')


input_string = input()
userList = input_string.split()
results = list(map(int, userList))
if results[0] + results[2] == results[1] + results[3]:
	print('YES')
elif results[0] + results[3] == results[1] + results[2]:
	print('YES')
elif results[0] + results[1] == results[2] + results[3]:
	print('YES')
elif results[0] + results[1] + results[2] == results[3]:
	print('YES')
elif results[0] + results[1] + results[3] == results[2]:
	print('YES')
elif results[0] + results[3] + results[2] == results[1]:
	print('YES')
elif results[3] + results[1] + results[2] == results[0]:
	print('YES')
else:
	print('NO')


l = sorted(map(int, input().split(' ')))
print('YES' if sum(l[:3]) == l[3] or sum(l[::3]) == sum(l[1:3]) else 'NO')


(a, b, c, d) = list(map(int, input().split()))
j = [a, b, c, d]
j.sort()
flag = 0
if j[0] + j[1] == j[2] + j[3]:
	flag = 1
if j[0] + j[2] == j[1] + j[3]:
	flag = 1
if j[2] + j[1] == j[0] + j[3]:
	flag = 1
if j[0] + j[1] + j[2] == j[3]:
	flag = 1
if flag == 1:
	print('YES')
else:
	print('NO')


import sys
import math
a = list(map(int, input().split()))
a.sort()
flag = 0
if a[0] + a[1] + a[2] == a[3]:
	flag = 1
if a[0] + a[1] + a[3] == a[2]:
	flag = 1
if a[0] + a[2] + a[3] == a[1]:
	flag = 1
if a[1] + a[2] + a[3] == a[0]:
	flag = 1
if a[0] + a[1] == a[2] + a[3]:
	flag = 1
if a[0] + a[2] == a[1] + a[3]:
	flag = 1
if a[0] + a[3] == a[1] + a[2]:
	flag = 1
if a[1] + a[2] == a[0] + a[3]:
	flag = 1
if a[1] + a[3] == a[0] + a[2]:
	flag = 1
if a[2] + a[3] == a[1] + a[0]:
	flag = 1
if flag == 1:
	print('YES')
else:
	print('NO')
pass


(n1, n2, n3, n4) = map(int, input().split())
if n1 + n2 == n3 + n4:
	print('YES')
elif n1 + n3 == n2 + n4:
	print('YES')
elif n1 + n4 == n2 + n3:
	print('YES')
elif n1 == n2 + n3 + n4:
	print('YES')
elif n2 == n1 + n3 + n4:
	print('YES')
elif n3 == n1 + n2 + n4:
	print('YES')
elif n4 == n1 + n2 + n3:
	print('YES')
else:
	print('NO')


ints = map(int, input().strip().split())
ints = list(sorted(ints))
if ints[0] + ints[3] == ints[1] + ints[2] or sum(ints[0:3]) == ints[3]:
	print('YES')
else:
	print('NO')


a = input().split(' ')

def check_arr():
	for i in range(3):
		for j in range(3):
			_range = [0, 1, 2, 3]
			if i != j:
				_range.remove(i)
				_range.remove(j)
				if int(a[i]) + int(a[j]) == int(a[_range[0]]) + int(a[_range[1]]):
					print('YES')
					return
	for i in range(4):
		for j in range(4):
			for k in range(4):
				_range = [0, 1, 2, 3]
				if i != j and i != k and (j != k):
					_range.remove(i)
					_range.remove(j)
					_range.remove(k)
					if int(a[i]) + int(a[j]) + int(a[k]) == int(a[_range[0]]):
						print('YES')
						return
	print('NO')
check_arr()


(tot, ans) = (0, 0)

def backtrack(pos, sum):
	if pos == 4:
		global ans
		ans = ans or 2 * sum == tot
		return
	backtrack(pos + 1, sum)
	backtrack(pos + 1, sum + li[pos])
li = list(map(int, input().split()))
tot = sum(li)
backtrack(0, 0)
print(['NO', 'YES'][ans])


candies_in_bags = list(map(int, input().split()))
sorted_list = sorted(candies_in_bags)
b = sorted_list
if sorted_list[-1] == sorted_list[-3] + sorted_list[-2] + sorted_list[-4]:
	print('YES')
elif b[0] + b[2] == b[1] + b[3] or b[1] + b[2] == b[0] + b[3]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
totsum = sum(a)
flag = 0
for i in range(0, 4):
	for j in range(i + 1, 4):
		asum = a[i] + a[j]
		if asum == totsum - asum:
			flag = 1
			print('YES')
			break
	if flag == 1:
		break
if flag == 0:
	for val in a:
		if val == totsum - val:
			flag = 1
			print('YES')
			break
if flag == 0:
	print('NO')


def main():
	l = [int(a) for a in input().split()]
	t_sum = sum(l)
	n = len(l)
	if t_sum % 2 != 0:
		print('NO')
	else:
		half = t_sum / 2
		l = sorted(l)
		index = 0
		while index < n:
			c_sum = 0
			for i in range(index, n):
				c_sum += l[i]
				if c_sum == half:
					print('YES')
					return
				if c_sum > half:
					c_sum -= l[i]
			index += 1
		print('NO')
main()


def main():
	x = list(map(int, input().split()))
	total = sum(x)
	if total % 2 != 0:
		print('NO')
		exit(0)
	x.sort()
	total //= 2
	if x[0] + x[1] == total or x[0] + x[2] == total or x[0] + x[3] == total or (x[1] + x[2] == total) or (x[1] + x[0] + x[2] == total):
		print('YES')
		exit(0)
	else:
		print('NO')
main()


vs = sorted(map(int, input().split()))
if sum(vs[1:3]) == vs[0] + vs[3] or sum(vs[:3]) == vs[3]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
for i in range(1 << len(a)):
	f = 0
	s = 0
	cur = i
	for i in range(len(a)):
		if cur & 1:
			f += a[i]
		else:
			s += a[i]
		cur >>= 1
	if f == s:
		print('YES')
		exit()
print('NO')


myCandies = input()
myCandies = myCandies.split()
myNumberCaides = []
for i in myCandies:
	myNumberCaides.append(int(i))
mySortedCandies = []
for i in range(4):
	mySortedCandies.append(min(myNumberCaides))
	myNumberCaides.remove(min(myNumberCaides))
if mySortedCandies[3] == mySortedCandies[0] + mySortedCandies[1] + mySortedCandies[2]:
	print('Yes')
elif mySortedCandies[3] + mySortedCandies[0] == mySortedCandies[1] + mySortedCandies[2]:
	print('Yes')
else:
	print('No')


n = 4
v = [0] * n
s = 0
(a1, a2, a3, a4) = input().split()
(v[0], v[1], v[2], v[3]) = (int(a1), int(a2), int(a3), int(a4))
for i in range(n):
	s = s + v[i]
if s % 2 != 0:
	print('no')
else:
	max = 0
	i_special = -1
	for i in range(n):
		if v[i] > max:
			max = v[i]
			i_special = i
	s = 0
	for i in range(n):
		if i_special != i:
			s = s + v[i]
	if max == s:
		print('yes')
	elif v[0] + v[1] == v[2] + v[3] or v[0] + v[2] == v[1] + v[3] or v[0] + v[3] == v[1] + v[2]:
		print('yes')
	else:
		print('no')


bags = input().split(' ')
candies = []
total = 0
for bag in bags:
	candies.append(int(bag))
	total += int(bag)
flag = False
for candy in candies:
	if candy == total - candy:
		flag = True
		break
if candies[0] + candies[1] == candies[2] + candies[3] or candies[0] + candies[2] == candies[1] + candies[3] or candies[0] + candies[3] == candies[1] + candies[2]:
	flag = True or flag
else:
	flag = False or flag
if flag:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
a.sort()
if min(a[0], a[1]) + max(a[2], a[3]) == max(a[0], a[1]) + min(a[2], a[3]) or max(a[2], a[3]) - min(a[0], a[1]) == max(a[0], a[1] + min(a[2], a[3])):
	print('YES')
else:
	print('NO')


A = [*map(int, input().split())]
A.sort()
if A[0] + A[3] == A[1] + A[2]:
	print('YES')
elif A[0] + A[1] + A[2] == A[3]:
	print('YES')
else:
	print('NO')


import sys
import collections
input = sys.stdin.readline

def printnl(val):
	sys.stdout.write(str(val) + '\n')
(a1, a2, a3, a4) = map(int, input().split())
if a1 + a2 == a3 + a4 or a1 + a3 == a2 + a4 or a1 + a4 == a2 + a3 or (a1 == a2 + a3 + a4) or (a2 == a1 + a3 + a4) or (a3 == a1 + a2 + a4) or (a4 == a1 + a2 + a3):
	print('YES')
else:
	print('NO')


nums = list(map(int, input().strip().split()))
if sum(nums) % 2 == 1:
	print('NO')
else:
	valid = False
	for i in range(2 ** 4):
		total = 0
		binn = bin(i)[2:]
		while len(binn) < 4:
			binn = '0' + binn
		for j in range(4):
			if binn[j] == '1':
				total += nums[j]
		if total == sum(nums) // 2:
			valid = True
			break
	if valid:
		print('YES')
	else:
		print('NO')


def f():
	ls = [int(x) for x in input().split()]
	for i in range(7):
		ch = bin(i)[2:]
		ch = '0' * (3 - len(ch)) + ch
		res = ls[0]
		for num in range(3):
			res += (2 * (ch[num] == '1') - 1) * ls[num + 1]
		if res == 0:
			print('YES')
			return
	print('NO')
f()


import sys
a = [int(x) for x in input().split()]
if sum(a) % 2 != 0:
	print('NO')
	sys.exit()
l = sum(a) // 2
a.sort(reverse=True)
if a[0] > l:
	print('NO')
	sys.exit()
elif a[0] == l:
	if sum(a) - a[0] != l:
		print('NO')
		sys.exit()
	else:
		print('YES')
		sys.exit()
elif a[0] + a[3] == a[1] + a[2]:
	print('YES')
	sys.exit()
else:
	print('NO')


a = [int(x) for x in input().split(' ')]
total = sum(a)
flag = False
for i in range(0, 16):
	s = 0
	for j in range(len(a)):
		if i & 1 << j > 0:
			s += a[j]
	if total / 2 == s:
		flag = True
		break
if flag:
	print('YES')
else:
	print('NO')


s = input()
a = s.split(' ')
n = []
for i in range(4):
	n.append(int(a[i]))
x = 1
for i in range(3):
	if x != 0:
		x = 0
		for j in range(3):
			if n[j] > n[j + 1]:
				(n[j], n[j + 1]) = (n[j + 1], n[j])
				x += 1
	else:
		break
x = (n[0] + n[1] + n[2] + n[3]) / 2
if n[3] == x or n[3] + n[2] == x or n[3] + n[1] == x or (n[3] + n[0] == x):
	print('YES')
else:
	print('NO')


a = [int(i) for i in input().split()]
flag = 0
if a[0] == a[1] + a[2] + a[3]:
	flag = 1
elif a[1] == a[0] + a[2] + a[3]:
	flag = 1
elif a[2] == a[1] + a[0] + a[3]:
	flag = 1
elif a[3] == a[0] + a[2] + a[1]:
	flag = 1
elif a[0] + a[1] == a[2] + a[3]:
	flag = 1
elif a[0] + a[2] == a[1] + a[3]:
	flag = 1
elif a[0] + a[3] == a[2] + a[1]:
	flag = 1
if flag == 1:
	print('YES')
else:
	print('NO')


import math

def main():
	a = input().split()
	for i in range(0, len(a)):
		a[i] = int(a[i])
	a.sort()
	sum1 = int(a[0]) + int(a[3])
	sum2 = int(a[1]) + int(a[2])
	sum3 = int(a[0]) + int(a[2]) + int(a[1])
	if sum1 == sum2 or sum3 == int(a[3]):
		print('YES')
	else:
		print('NO')
main()


arr = [int(x) for x in input().split()]
for a in range(16):
	s = 0
	for i in range(4):
		if a & 2 ** i != 0:
			s += arr[i]
	if sum(arr) - s == s:
		print('YES')
		exit(0)
print('NO')


import itertools
a = list(map(int, input().split()))
b = list(itertools.combinations(a, 2))
ans = 'NO'
for i in range(len(b) // 2):
	if sum(b[i]) == sum(b[~i]):
		ans = 'YES'
if max(a) == sum(a) - max(a):
	ans = 'YES'
print(ans)


a = [*map(int, input().split())]
s = sum(a)
a.sort(reverse=True)
t = s // 2
for i in a:
	if t - i >= 0:
		t -= i
print(['yEs', 'nO'][s & 1 or t > 0])


lst = list(map(int, input().split()))
sum1 = 0
sum2 = 0
for i in range(4):
	if sum1 >= sum2:
		sum2 = sum2 + max(lst)
		lst.remove(max(lst))
	else:
		sum1 = sum1 + max(lst)
		lst.remove(max(lst))
if sum1 == sum2:
	print('YES')
else:
	print('NO')


n = list(map(int, input().split()))
k = sum(n)
if k % 2 == 0:
	if n[0] + n[1] == k / 2 or n[0] + n[2] == k / 2 or n[0] + n[2] == k / 2 or (n[0] + n[3] == k / 2) or (n[0] + n[1] + n[2] == n[3]) or (n[1] + n[2] + n[3] == k / 2) or (n[2] + n[3] + n[0] == n[1]) or (n[3] + n[0] + n[1] == n[2]):
		print('YES')
	else:
		print('NO')
else:
	print('NO')


NoOfCandies = input().split(' ')
CandiesList = [int(x) for x in NoOfCandies]

def Share(CandiesList):
	if CandiesList[0] + CandiesList[1] == CandiesList[2] + CandiesList[3]:
		return True
	elif CandiesList[0] + CandiesList[2] == CandiesList[1] + CandiesList[3]:
		return True
	elif CandiesList[1] + CandiesList[2] == CandiesList[0] + CandiesList[3]:
		return True
	elif CandiesList[0] + CandiesList[1] + CandiesList[2] == CandiesList[3]:
		return True
	elif CandiesList[0] + CandiesList[1] + CandiesList[3] == CandiesList[2]:
		return True
	elif CandiesList[0] + CandiesList[3] + CandiesList[2] == CandiesList[1]:
		return True
	elif CandiesList[3] + CandiesList[1] + CandiesList[2] == CandiesList[0]:
		return True
	else:
		return False
if Share(CandiesList):
	print('YES')
else:
	print('NO')


n = list(map(int, input().split()))
l = 0
if n[0] + n[1] == n[2] + n[3]:
	l = 1
if n[0] + n[2] == n[1] + n[3]:
	l = 1
if n[0] + n[3] == n[1] + n[2]:
	l = 1
if n[1] + n[2] == n[0] + n[3]:
	l = 1
if n[0] + n[3] + n[2] == n[1]:
	l = 1
if n[0] + n[1] + n[3] == n[2]:
	l = 1
if n[0] + n[1] + n[2] == n[3]:
	l = 1
if n[3] + n[1] + n[2] == n[0]:
	l = 1
if l == 0:
	print('NO')
if l == 1:
	print('YES')


import sys

def rint():
	return map(int, sys.stdin.readline().split())
a = list(rint())
a.sort()
s = sum(a)
if s % 2:
	print('NO')
	exit()
h = s // 2
for i in range(4):
	if a[i] == h:
		print('YES')
		exit()
ss = a[0]
for i in range(1, 4):
	if ss + a[i] == h:
		print('YES')
		exit()
print('NO')


def main(a):
	a.sort()
	return a[0] + a[3] == a[1] + a[2] or sum(a[:3]) == a[3]
a = list(map(int, input().rstrip().split()))
if main(a):
	print('YES')
else:
	print('NO')


def check(a, b, c, d):
	s = a + b + c + d
	if s % 2:
		return False
	s //= 2
	if a + b == s:
		return True
	if a + c == s:
		return True
	if a + d == s:
		return True
	if b + c == s:
		return True
	if b + d == s:
		return True
	if c + d == s:
		return True
	if a == s:
		return True
	if b == s:
		return True
	if c == s:
		return True
	if d == s:
		return True
	return False
(a, b, c, d) = map(int, input().split())
if check(a, b, c, d):
	print('YES')
else:
	print('NO')


var = input()
main_array = list(map(int, var.split()))
SUM = 0
FOUND = False
for i in range(0, 4):
	SUM = SUM + main_array[i]
for s in range(0, 4):
	array = list(map(int, var.split()))
	x = array.pop(s)
	for i in range(0, len(array)):
		if x == sum(array) and (not FOUND):
			print('YES')
			FOUND = True
		x = x + array.pop(0)
if not FOUND:
	print('NO')


c = input()
list1 = c.split(' ')
list0 = []
for i in list1:
	list0.append(int(i))
list0.sort()
list0.reverse()
f1 = int(list0[0])
f2 = 0
for i in range(1, len(list0)):
	if f1 > f2:
		f2 += int(list0[i])
	else:
		f1 += int(list0[i])
if f1 == f2:
	print('YES')
else:
	print('NO')


z = input
(a, b, l, n) = sorted(list(map(int, z().split())))
if a + n == b + l:
	print('YES')
elif a + b + l == n:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().strip().split())
e = 0
if a == b + c + d:
	e = 1
if b == a + c + d:
	e = 1
if c == a + b + d:
	e = 1
if d == a + b + c:
	e = 1
if a + b == c + d:
	e = 1
if a + c == b + d:
	e = 1
if a + d == b + c:
	e = 1
if e == 1:
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = list(map(int, input().split()))
if a1 + a2 == a3 + a4 or a1 + a3 == a2 + a4 or a1 + a4 == a2 + a3 or (max(a1, a2, a3, a4) == (a1 + a2 + a3 + a4) / 2):
	print('YES')
else:
	print('NO')


l = list(map(int, input().split()))
a = min(l)
b = max(l)
l.remove(a)
l.remove(b)
c = l[0]
d = l[1]
if a + b == c + d or a + c + d == b:
	print('YES')
else:
	print('NO')


(a, b, c, d) = sorted(map(int, input().split()))
print(('YES', 'NO')[a - c + d != b != d - a - c])


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')
(a, b, c, d) = map(int, input().split())
if (a + b + c + d) % 2 == 1:
	print('NO')
else:
	vals = [a, b, c, d]
	vals.sort()
	if vals[0] + vals[-1] == vals[1] + vals[2]:
		print('YES')
	elif vals[-1] == vals[0] + vals[1] + vals[2]:
		print('YES')
	else:
		print('NO')


candies = list(map(int, input().split()))
if sum(candies) % 2 == 1:
	print('NO')
else:
	target = sum(candies) // 2
	res = [0] * (target + 1)
	for i in range(len(candies)):
		for j in reversed(range(candies[i], target + 1)):
			res[j] = max(res[j], res[j - candies[i]] + candies[i])
	if res[-1] == target:
		print('YES')
	else:
		print('NO')


def solve(xs):
	s = sum(xs)
	if s % 2:
		return 'NO'
	h = s // 2
	for x in xs:
		if h == x:
			return 'YES'
	if xs[0] + xs[1] == h or xs[0] + xs[2] == h or xs[0] + xs[3] == h or (xs[1] + xs[2] == h) or (xs[1] + xs[3] == h) or (xs[2] + xs[3] == h):
		return 'YES'
	return 'NO'
xs = list(map(int, input().split()))
print(solve(xs))


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

def solve(a):
	a = sorted(a)
	sum = 0
	for i in a:
		sum += i
	if sum % 2 != 0 and a[3] > sum / 2:
		print('NO')
		return
	elif a[3] == sum / 2:
		print('YES')
		return
	else:
		for i in range(3):
			if a[0] + a[i + 1] == sum / 2:
				print('YES')
				return
	print('NO')
solve(array)


class cinn:

	def __init__(self):
		self.x = []

	def cin(self, t=int):
		if len(self.x) == 0:
			a = input()
			self.x = a.split()
			self.x.reverse()
		return self.get(t)

	def get(self, t):
		return t(self.x.pop())

	def clist(self, n, t=int):
		l = [0] * n
		for i in range(n):
			l[i] = self.cin(t)
		return l

	def clist2(self, n, t1=int, t2=int, t3=int, tn=2):
		l = [0] * n
		for i in range(n):
			if tn == 2:
				a1 = self.cin(t1)
				a2 = self.cin(t2)
				l[i] = (a1, a2)
			elif tn == 3:
				a1 = self.cin(t1)
				a2 = self.cin(t2)
				a3 = self.cin(t3)
				l[i] = (a1, a2, a3)
		return l

	def clist3(self, n, t1=int, t2=int, t3=int):
		return self.clist2(self, n, t1, t2, t3, 3)

	def cout(self, i, ans=''):
		if ans == '':
			print('Case #' + str(i + 1) + ':', end=' ')
		else:
			print('Case #' + str(i + 1) + ':', ans)

	def printf(self, thing):
		print(thing, end='')

	def countlist(self, l, s=0, e=None):
		if e == None:
			e = len(l)
		dic = {}
		for el in range(s, e):
			if l[el] not in dic:
				dic[l[el]] = 1
			else:
				dic[l[el]] += 1
		return dic

	def talk(self, x):
		print(x, flush=True)

	def dp1(self, k):
		L = [-1] * k
		return L

	def dp2(self, k, kk):
		L = [-1] * k
		for i in range(k):
			L[i] = [-1] * kk
		return L

	def isprime(self, n):
		if n == 1 or n == 0:
			return False
		for i in range(2, int(n ** 0.5 + 1)):
			if n % i == 0:
				return False
		return True

	def factors(self, n):
		from functools import reduce
		return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

	def nthprime(self, n):
		i = 0
		s = 2
		L = []
		while i < n:
			while not self.isprime(s):
				s += 1
			L.append(s)
			s += 1
			i += 1
		return L

	def matrixin(self, m, n, t=int):
		L = []
		for i in range(m):
			p = self.clist(n, t)
			L.append(p)
		return L

	def seive(self, k):
		n = k + 1
		L = [True] * n
		L[1] = False
		L[0] = False
		for i in range(2, n):
			if L[i] == True:
				for j in range(2 * i, n, i):
					L[j] = False
		return L

	def seiven(self, n, L):
		i = 0
		for j in range(len(L)):
			if L[j] == True:
				i += 1
			if i == n:
				return j

	def matrixin2(self, m, t=int):
		L = []
		for i in range(m):
			iny = self.cin(str)
			lsmall = []
			for el in iny:
				lsmall.append(t(el))
			L.append(lsmall)
		return L

def nor(a, b):
	return not (a and b)

def xor(a, b):
	return nor(nor(nor(a, a), b), nor(nor(b, b), a))
c = cinn()
a = c.cin()
b = c.cin()
e = c.cin()
f = c.cin()
L = [a, b, e, f]
L.sort()
if L[0] + L[3] == L[1] + L[2] or L[0] + L[1] + L[2] == L[3]:
	print('YES')
else:
	print('NO')


a = [int(x) for x in input().split(' ')]
for i in range(len(a)):
	sum = a[i]
	sub_sum = 0
	for j in range(len(a)):
		if i == j:
			continue
		sub_sum += a[j]
	if sub_sum == sum:
		print('YES')
		exit()
import itertools
for comb in list(itertools.combinations([0, 1, 2, 3], 2)):
	sum = a[comb[0]] + a[comb[1]]
	sub_sum = 0
	for j in range(len(a)):
		if comb[0] == j or comb[1] == j:
			continue
		sub_sum += a[j]
	if sub_sum == sum:
		print('YES')
		exit()
		break
print('NO')


arr = [int(a) for a in input().split()]
arr.sort()
a = arr[0] + arr[3]
b = arr[1] + arr[2]
c = arr[0] + arr[1] + arr[2]
d = arr[1] + arr[3]
if arr[0] + arr[3] == arr[1] + arr[2] or arr[3] == arr[0] + arr[1] + arr[2]:
	print('YES')
else:
	print('NO')


data = sorted(map(int, input().split()))
s = sum(data)
if s % 2 != 0:
	print('NO')
else:
	s /= 2
	s -= data[-1]
	if s == 0:
		print('YES')
	elif data[0] == s or data[1] == s:
		print('YES')
	else:
		print('NO')


import sys
for line in sys.stdin:
	numeros = line.split()
	n1 = int(numeros[0])
	n2 = int(numeros[1])
	n3 = int(numeros[2])
	n4 = int(numeros[3])
	s1 = n1 + n2
	s2 = n1 + n3
	s3 = n1 + n4
	st = n1 + n2 + n3 + n4
	if st % 2 == 1:
		print('NO')
	elif st / 2 == s1:
		print('YES')
	elif st / 2 == s2:
		print('YES')
	elif st / 2 == s3:
		print('YES')
	elif st / 2 == n1:
		print('YES')
	elif st / 2 == n2:
		print('YES')
	elif st / 2 == n3:
		print('YES')
	elif st / 2 == n4:
		print('YES')
	else:
		print('NO')


def candles(arr):
	if arr[0] + arr[1] == arr[2] + arr[3]:
		return 'yes'
	elif arr[0] + arr[2] == arr[1] + arr[3]:
		return 'yes'
	elif arr[0] + arr[3] == arr[1] + arr[2]:
		return 'yes'
	elif arr[0] + arr[1] + arr[2] == arr[3]:
		return 'yes'
	elif arr[0] + arr[1] + arr[3] == arr[2]:
		return 'yes'
	elif arr[0] + arr[3] + arr[2] == arr[1]:
		return 'yes'
	elif arr[3] + arr[1] + arr[2] == arr[0]:
		return 'yes'
	return 'no'
arr = list(map(int, input().strip().split(' ')))
print(candles(arr))


L = list(map(int, input().split()))
pos = 0
for i in range(16):
	c = bin(i)[2:].zfill(4)
	a = 0
	b = 0
	for (j, k) in enumerate(c):
		if k == '1':
			a += L[j]
		else:
			b += L[j]
	if a == b:
		pos = 1
		break
if pos:
	print('YES')
else:
	print('NO')


lst = list(map(int, input().split()))
sm = sum(lst)
ans = 'NO'
for i in range(1, 16):
	a = bin(i)[2:]
	a = (4 - len(a)) * '0' + a
	s = 0
	for j in range(4):
		if a[j] == '1':
			s += lst[j]
	if s == sm / 2:
		ans = 'YES'
		break
print(ans)


(a, b, c, d) = [int(x) for x in input().split()]
result = 0
v = [a, b, c, d]
if a + b == c + d or a + c == b + d or a + d == b + c:
	result = 1
else:
	result = 0
	for i in range(0, 4):
		sum = 0
		for j in range(0, 4):
			if j == i:
				continue
			else:
				sum += v[j]
		if v[i] == sum:
			result = 1
if result == 1:
	print('YES')
else:
	print('NO')


from itertools import combinations
arr = list(map(int, input().split()))
s = sum(arr)
for i in range(1, 4):
	x = list(combinations([0, 1, 2, 3], i))
	for j in x:
		count = 0
		for k in j:
			count += arr[k]
		if count == s - count:
			print('YES')
			exit()
print('NO')


import math
import heapq
from bisect import bisect_right, bisect_left
from collections import defaultdict, Counter
import itertools
import sys
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
INF = float('inf')

def main():
	(a, b, c, d) = map(int, input().split())
	if a + b == c + d or a + c == b + d or a + d == b + c:
		print('YES')
	elif a + b + c == d or a + b + d == c or a + c + d == b or (b + c + d == a):
		print('YES')
	else:
		print('NO')
main()


a = list(map(int, input().split()))
a.sort()
flag = False
if len(a) != 4:
	print('NO')
else:
	if a[0] + a[1] == a[2] + a[3]:
		flag = True
	if a[0] + a[2] == a[1] + a[3]:
		flag = True
	if a[0] + a[3] == a[1] + a[2]:
		flag = True
	if a[3] == a[0] + a[1] + a[2]:
		flag = True
if flag:
	print('YES')
else:
	print('NO')


def isSubsetSum(arr, n, sum):
	if sum == 0:
		return True
	if n == 0 and sum != 0:
		return False
	if arr[n - 1] > sum:
		return isSubsetSum(arr, n - 1, sum)
	return isSubsetSum(arr, n - 1, sum) or isSubsetSum(arr, n - 1, sum - arr[n - 1])

def findPartion(arr, n):
	sum = 0
	for i in range(0, n):
		sum += arr[i]
	if sum % 2 != 0:
		return False
	return isSubsetSum(arr, n, sum // 2)
arr = list(map(int, input().split()))
n = len(arr)
if findPartion(arr, n) == True:
	print('YES')
else:
	print('NO')


x = input()
y = x.split()
z = [int(d) for d in y]
if z[0] + z[1] == z[2] + z[3]:
	print('YES')
elif z[0] + z[2] == z[1] + z[3]:
	print('YES')
elif z[0] + z[3] == z[1] + z[2]:
	print('YES')
elif z[2] + z[0] + z[1] == z[3]:
	print('YES')
elif z[0] + z[1] + z[3] == z[2]:
	print('YES')
elif z[0] + z[2] + z[3] == z[1]:
	print('YES')
elif z[1] + z[2] + z[3] == z[0]:
	print('YES')
else:
	print('NO')


a = list(map(int, input().strip().split()))[:4]
if a[0] + a[1] == a[2] + a[3]:
	print('YES')
elif a[0] + a[2] == a[1] + a[3]:
	print('YES')
elif a[0] + a[3] == a[1] + a[2]:
	print('YES')
elif a[0] == a[3] + a[1] + a[2]:
	print('YES')
elif a[3] == a[0] + a[1] + a[2]:
	print('YES')
elif a[1] == a[0] + a[2] + a[3]:
	print('YES')
elif a[2] == a[1] + a[3] + a[0]:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
flag = 0
sum = a + b + c + d
if a == sum / 2:
	flag = 1
if b == sum / 2:
	flag = 1
if c == sum / 2:
	flag = 1
if d == sum / 2:
	flag = 1
if a + b == sum / 2:
	flag = 1
if a + c == sum / 2:
	flag = 1
if a + d == sum / 2:
	flag = 1
if flag == 1:
	print('YES')
else:
	print('NO')


abcd = sorted([int(x) for x in input().split()], reverse=True)
need = 0
for x in abcd:
	if need <= 0:
		need += x
	else:
		need -= x
print(['No', 'Yes'][need == 0])


import itertools
bags = list(map(int, input().split()))
twos = itertools.combinations(bags, 2)
threes = itertools.combinations(bags, 3)
comb = list(twos) + list(threes)
bsum = sum(bags)
s = 0
for c in comb:
	if bsum - sum(c) == sum(c):
		s = 1
		break
if s:
	print('YES')
else:
	print('NO')


list1 = input()
a = list1.split(' ')
if int(a[0]) + int(a[1]) == int(a[2]) + int(a[3]) or int(a[0]) + int(a[2]) == int(a[1]) + int(a[3]) or int(a[0]) + int(a[3]) == int(a[1]) + int(a[2]) or (int(a[0]) + int(a[1]) + int(a[2]) == int(a[3])) or (int(a[0]) + int(a[2]) + int(a[3]) == int(a[1])) or (int(a[1]) + int(a[2]) + int(a[3]) == int(a[0])) or (int(a[0]) + int(a[1]) + int(a[3]) == int(a[2])):
	print('YES')
else:
	print('NO')


def main():
	nums = list(map(int, input().split()))
	nums.sort()
	if nums[0] + nums[-1] == nums[1] + nums[2]:
		print('YES')
	elif sum(nums[:-1]) == nums[-1]:
		print('YES')
	else:
		print('NO')
main()


l = list(map(int, input().split()))
l.sort()
sum = 0
for i in range(len(l)):
	sum = sum + l[i]
if sum / 2 == l[0] + l[-1] or sum / 2 == l[0] + l[1] + l[2]:
	print('YES')
else:
	print('NO')


n = input()
n = [int(x) for x in n.split()]
n = sorted(n)
a = n[-1]
b = 0
n.pop(-1)
n = n[::-1]
for x in n:
	if b < a:
		b += x
	else:
		a += x
if a == b:
	print('YES')
else:
	print('NO')


z = list(map(int, input().split()))
x = sum(z) / 2
status = True
for i in z:
	if x in z:
		if sum(z) - x:
			status = True
		else:
			status = False
	elif x - i in z:
		status = True
	else:
		status = False
		break
if status:
	print('YES')
else:
	print('NO')


x = input()
xx = x.split()
for i in range(0, 4):
	xx[i] = int(xx[i])
xx.sort()
if xx[0] + xx[3] == xx[2] + xx[1] or xx[0] + xx[1] + xx[2] == xx[3]:
	print('YES')
else:
	print('NO')


a = [int(s) for s in input().split()]
if a[0] + a[2] == a[1] + a[3]:
	print('YES')
elif a[0] + a[1] == a[2] + a[3]:
	print('YES')
elif a[0] + a[3] == a[1] + a[2]:
	print('YES')
elif a[0] == a[1] + a[2] + a[3]:
	print('YES')
elif a[1] == a[0] + a[2] + a[3]:
	print('YES')
elif a[2] == a[0] + a[1] + a[3]:
	print('YES')
elif a[3] == a[0] + a[1] + a[2]:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
arr = [int(x) for x in stdin.readline().split()]
arr = sorted(arr, reverse=True)
sumi = sum(arr)
if sumi % 2 != 0:
	stdout.write('NO')
	exit()
sumi = sum(arr) / 2
found = 0
if arr[0] > sumi:
	stdout.write('NO')
	exit()
elif arr[0] == sumi:
	stdout.write('YES')
	exit()
else:
	rem = sumi - arr[0]
	if rem in arr:
		stdout.write('YES')
	else:
		stdout.write('NO')


(a, b, c, d) = map(int, input().split())
test = 'NO'
if a + b == c + d:
	test = 'YES'
elif a + c == b + d:
	test = 'YES'
elif a + d == b + c:
	test = 'YES'
elif a + b + c == d:
	test = 'YES'
elif a + b + d == c:
	test = 'YES'
elif b + c + d == a:
	test = 'YES'
elif a + c + d == b:
	test = 'YES'
print(test)


a = list(map(int, input().split()))
a.sort()
r = sum(a[:3])
g = r == a[3]
d = [a[0] + a[1], a[2] + a[3]]
d1 = [a[0] + a[2], a[1] + a[3]]
d2 = [a[0] + a[3], a[2] + a[1]]
b = d[0] == d[1] or g
c = d1[0] == d1[1] or g
d = d2[0] == d2[1] or g
if b or c or d:
	print('YES')
else:
	print('NO')


c = input()
M = [int(x) for x in c.split()]
suma = M[0] + M[1] + M[2] + M[3]
i = 0
j = 1
res = 'NO'
while i < 4:
	if suma - M[i] == M[i]:
		res = 'YES'
		break
	i += 1
i = 0
while i < 4:
	while j < 4:
		if suma - M[i] - M[j] == M[i] + M[j] and i != j:
			res = 'YES'
		break
		j += 1
	i += 1
	j = 0
print(res)