delegate.Name = root.Name + "-" + delegate.Name
	}
	if delegate.Rewrite == nil {
		delegate.Rewrite = root.Rewrite
	}
	if delegate.DirectResponse == nil {
		delegate.DirectResponse = root.DirectResponse
	}
	if delegate.Timeout == nil {
		delegate.Timeout = root.Timeout
	}
	if delegate.Retries == nil {
		delegate.Retries = root.Retries
	}
	if delegate.Fault == nil {
		delegate.Fault = root.Fault
	}

                                    type, rewriter);
  return rewriter.create<mhlo::TransposeOp>(value.getLoc(), type, value,
                                            permutation);
}

Value CreateCastToInt32(Value val, Location loc, PatternRewriter& rewriter) {
  IntegerType new_ele_type = rewriter.getIntegerType(32);
  if (auto shaped_type = mlir::dyn_cast<RankedTensorType>(val.getType())) {

    if (func_name.contains("_relu6_")) {
      auto min = rewriter.create<mlir::stablehlo::ConstantOp>(
          req_op.getLoc(), rewriter.getF32FloatAttr(0));
      auto max = rewriter.create<mlir::stablehlo::ConstantOp>(
          req_op.getLoc(), rewriter.getF32FloatAttr(6));
      new_result = rewriter.create<mlir::stablehlo::ClampOp>(
          req_op.getLoc(), min, new_result, max);

                                        PatternRewriter* rewriter) {
  // Build ShapeOp
  auto input_shape =
      rewriter->create<TF::ShapeOp>(loc, value, rewriter->getBoolAttr(true));

  // Build UnsortedSegmentProdOp
  Type segProdresultType =
      RankedTensorType::get(num_reshape_segids, rewriter->getIntegerType(32));
  auto segids_tensor = createI32ConstantOp(reshape_segids, loc, rewriter);
  auto num_reshape_segids_tensor =

      : OpRewritePattern<TF::ConstOp>(context),
        quant_options_(quantization_options) {}

  LogicalResult matchAndRewrite(TF::ConstOp op,
                                PatternRewriter& rewriter) const override {
    auto weight_component_spec = GetWeightComponentSpec(quant_options_);
    if (!weight_component_spec) return failure();

    // 1. Check if the constant is quantizable.

  auto lhs_batch_and_out_cst = rewriter.create<TFL::ConstOp>(
      loc, rewriter.getI64TensorAttr(lhs_batch_and_out));
  auto lhs_batch_and_out_dims = rewriter.create<TFL::GatherOp>(
      loc,
      RankedTensorType::get({static_cast<int>(lhs_batch_and_out.size())},
                            rewriter.getIntegerType(32)),
      lhs_shape, lhs_batch_and_out_cst,

          index_depth == 1 && num_updates == 1) {
        ImplicitLocOpBuilder builder(loc, rewriter);
        auto indices_shape = BuildIntArrayConstOp(
            builder, rewriter,
            llvm::SmallVector<int64_t>({num_updates, index_depth}),
            rewriter.getI32Type());
        new_indices = rewriter.create<TF::ReshapeOp>(
            loc,
            RankedTensorType::get({num_updates, index_depth},

                                               PatternRewriter& rewriter,
                                               Value& scale,
                                               Value& zero_point) {
  TensorType scale_type = RankedTensorType::get({}, rewriter.getF32Type());
  TensorType zero_point_type = scale_type.clone(rewriter.getI32Type());
  scale = rewriter.create<TF::ConstOp>(
      loc, scale_type,

      rewriter.replaceOp(reduce_op, {tf_reduce_op, tf_argreduce_op});
    } else {
      auto tf_reduce_op = rewriter.create<Reduce>(
          reduce_op.getLoc(), reduce_op->getResult(0).getType(), operand,
          reduction_indices,
          /*keep_dim=*/rewriter.getBoolAttr(false));

      auto tf_argreduce_op = rewriter.create<ArgReduce>(
          reduce_op.getLoc(), reduce_op->getResult(1).getType(), operand,

    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()));

  if (auto bc = mhlo_custom_call.getBackendConfig()) {