LinkedHashMap::new,
                        Collectors.mapping(Plugin::getArtifactId, Collectors.toSet())));
        request.getPluginGroups().forEach(g -> candidates.put(g, null));
        PluginPrefixResult result = resolveFromRepository(request, candidates);

        // If we haven't been able to resolve the plugin from the repository,
        // as a last resort, we go through all declared plugins, load them

        mavenCentral()
        gradlePluginPortal()
    }
}

pluginManagement {
    repositories {
        maven {
            url = uri("https://repo.gradle.org/gradle/enterprise-libs-release-candidates")
            content {
                val rcAndMilestonesPattern = "\\d{1,2}?\\.\\d{1,2}?(\\.\\d{1,2}?)?-((rc-\\d{1,2}?)|(milestone-\\d{1,2}?))"
                // GE plugin marker artifact

	// Set of env vars for the sub-system to validate.
	candidates := set.CreateStringSet(subSysEnvVars...)

	// Remove all default target env vars from the candidates set (as they
	// are valid).
	for _, param := range validKeys {
		paramEnvName := getEnvVarName(subSys, Default, param)
		candidates.Remove(paramEnvName)
	}

	isSingleTarget := SubSystemsSingleTargets.Contains(subSys)

        final char[] candidates = { ',', '\t', ';', '|' };
        int maxCount = 0;
        char bestDelimiter = ',';

        for (final char candidate : candidates) {
            final int count = countOccurrences(line, candidate);
            if (count > maxCount) {
                maxCount = count;
                bestDelimiter = candidate;
            }
        }

   * requires us to have a DNS address for both hosts, which only happens after route planning. We
   * can't coalesce connections that use a proxy, since proxies don't tell us the origin server's IP
   * address.
   */
  private fun routeMatchesAny(candidates: List<Route>): Boolean =
    candidates.any {
      it.proxy.type() == Proxy.Type.DIRECT &&

                    .highlighter(new ReplHighlighter())
                    .completer(systemRegistry.completer())
                    .parser(parser)
                    .variable(LineReader.LIST_MAX, 50) // max tab completion candidates
                    .variable(LineReader.HISTORY_FILE, history)
                    .variable(LineReader.OTHERS_GROUP_NAME, "Others")
                    .variable(LineReader.COMPLETION_STYLE_GROUP, "fg:blue,bold")

  }

  private final int k;
  private final Comparator<? super T> comparator;

  /*
   * We are currently considering the elements in buffer in the range [0, bufferSize) as candidates
   * for the top k elements. Whenever the buffer is filled, we quickselect the top k elements to the
   * range [0, k) and ignore the remaining elements.
   */
  private final @Nullable T[] buffer;

      check(toClose == null)
      return ReusePlan(candidate)
    }

    // The call's connection was released.
    toClose?.closeQuietly()
    call.eventListener.connectionReleased(call, candidate)
    candidate.connectionListener.connectionReleased(candidate, call)
    if (toClose != null) {
      candidate.connectionListener.connectionClosed(candidate)
    } else if (noNewExchangesEvent) {

            }

            if (candidate != null
                && candidate.getKey().isConnected(subRange)
                && candidate.getKey().intersection(subRange).equals(r)) {
              return candidate.getValue();
            }
          }
        } catch (ClassCastException e) {
          return null;
        }
        return null;
      }

			}
		}
	}

	if found {
		// Update candidate FileInfo with succModTime and numVersions in quorum when available
		if props, ok := otherPropsMap.GetValueWithQuorum(quorum); ok {
			candidate.SuccessorModTime = props.succModTime
			candidate.IsLatest = props.succModTime.IsZero()
			candidate.NumVersions = props.numVersions
		}
		return candidate, nil
	}