// CHECK-NEXT:  [[HASH_TABLE:%.*]] = "tfl.hashtable"() <{key_dtype = !tf_type.string, table_id = -1323619995 : i32, value_dtype = i64}> : () -> tensor<1x!tf_type.resource>
  // CHECK-NEXT:   "tfl.hashtable_import"([[HASH_TABLE]], [[CST]], [[CST_1]]) : (tensor<1x!tf_type.resource>, tensor<3x!tf_type.string>, tensor<3xi64>) -> ()

}

// Checks if the HashTable is initialized. This function assumes that the
// HashTable is initialized if it appears in the initializer since it can't
// check the actual value.
bool IsResourceInitialized(ModuleOp module_op, Operation* hash_table) {
  StringRef shared_name = GetSharedName(hash_table);
  if (shared_name.empty()) return false;

  for (func::FuncOp init_func_op :

    return %6 : tensor<*xi64>
  }
// Check that HashTable op is lifted.
// CHECK: func.func private @serving_default
// CHECK-SAME: (%arg0: tensor<?x!tf_type.string>, %arg1: tensor<!tf_type.resource>, %arg2: tensor<!tf_type.resource>) -> tensor<*xi64>
// CHECK-SAME: tf.entry_function = {control_outputs = "", inputs = "input_vocabs:0,hash_table_1:0,hash_table_2:0", outputs = "FakeQuantWithMinMaxArgs_2:0"}

The scalar `default_value` is the value output for keys not present in the
table. It must also be of the same type as the table values.
  }];

  let arguments = (ins
    TFL_ResourceTensor:$hash_table,
    TFL_TensorOf<[I32, TFL_Str, I64]>:$keys,
    TFL_TensorOf<[F32, I32, TFL_Str, I64]>:$default_value
  );

  let results = (outs TFL_TensorOf<[F32, I32, TFL_Str, I64]>:$out);
}

}

bool checkWhetherGraphHasValidStaticLookupTables(ModuleOp module) {
  auto hashtables = GetAllOps<TF::HashTableV2Op>(&module);
  // No needs to run the legalization patterns.
  if (hashtables.empty()) {
    return false;
  }

  for (auto hashtable : hashtables) {
    auto key_dtype = hashtable.getKeyDtype();
    auto value_dtype = hashtable.getValueDtype();

  @Override
  public int count(@CheckForNull Object element) {
    @Nullable ImmutableEntry<?>[] hashTable = this.hashTable;
    if (element == null || hashTable.length == 0) {
      return 0;
    }
    int hash = Hashing.smearedHash(element);
    int mask = hashTable.length - 1;
    for (ImmutableEntry<?> entry = hashTable[hash & mask];
        entry != null;
        entry = entry.nextInBucket()) {

        }
        outI++;
      }
      return outI == n ? hashTable : new Object[] {hashTable, outI, duplicateKey};
    } else {
      /*
       * Use 32 bits per entry.
       */
      int[] hashTable = new int[tableSize];
      Arrays.fill(hashTable, ABSENT);

      int outI = 0;
      entries:
      for (int i = 0; i < n; i++) {

          int index = j & mask;
          if (hashTable[index] == null) {
            hashTable[index] = e;
            break;
          }
        }
      }
      return hashTable;
    }

    void ensureTableCapacity(int minCapacity) {
      int newTableSize;
      if (hashTable == null) {
        newTableSize = chooseTableSize(minCapacity);
        hashTable = new Object[newTableSize];

        }
    }

    @Test
    fun `can handle Hashtable`() {
        val hashtable = Hashtable<String, Any>(100)
        hashtable.put("key1", "value1")
        hashtable.put("key2", true)
        hashtable.put("key3", 42)
        configurationCacheRoundtripOf(hashtable).run {
            assertThat(hashtable, equalTo(this))
        }
    }

public class LdapUser implements FessUser {

    private static final long serialVersionUID = 1L;

    protected Hashtable<String, String> env;

    protected String name;

    protected String[] permissions = null;

    public LdapUser(final Hashtable<String, String> env, final String name) {
        this.env = env;
        this.name = name;
    }

    @Override
    public String getName() {