}
    assert(data.getNumElements() == element_count);
  }

  using StridedArrayViewBase::NextTensorIndex;
  using StridedArrayViewBase::size;

  int64_t operator[](int64_t i) const {
    return data_.getValues<APInt>()[OffsetForIndex(i)].getSExtValue();
  }

 private:
  const DenseIntElementsAttr& data_;
};

// It matches %iota generated from the following mlir codes:
//

    SparseElementsAttr realSparseAttr,
    quant::QuantizedType quantizedElementType,
    const UniformQuantizedValueConverter &converter) {
  DenseElementsAttr realDenseAttr = realSparseAttr.getValues();
  if (!mlir::isa<DenseFPElementsAttr>(realDenseAttr)) {
    return nullptr;
  }
  DenseElementsAttr quantDenseAttr =
      convertDenseFPElementsAttr(mlir::cast<DenseFPElementsAttr>(realDenseAttr),

    int64_t rank = transpose_perm.size();
    DenseIntElementsAttr new_padding_attr = nullptr;
    if (padding.has_value()) {
      SmallVector<int64_t> new_padding(rank * 2, 0);
      auto old_padding = (*padding).getValues<int64_t>();
      for (int64_t idx = 0; idx < rank; ++idx) {
        new_padding[2 * transpose_perm[idx]] = old_padding[2 * idx];
        new_padding[2 * transpose_perm[idx] + 1] = old_padding[2 * idx + 1];
      }

    const ArrayRef<int64_t> original_shape =
        value_attr.getShapedType().getShape();

    const SmallVector<float> original_values =
        llvm::to_vector(value_attr.getValues<float>());

    // Fold the constant value by transposing the values according to the
    // `TransposeOp`'s permutation attribute.
    const DenseElementsTransposer transposer(original_shape,

            if (argumentExpression instanceof GStringExpression) {
                GStringExpression gStringExpression = (GStringExpression) argumentExpression;
                for (Expression value : gStringExpression.getValues()) {
                    if (!(value instanceof VariableExpression)) {
                        return false;
                    }
                }

                return true;
            }
        }

    if (hashtable_op == nullptr) return failure();
    rewriter.replaceOpWithNewOp<TFL::HashtableImportOp>(
        import_op, import_op->getResultTypes(), import_op.getTableHandle(),
        import_op.getKeys(), import_op.getValues());
    return success();
  }
};

class LegalizeHashTableSizeOpPattern
    : public OpRewritePattern<TF::LookupTableSizeV2Op> {
 public:

  auto max_count_const_op = llvm::dyn_cast<TF::ConstOp>(max_count_op);
  if (!max_count_const_op) return op->emitOpError("unknown max element count");
  int64_t max_size_const =
      (*max_count_const_op.getValue().getValues<APInt>().begin())
          .getSExtValue();
  return CreateInitBufferValue(element_shape, max_size_const, op, element_dtype,
                               builder, buffer);
}

                getLogger().debug("ExtractData: {}", extractData);
            }
            // meta
            extractData.getKeySet().stream().filter(k -> extractData.getValues(k) != null).forEach(key -> {
                final String[] values = extractData.getValues(key);
                metaDataMap.put(key, values);

                // meta -> content
                if (fessConfig.isCrawlerMetadataContentIncluded(key)) {

  // etc.
  constexpr int64_t kLookupTableFindCostScale = 8;
  constexpr int64_t kLookupTableFindStringKeyCostScale = 16;

  auto value_type = mlir::cast<mlir::TensorType>(op.getValues().getType());
  auto key_type = mlir::cast<mlir::TensorType>(op.getKeys().getType());

  int64_t output_size = InferTensorSize(context, value_type);

  int64_t cost = kLookupTableFindCostScale * output_size;

	}
	ptrVal.Elem().Set(defVal)
	return textValue{p}
}

func (v textValue) Set(s string) error {
	return v.p.UnmarshalText([]byte(s))
}

func (v textValue) Get() interface{} {
	return v.p
}

func (v textValue) String() string {
	if m, ok := v.p.(encoding.TextMarshaler); ok {
		if b, err := m.MarshalText(); err == nil {