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.lang.*;
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;

// Created by @thesupremeone on 12/07/21
public class A {
    void solve() throws IOException {
        int n = getInt();
        int m = getInt();
        boolean[] points = new boolean[m+1];
        for (int i = 0; i < n; i++) {
            int li = getInt();
            int ri = getInt();
            for (int j = li; j <=ri; j++) {
                points[j] = true;
            }
        }
        int count = 0;
        StringBuilder output = new StringBuilder();
        for (int i = 1; i <= m; i++) {
            if(!points[i]) {
                count++;
                output.append(i).append(" ");
            }
        }
        println(count);
        println(output.toString());
    }

    public static void main(String[] args) throws Exception {
        new A().run();
    }
    private void run() throws Exception{
        if (isOnlineJudge()) {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
            out = System.out;
            solve();
        } else {
            localJudge = new Thread();
            din = new DataInputStream(new FileInputStream("input.txt"));
            out = new FileOutputStream("output.txt");
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
            localJudge.start();
            solve();
            localJudge.suspend();
        }
        flush();
        close();
    }
    boolean isOnlineJudge(){
        try {
            return System.getProperty("ONLINE_JUDGE")!=null
                    || System.getProperty("LOCAL")==null;
        }catch (Exception e){
            return true;
        }
    }

    static Thread localJudge = null;
    // For input
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;
    // For output
    private static final int BUF_SIZE = 1<<13;
    private final byte[] buf = new byte[BUF_SIZE];
    private OutputStream out;
    private int ptr = 0;
    // Fast Input Methods
    public String getLine() throws IOException {
        byte[] buf = new byte[64]; // line length
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == '\n') {
                if (cnt != 0) break;
                else continue;
            }
            buf[cnt++] = (byte)c;
        }
        return new String(buf, 0, cnt);
    }
    public int getInt() 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;
    }
    public long getLong() 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;
    }
    public double getDouble() 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;
    }
    private void fillBuffer() throws IOException {
        bytesRead = din.read(buffer, bufferPointer = 0,
                BUFFER_SIZE);
        if (bytesRead == -1) buffer[0] = -1;
    }
    private byte read() throws IOException {
        if (bufferPointer == bytesRead) fillBuffer();
        return buffer[bufferPointer++];
    }
    public void close() throws IOException {
        if (din == null) return;
        din.close();
    }
    // Fast Output Methods
    public void print(byte b) {
        buf[ptr++] = b;
        if(ptr == BUF_SIZE)innerflush();
    }
    public void print(char c) {
        print((byte)c);
    }
    public void print(char[] s) {
        for(char c : s){
            buf[ptr++] = (byte)c;
            if(ptr == BUF_SIZE)innerflush();
        }
    }
    public void print(String s) {
        s.chars().forEach(c -> {
            buf[ptr++] = (byte)c;
            if(ptr == BUF_SIZE)innerflush();
        });
    }
    private static int countDigits(int l) {
        if (l >= 1000000000) return 10;
        if (l >= 100000000) return 9;
        if (l >= 10000000) return 8;
        if (l >= 1000000) return 7;
        if (l >= 100000) return 6;
        if (l >= 10000) return 5;
        if (l >= 1000) return 4;
        if (l >= 100) return 3;
        if (l >= 10) return 2;
        return 1;
    }
    public void print(int x) {
        if(x == Integer.MIN_VALUE){
            print((long)x);
            return;
        }
        if(ptr + 12 >= BUF_SIZE)innerflush();
        if(x < 0){
            print((byte)'-');
            x = -x;
        }
        int d = countDigits(x);
        for(int i = ptr + d - 1;i >= ptr;i--){
            buf[i] = (byte)('0'+x%10);
            x /= 10;
        }
        ptr += d;
    }
    private static int countDigits(long l) {
        if (l >= 1000000000000000000L) return 19;
        if (l >= 100000000000000000L) return 18;
        if (l >= 10000000000000000L) return 17;
        if (l >= 1000000000000000L) return 16;
        if (l >= 100000000000000L) return 15;
        if (l >= 10000000000000L) return 14;
        if (l >= 1000000000000L) return 13;
        if (l >= 100000000000L) return 12;
        if (l >= 10000000000L) return 11;
        if (l >= 1000000000L) return 10;
        if (l >= 100000000L) return 9;
        if (l >= 10000000L) return 8;
        if (l >= 1000000L) return 7;
        if (l >= 100000L) return 6;
        if (l >= 10000L) return 5;
        if (l >= 1000L) return 4;
        if (l >= 100L) return 3;
        if (l >= 10L) return 2;
        return 1;
    }
    public void print(long x) {
        if(x == Long.MIN_VALUE){
            print("" + x);
            return;
        }
        if(ptr + 21 >= BUF_SIZE)innerflush();
        if(x < 0){
            print((byte)'-');
            x = -x;
        }
        int d = countDigits(x);
        for(int i = ptr + d - 1;i >= ptr;i--){
            buf[i] = (byte)('0'+x%10);
            x /= 10;
        }
        ptr += d;
    }
    public void print(double x, int precision) {
        if(x < 0){
            print('-');
            x = -x;
        }
        x += Math.pow(10, -precision)/2;
        //		if(x < 0){ x = 0; }
        print((long)x);
        print(".");
        x -= (long)x;
        for(int i = 0;i < precision;i++){
            x *= 10;
            print((char)('0'+(int)x));
            x -= (int)x;
        }
    }
    public void println(char c){
        print(c);
        println();
    }
    public void println(int x){
        print(x);
        println();
    }
    public void println(long x){
        print(x);
        println();
    }
    public void println(double x, int precision){
        print(x, precision);
        println();
    }
    public void print(int... xs) {
        boolean first = true;
        for(int x : xs) {
            if (!first) print(' ');
            first = false;
            print(x);
        }
    }
    public void print(long... xs) {
        boolean first = true;
        for(long x : xs) {
            if (!first) print(' ');
            first = false;
            print(x);
        }
    }
    public void println() {
        print((byte)'\n');
    }
    public void println(int... xs) {
        print(xs);
        println();
    }
    public void println(long... xs) {
        print(xs);
        println();
    }
    public void println(char[] line) {
        print(line);
        println();
    }
    public void println(char[]... map) {
        for(char[] line : map){
            print(line);
            println();
        }
    }
    public void println(String s) {
        print(s);
        println();
    }
    private void innerflush() {
        try {
            out.write(buf, 0, ptr);
            ptr = 0;
        } catch (IOException e) {
            throw new RuntimeException("innerflush");
        }
    }
    public void flush() {
        innerflush();
        try {
            out.flush();
        } catch (IOException e) {
            throw new RuntimeException("flush");
        }
    }
}