locality := localityLbEndpoint.Locality
		if locality.Region == "region1" && locality.Zone == "zone1" && locality.SubZone == "subzone1" {
			g.Expect(localityLbEndpoint.Priority).To(Equal(uint32(0)))
		} else if locality.Region == "region1" && locality.Zone == "zone1" && locality.SubZone == "subzone2" {
			g.Expect(localityLbEndpoint.Priority).To(Equal(uint32(1)))
		} else if locality.Region == "region2" {

						Locality: model.Locality{
							ClusterID: "cluster-1",
							Label:     "region1/zone1/subzone1",
						},
						LbWeight: 30,
						Network:  "filtered-out",
					},
				},
			},
			expected: []*endpoint.LocalityLbEndpoints{
				{
					Locality: &core.Locality{
						Region:  "region1",
						Zone:    "zone1",
						SubZone: "subzone1",
					},

	4:   {lang: 0x1f, region: 0x9a},
	5:   {lang: 0x3a, region: 0x6c},
	7:   {lang: 0x3b, region: 0x9d},
	8:   {lang: 0x1d7, region: 0x28},
	9:   {lang: 0x13, region: 0x9d},
	10:  {lang: 0x5b, region: 0x96},
	11:  {lang: 0x60, region: 0x52},
	12:  {lang: 0xb9, region: 0xb5},
	13:  {lang: 0x63, region: 0x96},
	14:  {lang: 0xa5, region: 0x35},
	15:  {lang: 0x3e9, region: 0x9a},
	17:  {lang: 0x529, region: 0x12f},

			},
			expectedInitialStates: map[string]ZoneState{
				testutil.CreateZoneID("region1", "zone1"): stateFullDisruption,
				testutil.CreateZoneID("region1", "zone2"): stateFullDisruption,
			},
			expectedFollowingStates: map[string]ZoneState{
				testutil.CreateZoneID("region1", "zone1"): stateFullDisruption,
				testutil.CreateZoneID("region1", "zone2"): stateNormal,
			},
		},

  // IfRegion condition should always be a scalar. Select the region to fold to.
  bool cond = cond_attr.getSplatValue<BoolAttr>().getValue();
  Region& region = cond ? op.getThenBranch() : op.getElseBranch();

  // If the IfRegion is stateless but the region being inlined itself is not
  // stateless, then inlining the region could cause a loss of information.

    // Add the successor regions using the condition.
    regions.push_back(RegionSuccessor(condition ? &getThenRegion() : else_reg));
  } else {
    // If the condition isn't constant, both regions may be executed.
    regions.push_back(RegionSuccessor(&getThenRegion()));
    // If the else region does not exist, it is not a viable successor.
    if (else_reg) regions.push_back(RegionSuccessor(else_reg));
    return;

    --network="${NETWORK}" \
    --regions="${REGION}" \
    --project="${NETWORK_PROJECT}" \
    --limit=1 \
    --format='value(name)' 2>/dev/null)

  if [[ -n ${SUBNETWORK:-} ]]; then
    echo "Found subnet for region ${REGION} in network ${NETWORK}: ${SUBNETWORK}"
    return 0
  fi

  echo "${color_red}Could not find subnetwork with region ${REGION}, network ${NETWORK}, and project ${NETWORK_PROJECT}"

    TypeRange input_types, ArrayRef<Region*> regions, int64_t max_iterations) {
  DCOMMENT("\tPropagating shapes to regions");
  bool any_failure = false;
  bool any_nonconvergence = false;
  // If shape propagation fails for one region, return failure, but do not
  // early exit and attempt to propagate shapes for all provided regions to
  // have a best-effort propagation.
  for (auto region : regions) {

		{
			name: "backfill required for new stable labels for os/arch/zones/regions/instance-type",
			initialNode: &v1.Node{
				ObjectMeta: metav1.ObjectMeta{
					Labels: map[string]string{
						v1.LabelHostname:                "new-hostname",
						v1.LabelTopologyZone:            "new-zone-failure-domain",
						v1.LabelTopologyRegion:          "new-zone-region",
						v1.LabelFailureDomainBetaZone:   "new-zone-failure-domain",

}

def FunctionalControlFlowToRegionsPass : Pass<"tf-functional-control-flow-to-regions", "ModuleOp"> {
  let summary = "Transforms functional control flow operations to their region-based counterparts";

  let description = [{
    This pass transforms functional control flow operations in the TensorFlow
    dialect to their region-based counterparts, i.e., `tf.If` is transformed to