#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; (i) < (int)(n); ++ (i))
#define REP3(i, m, n) for (int i = (m); (i) < (int)(n); ++ (i))
#define REP_R(i, n) for (int i = int(n) - 1; (i) >= 0; -- (i))
#define REP3R(i, m, n) for (int i = int(n) - 1; (i) >= (int)(m); -- (i))
#define ALL(x) begin(x), end(x)
#define dump(x) cerr << #x " = " << x << endl
using ll = long long;
using namespace std;
template <class T> using reversed_priority_queue = priority_queue<T, vector<T>, greater<T> >;
template <class T, class U> inline void chmax(T & a, U const & b) { a = max<T>(a, b); }
template <class T, class U> inline void chmin(T & a, U const & b) { a = min<T>(a, b); }
template <typename X, typename T> auto vectors(X x, T a) { return vector<T>(x, a); }
template <typename X, typename Y, typename Z, typename... Zs> auto vectors(X x, Y y, Z z, Zs... zs) { auto cont = vectors(y, z, zs...); return vector<decltype(cont)>(x, cont); }
template <typename T> ostream & operator << (ostream & out, vector<T> const & xs) { REP (i, int(xs.size()) - 1) out << xs[i] << ' '; if (not xs.empty()) out << xs.back(); return out; }

default_random_engine gen(33);

bool solve(int n, int m, vector<pair<int, int> > const & edges) {
    vector<vector<int> > g(n);
    REP (i, m) {
        int a, b; tie(a, b) = edges[i];
        g[a].push_back(i);
        g[b].push_back(i);
    }
    REP (a, n) {
        if (g[a].size() % 2 == 1) {
            return false;
        }
        shuffle(ALL(g[a]), gen);
    }

    vector<vector<int> > circuits;
    vector<bool> used_edge(m);

    vector<int> order(m);
    iota(ALL(order), 0);
    shuffle(ALL(order), gen);
    for (int i : order) if (not used_edge[i]) {
        int a = edges[i].first;
        vector<int> circuit;
        int j = i;
        int b = a;
        while (true) {
            circuit.push_back(b);
            used_edge[j] = true;
            b ^= edges[j].first ^ edges[j].second;
            if (a == b) break;
            while (not g[b].empty() and used_edge[g[b].back()]) {
                g[b].pop_back();
            }
            if (g[b].empty()) {
                return false;
            }
            j = g[b].back();
        }
        circuit.push_back(b);
        circuits.push_back(circuit);
    }
    cerr << "circuits = " << circuits.size() << endl;

    int count = 0;
    vector<int> used_vertices(n, -1);
    for (auto const & circuit : circuits) {
        REP (i, circuit.size()) {
            int a = circuit[i];
            if (used_vertices[a] == -1) {
                used_vertices[a] = i;
            } else {
                ++ count;
                if (count >= 3) return true;
                REP3 (j, used_vertices[a] + 1, i) {
                    used_vertices[circuit[j]] = -1;
                }
            }
        }
        for (int a : circuit) {
            used_vertices[a] = -1;
        }
    }
    cerr << "count = " << count << endl;
    return false;
}

int main() {
    int n, m; cin >> n >> m;
    vector<pair<int, int> > edges(m);
    REP (i, m) {
        int a, b; cin >> a >> b;
        -- a;
        -- b;
        edges[i] = make_pair(a, b);
    }
    bool answer = solve(n, m, edges);
    cout << (answer ? "Yes" : "No") << endl;
    return 0;
}


Measured memory_bytes: 7800