/*　　　　　　　　　　　　　　　　　　　 　　　　だ　　　　　オ　　　　　こ　　　　　な

.　　　　　　　　　　　　　　　　　　　　　　　　 っ　　 　 　｜　 　 　　こ　　　　　ん

　　　　　　　　　　　　　　　　　　　　　　　 　た　　　　　バ 　 　 　 が　　　　　て

　　　　　　　　　　　　　　　　　　　　　　　.　の　　　　　｜ 　 　 　　 　　　 　 .事

　　　　　　　　 ＿　　　　　　　　　　　 　　　か.　　　　　ラ　　　　　　　　　　　だ
　　　　　 ／ﾌ´ ⌒ヾ＼
　　　 .ｔ:く.〈〈! ﾘNｿﾊ＿rァ　　　　　　　　　　　　　　　　 ン
　 　　 　＼>|!|ﾟοﾟ|ｉK／
　 　　　　,八げ丞!け )ヽ.　　　　　　　　　　　　　　　　　ド
-‐‐=-.. （(　ﾉく∩_,｣>レｿ
:　 　 　　::＼,,.. []┤
: 　 　 　:::　. :;　└'.`'::￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣
:　:: 　　　::　 　 :;　::: .:: `':.､. ∴∴/::｀"''｀~"''''ｰ-‐ｰ-､,､.,,.、‐-　　　_　　...　　............　.........　......　 ...
.　　　　　 :　 ::　　:;　:: ::.　::`'::､,／:: 　　　 　 　 　 　 　 　 ｀⌒´"'^'ｰ-‐､,　ｰ -　　_　.:::::::::　::::::.. ..:.
　　　　　　　　　　　　　　　　.　　　　　　　　　　　　　　 　 　 　 　 　 ○_ ´｀"'"''ｰ'ｰ-､,.｀　ｰ - _ ::...:
　　　.　　　　　　　　　　　　　　　　　　　　　　.　　　　　　　　　　　　 |＼＼　　 　 　 　 ｀^´｀"''ｰ～､
　　　　　　　　　　　　　　.　　　　　　　　　　　　　　　　.　　　　　　　　.<￣<     */

#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>

using namespace std;
using ll = long long;
using ull = unsigned long long;

#ifndef __MACRO_H__
#define __MACRO_H__

#define all(collection)  (collection).begin(), (collection).end()		// begin to end
#define rep(i, begin, end) for (ll i = begin; i < end; i++)					// repeat
#define repr(i, begin, end) for (ll i = begin - 1; end <= i; i--)		// repeat reverse

std::chrono::system_clock::time_point  start;

void TimeStart(void)
{
	start = std::chrono::system_clock::now();
}

void TimeEnd(void)
{
	auto time = std::chrono::system_clock::now() - start;
	auto msec = std::chrono::duration_cast<std::chrono::milliseconds>(time).count();
	cerr << endl << msec << " msec " << endl;
}

#endif

class NyaGadgetPositionalNotation
{	// N進数を表現するクラス
public:
	NyaGadgetPositionalNotation(long long cardinal)
	{
		cardinal_ = cardinal;
		symbol_index_collection_.push_back(0);
	}
	void Inc()
	{	// 返り値なしのインクリメント
		bool carry = true;
		long long index = (long long)symbol_index_collection_.size() - 1;
		while (0 <= index && carry)
		{
			if (symbol_index_collection_[index] != cardinal_ - 1)
			{
				symbol_index_collection_[index]++;
				carry = false;
			}
			else
			{	// 桁上り
				symbol_index_collection_[index] = 0;
				if (index == 0)
					symbol_index_collection_.push_front(1);
				carry = true;
			}
			index--;
		}
	}
	NyaGadgetPositionalNotation operator ++()
	{	// 前置インクリメント
		Inc();
		return *this;
	}
	NyaGadgetPositionalNotation operator ++(int)
	{  // 後置インクリメント
		NyaGadgetPositionalNotation pn = *this;
		Inc();
		return pn;
	}
	/**
	@brief N進数取得関数
	@note
	 d桁のN進数として文字列で取得
	---------------------------------------------------------------------------
	[sample]
	long long main()
	{	// 16進数テスト
		NyaGadgetPositionalNotation pn(16);

		for (long long i = 0; i < 30; i++)
			pn++;

		cout << pn() << endl;		// 30を16進数で表示
		cout << pn(5) << endl;		// 5桁表示

		return 0;
	}
	---------------------------------------------------------------------------
	[output]
	1E
	0001E
	**/
	string operator()(long long d = 0)
	{
		std::string positional_nation;

		for (const auto& e : symbol_index_collection_)
			positional_nation += symbols_[e];

		if (d == 0 || d == (long long)positional_nation.size())
			return positional_nation;

		if ((long long)positional_nation.size() < d)
		{	// 表示桁に空きがあるときは0で埋める
			std::string zero(d - positional_nation.size(), '0');
			positional_nation = zero + positional_nation;
		}

		return positional_nation;
	}
	/**
	@brief d桁目を取得する演算子
	@note
	 d桁目の数字を文字列で取得する。
	-------------------------------------------------------------------------- -
	[sample]
	long long main()
	{	// 16進数テスト
		NyaGadgetPositionalNotation pn(16);

		for (long long i = 0; i < 30; i++)
			pn++;

		cout << pn.() << endl;		// 30を16進数で表示
		cout << pn[0] << endl;		// １桁目を表示
		cout << pn[1] << endl;		// ２桁目を表示

		return 0;
	}
	-------------------------------------------------------------------------- -
	[output]
	1E
	E
	1
	**/
	char operator[](long long d)
	{	// d桁目の数字を取得する
		long long index = (long long)symbol_index_collection_.size() - 1 - d;
		if (index < 0)
			return symbols_[0][0];
		return symbols_[symbol_index_collection_[index]][0];
	}
private:
	long long cardinal_;	// 基数
	string symbols_[36] =
	{	// 36進数まで対応
		"0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
		"A", "B", "C", "D", "E", "F", "G", "H", "I", "J",
		"K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
		"U", "V", "W", "X", "Y", "Z",
	};
	// シンボルそのものでなく、シンボルに対応するindexを格納していく
	deque<long long> symbol_index_collection_;
};


class ABC128C
{
public:
	ABC128C()
	{
		k = 0;
		cin >> n >> m;
		s.resize(m);
		rep(i, 0, m)
		{
			cin >> k;
			s[i].resize(n, false);
			rep(j, 0, k)
			{
				ll index;
				cin >> index;
				s[i][index-1] = true;
			}
		}
		p.resize(m);
		rep(i, 0, m)
			cin >> p[i];
	}
	void Run(void)
	{
		NyaGadgetPositionalNotation pn(2);



		ll ans = 0;
		for(long long i = 0; i< pow(2, n); i++)
		{
			
			rep(j, 0, m)
			{
				if (!Judge(j, pn))
					break;
				if (j == m - 1)
					ans++;
			}
			pn++;
		}

		cout << ans;
	}
private:
	bool Judge(ll j, NyaGadgetPositionalNotation& pn)
	{
		ll count = 0;
		rep(i, 0, n)
		{
			if (pn[i] == '1')
			{
				if (s[j][i])
					count++;
			}
		}

		if (count % 2 == p[j])
			return true;

		return false;
	}
	ll n;
	ll m;
	ll k;
	vector<vector<bool>> s;
	vector<ll> p;
};

int main(void)
{
	ABC128C abc128c;
	abc128c.Run();

	return 0;
}

Measured memory_bytes: 512