code: def _maybe_resolve_mixed_calls(overlapping_candidates):
      """Yields variants with compatible genotype calls in order.
  
      This function differs from `_resolve_overlapping_variants` below in that the
      input here is a block of all candidate calls that overlap in a region, which
      may contain candidates that are deemed to be most likely reference calls.
      We often tune DeepVariant to be highly sensitive. Consequently, there can be
      many candidate calls that are predicted as reference. Since those do not
      contribute to potential incompatibilities, we split them out from variants
      predicted to contain non-reference genotypes since the computation of
      compatible haplotypes is exponential in the number of inputs.
  
      Args:
        overlapping_candidates: list(Variant). A non-empty list of Variant protos in
          coordinate-sorted order that overlap on the reference genome.
  
      Yields:
        Variant protos in coordinate-sorted order that try to resolve incompatible
        haplotypes.
      """
      # Short circuit the simplest case: A single variant in a region is compatible
      # with itself by definition.
      if len(overlapping_candidates) == 1:
          yield overlapping_candidates[0]
          return
  
      def has_variation(candidate):
          return _nonref_genotype_count(candidate) > 0
  
      reference_calls = [
          c for c in overlapping_candidates if not has_variation(c)
      ]
      variant_calls = [
          v for v in overlapping_candidates if has_variation(v)
      ]
  
      resolved_variant_calls = []
      for variant_group in _group_overlapping_variants(variant_calls):
          resolved_variant_calls.extend(
              _resolve_overlapping_variants(variant_group)
          )
  
      # Merge the reference and resolved variants back together in sorted order.
      # Note: This could be done in an interleaving fashion, but since the total
      # number of variants in the input is nearly always < 20 this is not an issue.
      for variant in sorted(
          reference_calls + resolved_variant_calls,
          key=variant_utils.variant_range_tuple,
      ):
          yield variant
  
imports: import copy
  import itertools
  from absl import flags
  from absl import logging
  import numpy
  from third_party.nucleus.util import genomics_math
  from third_party.nucleus.util import variant_utils
label_desc: Use image node_id 3 for calling a global function with example usage: _maybe_resolve_mixed_calls(overlapping_candidates) and returns: unknown