#include <bits/stdc++.h>
using namespace std;

#define F first
#define S second
#define ar array
typedef int uci;
#define int long long
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define ll long long
typedef pair<int, int> pii;
typedef vector<int> vi;
vi val, comp, z, cont;
int Time, ncomps;

vector<vi> comps;
template<class G> int dfs(int j, G& g) {
	int low = val[j] = ++Time, x; z.push_back(j);
	for (auto e : g[j]) if (comp[e] < 0)
		low = min(low, val[e] ?: dfs(e,g));

	if (low == val[j]) {
		do {
			x = z.back(); z.pop_back();
			comp[x] = ncomps;
			cont.push_back(x);
		} while (x != j);
		comps.push_back(cont); cont.clear();
		ncomps++;
	}
	return val[j] = low;
}
template<class G> void scc(G& g) {
	int n = sz(g);
	val.assign(n, 0); comp.assign(n, -1);
	Time = ncomps = 0;
	rep(i,0,n) if (comp[i] < 0) dfs(i, g);
}

vector<int> topo;
int high{};
void getneed(int v, vector<vector<bool>> &dag, vector<int> &mask, vector<bool> &vis){
    vis[v] = true;
    for(int i{}; i < high; ++i){
        if(dag[v][i]){
            if(!vis[i])
                getneed(i, dag, mask, vis);
        }
    }
    topo.push_back(v);
}

int sosdp[1<<20];
void solve(){
    ll N; cin >> N;
    vi A(N); rep(i,0,N) cin >> A[i];

    for(int i{}; i < N; ++i){
        int t = A[i];
        int c{};
        while(t){
            c++;
            t >>= 1;
        }
        high = max(high, c);
    }
    vector<vector<bool>> implies(high, vector<bool>(high, true));

    rep(i,0,N) {
    	rep(j,0,high) {
    		rep(k,0,high) {
    			if(A[i]&(1ll << k) && !(A[i]&(1ll<<j))) {
    				implies[k][j] = false;
    			}
    		}
    	}
    }

    vector<vi> adj(high);
    rep(i,0,high) rep(j,0,high) if(implies[i][j]) adj[i].push_back(j);


    scc(adj);

    if(comps.size() == 1){
        cout << 1 << '\n';
        return;
    }
    vector<vector<bool>> dag(comps.size(), vector<bool>(comps.size()));
    vector<int> cnum(high);
    for(int i{}; i < comps.size(); ++i){
        for(int j : comps[i]){
            cnum[j] = i;
        }
    }


    for(auto &t : comps){
        for(int j : t){
            for(int k : adj[j]){
                if(cnum[j] != cnum[k])
                    dag[cnum[j]][cnum[k]] = true;
            }
        }
    }


    int m = comps.size();
    /*
    for(int i{}; i < m; ++i){
        for(int j{}; j < m; ++j)
            cout << dag[i][j];
        cout << '\n';
    }
    */
    
    vector<int> mask(m);
    vector<bool> vis(m);
    for(int i{}; i < m; ++i){
        if(!vis[i]){
            getneed(i, dag, mask, vis);
        }
    }
    reverse(topo.begin(), topo.end());

    for(int i = topo.size()-1; i >= 0; --i){
        mask[topo[i]] |= (1ll<<i);
        for(int j{}; j < high; ++j){
            if(dag[topo[i]][j]){
                mask[topo[i]] |= mask[j];
            }
        }
    }
    /*
    for(int i : topo)
        cout << i << ' ';
    cout << '\n';
    for(int i{}; i < m; ++i)
        cout << mask[i] << ' ';
    cout << '\n';
    */

    int fh = m/2;
    int sh = (m+1)/2;
    int fmask = (1<<fh)-1;
    int smask = ((1<<sh)-1)<<fh;
    // do the last sh
    for(int i{}; i < (1<<sh); ++i){
        bool bad{};
        for(int j{}; j < sh; ++j){
            if(i&(1<<(j))){
                if((i&(mask[topo[j+fh]]>>fh)) != (mask[topo[j+fh]]>>fh)){
                    bad = true;
                    break;
                }
            }
        }
        if(!bad){
            //cout << i << '\n';
            sosdp[i]++;
        }
    }
    

    for(int i = 19; i >= 0; --i){
        for(int j{}; j < (1<<20); ++j){
            if((j&(1<<i)) == 0){
                sosdp[j] += sosdp[j^(1<<i)];
            }
        }
    }

    /*
    for(int i{}; i < 4; ++i)
        cout << sosdp[i] << ' ';
    cout << '\n';
    */

    // do the first 2^fh
    int out{};
    for(int i{}; i < (1<<fh); ++i){
        bool bad{};
        int maskneed{};
        for(int j{}; j < fh; ++j){
            if(i&(1<<(j))){
                if((i&mask[topo[j]]) != (fmask&mask[topo[j]])){
                    bad = true;
                    break;
                }
                maskneed |= mask[topo[j]];
            }
        }
        /*
        cout << i << ' ' << bad << '\n';
        cout << maskneed << '\n';
        cout << ((maskneed&smask)>>fh) << '\n';
        */
        if(!bad){
            out += sosdp[(maskneed&smask)>>fh];
        }
    }
    out--;
    for(int i{}; i < N; ++i){
        if(A[i] == 0){
            out++;
            break;
        }
    }

    cout << out << '\n';

}

uci main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    solve();
}