#include <bits/stdc++.h>

using namespace std;

ifstream fin("scmax.in");
ofstream fout("scmax.out");

const int Nmax = 1e5 + 3;

int n;
int valInit[Nmax];

int dp[Nmax], lmax;

struct normalizare{
    int val;
    int idxInit;
}v[Nmax];

bool comp1(normalizare a, normalizare b){ // ord crescator
    return a.val < b.val;
}

bool comp2(normalizare a, normalizare b){ // ord initial idx
    return a.idxInit < b.idxInit;
}

vector<int> aint(4 * Nmax);

void update(int nod, int le, int ri, int poz, int val) {
    if(le == ri){
        aint[nod] = max(aint[nod], val);
        return;
    }

    int mid = (le + ri) / 2;

    if(poz <= mid)
        update(2 * nod, le, mid, poz, val);
    else
        update(2 * nod + 1, mid + 1, ri, poz, val);

    aint[nod] = max(aint[2 * nod], aint[2 * nod + 1]);
}

int ans;

void query(int nod, int st, int dr, int le, int ri) {
    if(st <= le && ri <= dr){
        ans = max(ans, aint[nod]);
        return;
    }

    int mid = (le + ri) / 2;

    if(st <= mid)
        query(2 * nod, st, dr, le, mid);

    if(mid < dr)
        query(2 * nod + 1, st, dr, mid + 1, ri);
}

int main()
{
    fin >> n;
    for(int i = 1; i <= n; ++i)
    {
        fin >> v[i].val;
        valInit[i] = v[i].val;
        v[i].idxInit = i;
    }

    sort(v + 1, v + n + 1, comp1);

    int ant = v[1].val;
    v[1].val = 1;

    for(int i = 2; i <= n; ++i)
    {
        if(v[i].val == ant)
        {
            v[i].val = v[i - 1].val;
            continue;
        }

        ant = v[i].val;
        v[i].val = i;
    }

    sort(v + 1, v + n + 1, comp2);

    for(int i = 1; i <= n; ++i)
    {
        ans = 0;

        if(v[i].val > 1)
            query(1, 1, v[i].val - 1, 1, n);

        dp[i] = ans + 1;

        update(1, 1, n, v[i].val, dp[i]);

        lmax = max(lmax, dp[i]);
    }

    fout << lmax << '\n';

    int sol[Nmax], cnt = 0;

    int need = lmax;
    int lastVal = n + 1;

    for(int i = n; i >= 1 && need > 0; --i)
    {
        if(dp[i] == need && v[i].val < lastVal)
        {
            sol[++cnt] = valInit[i];

            lastVal = v[i].val;
            --need;
        }
    }

    for(int i = cnt; i >= 1; --i)
        fout << sol[i] << " ";

    return 0;
}