# from itertools import combinations


# nは頂点数。lは[頂点,頂点]がn-1個入ったリスト。Tree(n, l)としてobjectを生成。
class Tree():
    def __init__(self, n, l):

        self.n = n

        # 隣接する頂点のリストが格納された辞書
        self.w = {}
        for i in range(n - 1):
            a, b, path = l[i]
            if a in self.w:
                self.w[a].append((b, path))
            else:
                self.w[a] = [(b, path)]
            if b in self.w:
                self.w[b].append((a, path))
            else:
                self.w[b] = [(a, path)]


    # rootを根とした時の、各頂点の一つ上の親の頂点が格納された辞書を返す。
    def make_parents_list(self, root):
        self.parents = {}
        que = []
        seen = {}
        for i in range(1, n + 1):
            seen[i] = 0
        self.parents[root] = (None, None)
        seen[root] = 1
        que.append(root)
        while len(que) != 0:
            node = que.pop()
            for k in range(len(self.w[node])):
                node_2, path_2 = self.w[node][k]
                if seen[node_2] == 0:
                    seen[node_2] = 1
                    que.append(node_2)
                    self.parents[node_2] = (node, path_2)
                else:
                    continue
        return self.parents


    # 頂点uと頂点vの最小共通祖先(LCA)を求める。
    def lca(self, root, u, v):
        ancestors = set()
        if self.parents is None:
            parents = self.make_parents_list(root)
        else:
            parents = self.parents
        parent = u

        while parent is not None:
            ancestors.add(parent)
            parent = parents[parent][0]

        node = v
        while node not in ancestors:
            node = parents[node][0]

        return node


n = int(input())
l = []
for i in range(n - 1):
    a, b = [int(_) for _ in input().split()]
    l.append((a, b, i))
tree = Tree(n, l)
seiyaku = []
parents = tree.make_parents_list(1)
m = int(input())
for i in range(m):
    u, v = [int(_) for _ in input().split()]
    parent_node = tree.lca(1, u, v)
    s = set()
    node = u
    while node != parent_node:
        s.add(parents[node][1])
        node = parents[node][0]
    node = v
    while node != parent_node:
        s.add(parents[node][1])
        node = parents[node][0]
    seiyaku.append(s)

ans = 2 ** (n - 1)
for i in range(1, 2 ** m):
    i_bin = format(i, '0' + str(m) + 'b')
    k = 0
    q = []
    for j in range(m):
        if i_bin[j] == '1':
            q.append(j)
            k += 1
        else:
            continue
    s = set()
    for x in q:
        s |= seiyaku[x]
    ans += (-1) ** k * 2 ** (n - 1 -len(s))
    # print('*****************')
    # print('i_bin = ' ,i_bin)
    # print('k = ', k)
    # print('q = ', q)
    # print('s = ', s)
    # print('len(s) = ', len(s))
    # print('(-1) ** k * 2 ** (n - 1 - len(s)) = ', (-1) ** k * 2 ** (n - 1 - len(s)))
    # print('ans = ', ans)
print(ans)

# print('+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')

# cnt = 2**(n-1)

# f = 0
# for i in range(1, m+1):
#     flag = 1
#     if i % 2 == 1:
#         flag = -1
#     cc = combinations(list(range(m)), i)
#     for c in cc:
#         s = set()
#         for j in c:
#             s |= seiyaku[j]
#         cnt += (2**(n-1-len(s)))*flag
#         f += 1
#         print('*****************')
#         print('c = ' ,c)
#         print('flag = ', flag)
#         print('s = ', s)
#         print('len(s) = ', len(s))
#         print('(2**(n-1-len(s)))*flag = ', (2**(n-1-len(s)))*flag)
#         print('cnt = ', cnt)
# print(cnt)
# print('f = ', f)

Measured memory_bytes: 44904