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.IOException; 
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*; 

public class Main 
{ 	

    private static Reader r; 	


	public static void main(String[] args) 	throws Exception 	
	{ 	
		r = new Reader(); 	

		r.readLine();
		int n = r.readInt(0);
		int m = r.readInt(1);
		
		boolean flag[] = new boolean[200];
		
		for(int i=0;i<n;++i)
		{
			r.readLine();
			int f = r.readInt(0);
			int s = r.readInt(1);
			
			for(int j=f;j<=s;++j)
			{
				flag[j] = true;
			}
			
		}
		
		int count = 0;
		StringBuilder res = new StringBuilder();
		
		for(int i=1;i<=m;++i)
		{
			if(!flag[i])
			{
				++count;
				res.append(i);
				res.append(" ");
			}
		}
		
		System.out.println(count);
		System.out.println(res.toString().trim());

		r.close(); 
	}

	private static Map<Character,List<Integer>> getCharFreqWithIdx(char charArr[], int size)
	{
		Map<Character,List<Integer>> freqIdxs = new HashMap<>();

		int freq[] = new int[26];
		for (int i=0;i < size;++i)
		{
			int fr = ++freq[charArr[i] - 'a'];
			List<Integer> idx = new ArrayList<>();

			if (fr != 1)
				idx = freqIdxs.get(charArr[i]);
			else
				idx = new ArrayList<Integer>();

			idx.add(i);
			freqIdxs.put(charArr[i], idx);
		}

		return freqIdxs;
	}

	private static List<Integer> getDivs(int n)
	{
		List<Integer> divs = new ArrayList<>();

		for (int i=1; i <= Math.sqrt(n); i++) 
		{ 
			if (n % i == 0) 
			{ 
				if (n / i == i) 
					divs.add(i);
				else  
				{
					divs.add(i);
					divs.add(n / i);
				}
			} 
		} 
		return divs;
	}

	private static void reverse(char arr[], int fr, int to)
	{
		int step = (to - fr) / 2;
		for (int i=0;i <= step;++i)
		{
			char temp = arr[i];
			arr[i] = arr[to - i];
			arr[to - i] = temp;
		}
	}

	/*
	int par[] = new int[100];
	int root(int v)
	{
		return par[v] < 0 ? v : (par[v] = root(par[v]));
	} 

	void merge(int x, int y)
	{	//	x and y are some tools (vertices) 
		if ((x = root(x)) == (y = root(y)))
			return ; 	
		if (par[y] < par[x])	// balancing the height of the tree 	
		{
			int temp = x;
			x = y;
			y = temp;
		}
		par[x] += par[y]; 	
		par[y] = x; 
	}
	*/

} 

class Pair implements Comparable<Pair>
{ 	
	int f,s; 	
	public Pair() 	
	{} 
	public Pair(int f, int s) 	
	{ 	
		this.f = f; 	
		this.s = s; 	
	} 

	@Override 	
	public String toString() 
	{ 		
		return f + " " + s; 	
	} 	

	@Override 	
	public int compareTo(Pair o) 	
	{ 		
		if (f == o.f) 			
			return s - o.s; 		
		return f - o.f; 	
	} 
}

class Reader
{ 	
	private BufferedReader reader; 
	private String line[]; 	

	public Reader() 	
	{ 		
		reader = new BufferedReader(new InputStreamReader(System.in)); 	
	} 	

	public String[] getLine() 	
	{ 		
		return line; 	
	} 	

	public void readLine() 	throws IOException 
	{ 		
		line = reader.readLine().split(" "); 	
	} 	

	public List<Integer> getIntegersList()
	{
		List<Integer> res = new ArrayList<>();
		for (String str:line)
			res.add(Integer.parseInt(str));
		return res;

	}

	public int readInt(int pos)throws IOException 	
	{ 		
		return Integer.parseInt(line[pos]); 	
	} 	

	public double readDouble(int pos)throws IOException 	
	{ 		
		return Double.parseDouble(line[pos]); 	
	} 	

	public long readLong(int pos)throws IOException 
	{ 		
		return Long.parseLong(line[pos]); 
	} 	

	public String readString(int pos)throws IOException 	
	{ 		
		return line[pos]; 	
	} 	

	public void close()throws IOException 
	{ 		
		reader.close(); 	
	}

}

