} else if (isDigit) {
            buf = stripLeadingZeroes(buf);
            if (buf.length() <= MAX_INTITEM_LENGTH) {
                // lower than 2^31
                return new IntItem(buf);
            } else if (buf.length() <= MAX_LONGITEM_LENGTH) {
                // lower than 2^63
                return new LongItem(buf);
            }
            return new BigIntegerItem(buf);
        }

   * <p>The returned set's {@link Object#toString} method returns a shorthand form of the set's
   * contents, such as {@code "[1..100]}"}.
   *
   * @throws IllegalArgumentException if neither this range nor the domain has a lower bound, or if
   *     neither has an upper bound
   */
  public ImmutableSortedSet<C> asSet(DiscreteDomain<C> domain) {
    checkNotNull(domain);
    if (isEmpty()) {
      return ImmutableSortedSet.of();
    }

    /**
     * Implementation method for merging two XML nodes.
     *
     * @param dominant the dominant (higher priority) XML node
     * @param recessive the recessive (lower priority) XML node
     * @param childMergeOverride optional override for the child merge mode
     * @return the merged XML node, or null if both inputs are null
     */

        int uniqueBytes = countUniqueBytes(data);
        double entropy = (double) uniqueBytes / 256.0;

        // Estimate compression ratio based on entropy
        // Lower entropy = better compression
        return 0.3 + (entropy * 0.6); // Range from 30% to 90%
    }

    @Override
    public int getMinCompressionSize() {
        return MIN_COMPRESSION_SIZE;
    }

   * <p>Note however that this method does not always behave identically to expressions such as:
   *
   * <ul>
   *   <li>{@code string.toUpperCase().equals("UPPER CASE ASCII")}
   *   <li>{@code string.toLowerCase().equals("lower case ascii")}
   * </ul>
   *
   * <p>due to case-folding of some non-ASCII characters (which does not occur in {@link
   * String#equalsIgnoreCase}). However in almost all cases that ASCII strings are used, the author

        assertTrue(str.contains(specialRemark));
    }

    @Test
    @DisplayName("Test type masking with 0xFFFF")
    void testTypeMasking() {
        // Test that only lower 16 bits are considered for type determination
        int typeWithUpperBits = 0xFFFF0001; // Should be treated as type 1 (printer)
        SmbShareInfo info = new SmbShareInfo(TEST_NET_NAME, typeWithUpperBits, TEST_REMARK);

        boolean updateScope = false;
        Artifact farthestArtifact = farthest.getArtifact();
        Artifact nearestArtifact = nearest.getArtifact();

        /* farthest is runtime and nearest has lower priority, change to runtime */
        if (Artifact.SCOPE_RUNTIME.equals(farthestArtifact.getScope())
                && (Artifact.SCOPE_TEST.equals(nearestArtifact.getScope())

				c -= 'a' - 'A'
			}
			b[i] = c
		}
		return b
	}
	return Map(unicode.ToUpper, s)
}

// ToLower returns a copy of the byte slice s with all Unicode letters mapped to
// their lower case.
func ToLower(s []byte) []byte {
	isASCII, hasUpper := true, false
	for i := 0; i < len(s); i++ {
		c := s[i]
		if c >= utf8.RuneSelf {
			isASCII = false
			break
		}

  }

  @Override
  public E last() {
    if (isEmpty()) {
      throw new NoSuchElementException();
    }
    return elements.get(size() - 1);
  }

  @Override
  public @Nullable E lower(E element) {
    int index = headIndex(element, false) - 1;
    return (index == -1) ? null : elements.get(index);
  }

  @Override
  public @Nullable E floor(E element) {

   * <p>The returned set's {@link Object#toString} method returns a shorthand form of the set's
   * contents, such as {@code "[1..100]}"}.
   *
   * @throws IllegalArgumentException if neither this range nor the domain has a lower bound, or if
   *     neither has an upper bound
   */
  public ImmutableSortedSet<C> asSet(DiscreteDomain<C> domain) {
    checkNotNull(domain);
    if (isEmpty()) {
      return ImmutableSortedSet.of();
    }