#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
// #pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <cmath>
#include <bitset>
#include <cassert>
#include <queue>
#include <stack>
#include <deque>
#include <cassert>
#include <iomanip>
#include <random>
#include <sstream>
#include <complex>
 
using namespace std;


#define ull unsigned long long
#define double long double
#define time time228
#define left left228
#define right right228

template<typename T> void uin(T &a, T b) {
    if (b < a) a = b;
}

template<typename T> void uax(T &a, T b) {
    if (b > a) a = b;
}

const int maxn = 100 * 1000 + 228, INF = 1e9 + 228;

namespace ff
{
    int n;
    vector<int> g[maxn];
    int d[maxn], ptr[maxn], it = 0;

    struct edge
    {
        int from, to, cap, flow;
        edge() {}
        edge(int _from, int _to, int _cap, int _flow) {
            from = _from;
            to = _to;
            cap = _cap;
            flow = _flow;
        }
    };

    vector< edge > e;

    void add_edge(int u, int v, int c) {
        e.push_back({u, v, c, 0});
        g[u].push_back(it++);
        e.push_back({v, u, 0, 0});
        g[v].push_back(it++);
    }

    bool bfs(int s, int t) {
        for (int i = 1; i <= n; ++i) {
            d[i] = INF;
        }
        d[s] = 0;
        vector<int> q;
        q.push_back(s);
        for (int it = 0; it < (int)q.size(); ++it) {
            int v = q[it];
            for (int num : g[v]) {
                int to = e[num].to, cap = e[num].cap, flow = e[num].flow;
                if (d[v] + 1 < d[to] && cap - flow) {
                    d[to] = d[v] + 1;
                    q.push_back(to);
                }
            }
        }
        return d[t] != INF;
    }

    int Flow = 0;

    int dfs(int v, int t, int c) {
        if (v == t) {
            Flow += c;
            return c;
        }
        for (; ptr[v] < (int)g[v].size(); ++ptr[v]) {
            int num = g[v][ptr[v]];
            int to = e[num].to, cap = e[num].cap, flow = e[num].flow;
            if (d[v] + 1 == d[to] && cap - flow) {
                int x = dfs(to, t, min(c, cap - flow));
                if (x) {
                    e[num].flow += x;
                    e[num ^ 1].flow -= x;
                    return x;
                }
            }
        }
        return 0;
    }

    int get_flow(int s, int t) {
        Flow = 0;
        while (bfs(s, t)) {
            for (int i = 1; i <= n; ++i) {
                ptr[i] = 0;
            }
            while (dfs(s, t, 1)) ;
        }
        return Flow;
    }
}

int deg[maxn];

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    cin >> n >> m;
    ff::n = n;
    for (int i = 0; i < m; ++i) {
        int u, v;
        cin >> u >> v;
        ++deg[u];
        ++deg[v];
        ff::add_edge(u, v, 1);
        ff::add_edge(v, u, 1);
    }
    int c4 = 0;
    for (int i = 1; i <= n; ++i) {
        if (deg[i] & 1) {
            cout << "No\n";
            return 0;
        }
    }
    for (int i = 1; i <= n; ++i) {
        if (deg[i] >= 6) {
            cout << "Yes\n";
            return 0;
        }
        if (deg[i] >= 4) {
            ++c4;
        }
    }
    if (c4 >= 3) {
        cout << "Yes\n";
        return 0;
    }
    if (c4 == 2) {
        vector<int> four;
        for (int i = 1; i <= n; ++i) {
            if (deg[i] == 4) four.push_back(i);
        }
        if (ff::get_flow(four[0], four[1]) == 2) {
            cout << "Yes\n";
        } else {
            cout << "No\n";
        }
    } else cout << "No\n";
    return 0;
}


Measured memory_bytes: 16744