new ImmutableMap.Builder<>(mapEntries.size());
    int size = 0;

    for (Entry<? extends K, ? extends Collection<? extends V>> entry : mapEntries) {
      K key = entry.getKey();
      Collection<? extends V> values = entry.getValue();
      ImmutableList<V> list =
          (valueComparator == null)
              ? ImmutableList.copyOf(values)

     *
     * @param index
     *            the index
     * @return the key at the specified index
     */
    public K getKeyAt(final int index) {
        return getEntryAt(index).getKey();
    }

    /**
     * Returns the {@link java.util.Map.Entry} at the specified index.
     *
     * @param index
     *            the index

          Entry<K, V> backingEntry = backingIterator.next();
          return new AbstractMapEntry<K, ImmutableSet<V>>() {
            @Override
            public K getKey() {
              return backingEntry.getKey();
            }

            @Override
            public ImmutableSet<V> getValue() {
              return ImmutableSet.of(backingEntry.getValue());
            }
          };

        private Node<K, V> node;

        MapEntry(Node<K, V> node) {
          this.node = node;
        }

        @Override
        @ParametricNullness
        public K getKey() {
          return node.key;
        }

        @Override
        @ParametricNullness
        public V getValue() {
          return node.value;
        }

        @Override

                queryBuf.append(URLUtil.encode(entry.getKey(), Constants.UTF_8));
                formBuf.append("<input type=\"hidden\" name=\"");
                formBuf.append(StringEscapeUtils.escapeHtml4(entry.getValue()));
                formBuf.append("\" value=\"");
                formBuf.append(StringEscapeUtils.escapeHtml4(entry.getKey()));
                formBuf.append("\"/>");
            }

        cache,
        MAX_SIZE,
        new Receiver<ReferenceEntry<Integer, Integer>>() {
          @Override
          public void accept(ReferenceEntry<Integer, Integer> entry) {
            cache.getUnchecked(entry.getKey());
          }
        });
  }

  public void testUpdateRecency_onInvalidate() {
    IdentityLoader<Integer> loader = identityLoader();
    LoadingCache<Integer, Integer> cache =

            return size;
        }
        if (obj instanceof Map<?, ?>) {
            long size = 0;
            for (final Map.Entry<?, ?> entry : ((Map<?, ?>) obj).entrySet()) {
                size += sizeOf(entry.getKey());
                size += sizeOf(entry.getValue());
            }
            return size;
        }
        return 16L;
    }

                        ImmutableClassToInstanceMap.builder();
                    for (Object object : elements) {
                      Entry<?, ?> entry = (Entry<?, ?>) object;
                      builder.put((Class) entry.getKey(), (Impl) entry.getValue());
                    }
                    return (Map) builder.build();
                  }
                })
            .named("ImmutableClassToInstanceMap")
            .withFeatures(

          Map.Entry<E, Integer> mapEntry = backingEntries.next();
          return new Multisets.AbstractEntry<E>() {
            @Override
            public E getElement() {
              return mapEntry.getKey();
            }

            @Override
            public int getCount() {
              Integer frequency = backingMap.get(getElement());
              return (frequency == null) ? 0 : frequency;

                    for (Object object : elements) {
                      Entry<?, ?> entry = (Entry<?, ?>) object;
                      map.putInstance((Class) entry.getKey(), (Impl) entry.getValue());
                    }
                    return (Map) map;
                  }
                })
            .named("MutableClassToInstanceMap")
            .withFeatures(