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.
/* Rajkin Hossain */

import java.io.*;
import java.util.*;

public class B {
   
    FastInput k = new FastInput(System.in);
    //FastInput k = new FastInput("C:/Users/rajkin.h/Desktop/input.txt");
    FastOutput z = new FastOutput();
   
    int m;
    Pair [] y;
    
    boolean checkForAnswer(boolean fromLeft) {
    	int firstValue = fromLeft ? y[0].u : y[0].v;
    	
    	int secondValueL = -1;
    	int secondValueR = -1;
    	
    	boolean isPossible = true;
    	
    	for(int i = 1; i<m; i++) {
    		if(y[i].u == firstValue || y[i].v == firstValue) {
    			
    		}
    		else {
    			secondValueL = y[i].u;
    			secondValueR = y[i].v;
    			
    			boolean seeOnlyLeft = false;
    			boolean seeOnlyRight = false;
    			
    	    	for(int j = i+1; j<m; j++) {
    	    		boolean isFoundLeft = y[j].u == secondValueL || y[j].v == secondValueL;
    	    		boolean isFoundRight = y[j].u == secondValueR || y[j].v == secondValueR;
    	    		boolean isFoundFromFirstValue = y[j].u == firstValue || y[j].v == firstValue;
    	    		
    	    		if(isFoundFromFirstValue) {
    	    			
    	    		}
    	    		else if(seeOnlyLeft) {
    	    			if(isFoundLeft == false) {
        	    			isPossible = false;
        	    			break;
    	    			}
    	    		}
    	    		else if(seeOnlyRight) {
    	    			if(isFoundRight == false) {
        	    			isPossible = false;
        	    			break;
    	    			}
    	    		}
    	    		else if(isFoundLeft && isFoundRight) {
    	    			
    	    		}
    	    		else if(isFoundLeft) {
    	    			seeOnlyLeft = true;
    	    		}
    	    		else if(isFoundRight) {
    	    			seeOnlyRight = true;
    	    		}
    	    		else {
    	    			isPossible = false;
    	    			break;
    	    		}
    	    	}
    	    	
    	    	break;
    		}
    	}

    	return isPossible;
    }
    
    void startAlgorithm() {
    	while(k.hasNext()) {
    		k.nextInt();
    		m = k.nextInt();
    		
    		y = new Pair[m];
    		
    		for(int i = 0; i<m; i++) {
    			y[i] = new Pair(k.nextInt(), k.nextInt());
    		}
    		
    		z.println((checkForAnswer(true) || checkForAnswer(false)) ? "YES" : "NO");
    	}
    	
    	z.flush();
    	System.exit(0);
    }
    
    public static void main(String [] args) throws IOException {
    	new B().startAlgorithm();
    }
    
    class Pair {
    	int u;
    	int v;
    	
		public Pair(int u, int v) {
			this.u = u;
			this.v = v;
		}
    }
    
    
    /* MARK: FastInput and FastOutput */
 
    class FastInput {
        BufferedReader reader;
        StringTokenizer tokenizer;
 
        FastInput(InputStream stream){
            reader = new BufferedReader(new InputStreamReader(stream));
        }
       
        FastInput(String path){
            try {
                reader = new BufferedReader(new FileReader(path));
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            tokenizer = null;
        }
 
        String next() {
            return nextToken();
        }
       
        String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
           
            return null;
        }
 
        boolean hasNext(){
            try {
                return reader.ready();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return false;
        }
 
        String nextToken() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                String line = null;
                try {
                    line = reader.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                if (line == null) {
                    return null;
                }
                tokenizer = new StringTokenizer(line);
            }
            return tokenizer.nextToken();
        }
 
        int nextInt() {
            return Integer.parseInt(nextToken());
        }
       
        long nextLong() {
            return Long.valueOf(nextToken());
        }
    }
 
    class FastOutput extends PrintWriter {
          FastOutput() { super(new BufferedOutputStream(System.out)); }
    }
}