* All comments are ignored.
 *
 * Regular lines contain fields separated by semicolons.
 *
 * The first element on each line is a single hex code point (like 0041) or a hex code point range
 * (like 0030..0039).
 *
 * The second element on each line is a mapping type, like `valid` or `mapped`.
 *
 * For lines that contain a mapping target, the next thing is a sequence of hex code points (like

@Retention(RetentionPolicy.CLASS)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
@Documented
@GwtCompatible
public @interface GwtIncompatible {
  /**
   * Describes why the annotated element is incompatible with GWT. Since this is generally due to a
   * dependence on a type/method which GWT doesn't support, it is sufficient to simply reference the
   * unsupported type/method. E.g. "Class.isInstance".
   *

 * limitations under the License.
 */

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;

/**
 * A type which will never be used as the element type of any collection in our tests, and so can be
 * used to test how a Collection behaves when given input of the wrong type.
 */
@GwtCompatible
public enum WrongType {
  VALUE

import com.google.caliper.Benchmark;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import org.jspecify.annotations.NullUnmarked;

/**
 * Benchmark for HashMultiset.add for an already-present element.
 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class HashMultisetAddPresentBenchmark {
  private static final int ARRAY_MASK = 0x0ffff;
  private static final int ARRAY_SIZE = 0x10000;

    // If we are looking for the least element in the range, we can just do a linear search for it.
    // (We will hit this whenever we are doing quantile interpolation: our first selection finds
    // the lower value, our second one finds the upper value by looking for the next least element.)
    if (required == from) {
      int min = from;

    if (entries.isEmpty()) {
      return ImmutableMultiset.of();
    } else {
      return JdkBackedImmutableMultiset.create(entries);
    }
  }

  @Override
  public int count(@Nullable Object element) {
    throw new AssertionError();
  }

  @Override
  public ImmutableSet<E> elementSet() {
    throw new AssertionError();
  }

  @Override
  Entry<E> getEntry(int index) {

    @Override
    protected List<Double> create(Double[] elements) {
      return asList(elements);
    }
  }

  public static final class DoublesAsListHeadSubListGenerator extends TestDoubleListGenerator {
    @Override
    protected List<Double> create(Double[] elements) {
      Double[] suffix = {Double.MIN_VALUE, Double.MAX_VALUE};
      Double[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);

    position: absolute;
    top: 15px;
    left: 15px;
    display: inline-block;
    width: 15px;
    height: 15px;
    border-radius: 50%;
    /* A little hack to display the window buttons in one pseudo element. */
    background: #d9515d;
    -webkit-box-shadow: 25px 0 0 #f4c025, 50px 0 0 #3ec930;
            box-shadow: 25px 0 0 #f4c025, 50px 0 0 #3ec930;
}

[data-termynal]:after {
    content: 'bash';

     * {@return the project artifacts as immutable list}. Elements are the project POM artifact and the artifact
     * produced by this project build, if applicable. Hence, the returned list may have one or two elements
     * (never less than 1, never more than 2), depending on project packaging.
     * <p>
     * The list's first element is ALWAYS the project POM artifact. Presence of second element in the list depends
     * solely on the project packaging.

    @Override
    protected List<Short> create(Short[] elements) {
      return asList(elements);
    }
  }

  public static final class ShortsAsListHeadSubListGenerator extends TestShortListGenerator {
    @Override
    protected List<Short> create(Short[] elements) {
      Short[] suffix = {Short.MIN_VALUE, Short.MAX_VALUE};
      Short[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);