//     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

Diagnostics from elements:
  for PSI element of type KtParameter at (3,21-28)
    UNUSED_PARAMETER      text ranges: [(53,54)]
      PSI: KtParameter at (3,21-28)
  for PSI element of type KtParameter at (3,30-45)
    UNUSED_PARAMETER      text ranges: [(62,63)]

Diagnostics from elements:
  for PSI element of type KtStringTemplateExpression at (3,11-34)
    ERROR_SUPPRESSION      text ranges: [(27,50)]
      PSI: KtStringTemplateExpression at (3,11-34)
  for PSI element of type KtStringTemplateExpression at (8,11-34)
    ERROR_SUPPRESSION      text ranges: [(115,138)]

    return
  fi

  echo "Adding secondary ranges: pods-default (${CLUSTER_IP_RANGE}), services-default (${SERVICE_CLUSTER_IP_RANGE})"
  until gcloud compute networks subnets update "${IP_ALIAS_SUBNETWORK}" \
    --project="${PROJECT}" --region="${REGION}" \
    --add-secondary-ranges="pods-default=${CLUSTER_IP_RANGE},services-default=${SERVICE_CLUSTER_IP_RANGE}"; do

	fs.StringVar(&s.ServiceClusterIPRanges, "service-cluster-ip-range", s.ServiceClusterIPRanges, ""+
		"A CIDR notation IP range from which to assign service cluster IPs. This must not "+
		"overlap with any IP ranges assigned to nodes or pods. Max of two dual-stack CIDRs is allowed.")

	fs.Var(&s.ServiceNodePortRange, "service-node-port-range", ""+

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

					return nil, errors.New("invalid range")
				}
				if i >= size {
					i = size - 1
				}
				r.length = i - r.start + 1
			}
		}
		ranges = append(ranges, r)
	}
	if noOverlap && len(ranges) == 0 {
		// The specified ranges did not overlap with the content.
		return nil, errNoOverlap
	}
	return ranges, nil
}

                fun DiagnosticKey.print(indent: Int) {
                    val indentString = " ".repeat(indent)
                    append(indentString + factoryName)
                    appendLine("$indentString  text ranges: $textRanges")
                    appendLine("$indentString  PSI: ${psi::class.simpleName} at ${psi.textRange.asLineColumnRange()}")
                }
                appendLine("Diagnostics from elements:")

        .initializer(
          """
          |%T(⇥
          |sections = "%L",
          |ranges = "%L",
          |mappings = "%L",
          |⇤)
          """.trimMargin(),
          idnaMappingTable,
          data.sections.escapeDataString(),
          data.ranges.escapeDataString(),
          data.mappings.escapeDataString(),
        )
        .build(),
    )
    .build()
}

	mux.Handle("/", traceviewer.MainHandler([]traceviewer.View{
		{Type: traceviewer.ViewProc, Ranges: ranges},
		// N.B. Use the same ranges for threads. It takes a long time to compute
		// the split a second time, but the makeup of the events are similar enough
		// that this is still a good split.
		{Type: traceviewer.ViewThread, Ranges: ranges},
	}))

	// Catapult handlers.
	mux.Handle("/trace", traceviewer.TraceHandler())