import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws Exception {
        InputStream inputStream = new FileInputStream("scmax.in");
        OutputStream outputStream = new FileOutputStream("scmax.out");

        try (InputReader inputReader = new InputReader(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream)) {
            int N = inputReader.nextInt();
            int[] values = new int[N + 1];
            for (int i = 1; i <= N; i++) {
                values[i] = inputReader.nextInt();
            }

            List<Integer> longestIncreasingSubSeq = Solver.solve(N, values);
            printWriter.println(longestIncreasingSubSeq.size());
            for (Integer entry : longestIncreasingSubSeq) {
                printWriter.print(entry + " ");
            }
        }
    }

    static class Solver {

        public static List<Integer> solve(int N, int[] values) {
            // this array is sorted in increasing order
            ValueEntry[] bestSequence = new ValueEntry[N + 1];
            int totalLength = 0;
            int[] previousPos = new int[N + 1];

            for (int i = 1; i <= N; i++) {
                ValueEntry valueToInsert = new ValueEntry(values[i], i);
                int posToInsert;
                if (totalLength == 0 || bestSequence[totalLength - 1].compareTo(valueToInsert) < 0) {
                    posToInsert = totalLength++;
                } else {
                    posToInsert = Arrays.binarySearch(bestSequence, 0, totalLength, valueToInsert);
                    posToInsert = posToInsert < 0 ? -posToInsert - 1 : posToInsert;
                }

                bestSequence[posToInsert] = valueToInsert;
                previousPos[i] = posToInsert > 0 ? bestSequence[posToInsert - 1].originalPos : -1;
            }

            List<Integer> solution = new ArrayList<>(N);
            recons(values, previousPos, bestSequence[totalLength - 1].originalPos, solution);
            return solution;
        }

        private static void recons(int[] originalValues, int[] previousElem, int currPos, List<Integer> solution) {
            if (currPos < 0) {
                return;
            }

            recons(originalValues, previousElem, previousElem[currPos], solution);
            solution.add(originalValues[currPos]);
        }

        private static class ValueEntry implements Comparable<ValueEntry> {
            private int value;

            private int originalPos;

            public ValueEntry(int value, int originalPos) {
                this.value = value;
                this.originalPos = originalPos;
            }

            @Override
            public int compareTo(ValueEntry o) {
                return Integer.compare(value, o.value);
            }
        }
    }

    static class InputReader implements AutoCloseable {

        private BufferedReader bufferedReader;

        private StringTokenizer stringTokenizer;

        public InputReader(InputStream inputStream) {
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            stringTokenizer = null;
        }

        private String nextToken() {
            if (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
                try {
                    stringTokenizer = new StringTokenizer(bufferedReader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }

            return stringTokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(nextToken());
        }

        @Override
        public void close() throws Exception {
            bufferedReader.close();
        }
    }
}