.maximumSize(maxSize));
    long totalCapacity = 0;
    assertWithMessage("segments=%s, maxSize=%s", map.segments.length, maxSize)
        .that((long) map.segments.length)
        .isAtMost(max(1, maxSize / 10));
    for (int i = 0; i < map.segments.length; i++) {
      totalCapacity += map.segments[i].maxSegmentWeight;
    }
    assertWithMessage("totalCapacity=%s, maxSize=%s", totalCapacity, maxSize)

ls,"$1"+b+"$2$3")},h=!f&&d;b.length&&(b+="/"),h&&(f=1);for(var i=0;f>i;i++){var j,k,n,o;h?(j=d,m.push(g(a))):(j=e[i].match(c.regex.findStyles)&&RegExp.$1,m.push(RegExp.$2&&g(RegExp.$2))),n=j.split(","),o=n.length;for(var p=0;o>p;p++)k=n[p],l.push({media:k.split("(")[0].match(c.regex.only)&&RegExp.$2||"all",rules:m.length-1,hasquery:k.indexOf("(")>-1,minw:k.match(c.regex.minw)&&parseFloat(RegExp.$1)+(RegExp.$2||""),maxw:k.match(c.regex.maxw)&&parseFloat(RegExp.$1)+(RegExp.$2||"")})}u()},w=functio...

    public int compare(int[] left, int[] right) {
      int minLength = Math.min(left.length, right.length);
      for (int i = 0; i < minLength; i++) {
        if (left[i] != right[i]) {
          return UnsignedInts.compare(left[i], right[i]);
        }
      }
      return left.length - right.length;
    }

    @Override
    public String toString() {

    public static void main(String[] args) {
        if (args.length < 2 || args.length > 3) {
            System.err.println("Usage: java JvmConfigParser.java <jvm.config-path> <maven-project-basedir> [output-file]");
            System.exit(1);
        }

        Path jvmConfigPath = Paths.get(args[0]);
        String mavenProjectBasedir = args[1];
        Path outputFile = args.length == 3 ? Paths.get(args[2]) : null;

        return 4 + 2 * this.path.length();
    }

    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeInt2(this.maxReferralLevel, dst, dstIndex);
        dstIndex += 2;
        final byte[] pathBytes = this.path.getBytes(StandardCharsets.UTF_16LE);
        System.arraycopy(pathBytes, 0, dst, dstIndex, pathBytes.length);
        dstIndex += pathBytes.length;

    public SecureCredentialStorage(char[] masterPassword, byte[] salt) throws GeneralSecurityException {
        if (masterPassword == null || masterPassword.length == 0) {
            throw new IllegalArgumentException("Master password cannot be null or empty");
        }
        if (salt == null || salt.length != SALT_SIZE) {
            throw new IllegalArgumentException("Invalid salt");
        }

        this.salt = salt.clone();

        return "Type2Message[target=" + target + ",challenge=" + (challenge == null ? "null" : "<" + challenge.length + " bytes>")
                + ",context=" + (context == null ? "null" : "<" + context.length + " bytes>") + ",targetInformation="
                + (targetInformation == null ? "null" : "<" + targetInformation.length + " bytes>") + ",flags=0x"
                + jcifs.smb1.util.Hexdump.toHexString(getFlags(), 8) + "]";
    }

  }

  // enum singleton pattern
  private enum StringLengthComparator implements Comparator<String> {
    INSTANCE;

    @Override
    public int compare(String a, String b) {
      return a.length() - b.length();
    }
  }

  private static final Comparator<String> STRING_LENGTH = StringLengthComparator.INSTANCE;

  @Override
  protected <E extends Comparable<? super E>> SortedSet<E> of() {

        val module = r.module
        val expectedLength = group.length + 1 + module.length

        val isProvided = providedBy.any {
            // This method is called very often during dependency resolution.
            // This implementation avoids allocating new strings.
            it.length == expectedLength &&
                it[group.length] == ':' &&
                it.startsWith(group) &&

    assertEquals(4, map.concurrencyLevel);

    // concurrency level
    assertThat(map.segments).hasLength(4);
    // initial capacity / concurrency level
    assertEquals(16 / map.segments.length, map.segments[0].table.length());
  }

  public void testSetKeyEquivalence() {
    Equivalence<Object> testEquivalence =
        new Equivalence<Object>() {
          @Override