between the lower and upper bound specified by the Range Query. Range
		Queries can be inclusive or exclusive of the upper and lower bounds.
		If you want to find documents whose content_length fields have values
		between 1000 and 10000, inclusive, you can enter:
		<pre>content_length:[1000 TO 10000]</pre>
		If you want to exclude the upper and lower bounds, use "{}".
	</dd>
	<dt>Boost</dt>
	<dd>

        writeLittleEndianInt(baos, 10); // size
        writeLittleEndianLong(baos, 25); // Unaligned offset (not multiple of 8)
        // Add enough data to avoid array bounds issues
        while (baos.size() < 35) {
            baos.write(0);
        }
        byte[] pacData = baos.toByteArray();

import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * Based on what a {@link Type} is, dispatch it to the corresponding {@code visit*} method. By
 * default, no recursion is done for type arguments or type bounds. But subclasses can opt to do
 * recursion by calling {@link #visit} for any {@code Type} while visitation is in progress. For
 * example, this can be used to reject wildcards or type variables contained in a type as in:
 *

        }
    }

    /**
     * Validates array bounds for safe copying
     *
     * @param src source array
     * @param srcOffset source offset
     * @param dst destination array
     * @param dstOffset destination offset
     * @param length copy length
     * @throws IllegalArgumentException if bounds are invalid
     */

        @DisplayName("findUNITermination should throw exception when termination not found")
        void testFindUNITerminationNotFound() {
            // Given
            byte[] bufferWithoutTermination = "Hello".getBytes(StandardCharsets.UTF_16LE);

            // When & Then - the implementation throws ArrayIndexOutOfBoundsException when buffer bounds are exceeded
            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {

    }

    for (C value : values) {
      if (!contains(value)) {
        return false;
      }
    }
    return true;
  }

  /**
   * Returns {@code true} if the bounds of {@code other} do not extend outside the bounds of this
   * range. Examples:
   *
   * <ul>
   *   <li>{@code [3..6]} encloses {@code [4..5]}
   *   <li>{@code (3..6)} encloses {@code (3..6)}

pkg image, type RGBA64Image interface { At, Bounds, ColorModel, RGBA64At }
pkg image, type RGBA64Image interface, At(int, int) color.Color
pkg image, type RGBA64Image interface, Bounds() Rectangle
pkg image, type RGBA64Image interface, ColorModel() color.Model
pkg image, type RGBA64Image interface, RGBA64At(int, int) color.RGBA64
pkg image/draw, type RGBA64Image interface { At, Bounds, ColorModel, RGBA64At, Set, SetRGBA64 }

   * this range map are guaranteed to read through to the returned {@code Map}.
   *
   * <p>The returned {@code Map} iterates over entries in ascending order of the bounds of the
   * {@code Range} entries.
   *
   * <p>It is guaranteed that no empty ranges will be in the returned {@code Map}.
   */
  Map<Range<K>, V> asMapOfRanges();

  /**

        buffer.putInt(4, data.length);
        result = NtlmMessage.readSecurityBuffer(data, 0);
        assertEquals(0, result.length, "Should return empty array if offset is out of bounds but length is zero.");

        // Test with offset pointing outside array bounds (should throw ArrayIndexOutOfBoundsException)
        buffer.putShort(0, (short) 1);
        buffer.putShort(2, (short) 1);
        buffer.putInt(4, data.length + 1); // Invalid offset

  }

  private static <D extends GenericDeclaration> TypeVariable<D> withBounds(
      TypeVariable<D> typeVariable, Type... bounds) {
    return Types.newArtificialTypeVariable(
        typeVariable.getGenericDeclaration(), typeVariable.getName(), bounds);
  }

  private static class TypeVariableEqualsTester {
    private final EqualsTester tester = new EqualsTester();

    @CanIgnoreReturnValue