import java.io.*;
import java.util.*;
import java.awt.geom.*;

/**
 * Solution to Job Postings.
 * 
 * @author vanb
 */
public class jobpostings_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /**
     * A node of a max flow graph.
     */
    public class Node
    {
        // Cost from the Source to this node
        public int cost = 100;
        
        // List of edges from this node
        public LinkedList<Edge> edges = new LinkedList<Edge>();
        
        // The edge we got here from
        public Edge from = null;
        
        // For debugging
        public String name;
        
        // Is this node on the queue?
        public boolean onq;
        
        public Node( String name )
        {
            this.name = name;
        }
        
        /**
         * Clear this node for a new graph
         */
        public void clear()
        {
            cost = 0;
            edges.clear();
            from = null;
        }
    }
    
    /**
     * An edge of a max flow graph.
     */
    public class Edge
    {
        public Node destination;
        public int capacity;
        public int cost;
        public Edge dual;
        
        public Edge( Node d, int c, int s )
        {
            capacity = c;
            cost = s;
            destination = d;
            dual = null;
        }
    }
    
    /**
     * Create a link between two nodes of a max flow graph.
     * 
     * @param n1 From node
     * @param n2 To node
     * @param capacity Capacity from n1 to n2
     * @param cost Cost to go from n1 to n2
     */
    public void link( Node n1, Node n2, int capacity, int cost )
    {
        Edge e12 = new Edge( n2, capacity, cost );
        Edge e21 = new Edge( n1, 0, -cost );
        e12.dual = e21;
        e21.dual = e12;
        n1.edges.add( e12 );
        n2.edges.add( e21 );
    }
    
    public LinkedList<Node> queue = new LinkedList<Node>();
    
    
    /**
     * Perform the Ford/Fulkerson algorithm on a graph.
     * 
     * @param src Source node
     * @param snk Sink node
     * @param nodes The graph, represented as a list of nodes
     * @return The max flow from the source to the sink
     */
    public int fordfulkerson( Node src, Node snk, List<Node> nodes )
    {
        int total = 0;
        
        // Keep going until you can't get from the source to the sink
        for(;;)
        {  
            // Reset the graph
            for( Node node : nodes )
            {
                // Since the highest cost we'll ever get is 12, 
                // 100 is, for all practical purposes, infinity.
                node.cost = 100;
                node.from = null;
            }
            src.cost = 0;
            
            queue.clear();
            queue.add( src );
            src.onq = true;
            
            while( !queue.isEmpty() )
            {
                Node node = queue.removeFirst();
                node.onq = false;
                for( Edge edge : node.edges )
                {
                    if( edge.capacity>0 && node.cost+edge.cost<edge.destination.cost) 
                    {
                        edge.destination.cost = node.cost+edge.cost;
                        edge.destination.from = edge;
                        if( !edge.destination.onq )
                        {
                            edge.destination.onq = true;
                            queue.add( edge.destination );
                        }
                    }
                }
                
            }
           
            // If we were unable to get to the sink, then we're done
            if( snk.from==null ) break;
            
            // Otherwise, look along the path to find the minimum capacity
            int min = Integer.MAX_VALUE;
            for( Node node = snk; node.from != null; )
            {
                Edge edge = node.from;
                if( edge.capacity < min ) min = edge.capacity;
                node = edge.dual.destination;
            }           
            
            // Go back along the path, and for each edge, move the min
            // capacity from the edge to its dual.
            for( Node node = snk; node.from != null; )
            {
                Edge edge = node.from;
                edge.capacity -= min;
                edge.dual.capacity += min;
                node = edge.dual.destination;
            }        
            
            // Add the cost to the total
            total += snk.cost;
        }
        
        // Return the total
        return total;
    }
    
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner (System.in);
        ps = System.out; 
                
        LinkedList<Node> nodes = new LinkedList<Node>();
                      
        for(;;)
        {
            int n = sc.nextInt();
            int m = sc.nextInt();
            if( n==0 ) break;
            
            nodes.clear();
            Node source = new Node( "Source" );
            nodes.add( source );
            Node sink = new Node( "Sink" );
            nodes.add( sink );

            // Create nodes for all of the available positions
            Node positions[][] = new Node[n][];
            for( int i=0; i<n; i++ )
            {
                int p = sc.nextInt();
                positions[i] = new Node[p];
                for( int j=0; j<p; j++ )
                {
                    Node node = new Node( "Job " + i + ": " + j );
                    positions[i][j] = node;
                    nodes.add( node );
                    link( node, sink, 1, 0 );
                }
            }
            
            // Create nodes for all of the students, link them to positions
            for( int i=0; i<m; i++ )
            {
                Node student = new Node( "Student " + i );
                nodes.add( student );
                link( source, student, 1, 0 );
                
                // Instead of maximizing satisfaction, we're going to minimize cost,
                // where cost is 13-satisfaction
                int year = sc.nextInt();
                int basecost = 13 - year*4;
                
                for( int j=0; j<4; j++ )
                {
                    int preference = sc.nextInt();
                    for( int k=0; k<positions[preference].length; k++ )
                    {
                        link( student, positions[preference][k], 1, basecost+j );
                    }
                }
            }
            
            int result = fordfulkerson( source, sink, nodes );
            
            // FF returns min cost.
            // We've got to convert from cost back to satisfaction,
            // which is 13-cost for each student
            ps.println( 13*m - result );
        }
    }

    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        long start = System.currentTimeMillis();
        new jobpostings_vanb().doit();     
        System.err.println( System.currentTimeMillis()-start );
        
//        Random random = new Random();
//        System.out.println( "140 70" );
//        for( int i=0; i<140; i++ )
//        {
//            System.out.println( random.nextInt(10)+1 );
//        }
//        for( int i=0; i<70; i++ )
//        {
//            int year = random.nextInt(3)+1;
//            int p0 = random.nextInt(140);
//            int p1 = random.nextInt(140);
//            int p2 = random.nextInt(140);
//            int p3 = random.nextInt(140);
//            System.out.println( year + " " + p0 + " " + p1 + " " + p2 + " " + p3 );
//        }
    }
}