// doesn't require quantization.
  auto tensor_type = mlir::dyn_cast<TensorType>(value.getType());
  if (!tensor_type) {
    // There are none type values.
    return;
  }
  if (!tensor_type.getElementType().isF32()) return;

  // If the result is consumed by a quantize op, it has been quantized.
  if (value.hasOneUse() &&
      llvm::isa<TFL::QuantizeOp>(*value.getUsers().begin()))
    return;

      mlir::dyn_cast<DenseElementsAttr>(Quantize(attr, shaped_quantized_type));
  if (!tensor_proto_attr) {
    return nullptr;
  }

  Type storage_type =
      mlir::cast<QuantizedType>(shaped_quantized_type.getElementType())
          .getStorageType();
  ShapedType new_type = shaped_quantized_type.clone(storage_type);

  rewriter.setInsertionPointAfter(op);
  auto const_op =

        if (mlir::isa<NoneType>(operand_type)) {
          inputs.push_back(operand);
          continue;
        }

        auto ele_type =
            mlir::cast<TensorType>(operand.getType()).getElementType();
        if (auto dq_op =
                dyn_cast_or_null<DequantizeOpT>(operand.getDefiningOp())) {
          inputs.push_back(dq_op.getOperand());
        } else if (!ele_type.isF32()) {

    if (!splat_elements_attr) {
      return;
    }
    if (splat_elements_attr.getNumElements() == 1) {
      return;
    }
    auto element_type = splat_elements_attr.getType().getElementType();
    if (mlir::isa<ComplexType>(element_type) ||
        mlir::isa<quant::QuantizedType>(element_type)) {
      return;
    }
    op_builder->setInsertionPoint(const_op);

        if (parameterInfo.getKind() == ParameterKindInfo.VARARG_METHOD_PARAMETER && renderVararg) {
            return CodeBlock.of("$T...", typeName(parameterInfo.getParameterType().getElementType()));
        }
        return CodeBlock.of("$T", typeName(parameterInfo.getParameterType()));
    }

                defaultArtifacts = null;
                changingValue.handle(previousArtifacts);
            }
        }

        @Override
        public Class<? extends PublishArtifact> getElementType() {
            return PublishArtifact.class;
        }

        @Override
        public int size() {
            if (artifacts == null) {
                return 0;
            }

    SmallVector<int64_t, 4> new_shape(permutation.size());
    for (size_t i = 0; i < permutation.size(); ++i)
      new_shape[i] = shape[permutation[i]];

    return RankedTensorType::get(new_shape, ranked_type.getElementType());
  }

  return type;
}

bool AreCancellablePermutations(DenseIntElementsAttr perm0,
                                DenseIntElementsAttr perm1) {

}

StatusOr<mlir::ElementsAttr> ConvertIntBuffer(
    mlir::RankedTensorType shaped_type, const std::vector<uint8_t>& buffer,
    bool truncate) {
  mlir::Type elem_type = shaped_type.getElementType();
  unsigned bit_width;
  if (auto itype = mlir::dyn_cast<mlir::IntegerType>(elem_type)) {
    bit_width = itype.getWidth();
  } else if (auto qtype =

}

ExpressedToQuantizedConverter ExpressedToQuantizedConverter::forInputType(
    Type input_type) {
  if (isa<TensorType, VectorType>(input_type)) {
    Type element_type = cast<ShapedType>(input_type).getElementType();
    if (!isQuantizablePrimitiveType(element_type))
      return ExpressedToQuantizedConverter{input_type, nullptr};
    return ExpressedToQuantizedConverter{input_type, element_type};
  }

                    ScalarCollectionModelProjection.forList(schema.getElementType(), !writable),
                    new ModelElementProjection(schema.getType())
                );
            } else {
                return new ProjectionOnlyNodeInitializer(
                    ScalarCollectionModelProjection.forSet(schema.getElementType(), !writable),
                    new ModelElementProjection(schema.getType())