Toad Ivan has m pairs of integers, each integer is between 1 and n, inclusive. The pairs are (a_1, b_1), (a_2, b_2), …, (a_m, b_m). 

He asks you to check if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y.

Input

The first line contains two space-separated integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the upper bound on the values of integers in the pairs, and the number of given pairs.

The next m lines contain two integers each, the i-th of them contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the integers in the i-th pair.

Output

Output "YES" if there exist two integers x and y (1 ≤ x < y ≤ n) such that in each given pair at least one integer is equal to x or y. Otherwise, print "NO". You can print each letter in any case (upper or lower).

Examples

Input


4 6
1 2
1 3
1 4
2 3
2 4
3 4


Output


NO


Input


5 4
1 2
2 3
3 4
4 5


Output


YES


Input


300000 5
1 2
1 2
1 2
1 2
1 2


Output


YES

Note

In the first example, you can't choose any x, y because for each such pair you can find a given pair where both numbers are different from chosen integers.

In the second example, you can choose x=2 and y=4.

In the third example, you can choose x=1 and y=2.
import java.io.*;
import java.math.*;
import java.security.KeyStore.Entry;
import java.util.*;

public class my {
	private static boolean[] vis;
	private static long[] dist;
	public static void merge(int arr[], int l, int m, int r) 
    { 
        // Find sizes of two subarrays to be merged 
        int n1 = m - l + 1; 
        int n2 = r - m; 
  
        /* Create temp arrays */
        int L[] = new int [n1]; 
        int R[] = new int [n2]; 
  
        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i) 
            L[i] = arr[l + i]; 
        for (int j=0; j<n2; ++j) 
            R[j] = arr[m + 1+ j]; 
  
  
        /* Merge the temp arrays */
  
        // Initial indexes of first and second subarrays 
        int i = 0, j = 0; 
  
        // Initial index of merged subarry array 
        int k = l; 
        while (i < n1 && j < n2) 
        { 
            if (L[i] <= R[j]) 
            { 
                arr[k] = L[i]; 
                i++; 
            } 
            else
            { 
                arr[k] = R[j]; 
                j++; 
            } 
            k++; 
        } 
  
        /* Copy remaining elements of L[] if any */
        while (i < n1) 
        { 
            arr[k] = L[i]; 
            i++; 
            k++; 
        } 
  
        /* Copy remaining elements of R[] if any */
        while (j < n2) 
        { 
            arr[k] = R[j]; 
            j++; 
            k++; 
        } 
    } 
	 public static void sort(int arr[], int l, int r) 
	    { 
	        if (l < r) 
	        { 
	            // Find the middle point 
	            int m = (l+r)/2; 
	  
	            // Sort first and second halves 
	            sort(arr, l, m); 
	            sort(arr , m+1, r); 
	  
	            // Merge the sorted halves 
	            merge(arr, l, m, r); 
	        } 
	    } 
	 private static int gcd(int n, int l) {
	        if (l == 0)
	            return n;
	        return gcd(l, n % l);
	    }
	 public static void dfs(ArrayList<Pair>[] gr,int v)
	    {
	         vis[v]=true;
	         ArrayList<Pair> arr=gr[v];
	         for(int i=0;i<arr.size();i++)
	         {
	             if(!vis[arr.get(i).v])
	             {  
	            	 dfs(gr,arr.get(i).v);
	             }
	         }
	    }
	 private static class Pairs implements Comparable<Pairs>{
	        String v;int i;int j;
	        public Pairs(String a,int b,int c){
	            v=a;
	            i=b;
	            j=c;
	        }
	        @Override
	        public int compareTo(Pairs arg0) {
	            {
	            	if(!this.v.equals(arg0.v))
	            		return this.v.compareTo(arg0.v);
	            	else
	            		return arg0.i-this.i;
	            }
	        }
	    }
	 private static class Pair implements Comparable<Pair>{
	        int v,i;Pair j;
	        public Pair(int a,int b){
	            v=a;
	            i=b;
	        }
	        public Pair(int a,Pair b)
	        {
	            v=a;
	            j=b;
	        }
	        @Override
	        public int compareTo(Pair arg0) {
	            {
	            	return this.v-arg0.v;
	            }
	        }
	    }
	public static void main(String[] args) throws Exception
	{
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();int m=sc.nextInt();
		Pair[] arr=new Pair[m];
		for(int i=0;i<m;i++)	arr[i]=new Pair(sc.nextInt(),sc.nextInt());
		int x1=arr[0].v,x2=arr[0].i;int y1=-1;int y2=-1;
		for(int i=1;i<m;i++)
		{
			//System.out.println(x1+" "+x2+" "+arr[i].v+" "+arr[i].i);
			if(arr[i].v!=x1 && arr[i].i!=x1 && arr[i].v!=x2 && arr[i].i!=x2)
			{
				y1=arr[i].v;y2=arr[i].i;
			}
		}
		if(y1==-1 && y2==-1)
			System.out.println("YES");
		else
		{
			boolean flag;
			flag=false;
			for(int i=0;i<m;i++)
			{
				if(arr[i].v!=x1 && arr[i].i!=x1 && arr[i].v!=y1 && arr[i].i!=y1)
					flag=true;
			}
			if(!flag)
			{
				System.out.println("YES");
				return;
			}
			flag=false;
			for(int i=0;i<m;i++)
			{
				if(arr[i].v!=x1 && arr[i].i!=x1 && arr[i].v!=y2 && arr[i].i!=y2)
					flag=true;
			}
			if(!flag)
			{
				System.out.println("YES");
				return;
			}
			flag=false;
			for(int i=0;i<m;i++)
			{
				if(arr[i].v!=x2 && arr[i].i!=x2 && arr[i].v!=y1 && arr[i].i!=y1)
					flag=true;
			}
			if(!flag)
			{
				System.out.println("YES");
				return;
			}
			flag=false;
			for(int i=0;i<m;i++)
			{
				if(arr[i].v!=x2 && arr[i].i!=x2 && arr[i].v!=y2 && arr[i].i!=y2)
					flag=true;
			}
			if(!flag)
			{
				System.out.println("YES");
				return;
			}
			flag=false;
			for(int i=0;i<m;i++)
			{
				if(arr[i].v!=y1 && arr[i].i!=y1 && arr[i].v!=y2 && arr[i].i!=y2)
					flag=true;
			}
			if(!flag)
			{
				System.out.println("YES");
				return;
			}
			System.out.println("NO");
		}
	}
}
