44 58 90 53
 20 14 37 71
 4 2 4 2
 1 2 5 5
 1 2 8 9
 99 100 3 98
 92 69 83 97
 3 1 1 1
 18 88 18 18
 1 1 1 1
 69 7 44 30
 90 30 30 30
 1 2 3 5
 1 1 3 1
 6 3 6 6
 26 52 7 19
 6 4 8 6
 10 2 3 5
 34 11 84 39
 1 1 14 12
 3 2 1 1
 2 4 6 6
 1 1 2 1
 72 96 2 26
 97 95 91 27
 1 2 1 3
 1 1 2 3
 1 1 1 2
 1 1 10 20
 2 3 2 5
 1 2 10 7
 2 1 28 9
 4 4 4 8
 2 2 4 6
 72 52 62 62
 76 97 99 74
 100 100 99 100
 30 74 41 63
 5 10 1 6
 18 17 17 20
 2 4 1 1
 7 3 6 3
 1 1 4 5
 2 2 6 2
 1 2 6 3
 3 5 1 3
 70 100 10 86
 48 14 3 31
 2 6 3 2
 2 3 10 10
 4 4 12 4
 14 9 10 6
 100 98 99 97
 5 7 1 3
 1 1 4 2
 14 10 18 24
 1 100 100 1
 1 2 4 5
 1 2 3 4
 1 2 3 3
 4 4 4 5
 66 68 16 82
 1 2 3 2
 2 3 3 4
 100 100 100 100
 1 2 2 7
 3 14 36 53
 1 1 3 4

NO
 YES
 YES
 NO
 YES
 NO
 NO
 YES
 NO
 YES
 NO
 YES
 NO
 YES
 NO
 YES
 YES
 YES
 YES
 YES
 NO
 NO
 NO
 YES
 NO
 NO
 NO
 NO
 NO
 NO
 YES
 NO
 NO
 NO
 YES
 YES
 NO
 YES
 YES
 NO
 YES
 NO
 NO
 YES
 YES
 YES
 NO
 YES
 NO
 NO
 YES
 NO
 YES
 YES
 YES
 NO
 YES
 YES
 YES
 NO
 NO
 NO
 YES
 YES
 YES
 NO
 YES
 NO

import java.util.Scanner;

public final class main {

  public static boolean canPartition(int[] num) {
    int sum = 0;
    for (int i = 0; i < num.length; i++)
      sum += num[i];

    // if 'sum' is a an odd number, we can't have two subsets with equal sum
    if (sum % 2 != 0)
      return false;

    Boolean[][] dp = new Boolean[num.length][sum / 2 + 1];
    return canPartitionRecursive(dp, num, sum / 2, 0);
  }

  private static boolean canPartitionRecursive(Boolean[][] dp, int[] num, int sum, int currentIndex) {
    // base check
    if (sum == 0)
      return true;

    if (num.length == 0 || currentIndex >= num.length)
      return false;

    // if we have not already processed a similar problem
    if (dp[currentIndex][sum] == null) {
      // recursive call after choosing the number at the currentIndex
      // if the number at currentIndex exceeds the sum, we shouldn't process this
      if (num[currentIndex] <= sum) {
        if (canPartitionRecursive(dp, num, sum - num[currentIndex], currentIndex + 1)) {
          dp[currentIndex][sum] = true;
          return true;
        }
      }

      // recursive call after excluding the number at the currentIndex
      dp[currentIndex][sum] = canPartitionRecursive(dp, num, sum, currentIndex + 1);
    }

    return dp[currentIndex][sum];
  }

  public static void main(String[] args) {
	 
    int[] num =new int[4];
    Scanner s  = new Scanner(System.in);
    for(int i=0;i<4;i++)
    	num[i]=s.nextInt();
    if(canPartition(num))
    System.out.println("YES");
    else
    	System.out.println("NO");
    
  }
}