assertMapEquals(
        builder.buildKeepingLast(), "three", 3, "one", 1, "five", 5, "four", 4, "two", 2);
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> builder.buildOrThrow());
    // We don't really care which values the exception message contains, but they should be
    // different from each other. If buildKeepingLast() collapsed duplicates, that might end up not

    @Nullable Comparator<? super V> valueComparator;
    @Nullable Object[] alternatingKeysAndValues;
    int size;
    boolean entriesUsed;

    /**
     * If non-null, a duplicate key we found in a previous buildKeepingLast() or buildOrThrow()
     * call. A later buildOrThrow() can simply report this duplicate immediately.
     */
    @Nullable DuplicateKey duplicateKey;

    /**

  /*
   * We have some considerable complexity in these create methods because of
   * Builder.buildKeepingLast(). The same Builder might be called with buildKeepingLast() and then
   * buildOrThrow(), or vice versa. So in particular, if we modify alternatingKeysAndValues to
   * eliminate duplicate keys (for buildKeepingLast()) then we have to ensure that a later call to

        entriesUsed = false;
      }
    }

    /**
     * Associates {@code key} with {@code value} in the built map. If the same key is put more than
     * once, {@link #buildOrThrow} will fail, while {@link #buildKeepingLast} will keep the last
     * value put for that key.
     */
    @CanIgnoreReturnValue
    public Builder<K, V> put(K key, V value) {
      ensureCapacity(size + 1);
      Entry<K, V> entry = entryOf(key, value);

      return build(/* throwIfDuplicateKeys= */ true);
    }

    public ImmutableMap<K, V> buildKeepingLast() {
      if (valueComparator != null) {
        // Probably not worth supporting this in GWT
        throw new UnsupportedOperationException(
            "orderEntriesByValue + buildKeepingLast not supported under GWT");
      }
      return build(/* throwIfDuplicateKeys= */ false);
    }

            // unusual execution environments where that might not be true.
          }
          builder.put(method.getName(), method);
        }
      }
      typeVariableMethods = builder.buildKeepingLast();
    }

    private final TypeVariableImpl<?> typeVariableImpl;

    TypeVariableInvocationHandler(TypeVariableImpl<?> typeVariableImpl) {
      this.typeVariableImpl = typeVariableImpl;
    }

     * @deprecated This method does not make sense for bimaps and should not be called.
     * @since 31.1
     */
    @DoNotCall
    @Deprecated
    @Override
    public ImmutableBiMap<K, V> buildKeepingLast() {
      throw new UnsupportedOperationException("Not supported for bimaps");
    }
  }

  /**
   * Returns an immutable bimap containing the same entries as {@code map}. If {@code map} somehow

            // unusual execution environments where that might not be true.
          }
          builder.put(method.getName(), method);
        }
      }
      typeVariableMethods = builder.buildKeepingLast();
    }

    private final TypeVariableImpl<?> typeVariableImpl;

    TypeVariableInvocationHandler(TypeVariableImpl<?> typeVariableImpl) {
      this.typeVariableImpl = typeVariableImpl;
    }