#include <cstdio>
#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

const int BSIZE = (1 << 16), NMAX = 1e5 + 5;

int N, A[NMAX], dp[NMAX], V[NMAX], B[NMAX];

int AIB[NMAX];

/// IN-PARSER:
int pos = BSIZE - 1;
char buff[BSIZE];

static inline char Char ()
{
    ++pos;

    if(pos == BSIZE)
    {
        pos = 0;

        fread(buff, 1, BSIZE, stdin);
    }

    return buff[pos];
}

static inline int Int ()
{
    int sign = 1, r = 0;

    for( ; ;)
    {
        char ch = Char();

        if(ch == '-')
        {
            sign = -1;

            break;
        }

        if(isdigit(ch))
        {
            r = r * 10 + (ch - '0');

            break;
        }
    }

    for( ; ; )
    {
        char ch = Char();

        if(isdigit(ch))
            r = r * 10 + (ch - '0');
        else
            break;
    }

    r *= sign;

    return r;
}
///

/// Fenwick Tree:
static inline int LB (int X)
{
    return (X & (-X));
}

static inline void Update (int pos, int val)
{
    for(int i = pos; i <= B[0]; i += LB(i))
        AIB[i] = max(AIB[i], val);

    return;
}

static inline int Query (int pos)
{
    int r = 0;

    for(int i = pos; i >= 1; i -= LB(i))
        r = max(r, AIB[i]);

    return r;
}
///

static inline void Read ()
{
    ios_base :: sync_with_stdio(false);
    cin.tie(NULL);

    freopen("scmax.in", "r", stdin);
    freopen("scmax.out", "w", stdout);

    N = Int();

    for(int i = 1; i <= N; ++i)
        A[i] = Int(), V[i] = A[i];

    return;
}

static inline void Normalize ()
{
    sort(V + 1, V + N + 1);

    B[++B[0]] = V[1];

    for(int i = 2; i <= N; ++i)
        if(V[i] != V[i - 1])
            B[++B[0]] = V[i];

    for(int i = 1; i <= N; ++i)
        A[i] = (lower_bound(B + 1, B + B[0] + 1, A[i]) - B);

    return;
}

static inline void Solve ()
{
    int Min = 2e9 + 1;

    for(int i = 1; i <= N; ++i)
    {
        if(A[i] < Min)
        {
            Min = A[i];

            dp[i] = 1;

            Update(A[i], 1);

            continue;
        }

        dp[i] = Query(A[i] - 1) + 1;

        Update(A[i], dp[i]);
    }

    int ans = 0, pos = 0;

    for(int i = 1; i <= N; ++i)
        if(dp[i] > ans)
        {
            ans = dp[i];

            pos = i;
        }

    printf("%d\n", ans);

    vector < int > Q;

    Q.push_back(pos);

    for(int i = pos - 1; i >= 1 && ans; --i)
        if(A[i] < A[pos] && dp[i] == ans - 1)
        {
            Q.push_back(i);

            --ans;

            pos = i;
        }

    reverse(Q.begin(), Q.end());

    for(auto it : Q)
        printf("%d ", B[A[it]]);

    printf("\n");

    return;
}

int main ()
{
    Read();

    Normalize();

    Solve();

    return 0;
}