if (!dict_attr) continue;

      OpBuilder builder(func.getContext());
      builder.setInsertionPointToStart(&func.getBlocks().front());
      builder.create<TFL::CallOnceOp>(func.getLoc(), init_func_op.getName());
    }
  }
}

}  // namespace

// Inserts a TFL::CallOnce op when tf_saved_model's session initializer is
// given.
std::unique_ptr<OperationPass<ModuleOp>>

              operand.getDefiningOp<corert::ConstDenseTensorOp>()) {
        new_values.push_back(
            rewriter.create<fallback_async::ConstDenseTensorOp>(
                op.getLoc(), rewriter.getType<fallback::TFTensorType>(),
                corert_const_dense_tensor_op.getValue()));
        should_rewrite = true;
        continue;
      }
      if (auto corert_const_string_tensor_op =

        // and once existing cases have been fixed.
        mlir::InFlightDiagnostic error =
            strict_clusters ? mlir::emitError(op.getLoc(), "")
                            : mlir::emitWarning(op.getLoc(), "");
        error << "Op has cyclic dependency with a compilation cluster:\n";
        error << "The cluster depends on\n";
        error << op.getName() << "\n"

  auto merged_execute_launch = builder->create<tf_device::LaunchOp>(
      merged_execute.getLoc(), execute_launch.getDeviceAttr(),
      merged_execute.getResultTypes());
  merged_execute_launch.getBody().push_back(new Block);

  builder->setInsertionPointToEnd(&merged_execute_launch.GetBody());
  builder->create<tf_device::ReturnOp>(merged_execute.getLoc(),
                                       merged_execute.getResults());

        transposer.TransposeValues(original_values);

    // Create a new constant op with the transposed values.
    const Location combined_loc =
        rewriter.getFusedLoc({const_op.getLoc(), op.getLoc()});
    auto new_value_type =
        RankedTensorType::getChecked(combined_loc, transposer.GetTargetShape(),
                                     /*elementType=*/rewriter.getF32Type());
    auto new_value_attr =

  Block* block = builder->createBlock(body);

  // Block arguments are scalars of the given element type.
  Type type = RankedTensorType::get(/*shape=*/{}, element_type);
  Location loc = body->getLoc();
  block->addArguments({type, type}, SmallVector<Location, 2>(2, loc));

  auto reducer =
      builder->create<Op>(loc, block->getArgument(0), block->getArgument(1));
  builder->create<ReturnOp>(loc, reducer.getResult());

    if (existing) return *existing;
  }

  ModuleOp module = region.getParentOfType<ModuleOp>();
  OpBuilder builder(module.getContext());
  auto loc = region.getParentOp()->getLoc();
  Block& entry = region.front();
  int num_region_arguments = entry.getNumArguments();
  Operation* terminator = entry.getTerminator();

  // Build the function type. Region arguments and extern values together

// another TF op.
// TODO(jpienaar): This is a workaround until behavior is established.
template <typename OpTy, typename... Args>
OpTy CreateTfOp(RewriterBase &b, Operation *op, Args &&...args) {
  auto ret = b.create<OpTy>(op->getLoc(), std::forward<Args>(args)...);
  CopyDeviceAndUnderscoredAttributes(op, ret.getOperation());
  return ret;
}

// Helper function to replace TF op with another op while copying all underscore

  tensorflow::Algorithm tensorflow_rng =
      tensorflow::ToTensorflowAlgorithm(xla_rng);

  OpBuilder opbuilder(get_alg_op);

  auto tf_const = opbuilder.create<TF::ConstOp>(
      get_alg_op->getLoc(), opbuilder.getI32IntegerAttr((int)tensorflow_rng));

  get_alg_op->replaceAllUsesWith(tf_const);
  get_alg_op->erase();
  return success();
}

void TFXLADeviceSpecificTransforms::runOnOperation() {

LogicalResult ConvertCustomCallOp::matchAndRewrite(
    mhlo::CustomCallOp mhlo_custom_call, OpAdaptor adaptor,
    ConversionPatternRewriter& rewriter) const {
  auto tfl_custom = rewriter.create<TFL::CustomOp>(
      mhlo_custom_call.getLoc(), mhlo_custom_call.getResultTypes(),
      mhlo_custom_call.getInputs());
  tfl_custom.setCustomCodeAttr(
      rewriter.getStringAttr(mhlo_custom_call.getCallTargetName()));