#include <bits/stdc++.h>
#define Intro ios::sync_with_stdio(0), cin.tie(0)
#define ll long long
using namespace std;
ifstream fin("scmax.in");
ofstream fout("scmax.out");
int const N = 1e5 + 5;
vector<int> before(N), ordered_elements(N);
vector<pair<int, int>> tree(N);
map<int, int> pos;
int elements;

pair<int, int> query(int position) {
    int maximum = 0, max_pos = 0;
    while (position > 0) {
        if (maximum < tree[position].first) {
            maximum = tree[position].first;
            max_pos = tree[position].second;
        }
        position -= position & -position;
    }
    return {maximum + 1, max_pos};
}

void update(int beginning, int maximum, int max_pos) {
    while (beginning <= elements) {
        if (maximum > tree[beginning].first) {
            tree[beginning].first = maximum;
            tree[beginning].second = max_pos;
        } else if (maximum < tree[beginning].first) {
            maximum = tree[beginning].first;
            max_pos = tree[beginning].second;
        }
        beginning += beginning & -beginning;
    }
}

void print_longest_substring(int act_pos, int limit) {
    if (act_pos == 0 or limit == 0) {
        return;
    }
    print_longest_substring(before[act_pos], limit - 1);
    fout << ordered_elements[act_pos] << ' ';
}

int main() {
    fin >> elements;
    vector<int> unordered_elements(elements + 1);
    set<int> order;
    for (int i = 1; i <= elements; ++i) {
        fin >> unordered_elements[i];
        order.insert(unordered_elements[i]);
        tree[i].second = i;
    }
    int ind = 1;
    for (int element : order) {
        pos[element] = ind;
        ordered_elements[ind++] = element;
    }
    int last_pos = 1, maximum = 0;
    for (int i = 1; i <= elements; ++i) {
        pair<int, int> act_ans = query(pos[unordered_elements[i]] - 1);
        before[pos[unordered_elements[i]]] = act_ans.second;
        if (act_ans.first > maximum) {
            maximum = act_ans.first;
            last_pos = pos[unordered_elements[i]];
        }
        update(pos[unordered_elements[i]], act_ans.first, pos[unordered_elements[i]]);
    }
    fout << maximum << '\n';
    print_longest_substring(before[last_pos], maximum - 1);
    fout << ordered_elements[last_pos] << ' ';
    return 0;
}