#pragma comment(linker,"/STACK:102400000,102400000")

 #pragma GCC optimize("Ofast")

 #pragma GCC optimize("inline")

 #pragma GCC optimize("-fgcse")

 #pragma GCC optimize("-fgcse-lm")

 #pragma GCC optimize("-fipa-sra")

 #pragma GCC optimize("-ftree-pre")

 #pragma GCC optimize("-ftree-vrp")

 #pragma GCC optimize("-fpeephole2")

 #pragma GCC optimize("-ffast-math")

 #pragma GCC optimize("-fsched-spec")

 #pragma GCC optimize("unroll-loops")

 #pragma GCC optimize("-falign-jumps")

 #pragma GCC optimize("-falign-loops")

 #pragma GCC optimize("-falign-labels")

 #pragma GCC optimize("-fdevirtualize")

 #pragma GCC optimize("-fcaller-saves")

 #pragma GCC optimize("-fcrossjumping")

 #pragma GCC optimize("-fthread-jumps")

 #pragma GCC optimize("-funroll-loops")

 #pragma GCC optimize("-fwhole-program")

 #pragma GCC optimize("-freorder-blocks")

 #pragma GCC optimize("-fschedule-insns")

 #pragma GCC optimize("inline-functions")

 #pragma GCC optimize("-ftree-tail-merge")

 #pragma GCC optimize("-fschedule-insns2")

 #pragma GCC optimize("-fstrict-aliasing")

 #pragma GCC optimize("-fstrict-overflow")

 #pragma GCC optimize("-falign-functions")

 #pragma GCC optimize("-fcse-skip-blocks")

 #pragma GCC optimize("-fcse-follow-jumps")

 #pragma GCC optimize("-fsched-interblock")

 #pragma GCC optimize("-fpartial-inlining")

 #pragma GCC optimize("no-stack-protector")

 #pragma GCC optimize("-freorder-functions")

 #pragma GCC optimize("-findirect-inlining")

 #pragma GCC optimize("-fhoist-adjacent-loads")

 #pragma GCC optimize("-frerun-cse-after-loop")

 #pragma GCC optimize("inline-small-functions")

 #pragma GCC optimize("-finline-small-functions")

 #pragma GCC optimize("-ftree-switch-conversion")

 #pragma GCC optimize("-foptimize-sibling-calls")

 #pragma GCC optimize("-fexpensive-optimizations")

 #pragma GCC optimize("-funsafe-loop-optimizations")

 #pragma GCC optimize("inline-functions-called-once")

 #pragma GCC optimize("-fdelete-null-pointer-checks")

 #include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 #include<cmath>

 #include<queue>

 #define dbg(x) cerr << #x << " = " << x <<endl

 #define dbg2(x,y) cerr<< #x <<" = "<< x <<"  "<< #y <<" = "<< y <<endl

 using namespace std;

 typedef long long ll;

 typedef double db;

 typedef pair<int,int> pii;

 template<typename T>inline T _min(T A,T B){return A<B?A:B;}

 template<typename T>inline T _max(T A,T B){return A>B?A:B;}

 template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,):;}

 template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,):;}

 template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}

 template<typename T>inline T read(T&x){

     x=;int f=;char c;while(!isdigit(c=getchar()))if(c=='-')f=;

     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;

 }

 const int N=2e5+,INF=0x3f3f3f3f;

 int len,n,thxorz;

 int A[N];

 int anc[N];

 inline int get_anc(int x){return anc[x]==x?x:anc[x]=get_anc(anc[x]);}

 struct _01trie{

     int tr[N*][],maxv[N*],minv[N*],id[N*],tot;

     _01trie(){maxv[]=,minv[]=INF;}

     inline void Insert(int x,int j){//dbg2(x,j);

         int u=;

         for(register int i=len,d;~i;--i){

             if(!tr[u][d=(x>>i)&])tr[u][d]=++tot;

             u=tr[u][d];

         }

         id[u]=j;

     }

     void Maintain(int i){//++thxorz;

         if(!tr[i][]&&!tr[i][]){maxv[i]=minv[i]=get_anc(id[i]);return;}

         if(tr[i][])Maintain(tr[i][]);

         if(tr[i][])Maintain(tr[i][]);

         maxv[i]=_max(maxv[tr[i][]],maxv[tr[i][]]);

         minv[i]=_min(minv[tr[i][]],minv[tr[i][]]);//dbg2(i,tr[i][0]),dbg2(minv[i],maxv[i]);

     }

     inline void Build(){for(register int i=;i<=n;++i)Insert(A[i],i);}

     inline int Query(int x,int j){

         int u=,rt=get_anc(j);//dbg2(rt,x);

         for(register int i=len,d;~i;--i){//++thxorz;

             d=(x>>i)&;//dbg2(d,tr[u][d]),dbg2(maxv[tr[u][d]],minv[tr[u][d]]);

             if(tr[u][d]&&(maxv[tr[u][d]]^rt||minv[tr[u][d]]^rt))u=tr[u][d];

             else u=tr[u][d^];

         }//dbg(id[u]);

         return id[u];

     }

 }T;

 int minw[N],minp[N];

 inline void Boruvka(){

     int k=;ll ans=;

     T.Build();

     for(register int i=;i<=n;++i)anc[i]=i;

     while(k<n-){//dbg("new round");

         T.maxv[]=,T.minv[]=INF,T.Maintain();memset(minw,0x7f,sizeof minw);

         for(register int i=,tmp;i<=n;++i)tmp=T.Query(A[i],i),MIN(minw[get_anc(i)],A[tmp]^A[i])&&(minp[anc[i]]=tmp);

         for(register int i=;i<=n;++i)if(get_anc(i)^get_anc(minp[get_anc(i)]))

             ans+=minw[anc[i]],++k,anc[anc[i]]=anc[minp[anc[i]]];//attention the order.

     }

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

 }

 int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);

     read(n);for(register int i=;i<=n;++i)MAX(len,read(A[i]));

     len=__lg(len);

     Boruvka();//dbg(thxorz);

     return ;

 }