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.util.*;
import java.io.*;
public class MyClass {
    static ArrayList<Pair> al = new ArrayList<>();
    static boolean ok(int x, int y){
        for(Pair p : al){
            if(p.x != x && p.x != y && p.y != x && p.y != y){
                return false;
            }
        }
        return true;
    }
    public static void main(String args[]) {
      FastReader sc = new FastReader();
      int n = sc.nextInt();
      int m = sc.nextInt();
      
      while(m-->0){
          int x = sc.nextInt();
          int y = sc.nextInt();
          al.add(new Pair(x,y));
      }
      for(Pair p : al){
          if(ok(p.x,-1)){
              System.out.println("YES");
              return;
          }
          for(int i=1;i<al.size();i++){
              if((al.get(i).x == p.x) || (al.get(i).y == p.x)){continue;}
              if( (ok(p.x,al.get(i).x)) || (ok(p.x,al.get(i).y)) ){
                  System.out.println("YES");
                  return;
              }
              break;
          }
          break;
      }
      for(Pair p : al){
          if(ok(p.y,-1)){
              System.out.println("YES");
              return;
          }
          for(int i=1;i<al.size();i++){
              if( (al.get(i).x == p.y) || (al.get(i).y == p.y) ){continue;}
              if( (ok(p.y,al.get(i).x) ) || (ok(p.y,al.get(i).y) ) ){
                  
                  System.out.println("YES");
                  return;
              }
              break;
          }
          break;
      }
      System.out.println("NO");
    }
}
class Pair{
    int x;
    int y;
    Pair(int x, int y){
        this.x = x;
        this.y = y;
    }
}
class FastReader 
	{ 
		BufferedReader br; 
		StringTokenizer st; 
 
		public FastReader() 
		{ 
			br = new BufferedReader(new
					InputStreamReader(System.in)); 
		} 
 
		String next() 
		{ 
			while (st == null || !st.hasMoreElements()) 
			{ 
				try
				{ 
					st = new StringTokenizer(br.readLine()); 
				} 
				catch (IOException e) 
				{ 
					e.printStackTrace(); 
				} 
			} 
			return st.nextToken(); 
		} 
 
		int nextInt() 
		{ 
			return Integer.parseInt(next()); 
		} 
 
		long nextLong() 
		{ 
			return Long.parseLong(next()); 
		} 
 
		double nextDouble() 
		{ 
			return Double.parseDouble(next()); 
		} 
 
		String nextLine() 
		{ 
			String str = ""; 
			try
			{ 
				str = br.readLine(); 
			} 
			catch (IOException e) 
			{ 
				e.printStackTrace(); 
			} 
			return str; 
		} 
	}
class func{
        public static void sort(long[] arr) {
            int n = arr.length, mid, h, s, l, i, j, k;
            long[] res = new long[n];
            for (s = 1; s < n; s <<= 1) {
                for (l = 0; l < n - 1; l += (s << 1)) {
                    h = Math.min(l + (s << 1) - 1, n - 1);
                    mid = Math.min(l + s - 1, n - 1);
                    i = l;
                    j = mid + 1;
                    k = l;
                    while (i <= mid && j <= h) res[k++] = (arr[i] <= arr[j] ? arr[i++] : arr[j++]);
                    while (i <= mid) res[k++] = arr[i++];
                    while (j <= h) res[k++] = arr[j++];
                    for (k = l; k <= h; k++) arr[k] = res[k];
                }
            }
        }
 
    }



	 	 