"true": integerType, "false": integerType, "null": integerType, "in": integerType, "as": integerType,
				"break": integerType, "const": integerType, "continue": integerType, "else": integerType,
				"for": integerType, "function": integerType, "if": integerType, "import": integerType,
				"let": integerType, "loop": integerType, "package": integerType, "namespace": integerType,

      float const_value;
      if (failed(GetConstantSplatValue<float>(init_value, const_value)) ||
          const_value != 1.0)
        return failure();
    } else if (mlir::isa<IntegerType>(type) && type.isSignlessInteger()) {
      int32_t const_value;
      if (failed(GetConstantSplatValue<int32_t>(init_value, const_value)) ||
          const_value != 1)
        return failure();
    } else {

  auto result_element_type =
      getType().cast<ShapedType>().getElementType().dyn_cast<IntegerType>();
  auto operand_element_type = getInput()
                                  .getType()
                                  .cast<ShapedType>()
                                  .getElementType()
                                  .dyn_cast<IntegerType>();
  // Returns nullptr if either result/operand element type is not integer.

                                         .cast<QuantizedType>()
                                         .getStorageType()
                                         .cast<IntegerType>();
    if (!IsSupportedByTfliteQuantizeOrDequantizeOps(output_storage_type)) {
      LLVM_DEBUG(llvm::dbgs()
                 << "Failed to match storage type of output quantized type.\n");
      return failure();

    if (!splat) return false;
    Type element_ty = splat.getType().getElementType();
    if (mlir::isa<FloatType>(element_ty))
      return splat.getSplatValue<llvm::APFloat>().isZero();
    if (mlir::isa<IntegerType>(element_ty))
      return splat.getSplatValue<llvm::APInt>().getSExtValue() == 0;
    return false;
  };

  for (const auto& it : llvm::enumerate(operands)) {
    if (IsKnownZero(it.value())) continue;

    TFL_I32OrI64Tensor:$output
  );

  let hasOptions = 1;

  DerivedTFLiteTypeAttr output_type = DerivedTFLiteTypeAttr<[{
    return getResult().getType().cast<TensorType>().getElementType().
        cast<IntegerType>().getWidth() > 32 ? tflite::TensorType_INT64 :
            tflite::TensorType_INT32;
    }], [{
      TypeAttr::get(getResult().getType().cast<TensorType>().getElementType())
    }]>;
}

  dimensions.reserve(rank);
  for (int i = 0; i < rank; ++i)
    dimensions.push_back(APInt(out_width, shape[i]));

  auto result_type = tensorflow::GetTypeFromTFTensorShape(
      {rank}, IntegerType::get(input_ty.getContext(), out_width));
  return DenseElementsAttr::get(result_type, dimensions);
}

OpFoldResult ShapeOp::fold(FoldAdaptor) {
  int width =

  auto element_type = mlir::cast<ShapedType>(value.getType()).getElementType();

  if (mlir::isa<FloatType>(element_type)) {
    return FloatValueEquals(value, raw_value);
  } else if (mlir::isa<IntegerType>(element_type)) {
    auto int_attr = mlir::dyn_cast_or_null<DenseIntElementsAttr>(value);
    if (!int_attr) return false;

    if (int_attr.isSplat()) {
      return int_attr.getSplatValue<APInt>() == raw_value;

func Alignof(variable ArbitraryType) uintptr
func Offsetof(selector ArbitraryType) uintptr
func Sizeof(variable ArbitraryType) uintptr

type IntegerType int  // shorthand for an integer type; it is not a real type
func Add(ptr Pointer, len IntegerType) Pointer
func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
</pre>

<p>
A <code>Pointer</code> is a <a href="#Pointer_types">pointer type</a> but a <code>Pointer</code>

    }
    if (ftype.isF64()) {
      return tflite::TensorType_COMPLEX128;
    }
    return Status(absl::StatusCode::kInvalidArgument, "Unsupported type");
  } else if (auto itype = mlir::dyn_cast<mlir::IntegerType>(type)) {
    switch (itype.getWidth()) {
      case 1:
        return tflite::TensorType_BOOL;
      case 4:
        if (itype.isUnsigned()) {
          return Status(absl::StatusCode::kInvalidArgument,