ImmutableRangeSet(ImmutableList<Range<C>> ranges) {
    this.ranges = ranges;
  }

  private ImmutableRangeSet(ImmutableList<Range<C>> ranges, ImmutableRangeSet<C> complement) {
    this.ranges = ranges;
    this.complement = complement;
  }

  private final transient ImmutableList<Range<C>> ranges;

  @Override
  public boolean intersects(Range<C> otherRange) {
    int ceilingIndex =
        SortedLists.binarySearch(

    NONE_APPLICABLE      text ranges: [(89,92)]
      PSI: KtNameReferenceExpression at (6,5-8)
  for PSI element of type KtNameReferenceExpression at (7,5-8)
    NONE_APPLICABLE      text ranges: [(100,103)]
      PSI: KtNameReferenceExpression at (7,5-8)
  for PSI element of type KtNameReferenceExpression at (8,5-8)
    NONE_APPLICABLE      text ranges: [(115,118)]
      PSI: KtNameReferenceExpression at (8,5-8)

    DEPRECATION      text ranges: [(302,320)]
      PSI: KtNameReferenceExpression at (71,21-39)
  for PSI element of type KtNameReferenceExpression at (72,21-39)
    DEPRECATION      text ranges: [(352,370)]
      PSI: KtNameReferenceExpression at (72,21-39)
  for PSI element of type KtNameReferenceExpression at (74,21-40)
    DEPRECATION      text ranges: [(396,415)]
      PSI: KtNameReferenceExpression at (74,21-40)

    } else {
      Range<K> range = ranges.get(index);
      return range.contains(key) ? Maps.immutableEntry(range, values.get(index)) : null;
    }
  }

  @Override
  public Range<K> span() {
    if (ranges.isEmpty()) {
      throw new NoSuchElementException();
    }
    Range<K> firstRange = ranges.get(0);
    Range<K> lastRange = ranges.get(ranges.size() - 1);

	}
}

// unifyCallRanges ensures that the ranges for a given inline
// transitively include all of the ranges for its child inlines.
func unifyCallRanges(inlcalls dwarf.InlCalls, idx int) {
	ic := &inlcalls.Calls[idx]
	for _, childIdx := range ic.Children {
		// First make sure child ranges are unified.
		unifyCallRanges(inlcalls, childIdx)

		// Then merge child ranges into ranges for this inline.
		cic := inlcalls.Calls[childIdx]

			ranges[0] = singleRange{first: 0}
			first = false
		}

		i := 0
		for _, r := range setText {
			if first {
				// lower bound in a new range
				ranges[i] = singleRange{first: r}
				first = false
			} else {
				ranges[i].last = r - 1
				i++
				first = true
			}
		}
	}

	return len(ranges)
}

type singleRange struct {
	first rune
	last  rune

    }

    internal
    fun erase(ranges: List<IntRange>): ProgramText =
        if (ranges.isEmpty()) this
        else ProgramText(text.erase(ranges))

    fun preserve(vararg ranges: IntRange): ProgramText =
        erase(complementOf(ranges))

    internal
    fun preserve(ranges: List<IntRange>): ProgramText =
        preserve(*ranges.toTypedArray())

    fun subText(range: IntRange): ProgramText =

  return result.toMap()
}

/**
 * Modifies [ranges] to combine any adjacent [MappedRange.InlineDelta] of same size to single entry.
 * @returns same instance of [ranges] for convenience
 */
internal fun mergeAdjacentDeltaMappedRanges(ranges: MutableList<MappedRange>): MutableList<MappedRange> {
  var i = 0
  while (i < ranges.size) {
    val curr = ranges[i]
    if (curr is MappedRange.InlineDelta) {
      val j = i + 1

	ranges, ok := v.ranges[r]
	return ok && slices.Contains(ranges, name)
}

func (v *Validator) addRange(r trace.ResourceID, name string) {
	ranges, _ := v.ranges[r]
	ranges = append(ranges, name)
	v.ranges[r] = ranges
}

func (v *Validator) hasAnyRange(r trace.ResourceID) bool {
	ranges, ok := v.ranges[r]
	return ok && len(ranges) != 0
}

    TYPE_MISMATCH      text ranges: [(97,159)]
      PSI: KtCallExpression at (23,20) - (26,2)
  for PSI element of type KtLambdaExpression at (23,24) - (26,2)
    TYPE_MISMATCH      text ranges: [(101,159)]
      PSI: KtLambdaExpression at (23,24) - (26,2)
  for PSI element of type KtNameReferenceExpression at (24,5-17)
    UNRESOLVED_REFERENCE      text ranges: [(107,119)]
      PSI: KtNameReferenceExpression at (24,5-17)