}

  /**
   * Adds the given element to this queue. If the queue is currently full, the element at the head
   * of the queue is evicted to make room.
   *
   * @return {@code true} always
   */
  @Override
  @CanIgnoreReturnValue
  public boolean offer(E e) {
    return add(e);
  }

  /**
   * Adds the given element to this queue. If the queue is currently full, the element at the head

// (m[key]) from the map. If m is nil or there is no such element, delete
// is a no-op.
func delete(m map[Type]Type1, key Type)

// The len built-in function returns the length of v, according to its type:
//
//   - Array: the number of elements in v.
//   - Pointer to array: the number of elements in *v (even if v is nil).

    }

    /**
     * Adds an element to the beginning of a sequenced collection.
     *
     * @param <E> the element type
     * @param collection the sequenced collection
     * @param element the element to add
     * @since Java 21
     */
    public static <E> void addFirst(final SequencedCollection<E> collection, final E element) {
        collection.addFirst(element);
    }

    /**

      return ImmutableSet.copyOf(elements);
    }
  }

  public static class DegeneratedImmutableSetGenerator extends TestStringSetGenerator {
    @SuppressWarnings("DistinctVarargsChecker") // deliberately testing deduplication
    @Override
    protected Set<String> create(String[] elements) {
      return ImmutableSet.of(elements[0], elements[0]);
    }
  }

    /**
     * Default mode for combining children DOMs during merge.
     * When element names match, the process will try to merge the element data,
     * rather than putting the dominant and recessive elements as siblings.
     */
    public static final String DEFAULT_CHILDREN_COMBINATION_MODE = CHILDREN_COMBINATION_MERGE;

    /** Attribute name controlling how the element itself is combined */

   * than one, not just two.
   */
  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  private static final class ToOptionalState {
    static final int MAX_EXTRAS = 4;

    @Nullable Object element;
    List<Object> extras;

    ToOptionalState() {
      element = null;
      extras = emptyList();
    }

   * Returns a fluent iterable containing the specified elements in order.
   *
   * <p><b>{@code Stream} equivalent:</b> {@link java.util.stream.Stream#of(Object[])
   * Stream.of(T...)}.
   *
   * @since 20.0
   */
  public static <E extends @Nullable Object> FluentIterable<E> of(
      @ParametricNullness E element, E... elements) {
    return from(Lists.asList(element, elements));
  }

  /**

 * according to when the first occurrence of the element was added. When the multiset contains
 * multiple instances of an element, those instances are consecutive in the iteration order. If all
 * occurrences of an element are removed, after which that element is added to the multiset, the
 * element will appear at the end of the iteration.
 *

    }

    /**
     * Removes an element from its parent.
     *
     * @param element the element to remove
     *
     */
    public static void removeElement(Element element) {
        Editor editor = new Editor(element.document());
        editor.removeElement(element);
    }

    /**
     * Convenience method to add GAV (groupId, artifactId, version) elements to a parent.
     *

     * {@code list.size()} if there is no such element.
     *
     * <p>Note that the return value will be {@code >= 0} if and only if there is an element of the
     * list that compares as equal to the key.
     *
     * <p>This is equivalent to the behavior of {@link java.util.Collections#binarySearch(List,