auto resultType =
          RankedTensorType::get(shape, inputType.getElementType(), extensions);
      arg.setType(resultType);
    }
    llvm::SmallVector<Type, 8> arg_types;
    for (auto arg : func.getArguments()) arg_types.push_back(arg.getType());
    func.setType(
        FunctionType::get(func.getContext(), arg_types,
                          func.front().getTerminator()->getOperandTypes()));

  // tensor<x!tf_type.string>.
  auto tensor_string_type =
      RankedTensorType::get({}, TF::StringType::get(builder.getContext()));
  main_func.getArguments().front().setType(tensor_string_type);
  main_func.setType(
      FunctionType::get(builder.getContext(), {tensor_string_type},
                        main_func.getFunctionType().getResults()));

    static {
        Map<Type, String> map = new HashMap<>();
        map.put(Type.BYTE_TYPE, "0");
        map.put(Type.SHORT_TYPE, "0");
        map.put(Type.INT_TYPE, "0");
        map.put(Type.LONG_TYPE, "0L");
        map.put(Type.FLOAT_TYPE, "0.0f");
        map.put(Type.DOUBLE_TYPE, "0.0");
        map.put(Type.CHAR_TYPE, "'\\u0000'");
        map.put(Type.BOOLEAN_TYPE, "false");

    op.getResult().setType(conv_result_type);

    squeeze_op.getResult().setType(bts_op.getOutput().getType());

    // Connect `biasadd_op` with the output of `squeeze_op`.
    if (biasadd_op) {
      biasadd_op.setOperand(0, squeeze_op.getOutput());
      biasadd_op.getOutput().setType(squeeze_op.getOutput().getType());
    }
  } else {
    if (biasadd_op) biasadd_op.setOperand(0, op.getOutput());

                                           quant::QuantParams quant_params) {
  Type expressed_type = value.getType();
  Type new_type = quant_params.castFromExpressedType(expressed_type);
  // This value isn't an expressed type (float), skip.
  if (!new_type) return;

  Block &block = value.getParentRegion()->front();
  Operation *op = value.getDefiningOp();
  if (op) {

    new_dequantize_op->setOperand(0, user_op->getResult(0));
    new_dequantize_op->getResult(0).setType(user_op->getResult(0).getType());
    user_op->getResult(0).replaceAllUsesExcept(new_dequantize_op->getResult(0),
                                               new_dequantize_op);
    user_op->getResult(0).setType(new_user_op_type);
  }

  LogicalResult matchAndRewrite(TF::PartitionedCallOp op,

        sitemapList.remove(sitemap);
    }

    public Sitemap[] getSitemaps() {
        return sitemapList.toArray(new Sitemap[sitemapList.size()]);
    }

    public void setType(final String type) {
        this.type = type;
    }

    public boolean isUrlSet() {
        return URLSET.equals(type);
    }

    public boolean isIndex() {
        return INDEX.equals(type);
    }

                                  const QuantizationComponent& component,
                                  const BitType bit_type,
                                  const BitWidth bit_width) {
  spec->set_quantization_component(component);
  spec->set_bit_type(bit_type);
  spec->set_bit_width(bit_width);
}

::stablehlo::quantization::QuantizationOptions FillPresetQuantizationOptions(

  private val client = OkHttpClient()

  fun run() {
    // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image
    val requestBody =
      MultipartBody.Builder()
        .setType(MultipartBody.FORM)
        .addFormDataPart("title", "Square Logo")
        .addFormDataPart(
          "image",
          "logo-square.png",
          File("docs/images/logo-square.png").asRequestBody(MEDIA_TYPE_PNG),

    auto ranked_type = mlir::dyn_cast<RankedTensorType>(input.getType());
    if (!ranked_type) return false;
    auto input_shape = ranked_type.getShape();
    auto space_to_depth =
        BuildSpaceToDepth(cluster_func, input, block_size, input_shape);
    entry.value().set(space_to_depth);
    block_arg.setType(space_to_depth.getType());
  }
  return true;
}