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)

	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]
		ic.Ranges = dwarf.MergeRanges(ic.Ranges, cic.Ranges)
	}

			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 =

          rangesBuffer.writeByte(range.b2)
          rangesBuffer.writeByte('-'.code)
        }
        is MappedRange.Inline2 -> {
          rangesBuffer.writeByte(range.b1)
          rangesBuffer.writeByte(range.b2)
          rangesBuffer.writeByte(range.b3)
        }
        is MappedRange.InlineDelta -> {
          rangesBuffer.writeByte(range.b1)
          rangesBuffer.writeByte(range.b2)

	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)

// It expects ev to be one such event.
func (g *procRangeGenerator) ProcRange(ctx *traceContext, ev *trace.Event) {
	if g.ranges == nil {
		g.ranges = make(map[trace.Range]activeRange)
	}
	r := ev.Range()
	switch ev.Kind() {
	case trace.EventRangeBegin:
		g.ranges[r] = activeRange{ev.Time(), ev.Stack()}
	case trace.EventRangeActive:
		// If we've seen a Sync event, then Active events are always redundant.

  }
  return @ranges;
}

sub PrintClass($$@) {
  my ($cname, $name, @ranges) = @_;
  print "var code$cname = []rune{  /* $name */\n";
  for (my $i=0; $i<@ranges; $i++) {
    my @a = @{$ranges[$i]};
    printf "\t0x%x, 0x%x,\n", $a[0], $a[1];
  }
  print "}\n\n";
  my $n = @ranges;
  my $negname = $name;
  if ($negname =~ /:/) {
    $negname =~ s/:/:^/;
  } else {
    $negname =~ y/a-z/A-Z/;
  }

	ranges := tagFilterRangeRx.FindAllStringSubmatch(filter, 2)
	if len(ranges) == 0 {
		return nil // No ranges were identified
	}
	v, err := strconv.ParseInt(ranges[0][1], 10, 64)
	if err != nil {
		panic(fmt.Errorf("failed to parse int %s: %v", ranges[0][1], err))
	}
	scaledValue, unit := measurement.Scale(v, ranges[0][2], ranges[0][2])
	if len(ranges) == 1 {