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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Random;
import java.util.Stack;
import java.util.StringTokenizer;

public class Jetch {
	static Random random;
	private static void mySort(int[] s) {
        for (int i = 0; i < s.length; ++i) {
            int j = random.nextInt(i + 1);
            int t = s[i];
            s[i] = s[j];
            s[j] = t;
        }
        Arrays.sort(s);
    }
	
	
	

	public static void main(String[] args) {
		random = new Random(543534151132L + System.currentTimeMillis());
		InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        
       
        int n=in.nextInt();
        int m=in.nextInt();
        
        int[] A=new int[m];
        int[] B=new int[m];
        
        for(int i=0;i<m;i++) {
        	A[i]=in.nextInt();
        	B[i]=in.nextInt();
        }
        
        int x=A[0];
        int y=B[0];
        
        int nn=0;
        int N[]=new int[n+1];
        
        for(int i=0;i<m;i++) {
        	if(x==A[i] || x==B[i])nn++;
        	else {
        		N[A[i]]++;
        		N[B[i]]++;
        	}
        }
        
        Boolean find=false;
        for(int i=0;i<n+1;i++) {
        	if(nn+N[i]==m) {
        		find=true;
        	}
        }
        
        nn=0;
        for(int i=0;i<n+1;i++)N[i]=0;
        for(int i=0;i<m;i++) {
        	if(y==A[i] || y==B[i])nn++;
        	else {
        		N[A[i]]++;
        		N[B[i]]++;
        	}
        }
        
        for(int i=0;i<n+1;i++) {
        	if(nn+N[i]==m) {
        		find=true;
        	}
        }
        
        if(find)out.println("YES");
        else out.println("NO");
        
        out.close();
		
	}
	
	
	
	public static int gcd(int a, int b)  
    { 
        BigInteger b1 = BigInteger.valueOf(a); 
        BigInteger b2 = BigInteger.valueOf(b); 
        BigInteger gcd = b1.gcd(b2); 
            return gcd.intValue(); 
    } 
      
    public static long gcd(long a, long b)  
    { 
        BigInteger b1 = BigInteger.valueOf(a); 
        BigInteger b2 = BigInteger.valueOf(b); 
        BigInteger gcd = b1.gcd(b2); 
            return gcd.longValue(); 
    } 
	
	static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        
        public long nextLong() {
            return Long.parseLong(next());
        }
        
        public double nextDouble() {
            return Double.parseDouble(next());
        }
        
        public float nextFloat() {
            return Float.parseFloat(next());
        }
        
    }

}
