#include <bits/stdc++.h>
#include <algorithm> //__gcd(a,b);
using namespace std;


void setIO(string s) {
    ios_base::sync_with_stdio(0); cin.tie(0); 
    freopen((s+".in").c_str(),"r",stdin);
    freopen((s+".out").c_str(),"w",stdout);
}

using ll = long long;
using ld = long double;
using db = double;
using str = string;

typedef long long ll;
typedef vector<ll> vl; 
typedef vector<pair<ll,ll>> vpl; 
 
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x) //will not work for bool
#define travBool(a,x) for (auto a: x)
#define print(x) trav(a,x){cout<<a<<" ";}cout<<endl; //will not work for bool
#define printPair(x) trav(a,x){cout<<"{"<<a.first<<" "<<a.second<<"} ";}cout<<endl; //will not work for bool
#define printBool(x) travBool(a,x){cout<<a<<" ";}cout<<endl;
#define print2d(x) trav(a,x){trav(b,a){cout<<b<<" ";}cout<<endl;}
#define print2dBool(x) trav(a,x){travBool(b,a){cout<<b<<" ";}cout<<endl;}
#define doPrefixSum2d(data, prefixSum,x,y){prefixSum.resize(x,vector<ll>(y,0));F0R(i,x){prefixSum[i][0]=0;}F0R(j,y){prefixSum[0][j]=0;}FOR(i,1,x){FOR(j,1,y){prefixSum[i][j]=data[i][j]+prefixSum[i-1][j]+prefixSum[i][j-1]-prefixSum[i-1][j-1];}}}//x and y are the size of prefixSum and data including the first row of 0s
#define printQueue(q){auto copyOfQ=q;if(copyOfQ.empty()){cout<<"empty";}while(!copyOfQ.empty()){cout<<copyOfQ.front()<<" ";copyOfQ.pop();}cout<<endl;}
#define printDeque(q){auto copyOfQ=q;if(copyOfQ.empty()){cout<<"empty";}while(!copyOfQ.empty()){cout<<copyOfQ.front()<<" ";copyOfQ.pop_front();}cout<<endl;}
#define printDequePair(q){auto copyOfQ=q;if(copyOfQ.empty()){cout<<"empty";}while(!copyOfQ.empty()){cout<<"{"<<copyOfQ.front().first<<" "<<copyOfQ.front().second<<"} ";copyOfQ.pop_front();}cout<<endl;}
#define printStack(q){auto copyOfQ=q;if(copyOfQ.empty()){cout<<"empty";}while(!copyOfQ.empty()){cout<<copyOfQ.top()<<" ";copyOfQ.pop();}cout<<endl;} //printed backwards, last in first out occurs first in the print


#define pb push_back
#define pf push_front //for deques
#define rsz resize
#define sz(x) int(x.size())
#define all(x) begin(x), end(x)
#define f first
#define s second

const int MOD = 1e9+7; // 998244353; //this is a completely different unrelated prime number
//const __int128 MOD = 13000000000000019; prime number, for hashing shit
const int MX = 2e5+5;
const ll INF = 1e18; // not too close to LLONG_MAX
const ld PI = acos((ld)-1);

bool debug=false;
bool ysort(const pair<ll,ll>& x, const pair<ll,ll>& y){
    return x.s<y.s;
}

ll findSum2d(vector<vector<ll>>& prefixSum,ll bx,ll by,ll ex,ll ey){
    return(prefixSum[ex][ey]-prefixSum[bx-1][ey]-prefixSum[ex][by-1]+prefixSum[bx-1][by-1]);
}//all 4 cords are inclusive
vector<bool> prime;// 0 and 1 are counted as prime
vector<ll> primeList;//2 is smallest prime
void precomputePrimes(ll a){
    prime.rsz(a+1,true);
    FOR(i,2,sqrt(a+1)+2){
        if(prime[i]==false) continue;
        ll k=2;
        while(k*i<=a){
            prime[k*i]=false;
            k++;
        }
    }
    FOR(i,2,prime.size()){
        if(prime[i]){
            primeList.pb(i);
        }
    }    
}
struct DSU {
    vector<int> e;
    DSU(int N) { e = vector<int>(N, -1); }

    // get representive component (uses path compression)
    int get(int x) { return e[x] < 0 ? x : e[x] = get(e[x]); }

    bool same_set(int a, int b) { return get(a) == get(b); }

    int size(int x) { return -e[get(x)]; }

    bool unite(int x, int y) {  // union by size, you can change this to return the new leader
        x = get(x), y = get(y);
        if (x == y) return false;
        if (e[x] > e[y]) swap(x, y);
        e[x] += e[y]; e[y] = x; return true;
    }
    void p(){
        print(e);
    }
};
struct BIT {//binary indexed tree AKA fenwick tree
    int size;
    //bit is vector that includes index 0 to n
    vector<int> bit;
    BIT(int n) : size(n+1), bit(n + 2) {}
    void rsz(ll n){
        size=n+1;
        bit.rsz(n+2);
    }
    void update(int x, int v) {
        x++;
        for (; x <= size; x += x & (-x)) {
            bit[x] += v;
        }
    }
    /** @return sum of the values in [0,b] */
    int query(int b) {
        b++;
        int result = 0;
        for (; b > 0; b -= b & (-b)) {
            result += bit[b];
        }
        return result;
    }
    void p(){//first index is -1, last is N
        print(bit);
    }
    void clear(){
        size=0;
        bit.clear();
    }
};
ll modInverse(ll a,ll m){//(euclidean algorithm) can also be done with fermat's little theorem if m is a prime
    //inverse of a mod m
    vector<pair<ll,pair<ll,ll>>> v;
    v.pb({m,{1,0}});
    v.pb({a,{0,1}});
    while(v[v.size()-1].f!=1){
        //cout<<"yay"<<endl;
        //cout<<v[v.size()-2].f<<" "<<v[v.size()-2].s.f<<" "<<v[v.size()-2].s.s<<endl;
        ll a=v[v.size()-2].f/v[v.size()-1].f;
        v.pb({v[v.size()-2].f-v[v.size()-1].f*a,
            {v[v.size()-2].s.f-v[v.size()-1].s.f*a,
            v[v.size()-2].s.s-v[v.size()-1].s.s*a}});
       // cout<<v[v.size()-2].s.f<<endl;
    }
    //v[v.size()-1].s.s/m=x;
    ll ans=v[v.size()-1].s.s;
    ans%=m;
    ans+=m;
    ans%=m;
    //cout<<"mod inverse "<<ans<<endl;
    return ans;
}
ll fastExponentiation(ll a,ll b,ll m){ 
    ll ans=1;
    a%=m;
    ll temp=a;
    while(b>0){
        if(b%2==1){
            ans*=temp;
            ans%=m;
        }
        temp*=temp;
        temp%=m;
        b/=2;
    }
    ans%=m;
    return ans;
}
vector<ll> factorial;
vector<ll> factorialInverse;//factorialInverse[0]=1
ll modInversePrime(ll a,ll p){    
    if(debug){
        cout<<"( 1/"<<a<<" )"<<endl;
    }
    return fastExponentiation(a,p-2,p);
}
void precomputeFactorial(ll a,ll m){//also computes factorialInverse for prime MOD
    factorial.pb(1);
    ll ans=1;
    FOR(i,1,a+1){
        ans*=i;
        ans%=m;
        factorial.pb(ans);
    }
    factorialInverse.rsz(a+1);
    ans=modInversePrime(factorial[a],MOD);
    factorialInverse[a]=ans;
    R0F(i,a){
        ans*=(i+1);
        ans%=MOD;
        factorialInverse[i]=ans;

    }
}
ll choose(ll a, ll b, ll m){//a choose b mod m
    if(debug){
        cout<<"( "<<a<<" c "<<b<<" )"<<endl;
    }
    return ((((factorial[a]*factorialInverse[b])%m)*factorialInverse[a-b])%m);
}
vector<ll> in;//resize to N+1
vector<ll> ot;//resize to N+1
vector<vector<ll>> par; //resize to N+1,vector<ll>(log base 2 MAX (usually about 22))
ll timer=1;//starts at 1
vector<vector<ll>> adjList;
void dfs(int v=1,int p=1)//dfs for euler tours, sets up par (log 2) for lowest common ancestor, as well as creates a list of first and final entry times
{
    in[v] = timer++;
    par[v][0] = p;
    for(int i = 1; i < 22; i++){
        par[v][i] = par[par[v][i-1]][i-1];
    }
    for(int x : adjList[v])
    {
        if(x == p) continue;
        dfs(x,v);
    }
    ot[v] = timer++;
}
bool anc(int u, int v)
{
    return (in[u] <= in[v] && ot[u] >= ot[v]);
}

// method finding all lca's
int lca(int u, int v)
{
    if(anc(u,v))
        return u;
    for(int i = 21; i >= 0; i--)
    {
        if(par[u][i] >= 0 && !anc(par[u][i], v))
            u = par[u][i];
    }
    return par[u][0];
}
set<ll> powerHash;
vector<ll> prePower;
void precomputePower(ll a,ll m){
    ll x=1;
    powerHash.insert(x);
    F0R(i,1000002){
        x*=a;
        x%=MOD;
        powerHash.insert(x);
    }
}
set<ll> powerHash2;
void precomputePower2(ll a,ll m){
    ll x=1;
    powerHash2.insert(x);
    F0R(i,1000002){
        x*=a;
        x%=MOD;
        powerHash2.insert(x);
    }
}
set<ll> powerHash3;
void precomputePower3(ll a,ll m){
    ll x=1;
    powerHash3.insert(x);
    F0R(i,1000002){
        x*=a;
        x%=MOD;
        powerHash3.insert(x);
    }
}
struct segTree{//0 indexed, has MOD for hashing 
    vector<ll> v;
    ll roundUp;
    ll power;
    segTree(vector<ll> b){
        ll a=b.size();
        if(a==1){
            power=0;
        }
        else{
            power=log2(a-1);
            power++; 
        }
        roundUp=pow(2,power);
        v.rsz(2*roundUp,0);
        F0R(i,a){
            v[i+roundUp]=b[i];
        }
        ROF(i,1,roundUp){
            v[i]=v[2*i]+v[2*i+1];
            v[i]%=MOD;
        }
    }
    ll queryRange(ll a,ll b){//a and b both inclusive
        ll ans=0;
        a+=roundUp;
        b+=roundUp;
        while(a<=b){
            if(a%2==1){
                ans+=v[a];
                a++;
                ans%=MOD;
            }
            if(b%2==0){
                ans+=v[b];
                b--;
                ans%=MOD;
            }
            a/=2;
            b/=2;
        }
        return ans;
    }
    ll queryValue(ll a){
        return v[a+roundUp];
    }
    void updateValue(ll a,ll k){//k gets added to index a
        a+=roundUp;
        while(a>0){
            v[a]+=k;
            v[a]%=MOD;
            a/=2;
        }
    }
    void p(){
        cout<<"segTree"<<endl;
        print(v);
    }
};
pair<vector<ll>,vector<ll>> factor(ll a){
    /*factor(84) will return
    {{2 3 7},
    {2 1 1}}*/
    if(a<=1){
        cout<<"Can't factor numbers <=1"<<endl;
    }
    ll index=0;
    vector<ll> pri;//prime
    vector<ll> pow;//power
    while(primeList[index]*primeList[index]<=a){
        if(a%primeList[index]==0){
            a/=primeList[index];
            if(pri.empty()||pri[pri.size()-1]!=primeList[index]){
                pri.pb(primeList[index]);
                pow.pb(1);
            }
            else{
                pow[pri.size()-1]++;
            }
        }
        else{
            index++;
        }
    }
    if(a!=1){
        if(!pri.empty()&&a==pri[pri.size()-1]){
            pow[pri.size()-1]++;
        }
        else{
        pri.pb(a);
        pow.pb(1);
        }
    }
    pair<vector<ll>,vector<ll>> ret={pri,pow};
    return ret;
}
//up down right left by 1
vector<ll> cordChanger1={0,1,0,-1};
vector<ll> cordChanger2={1,0,-1,0};
vector<vector<bool>> fFVisited;//needs to be reset before every flood fill
vector<vector<ll>> grid;
vector<vector<pair<ll,ll>>> fFQ;//resize it by 1 dimension to equal the max distance, the pair is the coordinate
vector<vector<ll>> adjMatrix;//set all values max
void floodFill(ll tempIndex, ll iBorder, ll jBorder){//tempIndex is just a useful variable, can be set to the number of the starting coordinate
    //before calling floodFill, points need to be added into fFQ
    //remember to clear values like fFVisited before each use, fFQ should auto clear because all this function exits when all points are processed
    //currently, negative numbers act as walls, 0 on grid is the movement that increases d, positive numbers can be passed through on the grid do not increase d
    //cout<<"grid"<<endl;print2d(grid);
    //cout<<"visited"<<endl;print2dBool(fFVisited);
    F0R(d,fFQ.size()){//uses a 2d vector to sort; I still named it a Q though.
        //cout<<"distance processing "<<d<<endl;
        ll fFTempIndex=0;//flood fill temporary index
        while(fFQ[d].size()>fFTempIndex){
            ll i=fFQ[d][fFTempIndex].f;
            ll j=fFQ[d][fFTempIndex].s;
            F0R(k,4){
                if(i+cordChanger1[k]>=0&&j+cordChanger2[k]>=0&&i+cordChanger1[k]<iBorder&&j+cordChanger2[k]<jBorder){
                    if(grid[i+cordChanger1[k]][j+cordChanger2[k]]>=0&&fFVisited[i+cordChanger1[k]][j+cordChanger2[k]]==false){
                        if(grid[i+cordChanger1[k]][j+cordChanger2[k]]==0){//0 on grid is the movement that increases d
                            fFQ[d+1].pb({i+cordChanger1[k],j+cordChanger2[k]});
                        }
                        else{//the movement does not increase d
                            fFQ[d].pb({i+cordChanger1[k],j+cordChanger2[k]});
                        }
                        if(grid[i+cordChanger1[k]][j+cordChanger2[k]]>=1){//this updates whatever condition
                            adjMatrix[grid[i+cordChanger1[k]][j+cordChanger2[k]]][tempIndex]=min(adjMatrix[grid[i+cordChanger1[k]][j+cordChanger2[k]]][tempIndex],(ll)d);
                        }
                        fFVisited[i+cordChanger1[k]][j+cordChanger2[k]]=true;
                    }
                }
            }
            fFTempIndex++;
        }
    }
    //cout<<visited<<endl;print2dBool(fFVisited);
}
//a is 97
//adjList, adjMatrix and grid are already used variable
ll T=0;//dont forget to clear global arrays after every t
ll N=0;
ll Q=0;
ll M=0;
vector<vector<ll>> modFine;
vector<long double> mnt;
vector<set<pair<long double,ll>>> slopes;
vector<ll> cowEnd;
vector<ll> h;
vector<ll> g;
vector<bool> shaded;
ll contestant=0;
ll best=MOD;
ll tripletSize=0;
vector<vector<ll>> triplet;
void tripletDfs(ll i){
    //cout<<i<<endl;
    //printBool(shaded);
    if(i==tripletSize){
        best=min(best,contestant);
        //cout<<"reached end"<<endl;
        return;
    }

    if(shaded[triplet[i][0]]==true || shaded[triplet[i][1]]==true || shaded[triplet[i][2]]==true){
        tripletDfs(i+1);

    }
    else{
            if(contestant==best){
                return;
            }
            shaded[triplet[i][0]]=true;
            contestant++;
            tripletDfs(i+1);
            contestant--;
            shaded[triplet[i][0]]=false;


            shaded[triplet[i][1]]=true;
            contestant++;
            tripletDfs(i+1);
            contestant--;
            shaded[triplet[i][1]]=false;

            shaded[triplet[i][2]]=true;
            contestant++;
            tripletDfs(i+1);
            contestant--;
            shaded[triplet[i][2]]=false;

    }
    return;
}
int main(){
    cin>>N;
    vector<ll> islanders;
    F0R(i,N){
        ll a=0;
        cin>>a;
        islanders.pb(a);

    }
    shaded.rsz(N,false);
    
    sort(islanders.begin(),islanders.end());
    //print(islanders);
    F0R(i,N){
        FOR(j,i+1,N){
            FOR(k,j+1,N){
                if((islanders[i]^islanders[j])==islanders[k]){
                    triplet.pb({i,j,k});
                }
            }
        }
    }
    tripletSize=triplet.size();
    //cout<<triplet.size()<<endl;
    //print2d(triplet);
    tripletDfs(0); 
    cout<<best<<endl;   


}