buffer[bufferSize++] = elem;
      // uncheckedCastNullableTToT is safe because bufferSize > 0.
      if (comparator.compare(elem, uncheckedCastNullableTToT(threshold)) > 0) {
        threshold = elem;
      }
      // uncheckedCastNullableTToT is safe because bufferSize > 0.
    } else if (comparator.compare(elem, uncheckedCastNullableTToT(threshold)) < 0) {
      // Otherwise, we can ignore elem; we've seen k better elements.

     *
     * @param v the version to compare against
     * @return whether this version is a least the given one
     */
    public boolean atLeast(final DialectVersion v) {
        return ordinal() >= v.ordinal();
    }

    /**
     * Check if this dialect version is at most the specified version
     *
     * @param v the version to compare against

      <artifactId>t08-c</artifactId>
      <version>1.0</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>maven-test</groupId>
      <artifactId>t08-d</artifactId>
      <version>1.1</version>
      <type>jar</type>
      <scope>compile</scope>
      <optional>false</optional>
    </dependency>
  </dependencies>

    private static final Pattern VALID_USERNAME = Pattern.compile("^[a-zA-Z0-9._\\-@]+$");
    private static final Pattern VALID_DOMAIN = Pattern.compile("^[a-zA-Z0-9._\\-]+$");
    private static final Pattern VALID_SHARE = Pattern.compile("^[a-zA-Z0-9._\\-$]+$");
    private static final Pattern PATH_TRAVERSAL = Pattern.compile("\\.\\.[\\\\/]");
    private static final Pattern INVALID_PATH_CHARS = Pattern.compile("[\\x00-\\x1f\"*:<>?|]");

    /**

            ComparableVersion c = new ComparableVersion(version);

            if (prev != null) {
                int compare = prev.compareTo(c);
                System.out.println(
                        "   " + prev + ' ' + ((compare == 0) ? "==" : ((compare < 0) ? "<" : ">")) + ' ' + version);
            }

            System.out.println(

        DEPENDENCY_GRAPH_EXCLUDE_CONFIGURATIONS: 'ktlint|checkstyle|.*[Tt]est(Compile|Runtime)Classpath|.*[Tt]estImplementationDependenciesMetadata|.*[Tt]estFixtures(Compile|Runtime)Classpath|.*[Tt]estFixturesImplementationDependenciesMetadata'...

   * equivalent {@link Boolean#compare} method instead.
   *
   * @param a the first {@code boolean} to compare
   * @param b the second {@code boolean} to compare
   * @return a positive number if only {@code a} is {@code true}, a negative number if only {@code
   *     b} is true, or zero if {@code a == b}
   */
  @InlineMe(replacement = "Boolean.compare(a, b)")
  public static int compare(boolean a, boolean b) {

    String LATEST_VERSION = "LATEST";

    String SNAPSHOT_VERSION = "SNAPSHOT";

    Pattern VERSION_FILE_PATTERN = Pattern.compile("^(.*)-(\\d{8}\\.\\d{6})-(\\d+)$");

    // TODO into artifactScope handler

    String SCOPE_COMPILE = "compile";

    String SCOPE_COMPILE_PLUS_RUNTIME = "compile+runtime";

    String SCOPE_TEST = "test";

    String SCOPE_RUNTIME = "runtime";

    this.ordering = ordering;
  }

  @Override
  public int compare(@Nullable T left, @Nullable T right) {
    if (left == right) {
      return 0;
    }
    if (left == null) {
      return RIGHT_IS_GREATER;
    }
    if (right == null) {
      return LEFT_IS_GREATER;
    }
    return ordering.compare(left, right);
  }

  @Override

            if (pos == current) {
                newClientMap.put(Pattern.compile(regex), client);
                added = true;
            }
            newClientMap.put(entry.getKey(), entry.getValue());
            current++;
        }
        if (!added) {
            newClientMap.put(Pattern.compile(regex), client);
        }
        clientMap = newClientMap;
    }

    /**