if (const TensorType type = mlir::dyn_cast<TensorType>(operand.getType())) {
      if (mlir::isa<FloatType>(type.getElementType())) {
        return false;
      }
      if (mlir::isa<UniformQuantizedType, UniformQuantizedPerAxisType>(
              type.getElementType())) {
        has_quantized_types = true;
      }
    }
  }
  for (const Value result : call_op.getResults()) {

    if (!output_type || !output_type.getElementType().isF32()) return failure();

    auto input_type = mlir::dyn_cast<ShapedType>(input_dequant.getType());
    // TODO(renjieliu): support UniformQuantizedPerAxisType.
    auto q_type = mlir::dyn_cast_or_null<quant::UniformQuantizedType>(
        input_type.getElementType());
    if (!q_type) return failure();

             .getElementType()
             .isF32()) {
      return failure();
    }
    MLIRContext *context = rewriter.getContext();
    llvm::SmallVector<Value, 2> operands{op.getA(), op.getB()};
    for (Value &operand : operands) {
      TensorType tensor_type = mlir::cast<TensorType>(operand.getType());
      Type element_type = tensor_type.getElementType();

  // is up to ~2x faster.
  const bool is_f16 = input_ty.getElementType().isF16();
  if (is_f16 && CanUseTensorCores(devices)) return "NHWC";

  // For f32/f16 data type decision depends on the filter size in spatial
  // dimensions, for other data types we keep current data format.
  if (!input_ty.getElementType().isF32() && !input_ty.getElementType().isF16())
    return getDataFormat();

            size.getSExtValue(),
            start.getType().cast<TensorType>().getElementType()),
        start, limit, delta);
  }
  return RangeOp::build(
      builder, result,
      tensorflow::GetTypeFromTFTensorShape(
          {-1}, start.getType().cast<TensorType>().getElementType()),
      start, limit, delta);
}

OpFoldResult RangeOp::fold(FoldAdaptor adaptor) {

    // Non-float tensors do not need quantization.
    QuantizationUnits quantizable_ops;
    const ShapedType type = mlir::dyn_cast<ShapedType>(op.getType());
    if (!type || !type.getElementType().isF32()) return quantizable_ops;

    const Value value = op.getResult();

    for (OpOperand& use : value.getUses()) {
      Operation* user = use.getOwner();

        }
        if (type.equals(Type.DOUBLE_TYPE)) {
            return ClassName.DOUBLE;
        }
        if (type.getSort() == Type.ARRAY) {
            return ArrayTypeName.of(typeName(type.getElementType()));
        }
        return className(type);
    }

    public static ClassName className(Type type) {
        return ClassName.bestGuess(type.getClassName().replace("$", "."));
    }

      mlir::dyn_cast<TensorFlowTypeWithSubtype>(operand_type.getElementType());
  if (!operand_handle_type) return result_type.getElementType();
  auto result_handle_type =
      mlir::cast<TensorFlowTypeWithSubtype>(result_type.getElementType());
  if (operand_handle_type.GetSubtypes().empty() ||
      !result_handle_type.GetSubtypes().empty())
    return result_type.getElementType();
  return operand_handle_type;
}

  output_shape[3] = composite_result_shape[1];

  auto input_type = mlir::cast<ShapedType>(old_op->getOperand(0).getType());

  return RankedTensorType::get(output_shape, input_type.getElementType());
}
}  // namespace odml

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