You are given m sets of integers A_1, A_2, …, A_m; elements of these sets are integers between 1 and n, inclusive.

There are two arrays of positive integers a_1, a_2, …, a_m and b_1, b_2, …, b_n. 

In one operation you can delete an element j from the set A_i and pay a_i + b_j coins for that.

You can make several (maybe none) operations (some sets can become empty).

After that, you will make an edge-colored undirected graph consisting of n vertices. For each set A_i you will add an edge (x, y) with color i for all x, y ∈ A_i and x < y. Some pairs of vertices can be connected with more than one edge, but such edges have different colors.

You call a cycle i_1 → e_1 → i_2 → e_2 → … → i_k → e_k → i_1 (e_j is some edge connecting vertices i_j and i_{j+1} in this graph) rainbow if all edges on it have different colors.

Find the minimum number of coins you should pay to get a graph without rainbow cycles.

Input

The first line contains two integers m and n (1 ≤ m, n ≤ 10^5), the number of sets and the number of vertices in the graph.

The second line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 10^9).

The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9).

In the each of the next of m lines there are descriptions of sets. In the i-th line the first integer s_i (1 ≤ s_i ≤ n) is equal to the size of A_i. Then s_i integers follow: the elements of the set A_i. These integers are from 1 to n and distinct.

It is guaranteed that the sum of s_i for all 1 ≤ i ≤ m does not exceed 2 ⋅ 10^5.

Output

Print one integer: the minimum number of coins you should pay for operations to avoid rainbow cycles in the obtained graph.

Examples

Input


3 2
1 2 3
4 5
2 1 2
2 1 2
2 1 2


Output


11


Input


7 8
3 6 7 9 10 7 239
8 1 9 7 10 2 6 239
3 2 1 3
2 4 1
3 1 3 7
2 4 3
5 3 4 5 6 7
2 5 7
1 8


Output


66

Note

In the first test, you can make such operations:

  * Delete element 1 from set 1. You should pay a_1 + b_1 = 5 coins for that. 
  * Delete element 1 from set 2. You should pay a_2 + b_1 = 6 coins for that. 



You pay 11 coins in total. After these operations, the first and the second sets will be equal to \{2\} and the third set will be equal to \{1, 2\}.

So, the graph will consist of one edge (1, 2) of color 3.

In the second test, you can make such operations:

  * Delete element 1 from set 1. You should pay a_1 + b_1 = 11 coins for that. 
  * Delete element 4 from set 2. You should pay a_2 + b_4 = 13 coins for that. 
  * Delete element 7 from set 3. You should pay a_3 + b_7 = 13 coins for that. 
  * Delete element 4 from set 4. You should pay a_4 + b_4 = 16 coins for that. 
  * Delete element 7 from set 6. You should pay a_6 + b_7 = 13 coins for that. 



You pay 66 coins in total.

After these operations, the sets will be:

  * \{2, 3\}; 
  * \{1\}; 
  * \{1, 3\}; 
  * \{3\}; 
  * \{3, 4, 5, 6, 7\}; 
  * \{5\}; 
  * \{8\}. 



We will get the graph:

<image>

There are no rainbow cycles in it.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class avoidrainbow {
	public static void main(String[] args) {
		FastScanner scan=new FastScanner();
		PrintWriter out=new PrintWriter(System.out);
		
		int m=scan.nextInt(), n=scan.nextInt();
		
		/*
		wanna be connecting numbers to their sets
		travel between sets via their common numbers
		so we can't connect two nodes in the dsu if they are already connected
		because that would result in a cycle
		like the kruskals mst
		*/
		
		DSU d=new DSU(n+m+1);
		
		long res=0L;
		int[] a=new int[m], b=new int[n];
		for(int i=0;i<m;i++) a[i]=scan.nextInt();
		for(int i=0;i<n;i++) b[i]=scan.nextInt();
		
		PriorityQueue<num> q=new PriorityQueue<>();
		for(int i=0;i<m;i++) {
			int x=scan.nextInt();
			for(int j=0;j<x;j++) {
				int val=scan.nextInt();
				q.offer(new num(i,j,val,a[i]+b[val-1]));
			}
		}
		
		while(!q.isEmpty()) {
			num cur=q.poll();
			if(d.unite(cur.set+n+1,cur.val)) res+=cur.cost;
		}
		
		out.println(res);
		out.close();
	}
	static class num implements Comparable<num> {
		int set,id,val,cost;
		num(int set, int id, int val, int cost) {
			this.set=set;
			this.id=id;
			this.val=val;
			this.cost=cost;
		}
		@Override
		public int compareTo(num o) {
			return o.cost-cost;
		}
	}
	static class DSU {
        int n;
        int[] parent, size;

        public DSU(int v) {
            n = v;
            parent = new int[n];
            size = new int[n];
            for(int i = 0; i < n; i++) {
                parent[i] = i;
                size[i] = 1;
            }
        }

        public int findRoot(int curr) {
            if(curr == parent[curr]) return curr;
            return parent[curr] = findRoot(parent[curr]);
        }

        public boolean unite(int a, int b) {
            int rootA = findRoot(a);
            int rootB = findRoot(b);
            if(rootA == rootB) return true;
            if(size[rootA] > size[rootB]) {
                parent[rootB] = rootA;
                size[rootA] += size[rootB];
            }
            else {
                parent[rootA] = rootB;
                size[rootB] += size[rootA];
            }
            return false;
        }

    }
	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

		public int nextInt() {return Integer.parseInt(next());}

		public long nextLong() {return Long.parseLong(next());}

		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}
	}
}