return createTreap(Ints.asList(keys));
      }

      // See http://en.wikipedia.org/wiki/Treap for details on the algorithm.
      private Optional<BinaryNode> createTreap(List<Integer> keys) {
        if (keys.isEmpty()) {
          return Optional.absent();
        }
        int minIndex = 0;
        for (int i = 1; i < keys.size(); i++) {
          if (keys.get(i) < keys.get(minIndex)) {
            minIndex = i;
          }

        if (value != null && expression.startsWith(bannedPrefix)) {
            String msg = "The expression ${" + expression + "} is deprecated.";
            if (newPrefix != null && !newPrefix.isEmpty()) {
                msg += " Please use ${" + newPrefix + expression.substring(bannedPrefix.length()) + "} instead.";
            }

        // Javadoc task will complain if we only have package-info.java files and no
        // other java files (as is with some Kotlin projects)
        !source.matching {
            exclude("**/package-info.java")
        }.isEmpty
    }

    options {
        this as StandardJavadocDocletOptions

        encoding = "utf-8"
        docEncoding = "utf-8"
        charSet = "utf-8"

        // Enable all javadoc warnings, except for:

        for (int i = 0; i < NUM; i++) {
            tokens.add(accessTokenHelper.generateAccessToken());
        }
        for (int i = 0; i < NUM; i++) {
            assertFalse(tokens.get(i).isEmpty());
            for (int j = i + 1; j < NUM; j++) {
                assertFalse(tokens.get(i).equals(tokens.get(j)));
            }
        }
    }

    public void test_getAccessTokenFromRequest_ok0() {

  @CollectionSize.Require(ONE)
  public void testValuesIteratorRemove() {
    Iterator<V> valuesItr = multimap().values().iterator();
    valuesItr.next();
    valuesItr.remove();
    assertTrue(multimap().isEmpty());
  }

    map.put("foo", 1);
    assertFalse(map.remove("foo", 2));
    assertFalse(map.remove("bar", 1));
    assertEquals(Integer.valueOf(1), map.get("foo"));
    assertTrue(map.remove("foo", 1));
    assertTrue(map.isEmpty());
  }

  public void testReplace() {
    TestMap map = new TestMap();
    map.put("foo", 1);
    assertEquals(Integer.valueOf(1), map.replace("foo", 2));
    assertNull(map.replace("bar", 3));

    var failure: IOException? = null

    try {
      request = source.readUtf8LineStrict()
      if (request.isEmpty()) {
        throw ProtocolException("no request because the stream is exhausted")
      }

      while (true) {
        val header = source.readUtf8LineStrict()
        if (header.isEmpty()) {
          break
        }
        addHeaderLenient(headers, header)

    assertEquals(expected.length, ByteSource.concat(b1, b2, b3).size());
    assertFalse(ByteSource.concat(b1, b2, b3).isEmpty());

    ByteSource emptyConcat = ByteSource.concat(ByteSource.empty(), ByteSource.empty());
    assertTrue(emptyConcat.isEmpty());
    assertEquals(0, emptyConcat.size());
  }

  public void testConcat_infiniteIterable() throws IOException {

  }

  /** Returns an immutable array containing the given values, in order. */
  public static ImmutableDoubleArray copyOf(Collection<Double> values) {
    return values.isEmpty() ? EMPTY : new ImmutableDoubleArray(Doubles.toArray(values));
  }

  /**
   * Returns an immutable array containing the given values, in order.
   *

      Multimap<? extends K, ? extends V> multimap,
      @CheckForNull Comparator<? super V> valueComparator) {
    checkNotNull(multimap); // eager for GWT
    if (multimap.isEmpty() && valueComparator == null) {
      return of();
    }

    if (multimap instanceof ImmutableSetMultimap) {
      @SuppressWarnings("unchecked") // safe since multimap is not writable