You are given n segments on the Ox-axis. You can drive a nail in any integer point on the Ox-axis line nail so, that all segments containing this point, are considered nailed down. If the nail passes through endpoint of some segment, this segment is considered to be nailed too. What is the smallest number of nails needed to nail all the segments down?

Input

The first line of the input contains single integer number n (1 ≤ n ≤ 1000) — amount of segments. Following n lines contain descriptions of the segments. Each description is a pair of integer numbers — endpoints coordinates. All the coordinates don't exceed 10000 by absolute value. Segments can degenarate to points.

Output

The first line should contain one integer number — the smallest number of nails needed to nail all the segments down. The second line should contain coordinates of driven nails separated by space in any order. If the answer is not unique, output any.

Examples

Input

2
0 2
2 5


Output

1
2 

Input

5
0 3
4 2
4 8
8 10
7 7


Output

3
7 10 3
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class solver implements Runnable {
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    // final boolean OJ = System.getProperty("ONLINE_JUDGE") != null;

    void init() throws FileNotFoundException {

        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);

        // try {
        // in = new BufferedReader(new FileReader("input.txt"));
        // out = new PrintWriter("output.txt");
        // } catch (Throwable e) {
        // in = new BufferedReader(new InputStreamReader(System.in));
        // out = new PrintWriter(System.out);
        // }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    public static void main(String[] args) {
        new Thread(null, new solver(), "", 128 * (1L << 20)).start();
    }

    public void run() {
        try {
            init();
            long time = System.currentTimeMillis();
            solve();
            System.err.println(System.currentTimeMillis() - time);
            out.close();
        } catch (IOException e) {
            System.err.println(e.getMessage());
            System.exit(-1);
        }
    }

    int gcd(int a, int b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    class Pair implements Comparable<Pair> {
        int x;
        int y;

        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(Pair o) {          
            return y - o.y;
        }
    }

    int[] iMasWithSort(int n) throws IOException {
        Integer[] a = new Integer[n];
        for (int i = 0; i < n; i++) {
            a[i] = readInt();
        }
        Arrays.sort(a);
        int[] sorted = new int[n];
        for (int i = 0; i < n; i++) {
            sorted[i] = a[i];
        }
        return sorted;
    }

    int[] iMas(int n) throws IOException {
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = readInt();
        }
        return a;
    }
    
    

    void solve() throws IOException {
        int n=readInt();
        Pair[] p=new Pair[n];
        
        for (int i=0;i<n;i++){
            int left=readInt();
            int right=readInt();
            
            if (left>right) {
                int t=left;
                left=right;
                right=t;
            }
            p[i]=new Pair(left,right);
        }
        Arrays.sort(p);
        ArrayList<Integer> list = new ArrayList<Integer>(); 
        for (int i=0;i<n;i++){          
            if (p[i].y==Integer.MIN_VALUE) continue;
            list.add(p[i].y);           
            for (int j=0;j<n;j++){
                if (i==j) continue;             
                if (p[j].x <= p[i].y && p[i].y<=p[j].y){
                    p[j].y = Integer.MIN_VALUE;
                }
            }
        }
        out.println(list.size());
        for (int x:list){
            out.print(x+" ");
        }
        
        
        
        
    
        
        
        
        
    }
}