<version>3.0</version>
        <configuration>
          <defaults><!-- equivalent to combine.children="merge" combine.self="merge" -->
            <!-- merge the content of the configuration element according to element name -->
            <parent>child</parent>
            <child>child</child>
            <parent-only>parent</parent-only>
          </defaults>
          <appends combine.children="append">

  private M multimap;

  protected M multimap() {
    return multimap;
  }

  /**
   * @return an array of the proper size with {@code null} as the key of the middle element.
   */
  protected Entry<K, V>[] createArrayWithNullKey() {
    Entry<K, V>[] array = createSamplesArray();
    int nullKeyLocation = getNullLocation();
    Entry<K, V> oldEntry = array[nullKeyLocation];

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * The annotated element must not be null.
 * <p>
 * Annotated fields must not be null after construction has completed.
 * <p>
 * When this annotation is applied to a method it applies to the method return value.
 *
 * @see Nullable

    }
    this.size = Ints.saturatedCast(size);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  public int count(@Nullable Object element) {
    return contents.get(element);
  }

  @Override
  public int size() {
    return size;
  }

  @Override
  public ImmutableSet<E> elementSet() {
    ImmutableSet<E> result = elementSet;

  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    return isEmpty() ? null : getEntry(length - 1);
  }

  @Override
  public int count(@Nullable Object element) {
    int index = elementSet.indexOf(element);
    return (index >= 0) ? getCount(index) : 0;
  }

  @Override
  public int size() {
    long size = cumulativeCounts[offset + length] - cumulativeCounts[offset];

    multimap.put(2, "foo");
    for (String element : elements) {
      multimap.put(3, element);
    }
  }

  static void populateMultimapForKeySet(Multimap<String, Integer> multimap, String[] elements) {
    for (String element : elements) {
      multimap.put(element, 2);
      multimap.put(element, 3);
    }
  }

    /**
     * Returns {@code true} if reported problem count exceeded allowed count, and issues were lost. When this
     * method returns {@code true}, it means that element count of stream returned by method {@link #problems()}
     * and the counter returned by {@link #totalProblemsReported()} are not equal (latter is bigger than former).
     *

  public void testPutAllNullForbidden() {
    assertThrows(NullPointerException.class, () -> multimap().putAll(null, singletonList(v3())));
  }

  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllEmptyCollectionOnAbsentKey() {
    assertFalse(multimap().putAll(k3(), Collections.emptyList()));
    expectUnchanged();
  }

      }

      @Override
      public T set(int index, T element) {
        return data.set(index, element);
      }

      @Override
      public boolean add(T element) {
        return data.add(element);
      }

      @Override
      public void add(int index, T element) {
        data.add(index, element);
      }

      @Override
      public T remove(int index) {

     */
    ParameterizedClassDesc getParameterizedClassDesc();

    /**
     * Returns the element type if this field is a parameterized {@link Collection}.
     *
     * @return the element type if this field is a parameterized {@link Collection}, otherwise {@literal null}
     */
    Class<?> getElementClassOfCollection();

    /**