public V get(@CheckForNull Object key) {
      Integer index = keyIndex.get(key);
      if (index == null) {
        return null;
      } else {
        return getValue(index);
      }
    }

    @Override
    @CheckForNull
    public V put(K key, @ParametricNullness V value) {
      Integer index = keyIndex.get(key);
      if (index == null) {
        throw new IllegalArgumentException(

#define LOAD(index, e) \
	MOVL	88(SP), SI; \
	MOVL	(index*4)(SI), DI; \
	BSWAPL	DI; \
	MOVL	DI, (index*4)(SP); \
	ADDL	DI, e

#define SHUFFLE(index, e) \
	MOVL	(((index)&0xf)*4)(SP), DI; \
	XORL	(((index-3)&0xf)*4)(SP), DI; \
	XORL	(((index-8)&0xf)*4)(SP), DI; \
	XORL	(((index-14)&0xf)*4)(SP), DI; \
	ROLL	$1, DI; \
	MOVL	DI, (((index)&0xf)*4)(SP); \
	ADDL	DI, e

        private int index = -1;
        private final int maxIndex = keyToIndex().size();

        @Override
        @CheckForNull
        protected Entry<K, V> computeNext() {
          for (index++; index < maxIndex; index++) {
            V value = getValue(index);
            if (value != null) {
              return Maps.immutableEntry(getKey(index), value);
            }
          }

        (1..count).each { index ->
            file("$baseDir/org/gradle/Class${index}${type}.java").text = """
            package org.gradle;

            import org.junit.Test;

            public class Class${index}${type} {
                @Test
                public void someTest() {
                    new Class${index}().isFoo("test");
                }
            }

  }

  @Override
  @CheckForNull
  public E lower(E element) {
    int index = headIndex(element, false) - 1;
    return (index == -1) ? null : elements.get(index);
  }

  @Override
  @CheckForNull
  public E floor(E element) {
    int index = headIndex(element, true) - 1;
    return (index == -1) ? null : elements.get(index);
  }

  @Override
  @CheckForNull
  public E ceiling(E element) {

    this.offset = offset;
    this.length = length;
  }

  private int getCount(int index) {
    return (int) (cumulativeCounts[offset + index + 1] - cumulativeCounts[offset + index]);
  }

  @Override
  Entry<E> getEntry(int index) {
    return Multisets.immutableEntry(elementSet.asList().get(index), getCount(index));
  }

  @Override
  @CheckForNull
  public Entry<E> firstEntry() {

        HashMap<String, FileSystemLocationSnapshot> index = new HashMap<>();
        snapshot.accept(entrySnapshot -> {
            index.put(entrySnapshot.getAbsolutePath(), entrySnapshot);
            return SnapshotVisitResult.CONTINUE;
        });
        return index;
    }

    public static Map<String, FileSystemLocationSnapshot> indexByRelativePath(FileSystemSnapshot snapshot) {

        @Override
        public E get(final int index) {
            return parent.get(index);
        }

        @Override
        public E set(final int index, final E element) {
            return parent.set(index, element);
        }

        @Override
        public void add(final int index, final E element) {
            parent.add(index, element);
        }

        @Override

  }

  @Override
  @CheckForNull
  public E lower(E element) {
    int index = headIndex(element, false) - 1;
    return (index == -1) ? null : elements.get(index);
  }

  @Override
  @CheckForNull
  public E floor(E element) {
    int index = headIndex(element, true) - 1;
    return (index == -1) ? null : elements.get(index);
  }

  @Override
  @CheckForNull
  public E ceiling(E element) {

            List<RegularFile> files = getArtifactFiles().get();
            for (int index = 0; index < ids.size(); index++) {
                ComponentArtifactIdentifier id = ids.get(index);
                ResolvedVariantResult variant = variants.get(index);
                RegularFile file = files.get(index);
                writer.print("FILE ");
                writer.println(file.getAsFile().getName());