code: def get_explaining_locations(traces):
      # Traces is a dict[interesting_origin | None, set[frozenset[tuple[str, int]]]]
      # Each trace in the set might later become a Counter instead of frozenset.
      if not traces:
          return {}
  
      unions = {
          origin: set().union(*values)
          for origin, values in traces.items()
      }
      seen_passing = {None}.union(*unions.pop(None, set()))
  
      always_failing_never_passing = {
          origin: reduce(
              set.intersection, [set().union(*v) for v in values]
          )
          - seen_passing
          for origin, values in traces.items()
          if origin is not None
      }
  
      # Build the observed parts of the control-flow graph for each origin
      cf_graphs = {origin: defaultdict(set) for origin in unions}
      for origin, seen_arcs in unions.items():
          for src, dst in seen_arcs:
              cf_graphs[origin][src].add(dst)
          assert cf_graphs[origin][
              None
          ], "Expected start node with >=1 successor"
  
      # For each origin, our explanation is the always_failing_never_passing lines
      # which are reachable from the start node (None) without passing through another
      # AFNP line.  So here's a whatever-first search with early stopping:
      explanations = defaultdict(set)
      for origin in unions:
          queue = {None}
          seen = set()
          while queue:
              assert queue.isdisjoint(
                  seen
              ), f"Intersection: {queue & seen}"
              src = queue.pop()
              seen.add(src)
              if src in always_failing_never_passing[origin]:
                  explanations[origin].add(src)
              else:
                  queue.update(cf_graphs[origin][src] - seen)
  
      # The last step is to filter out explanations that we know would be uninformative.
      # When this is the first AFNP location, we conclude that Scrutineer missed the
      # real divergence (earlier in the trace) and drop that unhelpful explanation.
      return {
          origin: {
              loc
              for loc in afnp_locs
              if not loc[0].endswith(UNHELPFUL_LOCATIONS)
          }
          for origin, afnp_locs in explanations.items()
      }
  
imports: import functools
  import os
  import subprocess
  import sys
  import types
  from collections import defaultdict
  from functools import lru_cache, reduce
  from os import sep
  from pathlib import Path
  from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
  from hypothesis._settings import Phase, Verbosity
  from hypothesis.internal.escalation import is_hypothesis_file
label_desc: Use image node_id 2 for calling a global function with example usage: get_explaining_locations(traces) and returns: unknown, dict