}

  xla::DeviceAssignmentProto device_assignment_proto;
  device_assignment.Serialize(&device_assignment_proto);

  return std::pair<TPUDevicesAndHosts, xla::DeviceAssignmentProto>(
      std::move(devices_and_hosts), std::move(device_assignment_proto));
}

mlir::LogicalResult GetTopology(mlir::tf_device::ClusterOp cluster,
                                std::string& topology) {
  mlir::StringAttr topology_attr =

void OptimizeIntGraph::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  populateWithGenerated(patterns);
  auto func = getOperation();
  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    signalPassFailure();
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreateOptimizeIntGraphPass() {
  return std::make_unique<OptimizeIntGraph>();
}

// ConfigSchemeGroupVersion is group version used to register these objects
var ConfigSchemeGroupVersion = schema.GroupVersion{Group: ConfigGroupName, Version: "v1beta1"}

var (
	// TODO: move SchemeBuilder with zz_generated.deepcopy.go to k8s.io/api.
	// localSchemeBuilder and AddToScheme will stay in k8s.io/kubernetes.
	SchemeBuilder      runtime.SchemeBuilder
	localSchemeBuilder = &SchemeBuilder

    return;                                                              \
  }                                                                      \
  lhs = std::move(*statusor)

#define TF_STATUS_RETURN_IF_ERROR(rexpr, c_status)                         \
  _TF_STATUS_RETURN_IF_ERROR_IMPL(_TF_STATUS_CONCAT(_status, __COUNTER__), \
                                  rexpr, c_status);

	// tree indexes telling us which tree to use for each 50 symbol block.
	numSelectors := br.ReadBits(15)
	treeIndexes := make([]uint8, numSelectors)

	// The tree indexes are move-to-front transformed and stored as unary
	// numbers.
	mtfTreeDecoder := newMTFDecoderWithRange(numHuffmanTrees)
	for i := range treeIndexes {
		c := 0
		for {
			inc := br.ReadBits(1)
			if inc == 0 {

 public:
  explicit MlirFunction(std::unique_ptr<MLIRContext> context,
                        OwningOpRef<mlir::ModuleOp> module, func::FuncOp func)
      : AbstractFunction(kMlir),
        context_(std::move(context)),
        module_(std::move(module)),
        func_(func) {}

  Status GetFunctionDef(const tensorflow::FunctionDef** f) override;

  absl::StatusOr<tensorflow::core::RefCountPtr<tensorflow::FunctionRecord>>

        get() = builder.rootSession

    override fun isEmpty(): Boolean = withValidityAssertion {
        // isEmpty check needs to be performed on an analyzed declaration
        // (annotations can move to a nested declaration after code analysis).
        // See 'FirTypeResolveTransformer.moveOrDeleteIrrelevantAnnotations()'
        return backingAnnotations.isEmpty()
    }

    override val size: Int

    val stepRunner = AnalysisStepRunner()

    private
    val conventionStorage = ConventionStorage()

    private
    val analysisContext = AnalysisStepContext(
        supportedDocumentChecks = emptyList(), // TODO: move the settings blocks check here,
        supportedResolutionResultHandlers = listOf(ConventionDefinitionCollector(conventionStorage), ConventionApplicationHandler(conventionStorage))
    )

    fun evaluate(

  if (!file) {
    return absl::InvalidArgumentError(
        absl::StrCat("Failed to open input file: ", error_message));
  }

  if (input_mlir) {
    source_mgr->AddNewSourceBuffer(std::move(file), llvm::SMLoc());
    return OwningOpRef<ModuleOp>(
        mlir::parseSourceFile<mlir::ModuleOp>(*source_mgr, context));
  }

  // Register extra TF ops passed as OpDef.

    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse move(final ListForm form) {
        saveToken();
        return doMove(form, 0);
    }

    protected HtmlResponse doMove(final ListForm form, final int move) {
        form.initialize();
        Integer pageNumber = form.pn;
        if (pageNumber != null && pageNumber > 0) {
            pageNumber = pageNumber + move;
            if (pageNumber < 1) {