Inaka has a disc, the circumference of which is n units. The circumference is equally divided by n points numbered clockwise from 1 to n, such that points i and i + 1 (1 ≤ i < n) are adjacent, and so are points n and 1.

There are m straight segments on the disc, the endpoints of which are all among the aforementioned n points.

Inaka wants to know if her image is rotationally symmetrical, i.e. if there is an integer k (1 ≤ k < n), such that if all segments are rotated clockwise around the center of the circle by k units, the new image will be the same as the original one.

Input

The first line contains two space-separated integers n and m (2 ≤ n ≤ 100 000, 1 ≤ m ≤ 200 000) — the number of points and the number of segments, respectively.

The i-th of the following m lines contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) that describe a segment connecting points a_i and b_i.

It is guaranteed that no segments coincide.

Output

Output one line — "Yes" if the image is rotationally symmetrical, and "No" otherwise (both excluding quotation marks).

You can output each letter in any case (upper or lower).

Examples

Input


12 6
1 3
3 7
5 7
7 11
9 11
11 3


Output


Yes


Input


9 6
4 5
5 6
7 8
8 9
1 2
2 3


Output


Yes


Input


10 3
1 2
3 2
7 2


Output


No


Input


10 2
1 6
2 7


Output


Yes

Note

The first two examples are illustrated below. Both images become the same as their respective original ones after a clockwise rotation of 120 degrees around the center.

<image>
/*
                              _                     _ 
                              _                     _ 
                            _ / |                 | \ _ 
                            _ / |         _       | \ _ 
                        _ / _   |       _ | \\    |   _ \ 
                        _ / _   |       _ | \ \   |   _ \ 
                    _ / _ / |   /     /         \ \   | \ _ \ _ 
                    _ / _ / |   /     /          \ \   | \ _ \ _ 
                _ / _ /     | /     /     _       \ \ |     \ _ \ _   
               _ / _ /      | /     /     _       \ \ |      \ _ \ _   
            _ / _ /         | |     |   |   \  O  / | |         \ _ \ _ 
           _ / _ /          | |     |   |    \   /  | |          \ _ \ _ 
          / _ /     |   |   | \     |   \ _   \|/   / |   |   |     \ _ \ 
         / _ /      |   |   | \     |   \ _    V    / |   |   |      \ _ \ 
        / /         |   |   |   \ _ /       \ _ _ /   |   |   |         \ \ 
       / /          |   |   |                         |   | | |          \ \ 
      / /       |   | | \     \       ROWECHEN      /     / | |   |       \ \ 
     / /    _ _ |   | | \     \        ZHONG        /     / | |   | _ _    \ \ 
    / / _ /   \ | | | |   \ / \ \                 / / \ /   | | | | /   \ _ \ \ 
   / / _ /    \ | | | |       \ \                 / /       | | | | /    \ _ \ \ 
  / / /         \ \ \ \ /       /                 \       \ / / / /         \ \ \ 
 \ / /          \ \ \ \ /       /                 \       \ / / / /          \ \ / 
  \|/             \|/         |         |         |           \|/             \|/ 
                  \|/         |         |   |     |           \|/ 
                              / _ |     |   | _     \ 
                              / _ |     |   | _     \ 
                            / / / _     | _ | | \ _   \ 
                            / / / _ |   | _ | | \ _   \ 
                            | / / | | / | | \ / | | \ | 
                            | / / | | / | | \ / | | \ |         
                              /   \ / | | | / | | / \ /           
                              /   \ / | | | / | | / \/           
                                  / | / \ |   \ /           
                                  / | / \ |    \/   
                                  \ /     |                                   
                                  \/      |                                                                   
*/
//TEMPLATE V2
	import java.io.*;
	import java.util.*;
	import java.math.*;
	
public class Main {
//Solution goes below: ------------------------------------

    public static void solution() throws IOException{
		int n = nextInt();
		int m = nextInt();
		int nn=n;
		List<Integer> factors = new Arr<>();
		for (int p = 2; p <= nn; p++) {
			if (nn % p > 0){
				continue;
			}
			factors.add(p);
			while (nn % p == 0){
				nn /= p;
			}
		};
		Arr<HashSet<Integer>> all = new Arr<HashSet<Integer>>();
		for(int i =0;i<n;i++){
			all.add(new HashSet<Integer>());
		}
		//All possible lines. These are ordered s.t. each [] has same length; there are n/2 possible lengths, but we'll add an additional aux column for simplicity.
		for(int i=0;i<m;i++){
			int a = nextInt()-1;
			int dist = nextInt()-1-a;
			if(dist<0){
				a+=dist;
				dist=-dist;
			}
			if(dist>(n>>1)){
				a+=dist;
				dist = (n-dist)%n;
			}
			all.get(a).add(dist);
			if(dist==(n>>1)){
				all.get((a+dist)%n).add(dist);
			}
		}
		boolean works=false;
		//Note that if there are no factors it must be false.
		for(int fac:factors){
			int rfac = n/fac;
			works = true;
			for(int i =0;i<n;i++){
				works = all.get(i).equals(all.get((i+rfac)%n));
				if(!works){
					break;
				}
			}
			if(works){
				break;
			}
			
		}
		println(works?"Yes":"No");

    }

//Solution goes above: ------------------------------------
	public static final String IN_FILE = "";
	public static final String OUT_FILE = "";
//-------------------- ------------------------------------
	//IO
	public static BufferedReader br;
	public static StringTokenizer st;
	public static BufferedWriter bw;
    public static void main(String[] args) throws IOException{
		if(IN_FILE==""){
			br = new BufferedReader(new InputStreamReader(System.in)); 
		}else{
			try {
				br = new BufferedReader(new FileReader(IN_FILE));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}
		if (OUT_FILE==""){
			bw = new BufferedWriter(new OutputStreamWriter(System.out));
		}else{
			bw = new BufferedWriter (new FileWriter(OUT_FILE) );
		}
		solution();
		bw.close();//Flushes too.
	}

	public static String nextToken() {
		while (st == null || !st.hasMoreElements()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return st.nextToken();
	}

	public static String nextLine() {
		st = null;
		try {
			return br.readLine();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

	public static int nextInt() {
		return Integer.parseInt(nextToken());
	}

	public static long nextLong() {
		return Long.parseLong(nextToken());
	}

	public static double nextDouble() {
		return Double.parseDouble(nextToken());
	}
	
	public static void println(Object s) throws IOException{
		bw.write(s.toString()+"\n");
	}
	
	public static void println() throws IOException{
		bw.newLine();
	}

    public static void print(Object s) throws IOException{
		bw.write(s.toString());
	}
	public static void flush() throws IOException{//Useful for debug
		bw.flush();
	}
	//Other
	public static class Arr<T> extends ArrayList<T> {} //I hate typing ArrayList
}