You are given a set of n segments on the axis Ox, each segment has integer endpoints between 1 and m inclusive. Segments may intersect, overlap or even coincide with each other. Each segment is characterized by two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ m) — coordinates of the left and of the right endpoints. 

Consider all integer points between 1 and m inclusive. Your task is to print all such points that don't belong to any segment. The point x belongs to the segment [l; r] if and only if l ≤ x ≤ r.

Input

The first line of the input contains two integers n and m (1 ≤ n, m ≤ 100) — the number of segments and the upper bound for coordinates.

The next n lines contain two integers each l_i and r_i (1 ≤ l_i ≤ r_i ≤ m) — the endpoints of the i-th segment. Segments may intersect, overlap or even coincide with each other. Note, it is possible that l_i=r_i, i.e. a segment can degenerate to a point.

Output

In the first line print one integer k — the number of points that don't belong to any segment.

In the second line print exactly k integers in any order — the points that don't belong to any segment. All points you print should be distinct.

If there are no such points at all, print a single integer 0 in the first line and either leave the second line empty or do not print it at all.

Examples

Input

3 5
2 2
1 2
5 5


Output

2
3 4 


Input

1 7
1 7


Output

0

Note

In the first example the point 1 belongs to the second segment, the point 2 belongs to the first and the second segments and the point 5 belongs to the third segment. The points 3 and 4 do not belong to any segment.

In the second example all the points from 1 to 7 belong to the first segment.
import java.util.*;
import java.lang.*;
import java.io.*;


public class Main
{	
	public static void main (String[] args) throws java.lang.Exception
	{
	    ProblemIO io = new ProblemIO();
	    Solver solver = new Solver();

		io.read(solver);        
        solver.solve();
   		io.print(solver);
	}

	static class Solver {
		int numSegs;
		int maxRight;
		int maxLeft;
		List<Integer> lefts;
		List<Integer> rights;
		List<Integer> ans;

		public Solver(){
			maxLeft = 1;
			lefts = new ArrayList<Integer>();
        	rights = new ArrayList<Integer>();
        	ans = new ArrayList<Integer>();
		}

		public void solve(){
			for (int i = 1; i <= maxRight; i++){
				boolean missing = true;
				for (int j = 0; j < lefts.size(); j++){
					int right = rights.get(j);
					int left = lefts.get(j);
					if (i >= left && i <= right){
						missing = false;
						break;
					}
				}
				if (missing){
					ans.add(i);
				}
			}
		}
	}

	static class ProblemIO {
		InputReader in;
		PrintWriter out;

		public ProblemIO(){
		    in = new InputReader((InputStream) System.in);
		    out = new PrintWriter((OutputStream) System.out);
		}

		public void read(Solver solver){
			solver.numSegs = in.nextInt();
		    solver.maxRight = in.nextInt();

			for (int i = 0; i < solver.numSegs; i++){
				int left = in.nextInt();
			    int right = in.nextInt();
	         	solver.lefts.add(left);
		    	solver.rights.add(right);
			}
		}

		public void print(Solver solver){
			out.println(solver.ans.size());
			for (Integer i : solver.ans){
				out.print(i + " ");
			}

			out.println();
			out.close();
		}
	}
	
	static class InputReader {
		BufferedReader reader;
		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());
		}
	}
}