auto one_val = DenseElementsAttr::get(type, kOne);
  auto one_cst =
      rewriter.create<stablehlo::ConstantOp>(rewriter.getUnknownLoc(), one_val);

  auto half_val = DenseElementsAttr::get(type, kHalf);
  auto half_cst =
      rewriter.create<stablehlo::ConstantOp>(one_cst.getLoc(), half_val);

  auto one_over_root2_val = DenseElementsAttr::get(type, kOneOverRoot2);

    attr = cst.getValue();
  } else if (auto cst = dyn_cast<tfl::QConstOp>(inst)) {
    attr = cst.getValue();
  } else if (auto cst = dyn_cast<mlir::stablehlo::ConstantOp>(inst)) {
    attr = cst.getValue();
  } else if (auto cst = dyn_cast<mlir::vhlo::ConstantOpV1>(inst)) {
    mlir::VhloToStablehloTypeConverter vhlo_type_converter;

        decomposed_partitioned_call_callees) {
  auto body = while_op.body_function();
  llvm::SmallDenseMap<Value, Value> body_map;
  auto find_arg_stack_type = [&](int64_t index) -> std::optional<Type> {
    auto it = data_var_to_size_var.find(while_op.getOperand(index));
    if (it == data_var_to_size_var.end()) return std::nullopt;
    return it->getFirst().getType();
  };

    auto op = cast<ResizeNearestNeighborOp>(src_op);
    auto loc = op.getLoc();
    auto result_ty = mlir::cast<ShapedType>(op.getType());

    auto input = op.getImages();
    auto input_ty = mlir::cast<ShapedType>(input.getType());
    auto input_element_ty = input_ty.getElementType();
    auto out_size = op.getSize();
    auto out_size_ty = mlir::cast<ShapedType>(out_size.getType());

  auto x2 = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(x2_shape));
  auto y = Sub(scope_, x1, x2);
  RunTest({x1, x2}, {x1_shape, x2_shape}, {y}, {x1_shape});
}

TEST_F(NaryGradTest, Mul) {
  TensorShape x1_shape({3, 2, 5});
  TensorShape x2_shape({2, 5});
  auto x1 = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(x1_shape));
  auto x2 = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(x2_shape));

  auto a = ops::Placeholder(scope.WithOpName("A"), DT_INT32);
  auto b = ops::Placeholder(scope.WithOpName("B"), DT_FLOAT);
  auto c = ops::Placeholder(scope.WithOpName("C"), DT_INT32);
  auto d = ops::Placeholder(scope.WithOpName("D"), DT_FLOAT);
  auto u = ops::Placeholder(scope.WithOpName("U"), DT_RESOURCE);
  auto v = ops::Placeholder(scope.WithOpName("V"), DT_RESOURCE);

                                    const OperatorT& quant_op, int idx) {
  const auto& builtin_code =
      GetBuiltinCode(quant_model.operator_codes[quant_op.opcode_index].get());
  for (const auto& expected_op : expected_graph.operators) {
    const auto& op_code =
        expected_model.operator_codes[expected_op->opcode_index].get();
    const auto& expected_code = GetBuiltinCode(op_code);
    if (expected_code == builtin_code) {

import _ "example.com/printversion"
-- $WORK/auto/auto.go --
package auto
-- $WORK/auto/replacement-version/go.mod --
module example.com/version
-- $WORK/auto/replacement-version/version.go --
package version

const V = "v1.0.0-replaced"
-- $WORK/modules-1.14.txt --
# example.com/printversion v1.0.0
## explicit
example.com/printversion
# example.com/version v1.0.0 => ./replacement-version
example.com/version

    Block& block, const llvm::SmallDenseMap<Value, SizeInfo>& buffer_to_size) {
  auto old_terminator = block.getTerminator();
  auto new_outputs = llvm::to_vector<8>(old_terminator->getOperands());
  llvm::SmallVector<std::tuple<int64_t, int64_t, bool>, 8>
      output_buffer_to_size;
  for (auto retval : llvm::enumerate(old_terminator->getOperands())) {
    auto it = buffer_to_size.find(retval.value());
    if (it == buffer_to_size.end()) continue;

  auto loop_operands_n = UnpackResults(loop_operands_indexes_i);
  auto forward_res_nm2 = UnpackResults(forward_res_indexes_im2);
  auto forward_res_nm1 = UnpackResults(forward_res_indexes_im1);
  auto core_tpu_res_nm2 = UnpackResults(core_tpu_res_indexes_im2);
  auto non_tpu_res_nm1 = UnpackResults(non_tpu_res_indexes_im1);
  auto C_nm2 = new_while_op->getResult(C_index_im2);
  auto C_nm1 = new_while_op->getResult(C_index_im1);