assertThat(set.headSet(2)).containsExactly(1).inOrder();
    assertThat(set.headSet(3)).containsExactly(1, 2).inOrder();
    assertThat(set.headSet(4)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(Integer.MAX_VALUE)).containsExactly(1, 2, 3).inOrder();
    assertThat(set.headSet(1, true)).containsExactly(1).inOrder();
    assertThat(set.headSet(2, true)).containsExactly(1, 2).inOrder();

                <c:if test="${crudMode==2 || crudMode==3 || crudMode==4}">
                    <la:hidden property="id"/>
                    <la:hidden property="versionNo"/>
                </c:if>
                <div class="row">
                    <div class="col-md-12">
                        <div

        }

        SMBUtil.writeInt2(NET_SHARE_ENUM, dst, dstIndex);
        dstIndex += 2;
        System.arraycopy(descr, 0, dst, dstIndex, descr.length);
        dstIndex += descr.length;
        SMBUtil.writeInt2(0x0001, dst, dstIndex);
        dstIndex += 2;
        SMBUtil.writeInt2(this.maxDataCount, dst, dstIndex);
        dstIndex += 2;

        return dstIndex - start;
    }


    @Override

			if i < 0 {
				break
			}
			idx += i
			p[idx] = '\n'
		}
		return n, nil
	}

	// 2 characters...
	for idx := 0; idx < len(p); {
		i := bytes.Index(p[idx:], rr.recordDelimiter)
		if i < 0 {
			break
		}
		idx += i

		p[idx] = '\n'
		p = append(p[:idx+1], p[idx+2:]...)
		n--
	}

	if p[n-1] != rr.recordDelimiter[0] {
		return n, nil
	}

                <c:if test="${crudMode==2 || crudMode==3 || crudMode==4}">
                    <la:hidden property="id"/>
                </c:if>
                <div class="row">
                    <div class="col-md-12">
                        <div

    @Override
    protected List<Short> create(Short[] elements) {
      Short[] prefix = {(short) 86, (short) 99};
      Short[] all = concat(prefix, elements);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  public static final class ShortsAsListMiddleSubListGenerator extends TestShortListGenerator {
    @Override
    protected List<Short> create(Short[] elements) {

    @Override
    protected List<Long> create(Long[] elements) {
      Long[] prefix = {(long) 86, (long) 99};
      Long[] all = concat(prefix, elements);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  public static final class LongsAsListMiddleSubListGenerator extends TestLongListGenerator {
    @Override
    protected List<Long> create(Long[] elements) {

    @Override
    protected List<Short> create(Short[] elements) {
      Short[] prefix = {(short) 86, (short) 99};
      Short[] all = concat(prefix, elements);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  public static final class ShortsAsListMiddleSubListGenerator extends TestShortListGenerator {
    @Override
    protected List<Short> create(Short[] elements) {

    @Override
    protected List<Character> create(Character[] elements) {
      Character[] prefix = {(char) 86, (char) 99};
      Character[] all = concat(prefix, elements);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  public static final class CharsAsListMiddleSubListGenerator extends TestCharListGenerator {
    @Override
    protected List<Character> create(Character[] elements) {

  var i = pos
  while (i < limit) {
    codePoint = encoded.codePointAt(i)
    if (codePoint == '%'.code && i + 2 < limit) {
      val d1 = encoded[i + 1].parseHexDigit()
      val d2 = encoded[i + 2].parseHexDigit()
      if (d1 != -1 && d2 != -1) {
        writeByte((d1 shl 4) + d2)
        i += 2
        i += Character.charCount(codePoint)
        continue
      }