TF::TensorListSetItemOp op, OpAdaptor adaptor,
      ConversionPatternRewriter &rewriter) const {
    Location loc = op.getLoc();
    Value input = adaptor.getOperands()[0];
    Value index = adaptor.getOperands()[1];
    Value item = adaptor.getOperands()[2];

    IntegerType shape_dtype = rewriter.getIntegerType(32);
    auto item_rank = rewriter.create<TF::RankOp>(

    if (common_inner_operands.empty()) {
      common_inner_operands.insert(common_inner_operands.end(),
                                   op->GetOperands().begin(),
                                   op->GetOperands().end());
    } else {
      common_inner_operands.clear();
      absl::c_copy_if(op->GetOperands(),
                      std::back_inserter(common_inner_operands),
                      [&](Predicate* sub_op) {

    Operation::operand_range mean(fused_batch_norm->getOperands());
    ::mlir::FloatAttr exponential_avg_factor;
    ::mlir::TF::FusedBatchNormV3Op root;
    Operation::operand_range offset(fused_batch_norm->getOperands());
    Operation::operand_range x(fused_batch_norm->getOperands());
    Operation::operand_range scale(fused_batch_norm->getOperands());
    Operation::operand_range variance(fused_batch_norm->getOperands());

  auto new_operands = llvm::to_vector<8>(caller->getOperands());
  llvm::SmallVector<int64_t, 8> changed_indices;
  // Find the operands to change, and create the loads.
  for (auto& entry : arg_data_type_and_updated_output_index) {
    int64_t index = entry.getFirst();
    Type new_type = entry.getSecond().first;
    int64_t updated_index = entry.getSecond().second;
    auto operand = caller->getOperand(index);
    builder.setInsertionPoint(caller);

        func::ReturnOp return_op = *callee.getOps<func::ReturnOp>().begin();
        auto val = return_op.getOperand(i);
        auto block_arg_number = ComesFromBlockArgNumber(val);
        if (block_arg_number >= 0) {
          replaceAllUsesInRegionWith(call_op->getResult(i),
                                     call_op->getOperand(block_arg_number),
                                     func.getRegion());
        }
      }
    }

    }
  }
  return false;
}

bool HasDynamicExternalValues(Operation* op) {
  return op
      ->walk([](Operation* walked_op) {
        for (Value v : walked_op->getOperands()) {
          if (mlir::TF::CanBeRefined(v.getType())) {
            return WalkResult::interrupt();
          }
        }
        return WalkResult::advance();
      })
      .wasInterrupted();
}

  mlir::Operation& return_op = region.back().back();
  mlir::Location loc = return_op.getLoc();
  op_builder.setInsertionPointToEnd(&region.back());
  op_builder.create<mlir::stablehlo::ReturnOp>(loc, return_op.getOperands());
  return_op.erase();
}

void InlineVhloOpRegion(mlir::Region& region, mlir::func::FuncOp func) {
  OpBuilder op_builder{region};
  mlir::IRMapping mapper;

      return failure();
    }

    return UniformQuantizeFunctionCallPattern(call_op);
  }

  Value GetInputValue() { return call_op_.getOperand(0); }

  Value GetInverseScalesValue() { return call_op_.getOperand(1); }

  Value GetZeroPointsValue() { return call_op_.getOperand(2); }

  stablehlo::ConstantOp GetZeroPointsConstantOp() {
    return cast<stablehlo::ConstantOp>(GetZeroPointsValue().getDefiningOp());
  }

    int weight_operand_idx = 1;
    Operation* weight_op = op.getOperand(weight_operand_idx).getDefiningOp();

    auto weight_type =
        mlir::dyn_cast<ShapedType>(weight_op->getResult(0).getType());
    auto input_type = mlir::dyn_cast<ShapedType>(op.getOperand(0).getType());

    llvm::ArrayRef<int64_t> weight_shape = weight_type.getShape();

class AllUsersAreAddOpsAndCanFuseWith<string op_to_fuse_with> : Constraint<CPred<
  "llvm::all_of($0.getUsers(), [&](Operation *user) {"
  "  if(!llvm::isa<TFL::AddOp>(user)) return false;"
  "  if(!user->getOperand(0).getDefiningOp<"#op_to_fuse_with#">()) return false;"
  "  return true;"
  "})">, "all users are AddOp and can fuse with "#op_to_fuse_with#"">;

// TODO(b/294385379): This pattern only appears when we convert