}
            }
        }
        if (!unresolvedSelectors.isEmpty()) {
            String requiredSelectors = unresolvedSelectors.stream()
                    .filter(pas -> !pas.activationSettings().optional())
                    .map(ProjectActivation.ProjectActivationSettings::selector)
                    .collect(Collectors.joining(", "));
            if (!requiredSelectors.isEmpty()) {

    public interface BoolCall<CQ extends EsAbstractConditionQuery> {

        void callback(CQ must, CQ should, CQ mustNot, CQ filter);
    }

    @FunctionalInterface
    public interface FilteredCall<CQ extends EsAbstractConditionQuery, CF extends EsAbstractConditionQuery> {

        void callback(CQ query, CF filter);
    }

    @FunctionalInterface
    public interface OperatorCall<CQ extends EsAbstractConditionQuery> {

    public interface BoolCall<CQ extends EsAbstractConditionQuery> {

        void callback(CQ must, CQ should, CQ mustNot, CQ filter);
    }

    @FunctionalInterface
    public interface FilteredCall<CQ extends EsAbstractConditionQuery, CF extends EsAbstractConditionQuery> {

        void callback(CQ query, CF filter);
    }

    @FunctionalInterface
    public interface OperatorCall<CQ extends EsAbstractConditionQuery> {

    long length = 0;
    for (char[] array : arrays) {
      length += array.length;
    }
    char[] result = new char[checkNoOverflow(length)];
    int pos = 0;
    for (char[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;
  }

  private static int checkNoOverflow(long result) {
    checkArgument(

    long length = 0;
    for (short[] array : arrays) {
      length += array.length;
    }
    short[] result = new short[checkNoOverflow(length)];
    int pos = 0;
    for (short[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;
  }

  private static int checkNoOverflow(long result) {
    checkArgument(

   *
   * <p>The caller is responsible for ensuring that the returned stream is closed. For example:
   *
   * {@snippet :
   * try (Stream<String> lines = source.lines()) {
   *   lines.map(...)
   *       .filter(...)
   *       .forEach(...);
   * }
   * }
   *
   * @throws IOException if an I/O error occurs while opening the stream
   * @since 33.4.0 (but since 22.0 in the JRE flavor)
   */
  @MustBeClosed

                (scenarioDurations["durations"] as List<Map<String, Any>>).flatMap { duration ->
                    val testProject = duration["testProject"] as String
                    duration.entries
                        .filter { (key, _) -> key != "testProject" }
                        .map { (osString, timeInMs) ->
                            val os = Os.valueOf(osString.uppercase(Locale.US))

 * iterators that don't support {@code remove()}. Otherwise, all optional operations are supported.
 * Null row keys, columns keys, and values are not supported.
 *
 * <p>Lookups by row key are often faster than lookups by column key, because the data is stored in
 * a {@code Map<R, Map<C, V>>}. A method call like {@code column(columnKey).get(rowKey)} still runs

       * Static final fields are presumed to be fastest, based on our experience with
       * UnsignedBytesBenchmark. TODO(cpovirk): benchmark this
       */
      /*
       * A CopyOnWriteArraySet<WeakReference> is faster than a newSetFromMap of a MapMaker map with
       * weakKeys() and concurrencyLevel(1), even up to at least 12 cached exception types.
       */

        if (crawlerContext.getMaxDepth() >= 0 && depth > crawlerContext.getMaxDepth()) {
            return;
        }

        // add url and filter
        final Set<String> urlSet = new HashSet<>();
        final List<UrlQueue<?>> childList = childUrlList.stream()
                .filter(d -> StringUtil.isNotBlank(d.getUrl()) && urlSet.add(d.getUrl()) && crawlerContext.urlFilter.match(d.getUrl()))
                .map(d -> {