// CHECK: [[CST:%.+]] = "tf.Const"() <{value = dense<"assets/table.txt"> : tensor<1x!tf_type.string>}> : () -> tensor<1x!tf_type.string>
    // CHECK: [[HASHTABLE:%.+]] = "tf.HashTableV2"()
    // CHECK: "tf.InitializeTableFromTextFileV2"([[HASHTABLE]], [[CST]])
    func.return
  }
}

// -----

module attributes {tf_saved_model.semantics} {

  // Test case: Sanity check handling of non-bound inputs.

    }
  }

  /**
   * Returns a larger power of 2 hashtable size given the current mask.
   *
   * <p>For hashtable sizes less than or equal to 32, the returned power of 2 is 4x the current
   * hashtable size to reduce expensive rehashing. Otherwise the returned power of 2 is 2x the
   * current hashtable size.
   */
  static int newCapacity(int mask) {
    return ((mask < 32) ? 4 : 2) * (mask + 1);

 */

package org.gradle.internal.snapshot.impl;

import com.google.common.collect.ImmutableList;
import org.gradle.internal.hash.Hashable;
import org.gradle.internal.hash.Hasher;

class AbstractMapSnapshot<T extends Hashable> implements Hashable {
    protected final ImmutableList<MapEntrySnapshot<T>> entries;

    public AbstractMapSnapshot(ImmutableList<MapEntrySnapshot<T>> entries) {

 */
package org.codelibs.core.naming;

import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotEmpty;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.util.Hashtable;

import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.codelibs.core.exception.NamingRuntimeException;

/**
 * {@link javax.naming.InitialContext 初期コンテキスト}を扱うためのユーティリティ・クラスです。

    //                                                                      ==============
    protected void prepareElementsHash() {
        elementsText = new Hashtable<>();
        elementsFile = new Hashtable<>();
        elementsAll = new Hashtable<>();
    }

    protected List<FileItem> parseRequest(final HttpServletRequest request, final ServletFileUpload upload) throws FileUploadException {

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.ldap;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

import org.codelibs.fess.helper.SystemHelper;
import org.codelibs.fess.mylasta.direction.FessConfig;

 * limitations under the License.
 */

package org.gradle.internal.snapshot.impl;

import org.gradle.internal.hash.Hashable;
import org.gradle.internal.hash.Hasher;

class AbstractManagedValueSnapshot<T extends Hashable> implements Hashable {
    protected final T state;

    public AbstractManagedValueSnapshot(T state) {
        this.state = state;
    }

    public T getState() {

        expect:
        actionLambdaSnapshot != consumerLambdaSnapshot
        hash(actionLambdaSnapshot) != hash(consumerLambdaSnapshot)
    }

    private HashCode hash(Hashable hashable) {
        def hasher = Hashing.newHasher()
        hasher.put(hashable)
        return hasher.hash()
    }

    private ImplementationSnapshot createLambdaSnapshot(lambda) {

 */

package org.gradle.internal.snapshot.impl;

import com.google.common.collect.ImmutableList;
import org.gradle.internal.hash.Hashable;
import org.gradle.internal.hash.Hasher;

import java.util.List;

class AbstractArraySnapshot<T extends Hashable> implements Hashable {
    protected final ImmutableList<T> elements;

    public AbstractArraySnapshot(ImmutableList<T> elements) {
        this.elements = elements;

 */

package org.gradle.internal.snapshot.impl;

import com.google.common.collect.ImmutableList;
import org.gradle.internal.hash.Hashable;
import org.gradle.internal.hash.Hasher;

import java.util.List;

class AbstractListSnapshot<T extends Hashable> implements Hashable {
    protected final ImmutableList<T> elements;

    public AbstractListSnapshot(ImmutableList<T> elements) {
        this.elements = elements;