// Build a subgraph with a given name out of the region either corresponding
  // to a function's body or while op. Modifies *region by calling
  // ExtractControlEdges.
  std::optional<BufferOffset<tflite::SubGraph>> BuildSubGraph(
      const std::string& name, Region* region, int index);

  // Modifies *block by unwrapping all ControlNodeOps. The DAG of the control

    output: A list of output tensors whose types are T.

    call:  Multiple regions, each of which encapsulates the same semantic
           computation but in different forms.
  }];

  let arguments = (ins Variadic<AnyTensor>:$input);

  let results = (outs Variadic<AnyTensor>:$output);

  let regions = (region VariadicRegion<SizedRegion<1>>:$calls);

  let hasCanonicalizer = 1;
}

      regions.push_back(getResults());
    } else {
      // For compatibility with older code, we allow the "yield" in a condition
      // to only yield a single boolean. In that case we can't forward any args.
      regions.push_back(RegionSuccessor(&getBody()));
      regions.push_back(RegionSuccessor());  // branch back to parent, no args
    }
  } else if (!point.isParent() && point == (*this)->getRegion(1)) {

  func.return %0 : tensor<2xf32>
}

// -----

// tf.Region yield number of results should match op number of results
func.func @testIfRegionThenResultCount(%arg0: tensor<i1>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  // expected-error @+1 {{'tf.IfRegion' op  region control flow edge from Region #0 to parent results: source has 2 operands, but target successor needs 1}}
  %0 = "tf.IfRegion"(%arg0) ({

  void runOnOperation() override;
};

using mhlo::DotDimensionNumbersAttr;

// Replaces `region`'s terminator to TF::Yield.
void ReplaceReturnOp(Region& region, PatternRewriter& rewriter) {
  OpBuilder::InsertionGuard guard(rewriter);

  for (auto& block : region.getBlocks()) {
    Operation* terminator = block.getTerminator();
    auto return_op = llvm::dyn_cast_or_null<mhlo::ReturnOp>(terminator);

		}
	}
}

// ServerProperties holds some server information such as, version, region
// uptime, etc..
type ServerProperties struct {
	Uptime       int64    `json:"uptime"`
	Version      string   `json:"version"`
	CommitID     string   `json:"commitID"`
	DeploymentID string   `json:"deploymentID"`
	Region       string   `json:"region"`
	SQSARN       []string `json:"sqsARN"`
}

entirety. nullable: true type: boolean failover: description: 'Optional: only one of distribute, failover or failoverPriority can be set.' items: properties: from: description: Originating region. type: string to: description: Destination region the traffic will fail over to when endpoints in the 'from' region becomes unhealthy. type: string type: object type: array failoverPriority: description: failoverPriority is an ordered list of labels used to sort endpoints to do priority based load balancing....

  }
  func.return
  // expected-remark@above {{ID: 9}}
  // expected-remark@above {{Sinks: {8}}}
}

// -----

// Tests that the pass adds control dependencies in nested regions with
// tf_device.replicate

func.func @with_replicate(
  // expected-remark@above {{ID: 12}}
  %arg0: tensor<*x!tf_type.resource<tensor<32xf32>>>,
  %arg1: tensor<*x!tf_type.resource<tensor<32xf32>>>,

    Federation control system then creates and maintains a single
    global virtual IP to load balance incoming HTTP(S) traffic across
    some or all the registered clusters, across all regions. Google's
    GCE L7 LoadBalancer is the first supported implementation, and
	is available in this release.
	([docs](http://kubernetes.io/docs/user-guide/federation/federated-ingress.md))

    // CHECK: return
    // CHECK-SAME: tensor<1x2x3xf32>
    func.return %0 : tensor<*xf32>
  }

  // Verify shape propagation from function arg -> if region body -> if region output -> function return type
  // CHECK-LABEL: shape_from_if_to_region_bodies_to_output
  // CHECK-SAME: -> tensor<1x2x3xf32>