#!/usr/bin/env pypy3
# 解説参照後

import array
import collections
import itertools
import sys


REC_LIMIT = 10000
INF = 10 ** 8


Edge = collections.namedtuple("Edge", "source sink capacity")


class FlowNetwork(object):

    def __init__(self, num_vertices):
        self.adj_edges = [set() for _ in range(num_vertices)]
        self.flow = None
        self.rev_edge = dict()
        self.used = None

    def get_edges_from(self, vertex):
        return self.adj_edges[vertex]

    def add_edge(self, source, sink, capacity):
        assert source != sink
        forward_edge = Edge(source, sink, capacity)
        backward_edge = Edge(sink, source, 0)
        self.rev_edge[forward_edge] = backward_edge
        self.rev_edge[backward_edge] = forward_edge
        self.adj_edges[source].add(forward_edge)
        self.adj_edges[sink].add(backward_edge)

    def dfs(self, source, sink, flow):
        if source == sink:
            return flow
        self.used[source] = True
        for edge in self.get_edges_from(source):
            rest = edge.capacity - self.flow[edge]
            if self.used[edge.sink] or rest <= 0:
                continue
            d = self.dfs(edge.sink, sink, min(flow, rest))
            if d > 0:
                self.flow[edge] += d
                self.flow[self.rev_edge[edge]] -= d
                return d
        return 0

    def ford_fulkerson(self, source, sink):
        self.flow = collections.defaultdict(int)
        max_flow = 0
        while True:
            self.used = collections.defaultdict(bool)
            df = self.dfs(source, sink, INF)
            if df == 0:
                return max_flow
            else:
                max_flow += df


def main():
    sys.setrecursionlimit(REC_LIMIT)
    w = int(input())
    # 原画マンの数
    n = int(input())
    js = array.array("I", map(int, input().split()))
    # 作画監督の数
    m = int(input())
    cs = array.array("I", map(int, input().split()))
    # hate[i][j]: 作画監督iは原画マンjを嫌っているか？
    hate = [array.array("B", (False for _ in range(n))) for _ in range(m)]
    for i in range(m):
        qxs = array.array("I", map(lambda x: int(x) - 1, input().split()))
        for j in qxs[1:]:
            hate[i][j] = True
    # ソースを頂点0とする
    # 原画マンを頂点1, 2, ..., 1 + j, ...,  nとする
    # 作画監督を頂点n + 1, n + 2, ..., n + i + 1, ..., n + mとする
    # シンクを頂点n + m + 1とする
    num_vertices = n + m + 2  # 頂点の数
    source = 0
    sink = n + m + 1
    network = FlowNetwork(num_vertices)
    # ソース -> 原画マン
    for j in range(n):
        network.add_edge(0, 1 + j, js[j])
    # 作画監督 -> シンク
    for i in range(m):
        network.add_edge(1 + n + i, sink, cs[i])
    # 嫌いではなければ原画マン -> 作画監督
    for j, i in itertools.product(range(n), range(m)):
        if not hate[i][j]:
            network.add_edge(1 + j, 1 + n + i, INF)
    mf = network.ford_fulkerson(source, sink)
    print("SHIROBAKO" if mf >= w else "BANSAKUTSUKITA")


if __name__ == '__main__':
    main()