return
		}
		err = en.WriteInt(za0002.NumVersions)
		if err != nil {
			err = msgp.WrapError(err, "Tiers", za0001, "NumVersions")
			return
		}
		// write "no"
		err = en.Append(0xa2, 0x6e, 0x6f)
		if err != nil {
			return
		}
		err = en.WriteInt(za0002.NumObjects)
		if err != nil {
			err = msgp.WrapError(err, "Tiers", za0001, "NumObjects")
			return
		}
	}
	return
}

    // Confirm the data strings are ASCII.
    for (dataString in listOf<String>(compactTable.sections, compactTable.ranges)) {
      for (codePoint in dataString.codePoints()) {
        assertThat(codePoint and 0x7f).isEqualTo(codePoint)
      }
    }

    // Confirm the sections are increasing.
    val rangesIndices = mutableListOf<Int>()
    val rangesOffsets = mutableListOf<Int>()

  val sourceCodePoint1: Int,
  val type: Int,
  val mappedTo: ByteString,
) {
  val section: Int
    get() = sourceCodePoint0 and 0x1fff80

  val rangeStart: Int
    get() = sourceCodePoint0 and 0x7f

  val hasSingleSourceCodePoint: Boolean
    get() = sourceCodePoint0 == sourceCodePoint1

  val spansSections: Boolean
    get() = (sourceCodePoint0 and 0x1fff80) != (sourceCodePoint1 and 0x1fff80)

        // T = 0x54 -> upper nibble: 0x5 -> 0x46 (F), lower nibble: 0x4 -> 0x45 (E)
        assertEquals('F', dst[1]); // (0x54 >> 4) + 0x41 = 0x46 = 'F'
        assertEquals('E', dst[2]); // (0x54 & 0x0F) + 0x41 = 0x45 = 'E'

        // Check padding (positions 8-30 should be 'CA' pairs for spaces)
        for (int i = 8; i < 31; i += 2) {
            assertEquals('C', dst[i + 1]);

        int chunk = (bytes[i++] & 0xFF) << 16 | (bytes[i++] & 0xFF) << 8 | (bytes[i++] & 0xFF);
        target.append(alphabet.encode(chunk >>> 18));
        target.append(alphabet.encode((chunk >>> 12) & 0x3F));
        target.append(alphabet.encode((chunk >>> 6) & 0x3F));
        target.append(alphabet.encode(chunk & 0x3F));
      }
      if (i < off + len) {

 * @since 15.0
 */
@GwtCompatible
public class XmlEscapers {
  private XmlEscapers() {}

  private static final char MIN_ASCII_CONTROL_CHAR = 0x00;
  private static final char MAX_ASCII_CONTROL_CHAR = 0x1F;

  // For each xxxEscaper() method, please add links to external reference pages
  // that are considered authoritative for the behavior of that escaper.

  /**

        val codepointDelta = (b1 and 0xF shl 14) or (b2 shl 7) or b3
        sink.writeUtf8CodePoint(codePoint - codepointDelta)
      }

      in 80..95 -> {
        // Mapped inline as codePoint delta to add
        val b2 = ranges[rangesIndex + 2].code
        val b3 = ranges[rangesIndex + 3].code

        val codepointDelta = (b1 and 0xF shl 14) or (b2 shl 7) or b3

                0x01, // ShareType (DISK)
                0x00, // Reserved
                0x01, 0x00, 0x00, 0x00, // ShareFlags
                0x08, 0x00, 0x00, 0x00, // Capabilities
                (byte) 0xFF, 0x01, 0x1F, 0x00 // MaximalAccess
        };

        // When
        int bytesRead = response.readBytesWireFormat(wireData, 0);

        // Then
        assertEquals(16, bytesRead);

        assertEquals(0, cap.getValue().length, "Optimistic token must be zero-length");
    }

    @ParameterizedTest
    @ValueSource(bytes = { 0x00, 0x7F, (byte) 0xFF })
    @DisplayName("initSecContext throws on invalid token type")
    void testInitSecContextInvalidTokenType(byte firstByte) throws Exception {
        SpnegoContext ctx = newContext();

            SMBUtil.writeInt4(4, buffer, errorStart + 4); // byte count

            // Write some error data
            buffer[errorStart + 8] = (byte) 0xFF;
            buffer[errorStart + 9] = (byte) 0xFE;
            buffer[errorStart + 10] = (byte) 0xFD;
            buffer[errorStart + 11] = (byte) 0xFC;

            testMessage.setBytesRead(0);
            testMessage.decode(buffer, 0);