Diagnostics from elements:
  for PSI element of type KtConstructorCalleeExpression at (33,2-12)
    NO_VALUE_FOR_PARAMETER      text ranges: [(114,124)]
      PSI: KtConstructorCalleeExpression at (33,2-12)
  for PSI element of type KtNameReferenceExpression at (31,8-10)
    UNRESOLVED_REFERENCE      text ranges: [(93,95)]

                    "typed_config": {
                      "@type": "type.googleapis.com/xds.type.matcher.v3.IPMatcher",
                      "range_matchers": [
                        {
                          "ranges": [
                            {
                              "address_prefix": "10.111.182.109",
                              "prefix_len": 32
                            }
                          ],

import javax.annotation.CheckForNull;

/**
 * A mapping from disjoint nonempty ranges to non-null values. Queries look up the value associated
 * with the range (if any) that contains a specified key.
 *
 * <p>In contrast to {@link RangeSet}, no "coalescing" is done of {@linkplain
 * Range#isConnected(Range) connected} ranges, even if they are mapped to the same value.
 *
 * @author Louis Wasserman
 * @since 14.0
 */

    // test that connected ranges are coalesced
    for (int i = 0; i + 1 < asRanges.size(); i++) {
      Range<C> range1 = asRanges.get(i);
      Range<C> range2 = asRanges.get(i + 1);
      assertFalse(range1.isConnected(range2));
    }

    // test that there are no empty ranges
    for (Range<C> range : asRanges) {
      assertFalse(range.isEmpty());
    }

Diagnostics from elements:
  for PSI element of type KtStringTemplateExpression at (4,15-38)
    ERROR_SUPPRESSION      text ranges: [(50,73)]
      PSI: KtStringTemplateExpression at (4,15-38)
  for PSI element of type KtStringTemplateExpression at (9,15-38)
    ERROR_SUPPRESSION      text ranges: [(154,177)]

Diagnostics from elements:
  for PSI element of type KtNamedFunction at (20,1) - (22,2)
    CONFLICTING_OVERLOADS      text ranges: [(394,415)]
      PSI: KtNamedFunction at (20,1) - (22,2)
  for PSI element of type KtNamedFunction at (7,1) - (9,2)
    CONFLICTING_OVERLOADS      text ranges: [(215,233)]

Diagnostics from elements:
  for PSI element of type KtStringTemplateExpression at (12,11-34)
    ERROR_SUPPRESSION      text ranges: [(152,175)]
      PSI: KtStringTemplateExpression at (12,11-34)
  for PSI element of type KtStringTemplateExpression at (7,11-34)
    ERROR_SUPPRESSION      text ranges: [(64,87)]

	}

	return cu, 0, nil
}

func (d *Data) dwarf2Ranges(u *unit, base uint64, ranges int64, ret [][2]uint64) ([][2]uint64, error) {
	if ranges < 0 || ranges > int64(len(d.ranges)) {
		return nil, fmt.Errorf("invalid range offset %d (max %d)", ranges, len(d.ranges))
	}
	buf := makeBuf(d, u, "ranges", Offset(ranges), d.ranges[ranges:])
	for len(buf.data) > 0 {
		low := buf.addr()
		high := buf.addr()

                    "typed_config": {
                      "@type": "type.googleapis.com/xds.type.matcher.v3.IPMatcher",
                      "range_matchers": [
                        {
                          "ranges": [
                            {
                              "address_prefix": "10.111.182.109",
                              "prefix_len": 32
                            }
                          ],

//     connectivity.
//   - CloudAllocator is an allocator that synchronizes PodCIDRs from IP
//     ranges assignments from the underlying cloud platform.
//   - (Alpha only) IPAMFromCluster is an allocator that has the similar
//     functionality as the RangeAllocator but also synchronizes cluster-managed
//     ranges into the cloud platform.
//   - (Alpha only) IPAMFromCloud is the same as CloudAllocator (synchronizes