// Dmitry _kun_ Sayutin (2019)

#include <bits/stdc++.h>

using std::cin;
using std::cout;
using std::cerr;

using std::vector;
using std::map;
using std::array;
using std::set;
using std::string;

using std::pair;
using std::make_pair;

using std::tuple;
using std::make_tuple;
using std::get;

using std::min;
using std::abs;
using std::max;
using std::swap;

using std::unique;
using std::sort;
using std::generate;
using std::reverse;
using std::min_element;
using std::max_element;

#ifdef LOCAL
#define LASSERT(X) assert(X)
#else
#define LASSERT(X) {}
#endif

template <typename T>
T input() {
    T res;
    cin >> res;
    LASSERT(cin);
    return res;
}

template <typename IT>
void input_seq(IT b, IT e) {
    std::generate(b, e, input<typename std::remove_reference<decltype(*b)>::type>);
}

#define SZ(vec)         int((vec).size())
#define ALL(data)       data.begin(),data.end()
#define RALL(data)      data.rbegin(),data.rend()
#define TYPEMAX(type)   std::numeric_limits<type>::max()
#define TYPEMIN(type)   std::numeric_limits<type>::min()

void kek(vector<vector<int>>& graph, set<pair<int, int>>& ban, vector<pair<int, int>>& order, int v) {
    while (not graph[v].empty()) {
        int u = graph[v].back();

        if (ban.count(make_pair(v, u)) or ban.count(make_pair(u, v))) {
            graph[v].pop_back();
            continue;
        }

        ban.insert(make_pair(v, u));
        graph[v].pop_back();

        kek(graph, ban, order, u);
        order.emplace_back(u, v);
    }
}

int main() {
    std::iostream::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    // code here
    int n = input<int>();
    int m = input<int>();
    
    vector<int> deg(n);

    vector<vector<int>> graph(n);
    
    for (int i = 0; i != m; ++i) {
        int v = input<int>() - 1;
        int u = input<int>() - 1;

        deg[v]++;
        deg[u]++;

        graph[v].push_back(u);
        graph[u].push_back(v);
    }

    bool kek = false;
    for (int d: deg)
        if (d % 2)
            kek = true;

    if (kek) {
        cout << "No\n";
    } else if (*std::max_element(ALL(deg)) >= 6)
        cout << "Yes\n";
    else {
        vector<pair<int,int>> order;

        set<pair<int, int>> ban;
        
        ::kek(graph, ban, order, 0);

        vector<int> lst;
        for (int i = 0; i != SZ(order); ++i)
            if (deg[order[i].first] == 4)
                lst.push_back(order[i].first);

        vector<char> mark(n, false);
        bool has_complete = false;
        for (int i = 0; i != SZ(lst); ++i)
            if (not mark[lst[i]]) {
                if (has_complete) {
                    cout << "Yes\n";
                    return 0;
                }
                
                mark[lst[i]] = true;
            } else {
                has_complete = true;
            }

        int rightmost = -1000;
        vector<int> started(n, -1);
        for (int i = 0; i != SZ(lst); ++i) {
            if (started[lst[i]] == -1) {
                started[lst[i]] = i;
            } else {

                if (rightmost > started[lst[i]]) {
                    cout << "Yes\n";
                    return 0;
                }
                
                rightmost = max(rightmost, started[lst[i]]);
            }
        }

        cout << "No\n";
    }
    
    return 0;
}


Measured memory_bytes: 24568