#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
typedef long double ld;
const ll INF = mod * mod;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;



typedef vector<int> vec;
typedef pair<vec, int> vect;
typedef vector<vect> mat;

bool uwaaaaaaaaaaa[300][300];
bool exi[300];
//bit.ver
//rankを返す
int Gaussian_elimination(mat &A) {
	fill(exi, exi + 300, false);
	int n = A.size(); int m = A[0].first.size();
	int le = 0;
	rep(j, m) {
		Rep(i, le, n) {
			if (A[i].first[j]) {
				swap(A[le], A[i]);
				rep(i2, n) {
					if (i2 == le)continue;
					if (A[i2].first[j]) {
						
						rep(i3, n) {
							if (uwaaaaaaaaaaa[A[le].second][i3]) {
								uwaaaaaaaaaaa[A[i2].second][i3] ^= 1;
							}
						}
						//uwaaaaaaaaaaa[A[i2].second][A[le].second] ^= 1;
						rep(k, m) {
							A[i2].first[k] ^= A[le].first[k];
						}
					}
				}
				exi[j] = true;
				le++; break;
			}
		}
	}
	return le;
}
int n, m, x;
mat A,B;
bool use[300];
struct zyoken {
	int t, l, r;
};
zyoken z[300];

int mem[300];
void solve() {
	cin >> n >> m >> x;
	A.resize(n);
	rep(i, n) {
		A[i].first.resize(30);
		int a; cin >> a; mem[i] = a;
		rep(j, 30) {
			if (a&(1 << j)) {
				A[i].first[j] = 1;
			}
		}
		A[i].second = i;
		/*cout << i << " ";
		rep(j, 30) {
			cout << A[i].first[j];
		}
		cout << endl;*/
	}
	rep(i, n) {
		uwaaaaaaaaaaa[i][i] ^= 1;
	}
	int r=Gaussian_elimination(A);
	/*rep(i, n) {
		rep(j, n) {
			cout << uwaaaaaaaaaaa[i][j];
		}
		cout << endl;
	}*/
	/*cout << r << "hello?" << endl;
	rep(i, n) {
		cout << A[i].second << " ";
		rep(j, 30) {
			cout << A[i].first[j];
		}
		cout << endl;
	}*/
	//debug
	/*rep(i, n) {
		rep(j, 30) {
			cout << A[i].first[j];
		}
		cout << endl;
	}
*/
	int s = 0;
	rep(i, r) {
		bool f = false;
		rep(j, 30) {
			if (!exi[j])continue;
			if (A[i].first[j] && (x&(1 << j))) {
				f = true;
				rep(i3, n) {
					if (uwaaaaaaaaaaa[A[i].second][i3]) {
						use[i3] ^= 1;
					}
				}
				break;
				//use[A[i].second] = true;
			}
		}
		if (f) {
			rep(j, 30) {
				if (A[i].first[j]) {
					s ^= (1 << j);
				}
			}
		}
	}
	rep(i, m) {
		int typ, le, ri; cin >> typ >> le >> ri;
		le--; ri--;
		z[i] = { typ,le,ri };
	}
	//cout << s << endl;
	if (s != x) {
		cout << 0 << endl;
		//cout << "hieizannennryakuzikonnryuu" << endl;
		return;
	}
	B.resize(n-r);
	bitset<300> b = 0;
	rep(i, m) {
		int num = 0;
		Rep1(j, z[i].l, z[i].r) {
			if (use[j])num ^= 1;
		}
		//cout << num << endl;
		if (num)b[i] = 1;
	}
	/*cout << "nanns" << endl;
	rep(j, m) {
		cout << b[j];
	}
	cout << endl;*/
	rep(j, m) {
		if (z[j].t)b[j] = b[j]^1;
	}
	Rep(i, r, n) {
		B[i - r].first.resize(m);
		rep(j, n) {
			if (uwaaaaaaaaaaa[A[i].second][j]) {
				use[j] ^= 1;
			}
		}
		//use[A[i].second] = 1;
		//int xu = mem[A[i].second];

		//rep(j, r) {
		//	rep(k, 30) {
		//		if (A[j].first[k] && (xu&(1 << k))) {
		//			int id = A[j].second;
		//			rep(i3, n) {
		//				if (uwaaaaaaaaaaa[id][i3]) {
		//					use[i3] ^= 1;
		//				}
		//			}
		//			break;
		//			//use[A[j].second] = true;
		//		}
		//	}
		//}
		rep(j, m) {
			int num = 0;
			Rep1(k, z[j].l, z[j].r) {
				if (use[k])num ^= 1;
			}
			if (num)B[i - r].first[j] = 1;
		}
		/*cout << "hello!!! I am "<<A[i].second<< endl;
		rep(j, n) {
			cout << use[j];
		}
		cout << endl;*/
	}
	//cout << n - r << endl;
	//cout << "hellooooooeveryyyyoneeeee" << endl;
	/*rep(i, n - r) {
		rep(j, m) {
			cout << B[i].first[j];
		}
		cout << endl;
	}
	cout << "finished" << endl;*/
	int rn=Gaussian_elimination(B);
	fill(use, use + rn, false);
	//bが存在してるか判定
	bitset<300> b_=0;
	rep(i, rn) {
		rep(j, n) {
			if (!exi[j])continue;
			if (b[j] && B[i].first[j])use[i] = true;
		}
		if (use[i]) {
			rep(j, m) {
				b_[j] = b_[j]^B[i].first[j];
			}
		}
	}
	//cout << n - r << endl;
	/*rep(i, n-r) {
		rep(j,m){
			cout << B[i].first[j];
		}
		cout << endl;
	}*/
	/*rep(i, m) {
		cout << b[i];
	}
	cout << endl;
	rep(i, m) {
		cout << b_[i];
	}
	cout << endl;*/
	if (b != b_) {
		cout << 0 << endl;
		return;
	}
	ll ans = 1;
	int d = n - r - rn;
	rep(i, d) {
		ans = ans * 2 % mod;
	}
	cout << ans << endl;
}

void check() {
	int n, m, x; cin >> n >> m >> x;
	vector<int> a(n);
	rep(i, n) {
		cin >> a[i];
	}
	rep(i, m) {
		cin >> z[i].t >> z[i].l >> z[i].r;
		z[i].l--; z[i].r--;
	}
	int cnt = 0;
	rep(i, (1 << n)) {
		int u[20] = {};
		int s = 0;
		rep(j, n) {
			if (i&(1 << j)) {
				s ^= a[j];
				u[j] = 1;
			}
		}
		if (s == x) {
			bool f = true;
			rep(j, m) {
				int num = 0;
				Rep1(k, z[j].l, z[j].r) {
					if (i&(1 << k))num ^= 1;
				}
				if (num^z[j].t)f = false;
			}
			if(f)cnt++;
		}
	}
	cout << cnt << endl;
}
int main() {
	solve();
	//check();
	//stop
	return 0;
}