// expected-remark@above {{ID: 0}}
        %handle2 = "tf.HashTableV2"() {container = "", device = "", key_dtype = !tf_type.string, shared_name = "some_name", use_node_name_sharing = false, value_dtype = i64} : () -> tensor<!tf_type.resource>
        // expected-remark@above {{ID: 1}}

  auto _table_id = _o->table_id;
  auto _key_dtype = _o->key_dtype;
  auto _value_dtype = _o->value_dtype;
  return tflite::CreateHashtableOptions(
      _fbb,
      _table_id,
      _key_dtype,
      _value_dtype);
}

inline HashtableFindOptionsT *HashtableFindOptions::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {

           << "Expect " << kValidNumOfOutput[input_type.getRank()]
           << "output(s) when input has rank " << input_type.getRank();
  }

  auto value_type = GetResultType(func, 0);
  if (!RankEquals(value_type, 1) ||
      !mlir::isa<StringType>(value_type.getElementType())) {
    return func.emitError() << "1st output should be string tensor";
  }
  if (func.getNumResults() > 1) {

                      llvm::ArrayRef<int32_t> redux_axes,
                      PatternRewriter* rewriter) {
  Value redux_op = createI32ConstantOp(redux_axes, loc, rewriter);

  auto value_type = mlir::cast<RankedTensorType>(value.getType());
  auto shape = value_type.getShape();
  llvm::SmallVector<int64_t> sum_shape;
  for (int i = 0; i < shape.size(); ++i) {
    if (std::find(redux_axes.begin(), redux_axes.end(), i) ==
        redux_axes.end()) {

                         TFE_TensorHandle* second, TF_Status* status);

// Assert that `handle` is equal to `expected_value`.
template <typename value_type>
void ExpectScalarEq(TFE_TensorHandle* handle, value_type expected_value);

template <std::size_t num_devices>
void RegisterParallelDevice(
    TFE_Context* context, const char* device_name,

    } finally {
        leaveScope(scope)
    }
}


internal
fun checkIsAssignable(valueType: DataType, isAssignableTo: DataType): Boolean = when (isAssignableTo) {
    is DataClass -> valueType is DataClass && (sameType(valueType, isAssignableTo) || isAssignableTo.name in valueType.supertypes)
    else -> sameType(valueType, isAssignableTo)
}


/**

    public <T> Property<T> property(Class<T> valueType) {
        if (valueType == null) {
            throw new IllegalArgumentException("Class cannot be null");
        }

        if (valueType.isPrimitive()) {
            // Kotlin passes these types for its own basic types
            return Cast.uncheckedNonnullCast(property(JavaReflectionUtil.getWrapperTypeForPrimitiveType(valueType)));
        }

    private final Class<K> keyType;
    private final Class<V> valueType;
    private final ValueSanitizer<K> keySanitizer;
    private final ValueSanitizer<V> valueSanitizer;

    public ValidatingMapEntryCollector(Class<K> keyType, Class<V> valueType, ValueSanitizer<K> keySanitizer, ValueSanitizer<V> valueSanitizer) {
        this.keyType = keyType;
        this.valueType = valueType;
        this.keySanitizer = keySanitizer;

        Class<?> valueType = propertyMetadata.getDeclaredType().getRawType();
        validateNotDirectoryType(propertyMetadata, validationContext, valueType);
        validateNotFileType(propertyMetadata, validationContext, valueType);
        validateNotOptionalPrimitiveType(propertyMetadata, validationContext, valueType);
        validateNotUrlType(propertyMetadata, validationContext);
    }

    TypeAttr:$key_dtype,
    TypeAttr:$value_dtype
  );

  let results = (outs
    Res<TF_ResourceTensor, [{Handle to a table.}], [TF_LookupTableAlloc]>:$table_handle
  );

  let builders = [
    OpBuilder<(ins "StringAttr":$container, "StringAttr":$shared_name,
      "BoolAttr":$use_node_name_sharing, "TypeAttr":$key_dtype, "TypeAttr":$value_dtype),
    [{
      build($_builder, $_state,