REGISTER_DECL64 native_uint WStrLen(char16_t* chars)
{
    if (!chars) return 0;

    if ((native_int)chars & 1)
    {
        char16_t* _s = chars;
        for (;;)
        {
            if (*_s == 0) break;
            _s++;
        }
        return ((native_uint)_s - (native_uint)chars) >> 1;
    }

    static native_uint arr[sizeof(native_uint) / sizeof(char16_t)] = {
        0,
        ((native_uint)1 << (16 * 1)) - 1
    #if defined (LARGEINT)
        ,
        ((native_uint)1 << (16 * 2)) - 1,
        ((native_uint)1 << (16 * 3)) - 1
    #endif
    };

    char8_t* s = (char8_t*)((native_int)chars & -sizeof(native_uint));
    native_uint index = ((native_int)chars & (sizeof(native_uint) - 1)) >> 1;
    native_uint x = *((native_uint*)s) | arr[index];

    for (;;x = *((native_uint*)s))
    {
    #if defined (SMALLINT)
        if ((x & 0x0000ffff) == 0) break;
        s += sizeof(char16_t);
        if ((x & 0xffff0000) == 0) break;
        s += sizeof(char16_t);
    #else
        native_uint u = x - MASK_0001_NATIVE;
        x = ~x & u;
        if (x & MASK_8000_NATIVE) break;
        s += sizeof(native_uint);
    #endif
    }
    #if defined (LARGEINT)
    s += (bit_fastindex(x & MASK_8000_NATIVE) >> 4) * sizeof(char16_t);
    #endif

    return ((native_uint)s - (native_uint)chars) >> 1;
}

FORCEINLINE bool InternalStrLen(char8_t** ptr_s, native_uint* ptr_mask,
  native_uint char_size, native_uint shift_bytes, block16 null, block16 CMPBLOCK16_MASKBITS)
{
    block16 xcmp, x;
    native_uint mask;
    native_uint high_clear_mask = (shift_bytes)?(0xffff >> char_size):((native_uint)-1);
    char8_t* s = *ptr_s;
    
    // first block
    block16* block = (block16*)((native_int)s & -sizeof(block16));
    native_uint invalid_bytes = ((native_uint)s - (native_uint)block - shift_bytes);
    if (!shift_bytes || (invalid_bytes != (sizeof(block16) - char_size)))
    {
        x = block16_switchshr_bytes(*block, *block, shift_bytes);
        xcmp = block16_cmpe_ex(x, null, char_size);
        mask = bitmask_clear(block16_cmpmask_ex(xcmp, CMPBLOCK16_MASKBITS), invalid_bytes) & high_clear_mask;
        if (mask) goto done;
    }  

    // block loop
    DISABLE_LOOP_UNROLL
    for (;;)
    {
        block++;
        if (shift_bytes) 
        {
            s = (uint8_t*)block + shift_bytes - char_size;
            if (StrGetChar(s, 0, char_size) == 0) 
            { 
                *ptr_s = s;
                return true;
            }    
        }

        x = block16_switchshr_bytes(*block, *block, shift_bytes);
        xcmp = block16_cmpe_ex(x, null, char_size);
        if (internal_block16_cmpmask_ex(&mask, xcmp, high_clear_mask)) goto done;
    }

done:
    *ptr_s = (uint8_t*)block + shift_bytes;
    *ptr_mask = mask; 
    return false;
}

FORCEINLINE native_uint StrLen(ptr_t chars, native_uint char_size)
{
    if (!chars) return 0;
   
    block16 null = volatile_null_block16;
    internal_block16_cmpmaskinit;

    native_uint mask;
    uint8_t* s = chars;
    if (likely(((native_int)s & (char_size - 1)) == 0))
    {
        if (InternalStrLen(&s, &mask, char_size, 0, null, CMPBLOCK16_MASKBITS)) goto done;
    }
    else if (((native_int)s & (char_size - 1)) == 1)
    {
        if (InternalStrLen(&s, &mask, char_size, 1, null, CMPBLOCK16_MASKBITS)) goto done;
    } 
    else if (((native_int)s & (char_size - 1)) == 2)
    {
        if (InternalStrLen(&s, &mask, char_size, 2, null, CMPBLOCK16_MASKBITS)) goto done;
    }
    else if (((native_int)s & (char_size - 1)) == 3)
    {
        if (InternalStrLen(&s, &mask, char_size, 3, null, CMPBLOCK16_MASKBITS)) goto done;
    }

    s += bit_fastindex(mask);

done:
    return ((native_uint)s - (native_uint)chars) / char_size;
}

REGISTER_DECL64 native_uint AStrLen(char8_t* chars)
{
    return StrLen(chars, sizeof(*chars));
}

REGISTER_DECL64 native_uint WStrLen(char16_t* chars)
{
    return StrLen(chars, sizeof(*chars));
}

REGISTER_DECL64 native_uint CStrLen(char32_t* chars)
{
    return StrLen(chars, sizeof(*chars));
}

WStrLen: # @WStrLen
  test eax, eax
  je .LBB0_1
  push esi
  mov edx, eax
  mov ecx, eax
  xorps xmm0, xmm0
  and edx, -16
  sub ecx, edx
  test al, 1
  jne .LBB0_6
  movdqa xmm1, xmmword ptr [edx]
  pcmpeqw xmm1, xmm0
  pmovmskb esi, xmm1
  shr esi, cl
  shl esi, cl
  test esi, esi
  jne .LBB0_14
.LBB0_4: # =>This Inner Loop Header: Depth=1
  movdqa xmm1, xmmword ptr [edx + 16]
  add edx, 16
  pcmpeqw xmm1, xmm0
  pmovmskb esi, xmm1
  test esi, esi
  je .LBB0_4
.LBB0_14:
  rep bsf ecx, esi
  add ecx, edx
.LBB0_15:
  sub ecx, eax
  shr ecx
  pop esi
  mov eax, ecx
  ret
.LBB0_1:
  xor ecx, ecx
  mov eax, ecx
  ret
.LBB0_6:
  dec ecx
  cmp ecx, 14
  je .LBB0_8
  movdqa xmm1, xmmword ptr [edx]
  psrldq xmm1, 1 # xmm1 = xmm1[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
  pcmpeqw xmm1, xmm0
  pmovmskb esi, xmm1
  shr esi, cl
  shl esi, cl
  and esi, 16383
  jne .LBB0_13
.LBB0_8:
  add edx, 15
.LBB0_9: # =>This Inner Loop Header: Depth=1
  cmp word ptr [edx], 0
  je .LBB0_10
  movdqa xmm1, xmmword ptr [edx + 1]
  add edx, 16
  psrldq xmm1, 1 # xmm1 = xmm1[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
  pcmpeqw xmm1, xmm0
  pmovmskb esi, xmm1
  and esi, 16383
  je .LBB0_9
  add edx, -15
.LBB0_13:
  inc edx
  jmp .LBB0_14
.LBB0_10:
  mov ecx, edx
  jmp .LBB0_15