if (value == null) {
            return this;
        }
        return snapshotter.snapshot(value);
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        hasher.putNull();
    }

    @Override
    public ValueSnapshot asSnapshot() {
        return this;
    }

    @Override
    public Object isolate() {
        return null;
    }

    @Nullable

    }

    @Override
    public void appendToHasher(Hasher hasher) {
        hasher.putString(className);
        if (value != null) {
            hasher.putString(value);
        } else {
            hasher.putNull();
        }
    }

    @Override
    public String toString() {
        return "(" + className + ") " + value;
    }

                return true;
            }
        }
        return false;
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        if (implementationHash == null) {
            hasher.putNull();
        } else {
            hasher.putHash(implementationHash);
        }
        hasher.putBytes(serializedValue);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {

    /**
     * Puts a hashable value into the hasher.
     */
    void put(Hashable hashable);

    /**
     * Feed a {@code null} value into the hasher.
     */
    void putNull();

    /**
     * Returns the combined hash.
     *
     * If the build cache hash is invalid, an exception is thrown.
     *
     * @throws IllegalStateException if the hasher state is invalid.
     */

            return this;
        }
        return snapshot;
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        if (implementationHash == null) {
            hasher.putNull();
        } else {
            hasher.putHash(implementationHash);
        }
        hasher.putBytes(serializedValue);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {

        then:
        hashes.size() == threadRange.size()
    }

    def 'null does not collide with other values'() {
        expect:
        def hasher = Hashing.newHasher()
        hasher.putNull()
        def hash = hasher.hash()
        hash != Hashing.hashString("abc")
    }

    def 'hash collision for bytes'() {
        def left = [[1, 2, 3], [4, 5]]
        def right = [[1, 2], [3, 4, 5]]

        }

        @Override
        public void put(Hashable hashable) {
            hashable.appendToHasher(this);
        }

        @Override
        public void putNull() {
            this.putInt(0);
        }

        @Override
        public HashCode hash() {
            return hasher.hash();
        }
    }

//go:nowritebarrier
func putempty(b *workbuf) {
	b.checkempty()
	work.empty.push(&b.node)
}

// putfull puts the workbuf on the work.full list for the GC.
// putfull accepts partially full buffers so the GC can avoid competing
// with the mutators for ownership of partially full buffers.
//
//go:nowritebarrier
func putfull(b *workbuf) {
	b.checknonempty()
	work.full.push(&b.node)
}

  public void testPutAllNonEmptyCollectionOnPresentKey() {
    assertTrue(multimap().putAll(k0(), Lists.newArrayList(v3(), v4())));
    assertGet(k0(), v0(), v3(), v4());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllNonEmptyIterableOnAbsentKey() {
    assertTrue(
        multimap()
            .putAll(
                k3(),
                new Iterable<V>() {
                  @Override

  public void testPutAll_supportedNonePresent() {
    putAll(createDisjointCollection());
    expectAdded(e3(), e4());
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testPutAll_unsupportedNonePresent() {
    try {
      putAll(createDisjointCollection());
      fail("putAll(nonePresent) should throw");
    } catch (UnsupportedOperationException expected) {
    }
    expectUnchanged();