#include <algorithm>
#include <array>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <optional>
#include <queue>
#include <set>
#include <string>
#include <string_view>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;

int64_t read_int() {
    int64_t ret = 0, sgn = 1;
    int ch = getchar_unlocked();
    while (isspace(ch)) { ch = getchar_unlocked(); }
    if (ch == '-') { sgn = -1; ch = getchar_unlocked(); }
    for (; isdigit(ch); ch = getchar_unlocked())
        ret = (ret * 10) + (ch - '0');
    ungetc(ch, stdin);
    return sgn * ret;
}

#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define ALL(c) (c).begin(), (c).end()

template <typename T> inline void assign_min(T& x, const T& value) noexcept { x = min(x, value); }
template <typename T> inline void assign_max(T& x, const T& value) noexcept { x = max(x, value); }

constexpr char LF = '\n';

//-------------------------------------------------------------------------------------------------

int main() {
    vector<int64_t> A(4);
    REP(i, 4) { A[i] = read_int(); }
    int all_sum = A[0]+A[1]+A[2]+A[3];

    bool ok = false;
    REP(a, 2) REP(b, 2) REP(c, 2) REP(d, 2) {
        if (a+b+c+d > 0) {
            int64_t sum = 0;
            if(a > 0) sum += A[0];
            if(b > 0) sum += A[1];
            if(c > 0) sum += A[2];
            if(d > 0) sum += A[3];
            if(sum == all_sum-sum) {
                ok = true;
            }
        }
    }
    if (ok) cout << "Yes\n";
    else cout << "No\n";
}

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int MAXN = 25;
int G[MAXN][MAXN];
int n, m;
int dp[(1 << 18) + 10];
int solve(int x) {
    if (dp[x]) return dp[x];
    bool flag = 1;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (((x >> i) & 1) && ((x >> j) & 1)) {
                if (!G[i + 1][j + 1]) {
                    flag = 0;
                    break;
                }
            }
        }
    }
    if (flag) {
        return dp[x] = 1;
    }
    int res = MAXN;
    for (int s = x; s > 0; s = (s - 1) & x) {
        if (s == 0) break;
        if (s == x) continue;

        res = min(res, solve(s) + solve(x ^ s));
    }
    return dp[x] = res;
}
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        G[u][v] = G[v][u] = 1;
    }
//    if (m == 0) {
//        printf("%d\n", n);
//        return 0;
//    }
    int ans = solve((1 << n) - 1);
    printf("%d\n", ans);
    return 0;
}