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.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Stack;
								
									 
							public	    class Main implements Runnable
									{
										static final int MAX = 1000000007;
										static class InputReader
										{
											private InputStream stream;
											private byte[] buf = new byte[1024];
											private int curChar;
											private int numChars;
											private SpaceCharFilter filter;
											private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
									
											public InputReader(InputStream stream)
											{
												this.stream = stream;
											}
											
											public int read()
											{
												if (numChars==-1) 
													throw new InputMismatchException();
												
												if (curChar >= numChars)
												{
													curChar = 0;
													try 
													{
														numChars = stream.read(buf);
													}
													catch (IOException e)
													{
														throw new InputMismatchException();
													}
													
													if(numChars <= 0)				
														return -1;
												}
												return buf[curChar++];
											}
										 
											public String nextLine()
											{
												String str = "";
									            try
									            {
									                str = br.readLine();
									            }
									            catch (IOException e)
									            {
									                e.printStackTrace();
									            }
									            return str;
											}
											public int nextInt()
											{
												int c = read();
												
												while(isSpaceChar(c)) 
													c = read();
												
												int sgn = 1;
												
												if (c == '-') 
												{
													sgn = -1;
													c = read();
												}
												
												int res = 0;
												do 
												{
													if(c<'0'||c>'9') 
														throw new InputMismatchException();
													res *= 10;
													res += c - '0';
													c = read();
												}
												while (!isSpaceChar(c)); 
												
												return res * sgn;
											}
											
											public long nextLong() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												int sgn = 1;
												if (c == '-') 
												{
													sgn = -1;
													c = read();
												}
												long res = 0;
												
												do 
												{
													if (c < '0' || c > '9')
														throw new InputMismatchException();
													res *= 10;
													res += c - '0';
													c = read();
												}
												while (!isSpaceChar(c));
													return res * sgn;
											}
											
											public double nextDouble() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												int sgn = 1;
												if (c == '-') 
												{
													sgn = -1;
													c = read();
												}
												double res = 0;
												while (!isSpaceChar(c) && c != '.') 
												{
													if (c == 'e' || c == 'E')
														return res * Math.pow(10, nextInt());
													if (c < '0' || c > '9')
														throw new InputMismatchException();
													res *= 10;
													res += c - '0';
													c = read();
												}
												if (c == '.') 
												{
													c = read();
													double m = 1;
													while (!isSpaceChar(c)) 
													{
														if (c == 'e' || c == 'E')
															return res * Math.pow(10, nextInt());
														if (c < '0' || c > '9')
															throw new InputMismatchException();
														m /= 10;
														res += (c - '0') * m;
														c = read();
													}
												}
												return res * sgn;
											}
											
											public String readString() 
											{
												int c = read();
												while (isSpaceChar(c))
													c = read();
												StringBuilder res = new StringBuilder();
												do 
												{
													res.appendCodePoint(c);
													c = read();
												} 
												while (!isSpaceChar(c));
												
												return res.toString();
											}
										 
											public boolean isSpaceChar(int c) 
											{
												if (filter != null)
													return filter.isSpaceChar(c);
												return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
											}
										 
											public String next() 
											{
												return readString();
											}
											
											public interface SpaceCharFilter 
											{
												public boolean isSpaceChar(int ch);
											}
											public boolean ready(){
												try {
													return br.ready();
												} catch (IOException e) {
													return false;
												}
											}
										}
									 	
										public static void main(String args[]) throws Exception
										{
											new Thread(null, new Main(),"Main",1<<26).start();
										}
										int a;
										int b;
										final int bit = 20;
										public void run()
										{	
											InputReader sc= new InputReader(System.in);
											PrintWriter w= new PrintWriter(System.out);
											int n = sc.nextInt();
											int[] arr=  new int[(1<<(bit))];
											int[] inp = new int[n];
											for(int i = 0;i < n;i++){
												inp[i] = sc.nextInt();
												arr[inp[i]]++;
											}
											int[] ans = new int[(1<<bit)];
											for(int i = 0;i < (1<<bit);i++){
												ans[i] = arr[i];
											}
											for(int i = 0;i < bit;i++){
												for(int j = 0;j < (1<<bit);j++){
													if((j & (1<<i)) != 0){
														ans[j^(1<<i)] += ans[j];
													}
												}
											}
											fun();
											long an =  0;
											for(int i = 0;i < (1<<bit);i++){
												int nbits = Integer.bitCount(i);
												long add = pow[ans[i]] + MAX - 1;
												if(nbits % 2 == 0){
													an = (an + add)%MAX;
												}else{
													an = (an + MAX - add)%MAX;
												}
											}
											w.println(an);
											w.close();
										}
										long pow[] = new long[1000005];
										void fun(){
											pow[0] = 1;
											for(int i = 1;i < pow.length;i++){
												pow[i] = (pow[i-1] * 2)%MAX;
											}
										}
										long power(int n,int m){
											long res = 1;
											n = (n) % MAX;
											while(m > 0){
												if((m & 1) == 1){
													res = (res * n) %MAX;
												}
												m = m >> 1;
												n = (n * n) % MAX;
											}
											return res;
										}
										
										static class Pair implements Comparable<Pair>{
											double a;
											double b;
											
											Pair(double a,double b){
												this.a = a;
												this.b = b;
												
											}
											public boolean equals(Object o)
											{
												Pair p = (Pair)o;
												return (p.a==this.a && p.b== this.b);
											}
											public int compareTo(Pair p){
												return Double.compare(this.a,p.a);
											}
											public int hashCode()
											{
												return new Double(a).hashCode()*31 + new Double(b).hashCode()*17;
											}
										}
									} 