2
1 31
 2
1 0
 10
450661 128600 993228 725823 293549 33490 843121 903634 556169 448234
 1
1
 5
1 3 5 7 9
 6
524 529 5249 524 529 529
 3
1 2 3
 2
0 1
 55
0 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 2 3 4 5 6 7 8 9 3 4 5 6 7 8 9 4 5 6 7 8 9 5 6 7 8 9 6 7 8 9 7 8 9 8 9 9
 16
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
 3
128 1024 2048
 10
3 3 3 5 5 3 3 3 3 5
 1
0
 2
1 2
 2
0 0
 2
1 1

0
 2
 632
 0
 0
 24
 2
 2
 621247139
 64594
 4
 0
 1
 1
 3
 0

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;


import java.util.StringTokenizer;

public class JzzhuAndNumbersTut {
	void log(Object o){

		//System.out.println(o);
			 output(o);

	}

	void info(Object o){
		System.out.println(o);
		//output(o);
	}

	void output(Object o){

		outputWln(""+o+"\n");

	}

	void outputWln(Object o){
		//		 System.out.print(o);

		try {
			out.write(""+ o);
		} catch (Exception e) {

		}
	}


	String next(){
		while (st== null|| !st.hasMoreTokens()) {
			try {
				st=new StringTokenizer(in.readLine());
			} catch (Exception e) {
			}
		}
		return st.nextToken();
	}

	String nextLine(){
		try {
			return in.readLine();
		} catch (Exception e) {
		}
		return null;
	}

	int nextInt(){
		return Integer.parseInt(next());
	}


	long nextLong(){
		return Long.parseLong(next());


	}

	int ln2(int x){
		int u=1;
		int k=0;
		while (2*u<=x){
			u=u*2;
			k++;
		}
		return k;
	}
	
	long powerMod(long b,long e,long m){
    	long x=1;
    	while (e>0) {
    		if (e%2==1)
    			x=(b*x)%m;
    		b=(b*b)%m;
    		e=e/2;
    	}
    	return x; 
    }
	
	
	int[][] F;

	void solve(){
		int MAX=1;
		int L=1;
		while (MAX<max) {
			MAX*=2;
			L++;
		}
	//	log("L:"+L+" MAX:"+MAX);
		F=new int[MAX][L];
		for (int i=0;i<N;i++)
			F[A[i]][0]++;
		int mask=1;
		for (int k=1;k<L;k++){
			for (int x=0;x<MAX;x++){
				if ((x & mask)==mask)
					F[x][k]=F[x][k-1];
				else
					F[x][k]=F[x][k-1]+F[(x | mask)][k-1];
			}
			mask*=2;
		}
		//for (int x=0;x<MAX;x++)
		//	log("x:"+x+" F[x]:"+F[x][L-1]);
		long count=0;
		for (int x=0;x<MAX;x++){
			long a=powerMod(2,F[x][L-1],MOD);
			int g=Integer.bitCount(x);
			if (g%2==0)
				count+=a;
			else
				count-=a;
			if (count<0){
				count%=MOD;
				count+=MOD;
			}
			if (count>=MOD)
				count%=MOD;
		}
		output(count);
	}
	

	// Global vars
	StringTokenizer st;
	BufferedReader in;
	BufferedWriter out;
	int N;
	int[] A;
	int MOD=1000000007;
	int max;
	
	
	

	
	void process() throws Exception {


		out = new BufferedWriter(new OutputStreamWriter(System.out));
		in=new BufferedReader(new InputStreamReader(System.in));

		N=nextInt();
		A=new int[N];
		max=0;
		for (int i=0;i<N;i++){
			A[i]=nextInt();
			if (A[i]>max)
				max=A[i];
		}
		solve();
		
		
		try {
			out.close();
		}
		catch (Exception e){}


	}



	public static void main(String[] args) throws Exception {
		JzzhuAndNumbersTut J=new JzzhuAndNumbersTut();


		J.process();


	}


}

/*

 not my solution
//algo taken from editorial: http://codeforces.com/blog/entry/13112


/* explication de l'algo 


On prend M la plus petite puissance de 2 supérieure strictement à tous les A[i]
Et L l'exposant

on cherche toutes les k-chaines dont le résultat est zero
cela veut dire que pour tout x, k-chaine & x =0

il suffit de tester les x tel que x a un seul bit mis 

on pose C(i) = ensemble des chaînes compatibles avec le bit "i" mis


E = ensemble des chaînes. Cardinal = pow(2,N)

on cherche cardinal de E- union(C(i))

on applique principe inclusion / exclusion

res = card[E] + (-1)k (intersection de k ensemble C(i))

or une k-chaîne appartient à l'intersection de k  (Ci) revient ) à dire que k chaîne & x == x pour x défini par les bits en question

mais en fait si un k-chaine est compatible avec x, alors c'est vrai pour tous les éléments A qui composent la k-chaine

donc on pose, pour x<M, on note H(x)={i tel que x ^ A[i] = x}
Et F(x)=# H(x) (cardinal)
Le cardinal de l'intersection des (Ci) est pow(2,F(x)) pour le x correspondant aux Ci


Il faut maintenant calculer F(x)
cela se fait par récurrence sur L, par la méthode proposée dans le  tutorial


*/

