Language: C++

#include <algorithm>//min/max/sort(rand-access it)/merge
#include <array>
#include <bitset>
// #include <chrono>//std::chrono::/system_clock/steady_clock/high_resolution_clock/duration
#include <climits>//INT_MAX/INT_MIN/ULLONG_MAX
#include <cmath>//fmin/fmax/fabs/sin(h)/cos(h)/tan(h)/exp/log/pow/sqrt/cbrt/ceil/floor/round/trunc
#include <cstdlib>//abs/atof/atoi/atol/atoll/strtod/strtof/..., srand/rand, calloc/malloc, exit, qsort
// #include <fstream>//ifstream/ofstream
#include <iomanip>//setfill/setw/setprecision/fixed/scientific
#include <iostream>//cin/cout/wcin/wcout/left/right/internal/dec/hex/oct/fixed/scientific
#include <iterator>
#include <limits>//numeric_limits<type>::max/min/lowest/epsilon/infinity/quiet_NaN/signaling_NaN
#include <list>
#include <queue>
#include <string>//stoi/stol/stoul/stoll/stoull/stof/stod/stold/to_string/getline
#include <tuple>
#include <utility>//pair
#include <valarray>
#include <vector>

#define PRIME_SHORT 10007
#define PRIME 1000000007

using namespace std;

typedef unsigned int ui;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, int> plli;
typedef pair<ull, int> puli;
typedef pair<double, int> pdi;
typedef pair<ll, ll> pllll;
typedef pair<ull, ull> pulul;
typedef pair<double, double> pdd;
typedef tuple<int, int, int> ti3;
typedef tuple<int, int, int, int> ti4;

const bool debug = false;

template<typename T> void rar(size_t n, T* a);
template<typename T> void rar2(size_t n, size_t m, T** a);

template<typename T> T ipow(T base, T exp);

inline size_t left(size_t current, bool swap);
inline size_t right(size_t current, bool swap);

template<typename T> inline T griddist(T x, T y, T s, T t);
template<typename T> inline T griddist(pair<T, T> one, pair<T, T> two);
template<typename T> inline T griddist(tuple<T, T> one, tuple<T, T> two);

template<typename T> inline T sqeucldist(T x, T y, T s, T t);
template<typename T> inline T sqeucldist(pair<T, T> one, pair<T, T> two);
template<typename T> inline T sqeucldist(tuple<T, T> one, tuple<T, T> two);

inline ull modadd(ull a, ull b, int mod);
inline ull modmult(ull a, ull b, int mod);

int main(void) {
    int a, b, c;
    cin >> a >> b >> c;

    if (a == b + c || b == a + c || c == a + b || a == b && b == c){
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }

    return 0;
}

template<typename T>
void rar(size_t n, T* a) {
    for (size_t i = 0; i < n; ++i) cin >> a[i];
    return;
}

template<typename T>
void rar2(size_t n, int m, T** a) {
    for (int i = 0; i < n; ++i) {
        a[i] = new int[m];
        for (int j = 0; j < m; ++j) cin >> a[i][j];
    } return;
}

template<typename T>
T ipow(T base, T exp) {
    T result = 1;
    while (exp) {
        if (exp & 1) result *= base;
        exp >>= 1;
        base *= base;
    }
    return result;
}

inline size_t left(size_t current, bool swap) {
    return swap ? right(current) : 2*current+1;
}
inline size_t right(size_t current, bool swap) {
    return swap ? left(current) : 2*(current+1);
}

template<typename T>
inline T griddist(T x, T y, T s, T t) {
    return abs(x-s) + abs(y-t);
}
template<typename T>
inline T griddist(pair<T, T> one, pair<T, T> two) {
    return abs(one.first - two.first) + abs(one.second - two.second);
}
template<typename T>
inline T griddist(tuple<T, T> one, tuple<T, T> two) {
    return abs(get<0>(one) - get<0>(two)) + abs(get<1>(one) - get<1>(two));
}

template<typename T>
inline T sqeucldist(T x, T y, T s, T t) {
    T a = x-s;
    T b = y-t;
    return a*a+b*b;
}
template<typename T>
inline T sqeucldist(pair<T, T> one, pair<T, T> two) {
    T a = one.first - two.first;
    T b = one.second - two.second;
    return a*a+b*b;
}
template<typename T>
inline T sqeucldist(tuple<T, T> one, tuple<T, T> two) {
    T a = get<0>(one) - get<0>(two);
    T b = get<1>(one) - get<1>(two);
    return a*a+b*b;
}

inline ull modadd(ull a, ull b, int mod) {
    return ((a%mod) + (b%mod))%mod;
}
inline ull modmult(ull a, ull b, int mod) {
    return ((a%mod)*(b%mod))%mod;
}


Compiler output:
a.cc: In function 'size_t left(size_t, bool)':
a.cc:99:24: error: no matching function for call to 'right(size_t&)'
   99 |     return swap ? right(current) : 2*current+1;
      |                   ~~~~~^~~~~~~~~
In file included from /usr/include/c++/14/iomanip:42,
                 from a.cc:9:
/usr/include/c++/14/bits/ios_base.h:1070:3: note: candidate: 'std::ios_base& std::right(ios_base&)'
 1070 |   right(ios_base& __base)
      |   ^~~~~
/usr/include/c++/14/bits/ios_base.h:1070:19: note:   no known conversion for argument 1 from 'size_t' {aka 'long unsigned int'} to 'std::ios_base&'
 1070 |   right(ios_base& __base)
      |         ~~~~~~~~~~^~~~~~
a.cc:47:15: note: candidate: 'size_t right(size_t, bool)'
   47 | inline size_t right(size_t current, bool swap);
      |               ^~~~~
a.cc:47:15: note:   candidate expects 2 arguments, 1 provided
a.cc: In function 'size_t right(size_t, bool)':
a.cc:102:23: error: no matching function for call to 'left(size_t&)'
  102 |     return swap ? left(current) : 2*(current+1);
      |                   ~~~~^~~~~~~~~
/usr/include/c++/14/bits/ios_base.h:1062:3: note: candidate: 'std::ios_base& std::left(ios_base&)'
 1062 |   left(ios_base& __base)
      |   ^~~~
/usr/include/c++/14/bits/ios_base.h:1062:18: note:   no known conversion for argument 1 from 'size_t' {aka 'long unsigned int'} to 'std::ios_base&'
 1062 |   left(ios_base& __base)
      |        ~~~~~~~~~~^~~~~~
a.cc:98:15: note: candidate: 'size_t left(size_t, bool)'
   98 | inline size_t left(size_t current, bool swap) {
      |               ^~~~
a.cc:98:15: note:   candidate expects 2 arguments, 1 provided