<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def _unfiltered_jvm_dependency_map(self, fully_transitive=False):
 """Jvm dependency map without filtering out non-JvmTarget keys, exposed for testing. Unfiltered because the keys in the resulting map include non-JvmTargets. See the explanation in the jvm_dependency_map() docs for what this method produces. :param fully_transitive: if true, the elements of the map will be the full set of transitive JvmTarget dependencies, not just the "direct" ones. (see jvm_dependency_map for the definition of "direct") :return: map of target -> set of JvmTarget "direct" dependencies. """

    targets = self.jvm_targets
    jvm_deps = defaultdict(set)

    def accumulate_jvm_deps(target):
      for dep in target.dependencies:
        if self._is_jvm_target(dep):
          jvm_deps[target].add(dep)
          if not fully_transitive:
            continue
        # If 'dep' isn't in jvm_deps, that means that it isn't in the `targets` list at all
        # (since this is a post-order traversal). If it's not in the targets list at all,
        # that means it cannot have any JvmTargets as transitive dependencies. In which case
        # we don't care about it, so it's fine that the line below is a no-op.
        #
        # Otherwise, we add in any transitive dependencies that were previously collected.
        jvm_deps[target].update(jvm_deps[dep])

    # Vanilla DFS runs in O(|V|+|E|), and the code inside the loop in accumulate_jvm_deps ends up
    # being run once for each in the graph over the course of the entire search, which means that
    # the total asymptotic runtime complexity is O(|V|+2|E|), which is still O(|V|+|E|).
    self.context.build_graph.walk_transitive_dependency_graph(
      addresses=[t.address for t in targets],
      work=accumulate_jvm_deps,
      postorder=True
    )

    return jvm_deps