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.*;
import java.math.*;
import java.util.*;

public class Task22D implements Runnable
{
    @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
    private InputReader in;
    private PrintWriter out;

    private static class Segment implements Comparable
    {
        public int a;
        public int b;
        public Segment(int a, int b)
        {
            this.a = a;
            this.b = b;
        }
        public int compareTo(Object obj)
        {
            return a - ((Segment)obj).a;
        }
    }
    private void solve()
    {
        int n = in.nextInt();
        Segment s[] = new Segment[n];
        for (int i = 0; i < n; ++i)
        {
            int a = in.nextInt();
            int b = in.nextInt();
            if (a > b)
            {
                int c = a;
                a = b;
                b = c;
            }
            s[i] = new Segment(a, b);
        }
        Arrays.sort(s);
        int tail = s[0].b;
        List<Integer> ret = new ArrayList<Integer>();
        for (int i = 1; i < n; ++i)
        {
            if (s[i].a > tail)
            {
                ret.add(tail);
                tail = s[i].b;
            }
            else
            {
                tail = Math.min(tail, s[i].b);
            }
        }
        ret.add(tail);
        out.println(ret.size());
        out.print(ret.get(0));
        for (int i = 1; i < ret.size(); ++i)
            out.print(" " + ret.get(i));
        out.println();
    }

    public static void main(String[] args)
    {
        new Task22D().run();
    }

    private Task22D()
    {
        @SuppressWarnings({"UnusedDeclaration"})
        String id = getClass().getName().toLowerCase();
        try
        {
            // System.setIn(new FileInputStream(id + ".in"));
            // System.setOut(new PrintStream(new FileOutputStream(id + ".out")));
            // System.setIn(new FileInputStream("input.txt"));
            // System.setOut(new PrintStream(new FileOutputStream("output.txt")));
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
        in = new InputReader(System.in);
        out = new PrintWriter(System.out);
    }

    public void run()
    {
        // int testCount = in.readInt();
        // for (int i = 0; i < testCount; i++)
        // while (true)
        solve();
        exit();
    }

    @SuppressWarnings({"UnusedDeclaration"})
    private void exit()
    {
        out.close();
        System.exit(0);
    }

    @SuppressWarnings({"UnusedDeclaration"})
    private static class InputReader
    {
        private InputStream stream;
        private byte buf[] = new byte[1024];
        private int curChar, numChars;

        public InputReader(InputStream stream)
        {
            this.stream = stream;
        }

        public int read()
        {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars)
            {
                curChar = 0;
                try
                {
                    numChars = stream.read(buf);
                }
                catch (IOException e)
                {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int nextInt()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do
            {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long nextLong()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do
            {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String next()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuffer res = new StringBuffer();
            do
            {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        private boolean isSpaceChar(int c)
        {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private String readLine()
        {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1)
            {
                if (c != '\r')
                    buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }

        public BigInteger nextBigInteger()
        {
            try
            {
                return new BigInteger(next());
            }
            catch (NumberFormatException e)
            {
                throw new InputMismatchException();
            }
        }

        public char nextChar()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            return (char) c;
        }

        public double nextDouble()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.')
            {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.')
            {
                c = read();
                double m = 1;
                while (!isSpaceChar(c))
                {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }
    }
}