## https://yukicoder.me/problems/no/1900

from collections import deque

##
##  最大フロー問題を解くためのグラフ
##

from collections import deque

class MFGraph:
    class Edge:
        __slots__ = ("to", "rev", "cap")
        def __init__(self, to, rev, cap):
            self.to = to
            self.rev = rev
            self.cap = cap

    def __init__(self, n):
        self.n = n
        self.g = [[] for _ in range(n)]

    def add_edge(self, fr, to, cap):
        forward = MFGraph.Edge(to, len(self.g[to]), cap)
        backward = MFGraph.Edge(fr, len(self.g[fr]), 0)
        self.g[fr].append(forward)
        self.g[to].append(backward)

    def flow(self, s, t):
        flow = 0
        INF = 10**30

        while True:
            level = [-1] * self.n
            q = deque([s])
            level[s] = 0

            # BFS
            while q:
                v = q.popleft()
                for e in self.g[v]:
                    if e.cap > 0 and level[e.to] < 0:
                        level[e.to] = level[v] + 1
                        q.append(e.to)

            if level[t] < 0:
                return flow

            it = [0] * self.n

            def dfs(v, f):
                if v == t:
                    return f
                for i in range(it[v], len(self.g[v])):
                    it[v] = i
                    e = self.g[v][i]
                    if e.cap > 0 and level[v] < level[e.to]:
                        d = dfs(e.to, min(f, e.cap))
                        if d > 0:
                            e.cap -= d
                            self.g[e.to][e.rev].cap += d
                            return d
                return 0

            while True:
                f = dfs(s, INF)
                if f == 0:
                    break
                flow += f

def main():
    N = int(input())
    A = list(map(int, input().split()))

    next_nodes = [[] for _ in range(N)]
    for i in range(N):
        for j in range(i + 1, N):
            a = A[i]
            b = A[j]

            c = a ^ b
            if c.bit_count() == 1:
                next_nodes[i].append(j)
                next_nodes[j].append(i)
    
    passed = [-1] * N
    answer = 0
    for s_i in range(N):
        if passed[s_i] == -1:
            passed[s_i] = 0
            queue = deque()
            queue.append(s_i)
            v_set = {s_i}
            while len(queue) > 0:
                v  = queue.popleft()
                for w in next_nodes[v]:
                    if passed[w] == -1:
                        v_set.add(w)
                        passed[w] = 1 - passed[v]
                        queue.append(w)
            if len(v_set) == 1:
                answer += 1
                continue
    
            mfgraph = MFGraph(2 + len(v_set))
            zero_list = []
            one_list = []
            for v in v_set:
                if passed[v] == 0:  
                    zero_list.append(v)
                else:
                    one_list.append(v)
            for i in range(len(zero_list)):
                mfgraph.add_edge(0, 1 + i, 1)
            for j in range(len(zero_list)):
                mfgraph.add_edge(1 + len(zero_list) + j, 1 + len(zero_list) + len(one_list), 1)

            for i in range(len(zero_list)):
                for j in range(len(one_list)):
                    a = A[zero_list[i]]
                    b = A[one_list[j]]
                    c = a ^ b
                    if c.bit_count() == 1:
                        mfgraph.add_edge(1+ i, 1 + len(zero_list) + j, 1)
            
            f = mfgraph.flow(0, 1 + len(v_set))
            answer += len(v_set) - f
    print(answer)                    
            








if __name__ == "__main__":
    main()