import sys, math

# Pretty important line here.
sys.setrecursionlimit(10**6)

def preprocess_original_tree(node, parent):
    # "Jumping" out the current node.
    global timer
    tin[node] = timer
    timer += 1

    # Building a chart of the 2^i ancestors of each node.
    up[node][0] = parent

    # Setting each node's (which is the current child) 2^i ancestors' value.
    for i in range(1, LOG):
        if up[node][i - 1] != -1:
            up[node][i] = up[up[node][i - 1]][i - 1]

    # Perform DFS to set current node's children's depth recursively.
    for neighbor in adj[node]:
        if neighbor == parent:
            continue
        depth[neighbor] = depth[node] + 1
        preprocess_original_tree(neighbor, node)

    # "Jumping" out of the current node.
    tout[node] = timer
    timer += 1

def lift_node(node, k):
    # Jumping to the greatest 2^i ancestor each time.
    for i in range(LOG - 1, -1, -1):
        if k & (1 << i):
            node = up[node][i]
    return node

def get_lca(u, v):
    # Equalizing both node's depths.
    if depth[u] < depth[v]:
        u, v = v, u
    u = lift_node(u, depth[u] - depth[v])
    if u == v:
        return u

    # Jumping to the greatest 2^i ancestor each time.
    for i in range(LOG - 1, -1, -1):
        if up[u][i] != up[v][i]:
            u = up[u][i]
            v = up[v][i]
    return up[u][0]

def get_distance(u, v):
    ancestor = get_lca(u, v)

    # It uses the original tree's preprocessed depths.
    return depth[u] + depth[v] - 2 * depth[ancestor]

def build_virtual_tree(nodes):
    # Adding relevant nodes to virtual tree.
    nodes.sort(key=lambda x: tin[x])
    m = len(nodes)
    vt_nodes = nodes[:]
    for i in range(m - 1):
        vt_nodes.append(get_lca(nodes[i], nodes[i + 1]))
    vt_nodes = list(set(vt_nodes))
    vt_nodes.sort(key=lambda x: tin[x])

    # Connecting nodes in virtual tree.
    tree = {node: [] for node in vt_nodes}
    stack = []
    
    # All virtual tree nodes are stored in the order in which they were found, thus preserving their hierarchy from left to right.
    for node in vt_nodes:
        # Validating if the last ancestor in the stack is the ancestor of the current node.
        while stack and tout[stack[-1]] < tin[node]:
            stack.pop()
        if stack:
            tree[stack[-1]].append(node)
        stack.append(node)
    return tree, vt_nodes

def solve_query(query_nodes):
    # Traversing query nodes (virtual tree's nodes)
    def dp(u):
        nonlocal res
        s = query_val.get(u, 0)

        # Performing DFS.
        for v in vt[u]:
            sub = dp(v)
            # Since 
            # sum(u in sub) * sum(v not in sub) 
            # = (sum(u in sub)) * (sum(v not in sub)) 
            # = sub * (S_total - sub)
            res = (res + sub * (S_total - sub) % MOD * get_distance(u, v)) % MOD
            s += sub

        # Returning the total sum of the current subtree.
        return s

    if len(query_nodes) < 2:
        return 0
    S_total = sum(query_nodes)
    query_val = {node: node for node in query_nodes}
    vt, vt_nodes = build_virtual_tree(query_nodes)

    res = 0
    dp(vt_nodes[0])
    return res

MOD = 10**9 + 7
timer = 0

data = sys.stdin.read().split()
it = iter(data)
n = int(next(it))
q = int(next(it))

LOG = int(math.log2(n)) + 1
up = [[-1] * LOG for _ in range(n + 1)]
depth = [0] * (n + 1)
tin = [0] * (n + 1)
tout = [0] * (n + 1)

# Building original tree.
adj = [[] for _ in range(n + 1)]
for _ in range(n - 1):
    u, v = int(next(it)), int(next(it))
    adj[u].append(v)
    adj[v].append(u)

preprocess_original_tree(1, -1)

res = []
for _ in range(q):
    k = int(next(it))
    query_nodes = [int(next(it)) for _ in range(k)]
    res.append(str(solve_query(query_nodes)))

sys.stdout.write("\n".join(res))

'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let inputString: string = '';
let inputLines: string[]=[];
process.stdin.on('data', function(inputStdin: string): void {
    inputString += inputStdin;
});

function readLine():string{
    return inputLines.shift();
}

const K = 1000000007;
const L = 200001;

let parents : number[] = Array(L);
let children : number[] = Array(L);
function resetChildren(){
    children = Array(L).fill(0);
}
let valuesSet : boolean[] = Array(L-1);
function resetValuesSet(){
    valuesSet= Array(L-1).fill(false);
}

process.stdin.on('end', function(): void {
    inputLines = inputString.split('\n');
    inputString = '';
    main();
});


function main(){
    const [n,q] = initMain();
    // edges
    prepareEdges(n);
    queryloop:for(let i = 0; i < q; i++){
        const k = parseInt(readLine());
        if(k < 2) {
            // result = 0
            process.stdout.write(`0\n`);
            // skip next line
            readLine();
            // continue loop
            continue queryloop;
        }
        const query = readLine().split(" ").map(v => parseInt(v));
    
        // reset valueSet
        resetValuesSet();

        // reset children
        resetChildren();
        
        let valuesSum = 0;
        for (const q of query) {
            valuesSum += q;
            valuesSet[q] = true;
        }
        let sum = 0;
        for (let j = n; j > 0; j--) {
            let a = children[j];
            if (valuesSet[j]) {
                a += j;
            }
            if (a) {
                let x = a * (valuesSum - a);// ((a % K) * ((valuesSum - a) % K)) % K; //
                // sum =(sum + x)%K;
                sum += x;
                // if(sum>K) sum = sum % K;
            }
            children[parents[j]] += a;
        }
        process.stdout.write(`${sum%K}\n`);
    }
}

function initMain(){
    return readLine().split(" ").map(v => parseInt(v));
}

function prepareEdges(n:number){
    for (let i = 1; i < n; i++){
        const [a,b] = readLine().split(" ").map(v=>parseInt(v));
        if(a<b)
            parents[b] = a;
        else
            parents[a] = b;
    }
    parents[1]=0;
}