testBuffer = new byte[100];
        testBuffer[0] = 0x00; // Allow ACE
        testBuffer[1] = 0x03; // FLAGS_OBJECT_INHERIT | FLAGS_CONTAINER_INHERIT
        testBuffer[2] = 0x20; // Size low byte (32)
        testBuffer[3] = 0x00; // Size high byte
        testBuffer[4] = (byte) 0xA9; // Access mask byte 0
        testBuffer[5] = 0x00; // Access mask byte 1
        testBuffer[6] = 0x12; // Access mask byte 2

    @Nullable Node<K, V> previous;
    int expectedModCount = modCount;

    NodeIterator(int index) {
      int size = size();
      checkPositionIndex(index, size);
      if (index >= (size / 2)) {
        previous = tail;
        nextIndex = size;
        while (index++ < size) {
          previous();
        }
      } else {
        next = head;
        while (index-- > 0) {
          next();

	var buf bytes.Buffer
	gob.NewEncoder(&buf).Encode(v)
	encoded := buf.Bytes()
	b.Log("Size:", buf.Len(), "bytes")
	b.SetBytes(1)
	b.ReportAllocs()

        return this;
    }

    /**
     * Gets the fragment size.
     *
     * @return the fragment size in characters
     */
    public int getFragmentSize() {
        return fragmentSize;
    }

    /**
     * Sets the fragment size with fluent interface.
     *
     * @param fragmentSize the fragment size in characters
     * @return this HighlightInfo instance for method chaining
     */

  @BeforeExperiment
  void setUp() {
    checkArgument(size > 0, "empty collection not supported");
    Set<Integer> set = new LinkedHashSet<>(size);

    Random random = new Random();
    while (set.size() < size) {
      set.add(random.nextInt());
    }
    List<Integer> list = new ArrayList<>(set);
    inputOrder.arrange(list);
    input = ImmutableList.copyOf(list);
  }

  @Benchmark
  int collections(int reps) {

      }
      this.size = size;
    }

    @Override
    public int size() {
      return size;
    }

    @Override
    public Range<C> get(int index) {
      checkElementIndex(index, size);

      Cut<C> lowerBound;
      if (positiveBoundedBelow) {
        lowerBound = (index == 0) ? Cut.belowAll() : ranges.get(index - 1).upperBound;
      } else {

            assertEquals(4, read, "Should return the fixed structure size (4)");
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 7 })
        @DisplayName("Throws when structure size is not 4")
        void throws_whenStructureSizeIsNotFour(int size) {
            // Arrange
            byte[] buffer = new byte[2];
            SMBUtil.writeInt2(size, buffer, 0);
            Smb2LogoffResponse resp = newResponse();

    }

    /**
     * Returns the page size.
     *
     * @return The page size.
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }
        return pageSize;
    }

    /**
     * Sets the page size.
     *
     * @param pageSize The page size.
     */
    public void setPageSize(final int pageSize) {

      return ImmutableList.of();
    }
    int[] stripes = new int[result.size()];
    for (int i = 0; i < result.size(); i++) {
      stripes[i] = indexFor(result.get(i));
    }
    Arrays.sort(stripes);
    // optimize for runs of identical stripes
    int previousStripe = stripes[0];
    result.set(0, getAt(previousStripe));
    for (int i = 1; i < result.size(); i++) {
      int currentStripe = stripes[i];

		{Name: "INT", DBName: "fint", BindNames: []string{"INT"}, DataType: schema.Int, Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:fint"`},
		{Name: "INT8", DBName: "fint8", BindNames: []string{"INT8"}, DataType: schema.Int, Creatable: true, Updatable: true, Readable: true, Size: 8, Tag: `gorm:"column:fint8"`},