codeforces675D

#include <bits/stdc++.h>
using namespace std;
typedef int ll;
inline ll read()
{
    ll s=0;
    bool f=0;
    char ch=‘ ‘;
    while(!isdigit(ch))
    {
        f|=(ch==‘-‘); ch=getchar();
    }
    while(isdigit(ch))
    {
        s=(s<<3)+(s<<1)+(ch^48); ch=getchar();
    }
    return (f)?(-s):(s);
}
#define R(x) x=read()
inline void write(ll x)
{
    if(x<0)
    {
        putchar(‘-‘); x=-x;
    }
    if(x<10)
    {
        putchar(x+‘0‘);    return;
    }
    write(x/10);
    putchar((x%10)+‘0‘);
    return;
}
#define W(x) write(x),putchar(‘ ‘)
#define Wl(x) write(x),putchar(‘\n‘)
const int N=200005,inf=0x3f3f3f3f;
int n,a[N],b[N];
namespace Pht
{
    int Points,Root;
    int Child[N][2];
    int Parent[N];
    int Quanzhi[N];
    int Cnt[N];
    int Size[N];
    
    inline void Init();
    inline int Check(int x);
    inline void PushUp(int x);
    inline void Rotate(int x);
    inline void Splay(int At,int To);
    inline void Insert(int Val);
    inline void Remove(int Val);
    inline void Find(int Val);
    inline int Ask_Lower(int Val);
    inline int Ask_Upper(int Val);
    inline int Ask_Kth(int Id);
    inline void Solve(); 
    
    inline void Init()
    {
        Points=Root=0;
        Insert(-inf);
        Insert(inf);
    }
    inline int Check(int x)
    {
        return (Child[Parent[x]][0]==x)?0:1;
    }
    inline void PushUp(int x)
    {
        Size[x]=Size[Child[x][0]]+Size[Child[x][1]]+Cnt[x];
    }
    inline void Rotate(int x)
    {
        int y,z,oo;
        y=Parent[x];
        z=Parent[y];
        oo=Check(x);
        Child[y][oo]=Child[x][oo^1]; Parent[Child[x][oo^1]]=y;
        Child[z][Check(y)]=x; Parent[x]=z;
        Child[x][oo^1]=y; Parent[y]=x;
        PushUp(x); PushUp(y);
    }
    inline void Splay(int At,int To)
    {
        while(Parent[At]!=To)
        {
            int Father=Parent[At];
            if(Parent[Father]==To)
            {
                Rotate(At);
            }
            else if(Check(At)==Check(Father))
            {
                Rotate(Father); Rotate(At);
            }
            else
            {
                Rotate(At); Rotate(At);
            }
        }
        if(To==0) Root=At;
    }
    inline void Insert(int Val)
    {
        int Now=Root,Par=0;
        while(Now&&(Quanzhi[Now]!=Val))
        {
            Par=Now;
            Now=Child[Now][(Val>Quanzhi[Now])?1:0];
        }
        if(Now)
        {
            Cnt[Now]++; Size[Now]++;
        }
        else
        {
            Now=++Points;
            if(Par)
            {
                Child[Par][(Val>Quanzhi[Par])?1:0]=Now;
            }
            Parent[Now]=Par;
            Child[Now][0]=Child[Now][1]=0;
            Cnt[Now]=Size[Now]=1;
            Quanzhi[Now]=Val;
        }
        Splay(Now,0);
    }
    inline void Remove(int Val)
    {
        int Lower=Ask_Lower(Val),Upper=Ask_Upper(Val);
        Splay(Lower,0);
        Splay(Upper,Lower);
        if(Cnt[Child[Upper][0]]>1)
        {
            Cnt[Child[Upper][0]]--; Size[Child[Upper][0]]--; Splay(Child[Upper][0],0);
        }
        else
        {
            Child[Upper][0]=0;
        }
    }
    inline void Find(int Val)
    {
        int Now=Root;
        if(!Now) return;
        while(Child[Now][(Val>Quanzhi[Now])?1:0]&&(Quanzhi[Now]!=Val))
        {
            Now=Child[Now][(Val>Quanzhi[Now])?1:0];
        }
        Splay(Now,0);
    }
    inline int Ask_Lower(int Val)
    {
        Find(Val);
        int Now=Root;
        if(Quanzhi[Now]<Val) return Now;
        Now=Child[Now][0];
        while(Child[Now][1]) Now=Child[Now][1];
        return Now;
    }
    inline int Ask_Upper(int Val)
    {
        Find(Val);
        int Now=Root;
        if(Quanzhi[Now]>Val) return Now;
        Now=Child[Now][1];
        while(Child[Now][0]) Now=Child[Now][0];
        return Now;
    }
    inline int Ask_Kth(int Id)
    {
        int Now=Root;
        if(Size[Root]-1<Id) return 0;
        for(;;)
        {
            if(Size[Child[Now][0]]>=Id)
            {
                Now=Child[Now][0];
            }
            else if(Size[Child[Now][0]]+Cnt[Now]<Id)
            {
                Id-=Size[Child[Now][0]]+Cnt[Now];
                Now=Child[Now][1];
            }
            else return Now;
        }
    }
    int Time[N];
    inline void Solve()
    {
        Init();
        int i,Min=a[1],Max=a[1],tt=0;
        Insert(a[1]); Time[Root]=++tt;
        for(i=2;i<=n;i++)
        {
            int Lower=Ask_Lower(a[i]),Upper=Ask_Upper(a[i]);
//            printf("T[%d]=%d T[%d]=%d ",Lower,Time[Lower],Upper,Time[Upper]);
            if(Time[Lower]>Time[Upper])
            {
                W(Quanzhi[Lower]);
            }
            else
            {
                W(Quanzhi[Upper]);
            }
            Insert(a[i]);
            Time[Root]=++tt;
//            puts("");
        }
    }
}
int main()
{
    int i;
    R(n);
    for(i=1;i<=n;i++) R(a[i]);
    Pht::Solve();
    return 0;
}
/*
Input
3
1 2 3
Output
1 2

Input
5
4 2 3 1 6
Output
4 2 2 4

Input
10
991309218 517452607 870021923 978357992 136426010 10601767 302627526 883615372 163475700 600546765
Output
991309218 517452607 870021923 517452607 136426010 136426010 978357992 302627526 870021923
*/