#if !STRINGLIB_IS_UNICODE

# error "codecs.h is specific to Unicode"

#include "pycore_bitutils.h" // _Py_bswap32()

#if (SIZEOF_SIZE_T == 8)

# define ASCII_CHAR_MASK 0x8080808080808080ULL

#elif (SIZEOF_SIZE_T == 4)

# define ASCII_CHAR_MASK 0x80808080U

# error C 'size_t' size should be either 4 or 8!

#define IS_CONTINUATION_BYTE(ch) ((ch) >= 0x80 && (ch) < 0xC0)

Py_LOCAL_INLINE(Py_UCS4)

STRINGLIB(utf8_decode)(const char **inptr, const char *end,

STRINGLIB_CHAR *dest,

Py_ssize_t *outpos)

{

Py_UCS4 ch;

const char *s = *inptr;

STRINGLIB_CHAR *p = dest + *outpos;

while (s < end) {

ch = (unsigned char)*s;

if (ch < 0x80) {

/* Fast path for runs of ASCII characters. Given that common UTF-8

if (_Py_IS_ALIGNED(s, ALIGNOF_SIZE_T)) {

/* Help register allocation */

const char *_s = s;

STRINGLIB_CHAR *_p = p;

while (_s + SIZEOF_SIZE_T <= end) {

/* Read a whole size_t at a time (either 4 or 8 bytes),

size_t value = *(const size_t *) _s;

if (value & ASCII_CHAR_MASK)

break;

#if PY_LITTLE_ENDIAN

_p[0] = (STRINGLIB_CHAR)(value & 0xFFu);

_p[1] = (STRINGLIB_CHAR)((value >> 8) & 0xFFu);

_p[2] = (STRINGLIB_CHAR)((value >> 16) & 0xFFu);

_p[3] = (STRINGLIB_CHAR)((value >> 24) & 0xFFu);

# if SIZEOF_SIZE_T == 8

_p[4] = (STRINGLIB_CHAR)((value >> 32) & 0xFFu);

_p[5] = (STRINGLIB_CHAR)((value >> 40) & 0xFFu);

_p[6] = (STRINGLIB_CHAR)((value >> 48) & 0xFFu);

_p[7] = (STRINGLIB_CHAR)((value >> 56) & 0xFFu);

# if SIZEOF_SIZE_T == 8

_p[0] = (STRINGLIB_CHAR)((value >> 56) & 0xFFu);

_p[1] = (STRINGLIB_CHAR)((value >> 48) & 0xFFu);

_p[2] = (STRINGLIB_CHAR)((value >> 40) & 0xFFu);

_p[3] = (STRINGLIB_CHAR)((value >> 32) & 0xFFu);

_p[4] = (STRINGLIB_CHAR)((value >> 24) & 0xFFu);

_p[5] = (STRINGLIB_CHAR)((value >> 16) & 0xFFu);

_p[6] = (STRINGLIB_CHAR)((value >> 8) & 0xFFu);

_p[7] = (STRINGLIB_CHAR)(value & 0xFFu);

_p[0] = (STRINGLIB_CHAR)((value >> 24) & 0xFFu);

_p[1] = (STRINGLIB_CHAR)((value >> 16) & 0xFFu);

_p[2] = (STRINGLIB_CHAR)((value >> 8) & 0xFFu);

_p[3] = (STRINGLIB_CHAR)(value & 0xFFu);

_s += SIZEOF_SIZE_T;

_p += SIZEOF_SIZE_T;

}

s = _s;

p = _p;

if (s == end)

break;

ch = (unsigned char)*s;

}

if (ch < 0x80) {

s++;

*p++ = ch;

continue;

}

}

if (ch < 0xE0) {

/* \xC2\x80-\xDF\xBF -- 0080-07FF */

Py_UCS4 ch2;

if (ch < 0xC2) {

/* invalid sequence

goto InvalidStart;

}

if (end - s < 2) {

/* unexpected end of data: the caller will decide whether

break;

}

ch2 = (unsigned char)s[1];

if (!IS_CONTINUATION_BYTE(ch2))

/* invalid continuation byte */

goto InvalidContinuation1;

ch = (ch << 6) + ch2 -

((0xC0 << 6) + 0x80);

assert ((ch > 0x007F) && (ch <= 0x07FF));

s += 2;

if (STRINGLIB_MAX_CHAR <= 0x007F ||

(STRINGLIB_MAX_CHAR < 0x07FF && ch > STRINGLIB_MAX_CHAR))

/* Out-of-range */

goto Return;

*p++ = ch;

continue;

}

if (ch < 0xF0) {

/* \xE0\xA0\x80-\xEF\xBF\xBF -- 0800-FFFF */

Py_UCS4 ch2, ch3;

if (end - s < 3) {

/* unexpected end of data: the caller will decide whether

if (end - s < 2)

break;

ch2 = (unsigned char)s[1];

if (!IS_CONTINUATION_BYTE(ch2) ||

(ch2 < 0xA0 ? ch == 0xE0 : ch == 0xED))

/* for clarification see comments below */

goto InvalidContinuation1;

break;

}

ch2 = (unsigned char)s[1];

ch3 = (unsigned char)s[2];

if (!IS_CONTINUATION_BYTE(ch2)) {

/* invalid continuation byte */

goto InvalidContinuation1;

}

if (ch == 0xE0) {

if (ch2 < 0xA0)

/* invalid sequence

goto InvalidContinuation1;

} else if (ch == 0xED && ch2 >= 0xA0) {

/* Decoding UTF-8 sequences in range \xED\xA0\x80-\xED\xBF\xBF

goto InvalidContinuation1;

}

if (!IS_CONTINUATION_BYTE(ch3)) {

/* invalid continuation byte */

goto InvalidContinuation2;

}

ch = (ch << 12) + (ch2 << 6) + ch3 -

((0xE0 << 12) + (0x80 << 6) + 0x80);

assert ((ch > 0x07FF) && (ch <= 0xFFFF));

s += 3;

if (STRINGLIB_MAX_CHAR <= 0x07FF ||

(STRINGLIB_MAX_CHAR < 0xFFFF && ch > STRINGLIB_MAX_CHAR))

/* Out-of-range */

goto Return;

*p++ = ch;

continue;

}

if (ch < 0xF5) {

/* \xF0\x90\x80\x80-\xF4\x8F\xBF\xBF -- 10000-10FFFF */

Py_UCS4 ch2, ch3, ch4;

if (end - s < 4) {

/* unexpected end of data: the caller will decide whether

if (end - s < 2)

break;

ch2 = (unsigned char)s[1];

if (!IS_CONTINUATION_BYTE(ch2) ||

(ch2 < 0x90 ? ch == 0xF0 : ch == 0xF4))

/* for clarification see comments below */

goto InvalidContinuation1;

if (end - s < 3)

break;

ch3 = (unsigned char)s[2];

if (!IS_CONTINUATION_BYTE(ch3))

goto InvalidContinuation2;

break;

}

ch2 = (unsigned char)s[1];

ch3 = (unsigned char)s[2];

ch4 = (unsigned char)s[3];

if (!IS_CONTINUATION_BYTE(ch2)) {

/* invalid continuation byte */

goto InvalidContinuation1;

}

if (ch == 0xF0) {

if (ch2 < 0x90)

/* invalid sequence

goto InvalidContinuation1;

} else if (ch == 0xF4 && ch2 >= 0x90) {

/* invalid sequence

goto InvalidContinuation1;

}

if (!IS_CONTINUATION_BYTE(ch3)) {

/* invalid continuation byte */

goto InvalidContinuation2;

}

if (!IS_CONTINUATION_BYTE(ch4)) {

/* invalid continuation byte */

goto InvalidContinuation3;

}

ch = (ch << 18) + (ch2 << 12) + (ch3 << 6) + ch4 -

((0xF0 << 18) + (0x80 << 12) + (0x80 << 6) + 0x80);

assert ((ch > 0xFFFF) && (ch <= 0x10FFFF));

s += 4;

if (STRINGLIB_MAX_CHAR <= 0xFFFF ||

(STRINGLIB_MAX_CHAR < 0x10FFFF && ch > STRINGLIB_MAX_CHAR))

/* Out-of-range */

goto Return;

*p++ = ch;

continue;

}

goto InvalidStart;

}

ch = 0;

Return:

*inptr = s;

*outpos = p - dest;

return ch;

InvalidStart:

ch = 1;

goto Return;

InvalidContinuation1:

ch = 2;

goto Return;

InvalidContinuation2:

ch = 3;

goto Return;

InvalidContinuation3:

ch = 4;

goto Return;

}

#undef ASCII_CHAR_MASK

Py_LOCAL_INLINE(PyBytesWriter*)

STRINGLIB(utf8_encoder)(PyObject *unicode,

const STRINGLIB_CHAR *data,

Py_ssize_t size,

_Py_error_handler error_handler,

const char *errors,

char **end)

{

#if STRINGLIB_SIZEOF_CHAR > 1

PyObject *error_handler_obj = NULL;

PyObject *exc = NULL;

PyObject *rep = NULL;

#if STRINGLIB_SIZEOF_CHAR == 1

const Py_ssize_t max_char_size = 2;

#elif STRINGLIB_SIZEOF_CHAR == 2

const Py_ssize_t max_char_size = 3;

#else /* STRINGLIB_SIZEOF_CHAR == 4 */

const Py_ssize_t max_char_size = 4;

assert(size >= 0);

if (size > PY_SSIZE_T_MAX / max_char_size) {

/* integer overflow */

PyErr_NoMemory();

*end = NULL;

return NULL;

}

PyBytesWriter *writer = PyBytesWriter_Create(size * max_char_size);

if (writer == NULL) {

*end = NULL;

return NULL;

}

/* next free byte in output buffer */

char *p = PyBytesWriter_GetData(writer);

Py_ssize_t i; /* index into data of next input character */

for (i = 0; i < size;) {

Py_UCS4 ch = data[i++];

if (ch < 0x80) {

/* Encode ASCII */

*p++ = (char) ch;

}

else

#if STRINGLIB_SIZEOF_CHAR > 1

if (ch < 0x0800)

{

/* Encode Latin-1 */

*p++ = (char)(0xc0 | (ch >> 6));

*p++ = (char)(0x80 | (ch & 0x3f));

}

#if STRINGLIB_SIZEOF_CHAR > 1

else if (Py_UNICODE_IS_SURROGATE(ch)) {

Py_ssize_t startpos, endpos, newpos;

Py_ssize_t k;

if (error_handler == _Py_ERROR_UNKNOWN) {

error_handler = _Py_GetErrorHandler(errors);

}

startpos = i-1;

endpos = startpos+1;

while ((endpos < size) && Py_UNICODE_IS_SURROGATE(data[endpos]))

endpos++;

/* Only overallocate the buffer if it's not the last write */

writer->overallocate = (endpos < size);

switch (error_handler)

{

case _Py_ERROR_REPLACE:

memset(p, '?', endpos - startpos);

p += (endpos - startpos);

_Py_FALLTHROUGH;

case _Py_ERROR_IGNORE:

i += (endpos - startpos - 1);

break;

case _Py_ERROR_SURROGATEPASS:

for (k=startpos; k<endpos; k++) {

ch = data[k];

*p++ = (char)(0xe0 | (ch >> 12));

*p++ = (char)(0x80 | ((ch >> 6) & 0x3f));

*p++ = (char)(0x80 | (ch & 0x3f));

}

i += (endpos - startpos - 1);

break;

case _Py_ERROR_BACKSLASHREPLACE:

/* subtract preallocated bytes */

writer->size -= max_char_size * (endpos - startpos);

p = backslashreplace(writer, p,

unicode, startpos, endpos);

if (p == NULL)

goto error;

i += (endpos - startpos - 1);

break;

case _Py_ERROR_XMLCHARREFREPLACE:

/* subtract preallocated bytes */

writer->size -= max_char_size * (endpos - startpos);

p = xmlcharrefreplace(writer, p,

unicode, startpos, endpos);

if (p == NULL)

goto error;

i += (endpos - startpos - 1);

break;

case _Py_ERROR_SURROGATEESCAPE:

for (k=startpos; k<endpos; k++) {

ch = data[k];

if (!(0xDC80 <= ch && ch <= 0xDCFF))

break;

*p++ = (char)(ch & 0xff);

}

if (k >= endpos) {

i += (endpos - startpos - 1);

break;

}

startpos = k;

assert(startpos < endpos);

_Py_FALLTHROUGH;

default:

rep = unicode_encode_call_errorhandler(

errors, &error_handler_obj, "utf-8", "surrogates not allowed",

unicode, &exc, startpos, endpos, &newpos);

if (!rep)

goto error;

if (newpos < startpos) {

writer->overallocate = 1;

p = PyBytesWriter_GrowAndUpdatePointer(writer,

max_char_size * (startpos - newpos),

p);

if (p == NULL) {

goto error;

}

}

else {

/* subtract preallocated bytes */

writer->size -= max_char_size * (newpos - startpos);

/* Only overallocate the buffer if it's not the last write */

writer->overallocate = (newpos < size);

}

char *rep_str;

Py_ssize_t rep_len;

if (PyBytes_Check(rep)) {

rep_str = PyBytes_AS_STRING(rep);

rep_len = PyBytes_GET_SIZE(rep);

}

else {

/* rep is unicode */

if (!PyUnicode_IS_ASCII(rep)) {

raise_encode_exception(&exc, "utf-8", unicode,

startpos, endpos,

"surrogates not allowed");

goto error;

}

rep_str = PyUnicode_DATA(rep);

rep_len = PyUnicode_GET_LENGTH(rep);

}

p = PyBytesWriter_GrowAndUpdatePointer(writer, rep_len, p);

if (p == NULL) {

goto error;

}

memcpy(p, rep_str, rep_len);

p += rep_len;

Py_CLEAR(rep);

i = newpos;

}

/* If overallocation was disabled, ensure that it was the last

assert(writer->overallocate || i == size);

}

else

#if STRINGLIB_SIZEOF_CHAR > 2

if (ch < 0x10000)

{

*p++ = (char)(0xe0 | (ch >> 12));

*p++ = (char)(0x80 | ((ch >> 6) & 0x3f));

*p++ = (char)(0x80 | (ch & 0x3f));

}

#if STRINGLIB_SIZEOF_CHAR > 2

else /* ch >= 0x10000 */

{

assert(ch <= MAX_UNICODE);

/* Encode UCS4 Unicode ordinals */

*p++ = (char)(0xf0 | (ch >> 18));

*p++ = (char)(0x80 | ((ch >> 12) & 0x3f));

*p++ = (char)(0x80 | ((ch >> 6) & 0x3f));

*p++ = (char)(0x80 | (ch & 0x3f));

}

#endif /* STRINGLIB_SIZEOF_CHAR > 2 */

#endif /* STRINGLIB_SIZEOF_CHAR > 1 */

}

#if STRINGLIB_SIZEOF_CHAR > 1

Py_XDECREF(error_handler_obj);

Py_XDECREF(exc);

*end = p;

return writer;

#if STRINGLIB_SIZEOF_CHAR > 1

error:

PyBytesWriter_Discard(writer);

Py_XDECREF(rep);

Py_XDECREF(error_handler_obj);

Py_XDECREF(exc);

*end = NULL;

return NULL;

}

#if SIZEOF_LONG == 8

# define UCS2_REPEAT_MASK 0x0001000100010001ul

#elif SIZEOF_LONG == 4

# define UCS2_REPEAT_MASK 0x00010001ul

# error C 'long' size should be either 4 or 8!

#if STRINGLIB_SIZEOF_CHAR == 1

# define FAST_CHAR_MASK (UCS2_REPEAT_MASK * (0xFFFFu & ~STRINGLIB_MAX_CHAR))

# define FAST_CHAR_MASK (UCS2_REPEAT_MASK * 0x8000u)

#define STRIPPED_MASK (UCS2_REPEAT_MASK * 0x00FFu)

#define SWAB(value) ((((value) >> 8) & STRIPPED_MASK) | \

(((value) & STRIPPED_MASK) << 8))

Py_LOCAL_INLINE(Py_UCS4)

STRINGLIB(utf16_decode)(const unsigned char **inptr, const unsigned char *e,

STRINGLIB_CHAR *dest, Py_ssize_t *outpos,

int native_ordering)

{

Py_UCS4 ch;

const unsigned char *q = *inptr;

STRINGLIB_CHAR *p = dest + *outpos;

/* Offsets from q for retrieving byte pairs in the right order. */

#if PY_LITTLE_ENDIAN

int ihi = !!native_ordering, ilo = !native_ordering;

int ihi = !native_ordering, ilo = !!native_ordering;

--e;

while (q < e) {

Py_UCS4 ch2;

/* First check for possible aligned read of a C 'long'. Unaligned

if (_Py_IS_ALIGNED(q, ALIGNOF_LONG)) {

/* Fast path for runs of in-range non-surrogate chars. */

const unsigned char *_q = q;

while (_q + SIZEOF_LONG <= e) {

unsigned long block = * (const unsigned long *) _q;

if (native_ordering) {

/* Can use buffer directly */

if (block & FAST_CHAR_MASK)

break;

}

else {

/* Need to byte-swap */

if (block & SWAB(FAST_CHAR_MASK))

break;

#if STRINGLIB_SIZEOF_CHAR == 1

block >>= 8;

block = SWAB(block);

}

#if PY_LITTLE_ENDIAN

# if SIZEOF_LONG == 4

p[0] = (STRINGLIB_CHAR)(block & 0xFFFFu);

p[1] = (STRINGLIB_CHAR)(block >> 16);

# elif SIZEOF_LONG == 8

p[0] = (STRINGLIB_CHAR)(block & 0xFFFFu);

p[1] = (STRINGLIB_CHAR)((block >> 16) & 0xFFFFu);

p[2] = (STRINGLIB_CHAR)((block >> 32) & 0xFFFFu);

p[3] = (STRINGLIB_CHAR)(block >> 48);

# if SIZEOF_LONG == 4

p[0] = (STRINGLIB_CHAR)(block >> 16);

p[1] = (STRINGLIB_CHAR)(block & 0xFFFFu);

# elif SIZEOF_LONG == 8

p[0] = (STRINGLIB_CHAR)(block >> 48);

p[1] = (STRINGLIB_CHAR)((block >> 32) & 0xFFFFu);

p[2] = (STRINGLIB_CHAR)((block >> 16) & 0xFFFFu);

p[3] = (STRINGLIB_CHAR)(block & 0xFFFFu);

_q += SIZEOF_LONG;

p += SIZEOF_LONG / 2;

}

q = _q;

if (q >= e)

break;

}

ch = (q[ihi] << 8) | q[ilo];

q += 2;

if (!Py_UNICODE_IS_SURROGATE(ch)) {

#if STRINGLIB_SIZEOF_CHAR < 2

if (ch > STRINGLIB_MAX_CHAR)

/* Out-of-range */

goto Return;

*p++ = (STRINGLIB_CHAR)ch;

continue;

}

/* UTF-16 code pair: */

if (!Py_UNICODE_IS_HIGH_SURROGATE(ch))

goto IllegalEncoding;

if (q >= e)

goto UnexpectedEnd;

ch2 = (q[ihi] << 8) | q[ilo];

q += 2;

if (!Py_UNICODE_IS_LOW_SURROGATE(ch2))

goto IllegalSurrogate;

ch = Py_UNICODE_JOIN_SURROGATES(ch, ch2);

#if STRINGLIB_SIZEOF_CHAR < 4

/* Out-of-range */

goto Return;

*p++ = (STRINGLIB_CHAR)ch;

}

ch = 0;

Return:

*inptr = q;

*outpos = p - dest;

return ch;

UnexpectedEnd:

ch = 1;

goto Return;

IllegalEncoding:

ch = 2;

goto Return;

IllegalSurrogate:

ch = 3;

goto Return;

}

#undef UCS2_REPEAT_MASK

#undef FAST_CHAR_MASK

#undef STRIPPED_MASK

#undef SWAB

#if STRINGLIB_MAX_CHAR >= 0x80

Py_LOCAL_INLINE(Py_ssize_t)

STRINGLIB(utf16_encode)(const STRINGLIB_CHAR *in,

Py_ssize_t len,

unsigned short **outptr,

int native_ordering)

{

unsigned short *out = *outptr;

const STRINGLIB_CHAR *end = in + len;

#if STRINGLIB_SIZEOF_CHAR == 1

if (native_ordering) {

const STRINGLIB_CHAR *unrolled_end = in + _Py_SIZE_ROUND_DOWN(len, 4);

while (in < unrolled_end) {

out[0] = in[0];

out[1] = in[1];

out[2] = in[2];

out[3] = in[3];

in += 4; out += 4;

}

while (in < end) {

*out++ = *in++;

}

} else {

# define SWAB2(CH) ((CH) << 8) /* high byte is zero */

const STRINGLIB_CHAR *unrolled_end = in + _Py_SIZE_ROUND_DOWN(len, 4);

while (in < unrolled_end) {

out[0] = SWAB2(in[0]);

out[1] = SWAB2(in[1]);

out[2] = SWAB2(in[2]);

out[3] = SWAB2(in[3]);

in += 4; out += 4;

}

while (in < end) {

Py_UCS4 ch = *in++;

*out++ = SWAB2((Py_UCS2)ch);

}

#undef SWAB2

}

*outptr = out;

return len;

if (native_ordering) {

#if STRINGLIB_MAX_CHAR < 0x10000

const STRINGLIB_CHAR *unrolled_end = in + _Py_SIZE_ROUND_DOWN(len, 4);

while (in < unrolled_end) {

/* check if any character is a surrogate character */

if (((in[0] ^ 0xd800) &

(in[1] ^ 0xd800) &

(in[2] ^ 0xd800) &

(in[3] ^ 0xd800) & 0xf800) == 0)

break;

out[0] = in[0];

out[1] = in[1];

out[2] = in[2];

out[3] = in[3];

in += 4; out += 4;

}

while (in < end) {

Py_UCS4 ch;

ch = *in++;

if (ch < 0xd800)

*out++ = ch;

else if (ch < 0xe000)

/* reject surrogate characters (U+D800-U+DFFF) */

goto fail;

#if STRINGLIB_MAX_CHAR >= 0x10000

else if (ch >= 0x10000) {

out[0] = Py_UNICODE_HIGH_SURROGATE(ch);

out[1] = Py_UNICODE_LOW_SURROGATE(ch);

out += 2;

}

else

*out++ = ch;

}

} else {

#define SWAB2(CH) (((CH) << 8) | ((CH) >> 8))

#if STRINGLIB_MAX_CHAR < 0x10000

const STRINGLIB_CHAR *unrolled_end = in + _Py_SIZE_ROUND_DOWN(len, 4);

while (in < unrolled_end) {

/* check if any character is a surrogate character */

if (((in[0] ^ 0xd800) &

(in[1] ^ 0xd800) &

(in[2] ^ 0xd800) &

(in[3] ^ 0xd800) & 0xf800) == 0)

break;

out[0] = SWAB2(in[0]);

out[1] = SWAB2(in[1]);

out[2] = SWAB2(in[2]);

out[3] = SWAB2(in[3]);

in += 4; out += 4;

}

while (in < end) {

Py_UCS4 ch = *in++;

if (ch < 0xd800)

*out++ = SWAB2((Py_UCS2)ch);

else if (ch < 0xe000)

/* reject surrogate characters (U+D800-U+DFFF) */

goto fail;

#if STRINGLIB_MAX_CHAR >= 0x10000

else if (ch >= 0x10000) {

Py_UCS2 ch1 = Py_UNICODE_HIGH_SURROGATE(ch);

Py_UCS2 ch2 = Py_UNICODE_LOW_SURROGATE(ch);

out[0] = SWAB2(ch1);

out[1] = SWAB2(ch2);

out += 2;

}

else

*out++ = SWAB2((Py_UCS2)ch);

}

#undef SWAB2

}

*outptr = out;

return len;

fail:

*outptr = out;

return len - (end - in + 1);

}

static inline uint32_t

STRINGLIB(SWAB4)(STRINGLIB_CHAR ch)

{

uint32_t word = ch;

#if STRINGLIB_SIZEOF_CHAR == 1

/* high bytes are zero */

return (word << 24);

#elif STRINGLIB_SIZEOF_CHAR == 2

/* high bytes are zero */

return ((word & 0x00FFu) << 24) | ((word & 0xFF00u) << 8);

return _Py_bswap32(word);

}

Py_LOCAL_INLINE(Py_ssize_t)

STRINGLIB(utf32_encode)(const STRINGLIB_CHAR *in,

Py_ssize_t len,

uint32_t **outptr,

int native_ordering)

{

uint32_t *out = *outptr;

const STRINGLIB_CHAR *end = in + len;

if (native_ordering) {

const STRINGLIB_CHAR *unrolled_end = in + _Py_SIZE_ROUND_DOWN(len, 4);

while (in < unrolled_end) {

#if STRINGLIB_SIZEOF_CHAR > 1

/* check if any character is a surrogate character */

if (((in[0] ^ 0xd800) &

(in[1] ^ 0xd800) &

(in[2] ^ 0xd800) &

(in[3] ^ 0xd800) & 0xf800) == 0)

break;

out[0] = in[0];

out[1] = in[1];

out[2] = in[2];

out[3] = in[3];

in += 4; out += 4;

}

while (in < end) {

Py_UCS4 ch;

ch = *in++;

#if STRINGLIB_SIZEOF_CHAR > 1

if (Py_UNICODE_IS_SURROGATE(ch)) {

/* reject surrogate characters (U+D800-U+DFFF) */

goto fail;

}

*out++ = ch;

}

} else {

const STRINGLIB_CHAR *unrolled_end = in + _Py_SIZE_ROUND_DOWN(len, 4);

while (in < unrolled_end) {

#if STRINGLIB_SIZEOF_CHAR > 1

/* check if any character is a surrogate character */

if (((in[0] ^ 0xd800) &

(in[1] ^ 0xd800) &

(in[2] ^ 0xd800) &

(in[3] ^ 0xd800) & 0xf800) == 0)

break;

out[0] = STRINGLIB(SWAB4)(in[0]);

out[1] = STRINGLIB(SWAB4)(in[1]);

out[2] = STRINGLIB(SWAB4)(in[2]);

out[3] = STRINGLIB(SWAB4)(in[3]);

in += 4; out += 4;

}

while (in < end) {

Py_UCS4 ch = *in++;

#if STRINGLIB_SIZEOF_CHAR > 1

if (Py_UNICODE_IS_SURROGATE(ch)) {

/* reject surrogate characters (U+D800-U+DFFF) */

goto fail;

}

*out++ = STRINGLIB(SWAB4)(ch);

}

}

*outptr = out;

return len;

#if STRINGLIB_SIZEOF_CHAR > 1

fail:

*outptr = out;

return len - (end - in + 1);

}