#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("avx2")

using namespace std;

#define x first
#define y second
#define pb push_back
#define all(a) a.begin(),a.end()
#define int long long

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int,int>pii;
typedef pair<ll,ll>pll;
typedef vector<ll>vll;
typedef vector<int>vi;
typedef vector<bool>vb;
typedef vector<vi>vvi;
typedef vector<vll>vvll;
typedef vector<pii>vpii;
typedef vector<pll>vpll;

const int N=1e5+55,mod=1e9+7;

const char nl='\n';

int sz[N],pr[N],p[N],n;

bool used[N],found=0;

map<pii,bool>can;

vi g[N],cyc;

int get(int v){
    if(pr[v]==v){
        return v;
    }
    return pr[v]=get(pr[v]);
}

void unite(int u,int v){
    u=get(u);
    v=get(v);
    if(u!=v){
        if(sz[u]<sz[v]){
            swap(u,v);
        }
        sz[u]+=sz[v];
        pr[v]=u;
    }
}

void dfs(int v,int pv,int start,int cnt){
//    cout << v << " ";
    used[v]=1;
    p[v]=pv;
    for(int to:g[v]){
        if(pv==to){
            continue;
        }
        if(to==start && cnt==n){
            p[start]=v;
            found=1;
            return;
        }
        if(used[to]){
            continue;
        }
        dfs(to,v,start,cnt+1);
    }
}

void find_cycle(int start){
    int v=p[start];
    cyc.pb(v);
    while(v!=start){
        v=p[v];
        cyc.pb(v);
    }
}

signed main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int m;
    cin>>n>>m;
    for(int i=1;i<=n;++i){
        pr[i]=i;
        sz[i]=1;
    }
    vpii have;
    for(int i=1;i<=m;++i){
        int u,v;
        cin>>u>>v;
        have.pb({u,v});
        can[{u,v}]=1;
    }
    vpii rest;
    for(auto[u,v]:have){
        if(get(u)!=get(v)){
            unite(u,v);
            g[u].pb(v);
            g[v].pb(u);
        }
        else{
            rest.pb({u,v});
        }
    }
//    for(auto[u,v]:rest){
//        cout<<u<<' '<<v<<nl;
//    }
    for(auto[u,v]:rest){
        for(int i=1;i<=n;++i){
            used[i]=p[i]=0;
        }
        cyc.clear();
        found=0;
        g[u].pb(v);
        g[v].pb(u);
        used[u]=1;
        p[v]=u;
        dfs(v,u,u,2);
//        cout << "\n";
        if(found){
            find_cycle(u);
            cout<<"YES\n";
        }
//        cout<<cyc.size()<<nl;
//        if(cyc.size()<n){
//            continue;
//        }
//        bool can1=1,can2=1;
//        for(int i=1;i<n;++i){
//            if(!can[{cyc[i-1],cyc[i]}]){
//                can1=0;
//                break;
//            }
//        }
//        for(int i=1;i<n;++i){
//            if(!can[{cyc[i],cyc[i-1]}]){
//                can2=0;
//                break;
//            }
//        }
//        if(can1 || can2){
//            cout<<"YES\n";
//            for(int c:cyc){
//                cout<<c<<' ';
//            }
//            exit(0);
//        }
    }
    cout<<"NO\n";
}
