#include <cstdio>

#include <cstring>

#include <vector>

#include<iostream>

#include <algorithm>

using namespace std;

namespace NetFlow

{

    const int MAXN=,MAXM=,inf=1e9;

    struct Edge

    {

        int v,c,f,nx;

        Edge() {}

        Edge(int v,int c,int f,int nx):v(v),c(c),f(f),nx(nx) {}

    } E[MAXM];

    int G[MAXN],cur[MAXN],pre[MAXN],dis[MAXN],gap[MAXN],N,sz;

    void init(int _n)

    {

        N=_n,sz=; memset(G,-,sizeof(G[])*N);

    }

    void link(int u,int v,int c)

    {

        E[sz]=Edge(v,c,,G[u]); G[u]=sz++;

        E[sz]=Edge(u,,,G[v]); G[v]=sz++;

    }

    int ISAP(int S,int T)

    {//S -> T

        int maxflow=,aug=inf,flag=false,u,v;

        for (int i=;i<N;++i)cur[i]=G[i],gap[i]=dis[i]=;

        for (gap[S]=N,u=pre[S]=S;dis[S]<N;flag=false)

        {

            for (int &it=cur[u];~it;it=E[it].nx)

            {

                if (E[it].c>E[it].f&&dis[u]==dis[v=E[it].v]+)

                {

                    if (aug>E[it].c-E[it].f) aug=E[it].c-E[it].f;

                    pre[v]=u,u=v; flag=true;

                    if (u==T)

                    {

                        for (maxflow+=aug;u!=S;)

                        {

                            E[cur[u=pre[u]]].f+=aug;

                            E[cur[u]^].f-=aug;

                        }

                        aug=inf;

                    }

                    break;

                }

            }

            if (flag) continue;

            int mx=N;

            for (int it=G[u];~it;it=E[it].nx)

            {

                if (E[it].c>E[it].f&&dis[E[it].v]<mx)

                {

                    mx=dis[E[it].v]; cur[u]=it;

                }

            }

            if ((--gap[dis[u]])==) break;

            ++gap[dis[u]=mx+]; u=pre[u];

        }

        return maxflow;

    }

    bool bfs(int S,int T)

    {

        static int Q[MAXN]; memset(dis,-,sizeof(dis[])*N);

        dis[S]=; Q[]=S;

        for (int h=,t=,u,v,it;h<t;++h)

        {

            for (u=Q[h],it=G[u];~it;it=E[it].nx)

            {

                if (dis[v=E[it].v]==-&&E[it].c>E[it].f)

                {

                    dis[v]=dis[u]+; Q[t++]=v;

                }

            }

        }

        return dis[T]!=-;

    }

    int dfs(int u,int T,int low)

    {

        if (u==T) return low;

        int ret=,tmp,v;

        for (int &it=cur[u];~it&&ret<low;it=E[it].nx)

        {

            if (dis[v=E[it].v]==dis[u]+&&E[it].c>E[it].f)

            {

                if (tmp=dfs(v,T,min(low-ret,E[it].c-E[it].f)))

                {

                    ret+=tmp; E[it].f+=tmp; E[it^].f-=tmp;

                }

            }

        }

        if (!ret) dis[u]=-; return ret;

    }

    int dinic(int S,int T)

    {

        int maxflow=,tmp;

        while (bfs(S,T))

        {

            memcpy(cur,G,sizeof(G[])*N);

            while (tmp=dfs(S,T,inf)) maxflow+=tmp;

        }

        return maxflow;

    }

}

using namespace NetFlow;

int  n,m;

int main(){

  while(~scanf("%d%d", &n, &m)) {

    init();

    int S = *n+, T = *n+;

    for(int i = ; i < m; i++) {

      int r, c;

      scanf("%d%d", &r, &c);

      r++;c++;

      link(c,r+n,);

    }

    for(int i=;i<=n;i++) {

        link(S,i,);

        link(i+n,T,);

    }

    int ans = dinic(S,T);

    if(ans == n) puts("YES");

    else puts("NO");

  }

  return ;

}