Problem:
Score : 300 points

Problem Statement

We have N switches with "on" and "off" state, and M bulbs. The switches are numbered 1 to N, and the bulbs are numbered 1 to M.

Bulb i is connected to k_i switches: Switch s_{i1}, s_{i2}, ..., and s_{ik_i}. It is lighted when the number of switches that are "on" among these switches is congruent to p_i modulo 2.

How many combinations of "on" and "off" states of the switches light all the bulbs?

Constraints

1 \leq N, M \leq 10

1 \leq k_i \leq N

1 \leq s_{ij} \leq N

s_{ia} \neq s_{ib} (a \neq b)

p_i is 0 or 1.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M
k_1 s_{11} s_{12} ... s_{1k_1}
:
k_M s_{M1} s_{M2} ... s_{Mk_M}
p_1 p_2 ... p_M

Output

Print the number of combinations of "on" and "off" states of the switches that light all the bulbs.

Sample Input 1

2 2
2 1 2
1 2
0 1

Sample Output 1

1

Bulb 1 is lighted when there is an even number of switches that are "on" among the following: Switch 1 and 2.

Bulb 2 is lighted when there is an odd number of switches that are "on" among the following: Switch 2.

There are four possible combinations of states of (Switch 1, Switch 2): (on, on), (on, off), (off, on) and (off, off). Among them, only (on, on) lights all the bulbs, so we should print 1.

Sample Input 2

2 3
2 1 2
1 1
1 2
0 0 1

Sample Output 2

0

Bulb 1 is lighted when there is an even number of switches that are "on" among the following: Switch 1 and 2.

Bulb 2 is lighted when there is an even number of switches that are "on" among the following: Switch 1.

Bulb 3 is lighted when there is an odd number of switches that are "on" among the following: Switch 2.

Switch 1 has to be "off" to light Bulb 2 and Switch 2 has to be "on" to light Bulb 3, but then Bulb 1 will not be lighted. Thus, there are no combinations of states of the switches that light all the bulbs, so we should print 0.

Sample Input 3

5 2
3 1 2 5
2 2 3
1 0

Sample Output 3

8

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;


namespace AtCoder
{
    static class Extensions
    {
        public static int LowerBound<T>(this IList<T> list, T value, IComparer<T> comp=null)
        {
            if (comp == null) comp = Comparer<T>.Default;

            var l = 0;
            var r = list.Count;

            while (l < r)
            {
                var m = (l + r) / 2;
                var c = comp.Compare(value, list[m]);
                if (c > 0) l = m + 1;
                else  r = m;
            }

            return l;
        }
        public static int UpperBound<T>(this IList<T> list, T value, IComparer<T> comp=null)
        {
            if (comp == null) comp = Comparer<T>.Default;

            var l = 0;
            var r = list.Count;

            while (l < r)
            {
                var m = (l + r) / 2;
                var c = comp.Compare(value, list[m]);
                if (c >= 0) l = m + 1;
                else r = m;
            }

            return r;
        }
    }
    class Program
    {
		static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        static int[] ReadIntArray(int n)
        {
            var a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = ReadInt();
            }
            return a;
        }
        static long[] ReadLongArray()
        {
            return Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
        }
        static long[] ReadLongArray(int n)
        {
            var a = new long[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = ReadLong();
            }
            return a;
        }
		
        public static int[] ZAlgotithm(string s)
        {
            var len = s.Length;

            var a = new int[len];
            a[0] = len;
            var i = 1;
            var j = 0;
            while (i < len)
            {
                while (i + j < len && s[j] == s[i + j]) j++;
                a[i] = j;

                if (j == 0)
                {
                    i++;
                    continue;
                }

                var k = 1;
                while (i + k < len && k + a[k] < j)
                {
                    a[i + k] = a[k];
                    k++;
                }
                i += k;
                j -= k;
            }

            return a;
        }
        public class MaxHeap<T> : IEnumerable<T>
        {
            private List<T> _list;
            private Comparer<T> _comp;
			
            public int Count
            {
                get
                {
                    return _list.Count;
                }
            }
            public MaxHeap() : this(0) { }
            public MaxHeap(int capacity, Comparison<T> comp=null)
            {
                _list = new List<T>(capacity);

                if (comp == null)
                {
                    _comp = Comparer<T>.Default;
                }
                else
                {
                    _comp = Comparer<T>.Create(comp);
                }
            }
            
            public void Push(T elem)
            {
                Upheap(elem);
            }

            public T Pop()
            {
                return Downheap();
            }

            public T Peek()
            {
                return _list[0];
            }

            
            private void Swap(int i, int j)
            {
                var a = _list[j];
                _list[j] = _list[i];
                _list[i] = a;
            }

            private void Upheap(T elem)
            {
                _list.Add(elem);
                var i = _list.Count - 1;

                while (true)
                {
                    if (i == 0) return;
                    var j = (i - 1) / 2;

                    var e = _list[i];
                    var p = _list[j];

                    var c = _comp.Compare(e, p);
                    if (c > 0)
                    {
                        Swap(i, j);
                        i = j;
                        continue;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            private T Downheap()
            {
                var result = _list[0];

                var last = _list.Count - 1;
                Swap(0, last);
                _list.RemoveAt(last);
                if (_list.Count == 0) return result;

                var i = 0;
                while (true)
                {
                    if (i == _list.Count - 1) return result;
                    var p = _list[i];

                    var j = i * 2 + 1;
                    if (j >= _list.Count) return result;

                    if(j+1 < _list.Count && _comp.Compare(_list[j], _list[j+1]) < 0)
                    {
                        j++;
                    }

                    if (_comp.Compare(_list[i], _list[j]) < 0)
                    {
                        Swap(i, j);
                        i = j;
                    }
                    else
                    {
                        return result;
                    }
                }
            }
            public MaxHeap<T> Copy(Comparison<T> comp=null)
            {
                var c = new MaxHeap<T>(0, comp);
                c._list = _list.ToList();

                return c;
            }
            public MaxHeap(List<T> list)
            {
                _list = list;

                _comp = Comparer<T>.Default;
            }

            public List<T> GetList()
            {
                return _list;
            }

            public IEnumerator<T> GetEnumerator()
            {
                return _list.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
        class InputLine
        {
            private string[] _inputs;
            private int _index = 0;

            InputLine(string input)
            {
                _inputs = input.Split();
                _index = 0;
            }

            public static InputLine Read()
            {
                return new InputLine(Console.ReadLine());
            }

            public int NextInt()
            {
                return int.Parse(_inputs[_index++]);
            }
            public long NextLong()
            {
                return long.Parse(_inputs[_index++]);
            }
            public double NextDouble()
            {
                return double.Parse(_inputs[_index++]);
            }
        }
        public static int GCD(int x, int y)
        {
            var a = Math.Max(x, y);
            var b = x + y - a;

            while (b != 0)
            {
                var c = b;
                b = a % b;
                a = c;
            }

            return a;
        }
        public static long GCD(long x, long y)
        {
            var a = Math.Max(x, y);
            var b = x + y - a;

            while (b != 0)
            {
                var c = b;
                b = a % b;
                a = c;
            }

            return a;
        }
        static long ModPower(long x, long y, long mod)
        {
            var bytes = BitConverter.GetBytes(y);
            var bits = new System.Collections.BitArray(bytes);

            var max2 = 0;
            for (int i = bits.Length - 1; i >= 0; i--)
            {
                if (bits[i])
                {
                    max2 = i;
                    break;
                }
            }

            long result = 1;
            for (int i = max2; i >= 0; i--)
            {
                result = (result * result) % mod;
                if (bits[i])
                {
                    result = (result * x) % mod;
                }
            }

            return result;
        }
        
        static long ModFact(long n, long mod)
        {
            long result = 1;

            for (int i = 1; i <= n; i++)
            {
                result = result * i % mod;
            }
            return result;
        }
		
        static long ModAdd(long x, long y, long mod)
        {
            return ((x % mod) + (y % mod)) % mod;
        }
        static long ModMul(long x, long y, long mod)
        {
            return ((x % mod) * (y % mod)) % mod;
        }

        static long ModDiv(long x, long y, long mod)
        {
            //フェルマーの小定理より、a^(-1) = a^(p-2)
            return ModMul(x, ModPower(y, mod - 2, mod), mod);
        }
        static long ModComb(long n, long r, long mod)
        {
            long numerator = 1;
            for (int i = 0; i < r; i++)
            {
                numerator = ModMul(numerator, n - i, mod);
            }

            long denominator = ModFact(r, mod);

            return ModDiv(numerator, denominator, mod);
        }
        class Graph
        {
            private int _size;
            private List<int>[] _map;

            public IEnumerable<int> this[int i]
            {
                get
                {
                    if (_map[i] == null) return Enumerable.Empty<int>();
                    return _map[i];
                }
            }

            public Graph(int size)
            {
                _size = size;
                _map = new List<int>[size];
            }

            public void Add(int from, int to)
            {
                if (_map[from] == null)
                {
                    _map[from] = new List<int>();
                }
                _map[from].Add(to);
            }
        }
        static long p1097 = 1000000007;
        static void Main(string[] args)
        {
			//↓

            var nm = ReadIntArray();
            var n = nm[0];
            var m = nm[1];
            var kss = new List<List<int>>(m);

            for (int i = 0; i < m; i++)
            {
                var ks = ReadIntArray().Skip(1).ToList();

                ks.Sort();
                ks.Reverse();
                kss.Add(ks);
            }

            var ps = ReadIntArray();

            var results = new HashSet<int>(Enumerable.Range(0, (int)Math.Pow(2, n)));
            var bits = new bool[n];
            
            for (int i = 0; i < m; i++)
            {
                var p = ps[i];
                var ks = kss[i];
                var rs = new HashSet<int>();

                foreach (var r in results)
                {
                    var rr = r;

                    for (int j = n - 1; j >= 0; j--)
                    {
                        var pow = (int)Math.Pow(2, j);
                        if(rr >= pow)
                        {
                            bits[j] = true;
                            rr -= pow;
                        }
                        else
                        {
                            bits[j] = false;
                        }
                    }

                    var count = 0;
                    for (int j = 0; j < ks.Count; j++)
                    {
                        if (bits[j]) count++;
                    }

                    if(count % 2 != p)
                    {
                        rs.Add(r);
                    }
                }

                foreach (var r in rs)
                {
                    results.Remove(r);
                }
            }

            Console.WriteLine(results.Count);


			//↑
        }

	}
}