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.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Prac {	
	static HashMap<Integer, Integer> map  =new HashMap<>();
	static String fun(String str, int i, int n, int ele, int sum) {
		if(map.containsKey(sum)) {
			return str;
		}
		char[] ch = str.toCharArray();
		sum-=(ch[i]-'0')*(ch[i]-'0');
		ch[i] = (char)(ele+'0');
		sum+=ele*ele;
		if(map.containsKey(sum)) return new String(ch);
		if(i==n-1) {
			for(int j=ele+1;j<=9;j++) {
				ch[i] = (char)(j+'0');
				sum-=(j-1)*(j-1);
				sum+=j*j;
				if(map.containsKey(sum)) return new String(ch);
			}
			return "";
		}
		else {
			String s = fun(new String(ch), i+1, n, ele, sum);
			return s;
		}
		
	}
	public static void main(String[] args) throws IOException {
		BufferInput in = new BufferInput();
		int n = in.nextInt();
		int m = in.nextInt();
		int[] arr = new int[m+1];
		for(int i=0;i<n;i++) {
			int  a= in.nextInt();
			int b = in.nextInt();
			for(int j=a;j<=b;j++) {
				arr[j] = 1;
			}
		}
		int ans = 0;
		ArrayList<Integer> al = new ArrayList<>();
		for(int i=1;i<=m;i++) {
			if(arr[i]==0) {
				ans++;
				al.add(i);
			}
		}
		System.out.println(ans);
		for(int i=0;i<al.size();i++) {
			System.out.print(al.get(i)+" ");
		}
		
	}
static class BufferInput {
		final private int BUFFER_SIZE = 1 << 16;
		
		private DataInputStream din;
		
		private byte[] buffer;
		
		private int bufferPointer, bytesRead;
		
		public BufferInput() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public BufferInput(String file_name) throws IOException {
			din = new DataInputStream(new FileInputStream(file_name));
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		/**
		 * Reads the input bytes until it encounters a new line char.
		 * @return
		 * @throws IOException
		 */
		public String readLine() throws IOException {
			byte[] buf = new byte[64];
			int cnt = 0, c;
			while ((c = read()) != -1) {
				if (c == '\n')
					break;
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt);
		}
		
		/**
		 * 
		 * @return
		 * @throws IOException
		 */
		public String nextString() throws IOException{
			
			// Skip all whitespace characters from the stream
			byte c = read();
			while(Character.isWhitespace(c)){
				c = read();
			}
			
			StringBuilder builder = new StringBuilder();
			builder.append((char)c);
			c = read();
			while(!Character.isWhitespace(c)){
				builder.append((char)c);
				c = read();
			}
			
			return builder.toString();
		}
			
		/**
		 * Reads an integer value.
		 * @return
		 * @throws IOException
		 */
		public int nextInt() throws IOException {
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}
		

		/**
		 * Reads an array of integers.
		 * @return
		 * @throws IOException
		 */
		public int[] nextIntArray(int n) throws IOException {
			int arr[] = new int[n];
			for(int i = 0; i < n; i++){
				arr[i] = nextInt();
			}
			return arr;
		}


		/**
		 * Reads a long value.
		 * @return
		 * @throws IOException
		 */
		public long nextLong() throws IOException {
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}
		
		
		/**
		 * Reads an array of long integers.
		 * @return
		 * @throws IOException
		 */
		public long[] nextLongArray(int n) throws IOException {
			long arr[] = new long[n];
			for(int i = 0; i < n; i++){
				arr[i] = nextLong();
			}
			return arr;
		}
		
		/**
		 * 
		 * @return
		 * @throws IOException
		 */
		public char nextChar() throws IOException{
			byte c = read();
			while(Character.isWhitespace(c)){
				c = read();
			}
			return (char) c;	
		}
		

		/**
		 * Reads a double value.
		 * @return
		 * @throws IOException
		 */
		public double nextDouble() throws IOException {
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();

			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (c == '.') {
				while ((c = read()) >= '0' && c <= '9') {
					ret += (c - '0') / (div *= 10);
				}
			}

			if (neg)
				return -ret;
			return ret;
		}

		/**
		 * Reads an array of double values.
		 * @return
		 * @throws IOException
		 */
		public double[] nextDoubleArray(int n) throws IOException {
			double arr[] = new double[n];
			for(int i = 0; i < n; i++){
				arr[i] = nextDouble();
			}
			return arr;
		}
		
		/**
		 * Fills the buffer from input stream.
		 * 
		 * @throws IOException
		 */
		private void fillBuffer() throws IOException {
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}

		/**
		 * 
		 * @return
		 * @throws IOException
		 */
		private byte read() throws IOException {
			if (bufferPointer == bytesRead)
				fillBuffer();
			return buffer[bufferPointer++];
		}

		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}
	}
 
}

