//include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>

#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>

#include <stdexcept>

using namespace std;

//conversion
//------------------------------------------
inline int toint(string s) { int v; istringstream sin(s); sin >> v; return v; }
template<class t> inline string tostring(t x) { ostringstream sout; sout << x; return sout.str(); }

//debug
#define dump(x)  cerr << #x << " = " << (x) << endl
#define debug(x) cerr << #x << " = " << (x) << " (l" << __line__ << ")" << " " << __file__ << endl

// type alias
using ll = long long;
using ull = unsigned long long;

template<class ll>
inline ll getCeilExponent(ll a)
{
	if (a <= 0)
	{
		throw invalid_argument("vaule equal to or less than 0 should not be valid");
	}

	ll index = 0;
	--a;
	for (; a != 0; a >>= 1)
	{
		++index;
	}
	return index;
}

template<class ll>
inline ll getFloorExponent(ll a)
{
	if (a <= 0)
	{
		throw invalid_argument("vaule equal to or less than 0 should not be valid");
	}

	ll index = 0;
	a >>= 1;
	for (; a != 0; a >>= 1)
	{
		++index;
	}
	return index;
}

// computational complexity: o(log(max(a, b))) 
template<class ll>
inline ll getGcd(ll a, ll b)
{
	if (b == 0)
	{
		return a;
	}
	return getGcd(b, a % b);
}

// computational complexity: o(log(max(a, b))) 
template<class ll>
inline pair<ll, ll> getBezoutsIdentitySolution(ll a, ll b)
{
	if (b == 0)
	{
		return { 1, 0 };
	}
	auto sol = getBezoutsIdentitySolution(b, a % b);
	return { sol.second, sol.first - (a / b) * sol.second };
}

//template <class Integer>
//class ResidueInteger
//{
//private:
//	Integer mod_;
//	Integer n_;
//	static Integer global_mod_;
//
//public:
//	Integer getModValue(const Integer& n) const
//	{
//		return (n % mod_ + mod_) % mod_;
//	}
//
//	// computational complexity: o(log(max(n, mod))) 
//	inline Integer getModInverse(const Integer& n) const
//	{
//		auto sol = getBezoutsIdentitySolution(n, mod_);
//		if (n * sol.first + mod_ * sol.second != 1)
//		{
//			return -1;
//		}
//		return getModValue(sol.first);
//	}
//		
//	ResidueInteger() : mod_(global_mod_), n_(getModValue(0)) {}
//	ResidueInteger(Integer n) : mod_(global_mod_), n_(getModValue(n)) {}
//	ResidueInteger(Integer n, Integer mod) : mod_(mod), n_(getModValue(n)){}
//
//	inline ResidueInteger operator+(const ResidueInteger& rhs) const
//	{
//		if (this->mod_ != rhs.mod_)
//		{
//			throw invalid_argument("The mods of both operands should be equal.");
//		}
//		return {this->n_ + rhs.n_, this->mod_};
//	}
//	inline ResidueInteger operator+(const Integer& rhs) const
//	{
//		return { this->n_ + getModValue(rhs), this->mod_ };
//	}
//	friend inline ResidueInteger operator+(const Integer& lhs, const ResidueInteger& rhs)
//	{
//		return { rhs.getModValue(lhs) + rhs.n_, rhs.mod_ };
//	}
//	inline ResidueInteger& operator+=(const ResidueInteger& rhs)
//	{
//		if (this->mod_ != rhs.mod_)
//		{
//			throw invalid_argument("The mods of both operands should be equal.");
//		}
//		this->n_ = getModValue(this->n_ + rhs.n_);
//		return *this;
//	}
//	inline ResidueInteger& operator+=(const Integer& rhs)
//	{
//		this->n_ = getModValue(this->n_ + getModValue(rhs));
//		return *this;
//	}
//
//	inline ResidueInteger operator-(const ResidueInteger& rhs) const
//	{
//		if (this->mod_ != rhs.mod_)
//		{
//			throw invalid_argument("The mods of both operands should be equal.");
//		}
//		return { this->n_ - rhs.n_, this->mod_ };
//	}
//	inline ResidueInteger operator-(const Integer& rhs) const
//	{
//		return { this->n_ - getModValue(rhs), this->mod_ };
//	}
//	friend inline ResidueInteger operator-(const Integer& lhs, const ResidueInteger& rhs)
//	{
//		return { rhs.getModValue(lhs) - rhs.n_, rhs.mod_ };
//	}
//	inline ResidueInteger& operator-=(const ResidueInteger& rhs)
//	{
//		if (this->mod_ != rhs.mod_)
//		{
//			throw invalid_argument("The mods of both operands should be equal.");
//		}
//		this->n_ = getModValue(this->n_ - rhs.n_);
//		return *this;
//	}
//	inline ResidueInteger& operator-=(const Integer& rhs)
//	{
//		this->n_ = getModValue(this->n_ - getModValue(rhs));
//		return *this;
//	}
//
//	inline ResidueInteger operator*(const ResidueInteger& rhs) const
//	{
//		if (this->mod_ != rhs.mod_)
//		{
//			throw invalid_argument("The mods of both operands should be equal.");
//		}
//		return { this->n_ * rhs.n_, this->mod_ };
//	}
//	inline ResidueInteger operator*(const Integer& rhs) const
//	{
//		return { this->n_ * getModValue(rhs), this->mod_ };
//	}
//	friend inline ResidueInteger operator*(const Integer& lhs, const ResidueInteger& rhs)
//	{
//		return { rhs.getModValue(lhs) * rhs.n_, rhs.mod_ };
//	}
//	inline ResidueInteger& operator*=(const ResidueInteger& rhs)
//	{
//		if (this->mod_ != rhs.mod_)
//		{
//			throw invalid_argument("The mods of both operands should be equal.");
//		}
//		this->n_ = getModValue(this->n_ * rhs.n_);
//		return *this;
//	}
//	inline ResidueInteger& operator*=(const Integer& rhs)
//	{
//		this->n_ = getModValue(this->n_ * getModValue(rhs));
//		return *this;
//	}
//
//	inline ResidueInteger operator/(const ResidueInteger& rhs) const
//	{
//		if (this->mod_ != rhs.mod_)
//		{
//			throw invalid_argument("The mods of both operands should be equal.");
//		}
//		return { this->n_ * getModInverse(rhs.n_), this->mod_ };
//	}
//	inline ResidueInteger operator/(const Integer& rhs) const
//	{
//		return { this->n_ * getModInverse(getModValue(rhs)), this->mod_ };
//	}
//	friend inline ResidueInteger operator/(const Integer& lhs, const ResidueInteger& rhs)
//	{
//		return { rhs.getModValue(lhs) * rhs.getModInverse(rhs.n_), rhs.mod_ };
//	}
//	inline ResidueInteger& operator/=(const ResidueInteger& rhs)
//	{
//		if (this->mod_ != rhs.mod_)
//		{
//			throw invalid_argument("The mods of both operands should be equal.");
//		}
//		this->n_ = getModValue(this->n_ * getModInverse(rhs.n_));
//		return *this;
//	}
//	inline ResidueInteger& operator/=(const Integer& rhs)
//	{
//		this->n_ = getModValue(this->n_ * getModInverse(getModValue(rhs)));
//		return *this;
//	}
//
//	inline bool operator==(const ResidueInteger& rhs) const
//	{
//		return (this->n_ == rhs.n_) && (this->mod_ == rhs.mod_);
//	}
//	inline bool operator==(const Integer& rhs) const
//	{
//		return this->n_ == getModValue(rhs);
//	}
//	friend bool operator==(const Integer& lhs, const ResidueInteger& rhs)
//	{
//		return rhs.getModValue(lhs) == rhs.n_;
//	}
//
//	friend std::ostream& operator<<(std::ostream& lhs, const ResidueInteger& rhs)
//	{
//		return lhs << rhs.n_;
//	}
//
//	friend std::istream& operator>>(std::istream& lhs, ResidueInteger& rhs)
//	{
//		lhs >> rhs.n_;
//		return lhs;
//	}
//};
//using rll = ResidueInteger<ll>;
//ll mod = 1000000007ll;
//ll rll::global_mod_ = mod;
//
//template<class Integer>
//class ResidueCombinatorialCalculator
//{
//private:
//	Integer mod_;
//	Integer n_;
//	map<Integer, ResidueInteger<Integer>> values_;
//public:
//	ResidueCombinatorialCalculator(Integer n, Integer mod) : mod_(mod), n_(n)
//	{
//		values_[0] = ResidueInteger<Integer>(1, mod_);
//	}
//	
//	ResidueInteger<Integer> calculate(Integer r)
//	{
//		if (r < 0 || n_ < r)
//		{
//			return 0;
//		}
//
//		if (values_.count(r) >= 1)
//		{
//			return values_[r];
//		}
//		if (values_.count(n_ - r) >= 1)
//		{
//			values_[r] = values_[n_ - r];
//			return values_[r];
//		}
//		if (n_ < r * 2)
//		{
//			values_[r] = calculate(n_ - r);
//			return values_[r];
//		}
//
//		values_[r] = calculate(r - 1) * (n_ - r + 1) / r;
//
//		return values_[r];
//	}
//};
//using rccll = ResidueCombinatorialCalculator<ll>;



int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);

	ll N, M;
	cin >> N >> M;

	ll K, v;
	vector<vector<ll>> ss(M);
	for (ll i = 0; i < M; ++i)
	{
		cin >> K;
		vector<ll> vs(K);
		for (ll j = 0; j < K; ++j)
		{
			cin >> v;
			vs[j] = v;
		}
		ss[i] = vs;
	}

	vector<ll> ps(M);
	for (ll i = 0; i < M; ++i)
	{
		cin >> ps[i];
	}

	vector<bool> is_on(N);
	ll res = 0;
	for (ll i = 0; i < (1 << N); ++i)
	{
		for (ll j = 0; j < N; ++j)
		{
			is_on[j] = ( ((i >> j) % 2) == 1);
		}

		bool is_all_on = true;
		for (ll j = 0; j < M; ++j)
		{
			ll switch_count = 0;
			for (ll k = 0; k < ss[j].size(); ++k)
			{
				if (is_on[ss[j][k] - 1])
				{
					++switch_count;
				}
			}
			if (switch_count % 2 != ps[j])
			{
				is_all_on = false;
				break;
			}
		}
		if (is_all_on)
		{
			++res;
		}
	}

	cout << res << endl;

	return 0;
}


Measured memory_bytes: 256