Striped<Lock> get(int stripes) {
        return new Striped.LargeLazyStriped<>(stripes, LOCK_SUPPLIER);
      }
    };

    abstract Striped<Lock> get(int stripes);
  }

  private Striped<Lock> striped;
  private int[] stripes;
  private List<Integer> bulkGetSet;

  @BeforeExperiment
  void setUp() {
    this.striped = impl.get(numStripes);
    stripes = new int[numStripes];
    for (int i = 0; i < numStripes; i++) {

      Striped<Lock> get(int stripes) {
        return new Striped.LargeLazyStriped<>(stripes, LOCK_SUPPLIER);
      }
    };

    abstract Striped<Lock> get(int stripes);
  }

  private Striped<Lock> striped;
  private int[] stripes;
  private List<Integer> bulkGetSet;

  @BeforeExperiment
  void setUp() {
    this.striped = impl.get(numStripes);
    stripes = new int[numStripes];
    for (int i = 0; i < numStripes; i++) {

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

class Graph {
    private enum DfsState {
        VISITING,
        VISITED
    }

    final Map<String, Vertex> vertices = new LinkedHashMap<>();

    public Vertex getVertex(String id) {
        return vertices.get(id);
    }

          R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object>
      extends AbstractCell<R, C, V> implements Serializable {
    @ParametricNullness private final R rowKey;
    @ParametricNullness private final C columnKey;
    @ParametricNullness private final V value;

    ImmutableCell(
        @ParametricNullness R rowKey,
        @ParametricNullness C columnKey,
        @ParametricNullness V value) {

  // This reference is only used by GWT compiler to infer the keys and values
  // of the map that needs to be serialized.
  private @Nullable Comparator<? super K> unusedComparatorForSerialization;
  private @Nullable K unusedKeyForSerialization;
  private @Nullable V unusedValueForSerialization;

  private final transient SortedMap<K, V> sortedDelegate;

  // The comparator used by this map.  It's the same as that of sortedDelegate,

  /**
   * Simple decorator that turns an array of replacement char[]s into a CharEscaper, this results in
   * a very fast escape method.
   */
  private static class CharArrayDecorator extends CharEscaper {
    private final char[] @Nullable [] replacements;
    private final int replaceLength;

    CharArrayDecorator(char[] @Nullable [] replacements) {
      this.replacements = replacements;

        return resource;
    }

    private String alignToBaseDirectory(String path, Path basedir) {
        String newPath = mayAlignToBaseDirectoryOrNull(path, basedir);
        if (newPath != null) {
            return newPath;
        }
        return path;
    }

    /**
     * Returns aligned path or {@code null} if no need for change.
     */

 *
 * @author Ben Yu
 * @since 14.0
 */
@ElementTypesAreNonnullByDefault
public final class Parameter implements AnnotatedElement {

  private final Invokable<?, ?> declaration;
  private final int position;
  private final TypeToken<?> type;
  private final ImmutableList<Annotation> annotations;

  /**
   * An {@code AnnotatedType} instance, or {@code null} under Android VMs (possible only when using

import org.mortbay.jetty.handler.ResourceHandler;
import org.mortbay.log.Log;

/**
 * @author shinsuke
 *
 */
public class CrawlerWebServer {
    private final File docRoot;

    private final Server server;

    private boolean tempDocRoot = false;

    public CrawlerWebServer(final int port) {
        this(port, createDocRoot(3));
        tempDocRoot = true;
    }

 *
 * @author George van den Driessche
 */
@GwtCompatible
public class ConflictingRequirementsException extends Exception {
  private Set<Feature<?>> conflicts;
  private Object source;

  public ConflictingRequirementsException(
      String message, Set<Feature<?>> conflicts, Object source) {
    super(message);
    this.conflicts = conflicts;