/*
Copyright (c) 2011, Intel Corporation
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
    * this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright notice,
    * this list of conditions and the following disclaimer in the documentation
    * and/or other materials provided with the distribution.

    * Neither the name of Intel Corporation nor the names of its contributors
    * may be used to endorse or promote products derived from this software
    * without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef USE_AS_STRCAT

# ifndef L
#  define L(label)	.L##label
# endif

# ifndef cfi_startproc
#  define cfi_startproc	.cfi_startproc
# endif

# ifndef cfi_endproc
#  define cfi_endproc	.cfi_endproc
# endif

# ifndef cfi_rel_offset
#  define cfi_rel_offset(reg, off)	.cfi_rel_offset reg, off
# endif

# ifndef cfi_restore
#  define cfi_restore(reg)	.cfi_restore reg
# endif

# ifndef cfi_adjust_cfa_offset
#  define cfi_adjust_cfa_offset(off)	.cfi_adjust_cfa_offset off
# endif

# ifndef ENTRY
#  define ENTRY(name)	\
	.type name, @function;	\
	.globl name;	\
	.p2align 4;	\
name:	\
	cfi_startproc
# endif

# ifndef END
#  define END(name)	\
	cfi_endproc;	\
	.size name, .-name
# endif

# define CFI_PUSH(REG)	\
	cfi_adjust_cfa_offset (4);	\
	cfi_rel_offset (REG, 0)

# define CFI_POP(REG)	\
	cfi_adjust_cfa_offset (-4);	\
	cfi_restore (REG)

# define PUSH(REG)	pushl REG; CFI_PUSH (REG)
# define POP(REG)	popl REG; CFI_POP (REG)

# ifndef STRCPY
#  define STRCPY  strcpy
# endif

# ifdef USE_AS_STRNCPY
#  define PARMS  8
#  define ENTRANCE PUSH (%ebx)
#  define RETURN  POP (%ebx); ret; CFI_PUSH (%ebx);
#  define RETURN1  POP (%edi); POP (%ebx); ret; CFI_PUSH (%ebx); CFI_PUSH (%edi)
# else
#  define PARMS  4
#  define ENTRANCE
#  define RETURN  ret
#  define RETURN1  POP (%edi); ret; CFI_PUSH (%edi)
# endif

# ifdef USE_AS_STPCPY
#  define SAVE_RESULT(n)  lea	n(%edx), %eax
#  define SAVE_RESULT_TAIL(n)  lea	n(%edx), %eax
# else
#  define SAVE_RESULT(n)  movl	%edi, %eax
#  define SAVE_RESULT_TAIL(n)  movl	%edx, %eax
# endif

# define STR1  PARMS
# define STR2  STR1+4
# define LEN  STR2+4

/* In this code following instructions are used for copying:
	movb	- 1 byte
	movw	- 2 byte
	movl	- 4 byte
	movlpd	- 8 byte
	movaps	- 16 byte - requires 16 byte alignment
	of	sourse and destination adresses.
*/

.text
ENTRY (STRCPY)
	ENTRANCE
	mov	STR1(%esp), %edx
	mov	STR2(%esp), %ecx
# ifdef USE_AS_STRNCPY
	movl	LEN(%esp), %ebx
	cmp	$8, %ebx
	jbe	L(StrncpyExit8Bytes)
# endif
	cmpb	$0, (%ecx)
	jz	L(ExitTail1)
	cmpb	$0, 1(%ecx)
	jz	L(ExitTail2)
	cmpb	$0, 2(%ecx)
	jz	L(ExitTail3)
	cmpb	$0, 3(%ecx)
	jz	L(ExitTail4)
	cmpb	$0, 4(%ecx)
	jz	L(ExitTail5)
	cmpb	$0, 5(%ecx)
	jz	L(ExitTail6)
	cmpb	$0, 6(%ecx)
	jz	L(ExitTail7)
	cmpb	$0, 7(%ecx)
	jz	L(ExitTail8)
# ifdef USE_AS_STRNCPY
	cmp	$16, %ebx
	jb	L(StrncpyExit15Bytes)
# endif
	cmpb	$0, 8(%ecx)
	jz	L(ExitTail9)
	cmpb	$0, 9(%ecx)
	jz	L(ExitTail10)
	cmpb	$0, 10(%ecx)
	jz	L(ExitTail11)
	cmpb	$0, 11(%ecx)
	jz	L(ExitTail12)
	cmpb	$0, 12(%ecx)
	jz	L(ExitTail13)
	cmpb	$0, 13(%ecx)
	jz	L(ExitTail14)
	cmpb	$0, 14(%ecx)
	jz	L(ExitTail15)
# if defined USE_AS_STRNCPY && !defined USE_AS_STRLCPY
	cmp	$16, %ebx
	je	L(ExitTail16)
# endif
	cmpb	$0, 15(%ecx)
	jz	L(ExitTail16)

# if defined USE_AS_STRNCPY && defined USE_AS_STRLCPY
	cmp	$16, %ebx
	je	L(StrlcpyExitTail16)
# endif

	PUSH	(%edi)
# ifndef USE_AS_STRLCPY
	mov	%edx, %edi
# else
	mov	%ecx, %edi
# endif
#endif
	PUSH	(%esi)
#ifdef USE_AS_STRNCPY
	mov	%ecx, %esi
	sub	$16, %ebx
	and	$0xf, %esi

/* add 16 bytes ecx_offset to ebx */

	add	%esi, %ebx
#endif
	lea	16(%ecx), %esi
	and	$-16, %esi
	pxor	%xmm0, %xmm0
	movlpd	(%ecx), %xmm1
	movlpd	%xmm1, (%edx)

	pcmpeqb	(%esi), %xmm0
	movlpd	8(%ecx), %xmm1
	movlpd	%xmm1, 8(%edx)

	pmovmskb %xmm0, %eax
	sub	%ecx, %esi

#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	mov	%edx, %eax
	lea	16(%edx), %edx
	and	$-16, %edx
	sub	%edx, %eax

#ifdef USE_AS_STRNCPY
	add	%eax, %esi
	lea	-1(%esi), %esi
	and	$1<<31, %esi
	test	%esi, %esi
	jnz	L(ContinueCopy)
	lea	16(%ebx), %ebx

L(ContinueCopy):
#endif
	sub	%eax, %ecx
	mov	%ecx, %eax
	and	$0xf, %eax
	mov	$0, %esi

/* case: ecx_offset == edx_offset */

	jz	L(Align16Both)

	cmp	$8, %eax
	jae	L(ShlHigh8)
	cmp	$1, %eax
	je	L(Shl1)
	cmp	$2, %eax
	je	L(Shl2)
	cmp	$3, %eax
	je	L(Shl3)
	cmp	$4, %eax
	je	L(Shl4)
	cmp	$5, %eax
	je	L(Shl5)
	cmp	$6, %eax
	je	L(Shl6)
	jmp	L(Shl7)

L(ShlHigh8):
	je	L(Shl8)
	cmp	$9, %eax
	je	L(Shl9)
	cmp	$10, %eax
	je	L(Shl10)
	cmp	$11, %eax
	je	L(Shl11)
	cmp	$12, %eax
	je	L(Shl12)
	cmp	$13, %eax
	je	L(Shl13)
	cmp	$14, %eax
	je	L(Shl14)
	jmp	L(Shl15)

L(Align16Both):
	movaps	(%ecx), %xmm1
	movaps	16(%ecx), %xmm2
	movaps	%xmm1, (%edx)
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	lea	16(%esi), %esi
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	movaps	16(%ecx, %esi), %xmm3
	movaps	%xmm2, (%edx, %esi)
	pcmpeqb	%xmm3, %xmm0
	pmovmskb %xmm0, %eax
	lea	16(%esi), %esi
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	movaps	16(%ecx, %esi), %xmm4
	movaps	%xmm3, (%edx, %esi)
	pcmpeqb	%xmm4, %xmm0
	pmovmskb %xmm0, %eax
	lea	16(%esi), %esi
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	movaps	16(%ecx, %esi), %xmm1
	movaps	%xmm4, (%edx, %esi)
	pcmpeqb	%xmm1, %xmm0
	pmovmskb %xmm0, %eax
	lea	16(%esi), %esi
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	movaps	16(%ecx, %esi), %xmm2
	movaps	%xmm1, (%edx, %esi)
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	lea	16(%esi), %esi
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	movaps	16(%ecx, %esi), %xmm3
	movaps	%xmm2, (%edx, %esi)
	pcmpeqb	%xmm3, %xmm0
	pmovmskb %xmm0, %eax
	lea	16(%esi), %esi
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	movaps	%xmm3, (%edx, %esi)
	mov	%ecx, %eax
	lea	16(%ecx, %esi), %ecx
	and	$-0x40, %ecx
	sub	%ecx, %eax
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	lea	112(%ebx, %eax), %ebx
#endif
	mov	$-0x40, %esi

L(Aligned64Loop):
	movaps	(%ecx), %xmm2
	movaps	32(%ecx), %xmm3
	movaps	%xmm2, %xmm4
	movaps	16(%ecx), %xmm5
	movaps	%xmm3, %xmm6
	movaps	48(%ecx), %xmm7
	pminub	%xmm5, %xmm2
	pminub	%xmm7, %xmm3
	pminub	%xmm2, %xmm3
	lea	64(%edx), %edx
	pcmpeqb	%xmm0, %xmm3
	lea	64(%ecx), %ecx
	pmovmskb %xmm3, %eax
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeaveCase2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Aligned64Leave)
	movaps	%xmm4, -64(%edx)
	movaps	%xmm5, -48(%edx)
	movaps	%xmm6, -32(%edx)
	movaps	%xmm7, -16(%edx)
	jmp	L(Aligned64Loop)

L(Aligned64Leave):
#ifdef USE_AS_STRNCPY
	lea	48(%ebx), %ebx
#endif
	pcmpeqb	%xmm4, %xmm0
	pmovmskb %xmm0, %eax
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	pcmpeqb	%xmm5, %xmm0
#ifdef USE_AS_STRNCPY
	lea	-16(%ebx), %ebx
#endif
	pmovmskb %xmm0, %eax
	movaps	%xmm4, -64(%edx)
	lea	16(%esi), %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	pcmpeqb	%xmm6, %xmm0
#ifdef USE_AS_STRNCPY
	lea	-16(%ebx), %ebx
#endif
	pmovmskb %xmm0, %eax
	movaps	%xmm5, -48(%edx)
	lea	16(%esi), %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	movaps	%xmm6, -32(%edx)
	pcmpeqb	%xmm7, %xmm0
#ifdef USE_AS_STRNCPY
	lea	-16(%ebx), %ebx
#endif
	pmovmskb %xmm0, %eax
	lea	16(%esi), %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl1):
	movaps	-1(%ecx), %xmm1
	movaps	15(%ecx), %xmm2
L(Shl1Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit1Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl1LoopExit)

	palignr	$1, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	31(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit1Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl1LoopExit)

	palignr	$1, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	31(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit1Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl1LoopExit)

	palignr	$1, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	31(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit1Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl1LoopExit)

	palignr	$1, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	31(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-15(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-1(%ecx), %xmm1

L(Shl1LoopStart):
	movaps	15(%ecx), %xmm2
	movaps	31(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	47(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	63(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$1, %xmm4, %xmm5
	palignr	$1, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl1Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave1)
#endif
	palignr	$1, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$1, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl1LoopStart)

L(Shl1LoopExit):
	movlpd	(%ecx), %xmm0
	movlpd	%xmm0, (%edx)
	movlpd	7(%ecx), %xmm0
	movlpd	%xmm0, 7(%edx)
	mov	$15, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl2):
	movaps	-2(%ecx), %xmm1
	movaps	14(%ecx), %xmm2
L(Shl2Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit2Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl2LoopExit)

	palignr	$2, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	30(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit2Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl2LoopExit)

	palignr	$2, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	30(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit2Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl2LoopExit)

	palignr	$2, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	30(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit2Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl2LoopExit)

	palignr	$2, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	30(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-14(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-2(%ecx), %xmm1

L(Shl2LoopStart):
	movaps	14(%ecx), %xmm2
	movaps	30(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	46(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	62(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$2, %xmm4, %xmm5
	palignr	$2, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl2Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave2)
#endif
	palignr	$2, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$2, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl2LoopStart)

L(Shl2LoopExit):
	movlpd	(%ecx), %xmm0
	movlpd	6(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 6(%edx)
	mov	$14, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl3):
	movaps	-3(%ecx), %xmm1
	movaps	13(%ecx), %xmm2
L(Shl3Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit3Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl3LoopExit)

	palignr	$3, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	29(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit3Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl3LoopExit)

	palignr	$3, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	29(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit3Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl3LoopExit)

	palignr	$3, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	29(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit3Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl3LoopExit)

	palignr	$3, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	29(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-13(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-3(%ecx), %xmm1

L(Shl3LoopStart):
	movaps	13(%ecx), %xmm2
	movaps	29(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	45(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	61(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$3, %xmm4, %xmm5
	palignr	$3, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl3Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave3)
#endif
	palignr	$3, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$3, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl3LoopStart)

L(Shl3LoopExit):
	movlpd	(%ecx), %xmm0
	movlpd	5(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 5(%edx)
	mov	$13, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl4):
	movaps	-4(%ecx), %xmm1
	movaps	12(%ecx), %xmm2
L(Shl4Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit4Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl4LoopExit)

	palignr	$4, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	28(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit4Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl4LoopExit)

	palignr	$4, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	28(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit4Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl4LoopExit)

	palignr	$4, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	28(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit4Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl4LoopExit)

	palignr	$4, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	28(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-12(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-4(%ecx), %xmm1

L(Shl4LoopStart):
	movaps	12(%ecx), %xmm2
	movaps	28(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	44(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	60(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$4, %xmm4, %xmm5
	palignr	$4, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl4Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave4)
#endif
	palignr	$4, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$4, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl4LoopStart)

L(Shl4LoopExit):
	movlpd	(%ecx), %xmm0
	movl	8(%ecx), %esi
	movlpd	%xmm0, (%edx)
	movl	%esi, 8(%edx)
	mov	$12, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl5):
	movaps	-5(%ecx), %xmm1
	movaps	11(%ecx), %xmm2
L(Shl5Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit5Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl5LoopExit)

	palignr	$5, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	27(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit5Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl5LoopExit)

	palignr	$5, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	27(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit5Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl5LoopExit)

	palignr	$5, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	27(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit5Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl5LoopExit)

	palignr	$5, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	27(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-11(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-5(%ecx), %xmm1

L(Shl5LoopStart):
	movaps	11(%ecx), %xmm2
	movaps	27(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	43(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	59(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$5, %xmm4, %xmm5
	palignr	$5, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl5Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave5)
#endif
	palignr	$5, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$5, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl5LoopStart)

L(Shl5LoopExit):
	movlpd	(%ecx), %xmm0
	movl	7(%ecx), %esi
	movlpd	%xmm0, (%edx)
	movl	%esi, 7(%edx)
	mov	$11, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl6):
	movaps	-6(%ecx), %xmm1
	movaps	10(%ecx), %xmm2
L(Shl6Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit6Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl6LoopExit)

	palignr	$6, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	26(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit6Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl6LoopExit)

	palignr	$6, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	26(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit6Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl6LoopExit)

	palignr	$6, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	26(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit6Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl6LoopExit)

	palignr	$6, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	26(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-10(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-6(%ecx), %xmm1

L(Shl6LoopStart):
	movaps	10(%ecx), %xmm2
	movaps	26(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	42(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	58(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$6, %xmm4, %xmm5
	palignr	$6, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl6Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave6)
#endif
	palignr	$6, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$6, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl6LoopStart)

L(Shl6LoopExit):
	movlpd	(%ecx), %xmm0
	movl	6(%ecx), %esi
	movlpd	%xmm0, (%edx)
	movl	%esi, 6(%edx)
	mov	$10, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl7):
	movaps	-7(%ecx), %xmm1
	movaps	9(%ecx), %xmm2
L(Shl7Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit7Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl7LoopExit)

	palignr	$7, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	25(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit7Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl7LoopExit)

	palignr	$7, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	25(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit7Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl7LoopExit)

	palignr	$7, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	25(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit7Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl7LoopExit)

	palignr	$7, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	25(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-9(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-7(%ecx), %xmm1

L(Shl7LoopStart):
	movaps	9(%ecx), %xmm2
	movaps	25(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	41(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	57(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$7, %xmm4, %xmm5
	palignr	$7, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl7Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave7)
#endif
	palignr	$7, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$7, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl7LoopStart)

L(Shl7LoopExit):
	movlpd	(%ecx), %xmm0
	movl	5(%ecx), %esi
	movlpd	%xmm0, (%edx)
	movl	%esi, 5(%edx)
	mov	$9, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl8):
	movaps	-8(%ecx), %xmm1
	movaps	8(%ecx), %xmm2
L(Shl8Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit8Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl8LoopExit)

	palignr	$8, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	24(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit8Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl8LoopExit)

	palignr	$8, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	24(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit8Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl8LoopExit)

	palignr	$8, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	24(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit8Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl8LoopExit)

	palignr	$8, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	24(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-8(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-8(%ecx), %xmm1

L(Shl8LoopStart):
	movaps	8(%ecx), %xmm2
	movaps	24(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	40(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	56(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$8, %xmm4, %xmm5
	palignr	$8, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl8Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave8)
#endif
	palignr	$8, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$8, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl8LoopStart)

L(Shl8LoopExit):
	movlpd	(%ecx), %xmm0
	movlpd	%xmm0, (%edx)
	mov	$8, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl9):
	movaps	-9(%ecx), %xmm1
	movaps	7(%ecx), %xmm2
L(Shl9Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit9Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl9LoopExit)

	palignr	$9, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	23(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit9Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl9LoopExit)

	palignr	$9, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	23(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit9Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl9LoopExit)

	palignr	$9, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	23(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit9Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl9LoopExit)

	palignr	$9, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	23(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-7(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-9(%ecx), %xmm1

L(Shl9LoopStart):
	movaps	7(%ecx), %xmm2
	movaps	23(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	39(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	55(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$9, %xmm4, %xmm5
	palignr	$9, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl9Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave9)
#endif
	palignr	$9, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$9, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl9LoopStart)

L(Shl9LoopExit):
	movlpd	-1(%ecx), %xmm0
	movlpd	%xmm0, -1(%edx)
	mov	$7, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl10):
	movaps	-10(%ecx), %xmm1
	movaps	6(%ecx), %xmm2
L(Shl10Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit10Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl10LoopExit)

	palignr	$10, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	22(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit10Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl10LoopExit)

	palignr	$10, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	22(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit10Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl10LoopExit)

	palignr	$10, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	22(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit10Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl10LoopExit)

	palignr	$10, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	22(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-6(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-10(%ecx), %xmm1

L(Shl10LoopStart):
	movaps	6(%ecx), %xmm2
	movaps	22(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	38(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	54(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$10, %xmm4, %xmm5
	palignr	$10, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl10Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave10)
#endif
	palignr	$10, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$10, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl10LoopStart)

L(Shl10LoopExit):
	movlpd	-2(%ecx), %xmm0
	movlpd	%xmm0, -2(%edx)
	mov	$6, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl11):
	movaps	-11(%ecx), %xmm1
	movaps	5(%ecx), %xmm2
L(Shl11Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit11Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl11LoopExit)

	palignr	$11, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	21(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit11Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl11LoopExit)

	palignr	$11, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	21(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit11Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl11LoopExit)

	palignr	$11, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	21(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit11Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl11LoopExit)

	palignr	$11, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	21(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-5(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-11(%ecx), %xmm1

L(Shl11LoopStart):
	movaps	5(%ecx), %xmm2
	movaps	21(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	37(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	53(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$11, %xmm4, %xmm5
	palignr	$11, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl11Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave11)
#endif
	palignr	$11, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$11, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl11LoopStart)

L(Shl11LoopExit):
	movlpd	-3(%ecx), %xmm0
	movlpd	%xmm0, -3(%edx)
	mov	$5, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl12):
	movaps	-12(%ecx), %xmm1
	movaps	4(%ecx), %xmm2
L(Shl12Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit12Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl12LoopExit)

	palignr	$12, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	20(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit12Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl12LoopExit)

	palignr	$12, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	20(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit12Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl12LoopExit)

	palignr	$12, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	20(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit12Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl12LoopExit)

	palignr	$12, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	20(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-4(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-12(%ecx), %xmm1

L(Shl12LoopStart):
	movaps	4(%ecx), %xmm2
	movaps	20(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	36(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	52(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$12, %xmm4, %xmm5
	palignr	$12, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl12Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave12)
#endif
	palignr	$12, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$12, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl12LoopStart)

L(Shl12LoopExit):
	movl	(%ecx), %esi
	movl	%esi, (%edx)
	mov	$4, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl13):
	movaps	-13(%ecx), %xmm1
	movaps	3(%ecx), %xmm2
L(Shl13Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit13Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl13LoopExit)

	palignr	$13, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	19(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit13Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl13LoopExit)

	palignr	$13, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	19(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit13Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl13LoopExit)

	palignr	$13, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	19(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit13Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl13LoopExit)

	palignr	$13, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	19(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-3(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-13(%ecx), %xmm1

L(Shl13LoopStart):
	movaps	3(%ecx), %xmm2
	movaps	19(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	35(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	51(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$13, %xmm4, %xmm5
	palignr	$13, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl13Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave13)
#endif
	palignr	$13, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$13, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl13LoopStart)

L(Shl13LoopExit):
	movl	-1(%ecx), %esi
	movl	%esi, -1(%edx)
	mov	$3, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl14):
	movaps	-14(%ecx), %xmm1
	movaps	2(%ecx), %xmm2
L(Shl14Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit14Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl14LoopExit)

	palignr	$14, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	18(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit14Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl14LoopExit)

	palignr	$14, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	18(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit14Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl14LoopExit)

	palignr	$14, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	18(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit14Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl14LoopExit)

	palignr	$14, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	18(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-2(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-14(%ecx), %xmm1

L(Shl14LoopStart):
	movaps	2(%ecx), %xmm2
	movaps	18(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	34(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	50(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$14, %xmm4, %xmm5
	palignr	$14, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl14Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave14)
#endif
	palignr	$14, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$14, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl14LoopStart)

L(Shl14LoopExit):
	movl	-2(%ecx), %esi
	movl	%esi, -2(%edx)
	mov	$2, %esi
	jmp	L(CopyFrom1To16Bytes)

	.p2align 4
L(Shl15):
	movaps	-15(%ecx), %xmm1
	movaps	1(%ecx), %xmm2
L(Shl15Start):
	pcmpeqb	%xmm2, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit15Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl15LoopExit)

	palignr	$15, %xmm1, %xmm2
	movaps	%xmm3, %xmm1
	movaps	%xmm2, (%edx)
	movaps	17(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit15Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl15LoopExit)

	palignr	$15, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	17(%ecx), %xmm2
	movaps	%xmm3, %xmm1

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
	movaps	%xmm2, %xmm3
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit15Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl15LoopExit)

	palignr	$15, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	17(%ecx), %xmm2

	pcmpeqb	%xmm2, %xmm0
	lea	16(%edx), %edx
	pmovmskb %xmm0, %eax
	lea	16(%ecx), %ecx
#ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	jbe	L(StrncpyExit15Case2OrCase3)
#endif
	test	%eax, %eax
	jnz	L(Shl15LoopExit)

	palignr	$15, %xmm3, %xmm2
	movaps	%xmm2, (%edx)
	lea	17(%ecx), %ecx
	lea	16(%edx), %edx

	mov	%ecx, %eax
	and	$-0x40, %ecx
	sub	%ecx, %eax
	lea	-1(%ecx), %ecx
	sub	%eax, %edx
#ifdef USE_AS_STRNCPY
	add	%eax, %ebx
#endif
	movaps	-15(%ecx), %xmm1

L(Shl15LoopStart):
	movaps	1(%ecx), %xmm2
	movaps	17(%ecx), %xmm3
	movaps	%xmm3, %xmm6
	movaps	33(%ecx), %xmm4
	movaps	%xmm4, %xmm7
	movaps	49(%ecx), %xmm5
	pminub	%xmm2, %xmm6
	pminub	%xmm5, %xmm7
	pminub	%xmm6, %xmm7
	pcmpeqb	%xmm0, %xmm7
	pmovmskb %xmm7, %eax
	movaps	%xmm5, %xmm7
	palignr	$15, %xmm4, %xmm5
	palignr	$15, %xmm3, %xmm4
	test	%eax, %eax
	jnz	L(Shl15Start)
#ifdef USE_AS_STRNCPY
	sub	$64, %ebx
	jbe	L(StrncpyLeave15)
#endif
	palignr	$15, %xmm2, %xmm3
	lea	64(%ecx), %ecx
	palignr	$15, %xmm1, %xmm2
	movaps	%xmm7, %xmm1
	movaps	%xmm5, 48(%edx)
	movaps	%xmm4, 32(%edx)
	movaps	%xmm3, 16(%edx)
	movaps	%xmm2, (%edx)
	lea	64(%edx), %edx
	jmp	L(Shl15LoopStart)

L(Shl15LoopExit):
	movl	-3(%ecx), %esi
	movl	%esi, -3(%edx)
	mov	$1, %esi
#if defined USE_AS_STRCAT || defined USE_AS_STRLCPY
	jmp	L(CopyFrom1To16Bytes)
#endif


#if !defined USE_AS_STRCAT && !defined USE_AS_STRLCPY

	.p2align 4
L(CopyFrom1To16Bytes):
# ifdef USE_AS_STRNCPY
	add	$16, %ebx
# endif
	add	%esi, %edx
	add	%esi, %ecx

	POP	(%esi)
	test	%al, %al
	jz	L(ExitHigh8)

L(CopyFrom1To16BytesLess8):
	mov	%al, %ah
	and	$15, %ah
	jz	L(ExitHigh4)

	test	$0x01, %al
	jnz	L(Exit1)
	test	$0x02, %al
	jnz	L(Exit2)
	test	$0x04, %al
	jnz	L(Exit3)

	.p2align 4
L(Exit4):
	movl	(%ecx), %eax
	movl	%eax, (%edx)
	SAVE_RESULT	(3)
# ifdef USE_AS_STRNCPY
	sub	$4, %ebx
	lea	4(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(ExitHigh4):
	test	$0x10, %al
	jnz	L(Exit5)
	test	$0x20, %al
	jnz	L(Exit6)
	test	$0x40, %al
	jnz	L(Exit7)

	.p2align 4
L(Exit8):
	movlpd	(%ecx), %xmm0
	movlpd	%xmm0, (%edx)
	SAVE_RESULT	(7)
# ifdef USE_AS_STRNCPY
	sub	$8, %ebx
	lea	8(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(ExitHigh8):
	mov	%ah, %al
	and	$15, %al
	jz	L(ExitHigh12)

	test	$0x01, %ah
	jnz	L(Exit9)
	test	$0x02, %ah
	jnz	L(Exit10)
	test	$0x04, %ah
	jnz	L(Exit11)

	.p2align 4
L(Exit12):
	movlpd	(%ecx), %xmm0
	movl	8(%ecx), %eax
	movlpd	%xmm0, (%edx)
	movl	%eax, 8(%edx)
	SAVE_RESULT	(11)
# ifdef USE_AS_STRNCPY
	sub	$12, %ebx
	lea	12(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(ExitHigh12):
	test	$0x10, %ah
	jnz	L(Exit13)
	test	$0x20, %ah
	jnz	L(Exit14)
	test	$0x40, %ah
	jnz	L(Exit15)

	.p2align 4
L(Exit16):
	movdqu	(%ecx), %xmm0
	movdqu	%xmm0, (%edx)
	SAVE_RESULT	(15)
# ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	lea	16(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

#  ifdef USE_AS_STRNCPY

	CFI_PUSH(%esi)

	.p2align 4
L(CopyFrom1To16BytesCase2):
	add	$16, %ebx
	add	%esi, %ecx
	add	%esi, %edx

	POP	(%esi)

	test	%al, %al
	jz	L(ExitHighCase2)

	cmp	$8, %ebx
	ja	L(CopyFrom1To16BytesLess8)

	test	$0x01, %al
	jnz	L(Exit1)
	cmp	$1, %ebx
	je	L(Exit1)
	test	$0x02, %al
	jnz	L(Exit2)
	cmp	$2, %ebx
	je	L(Exit2)
	test	$0x04, %al
	jnz	L(Exit3)
	cmp	$3, %ebx
	je	L(Exit3)
	test	$0x08, %al
	jnz	L(Exit4)
	cmp	$4, %ebx
	je	L(Exit4)
	test	$0x10, %al
	jnz	L(Exit5)
	cmp	$5, %ebx
	je	L(Exit5)
	test	$0x20, %al
	jnz	L(Exit6)
	cmp	$6, %ebx
	je	L(Exit6)
	test	$0x40, %al
	jnz	L(Exit7)
	cmp	$7, %ebx
	je	L(Exit7)
	jmp	L(Exit8)

	.p2align 4
L(ExitHighCase2):
	cmp	$8, %ebx
	jbe	L(CopyFrom1To16BytesLess8Case3)

	test	$0x01, %ah
	jnz	L(Exit9)
	cmp	$9, %ebx
	je	L(Exit9)
	test	$0x02, %ah
	jnz	L(Exit10)
	cmp	$10, %ebx
	je	L(Exit10)
	test	$0x04, %ah
	jnz	L(Exit11)
	cmp	$11, %ebx
	je	L(Exit11)
	test	$0x8, %ah
	jnz	L(Exit12)
	cmp	$12, %ebx
	je	L(Exit12)
	test	$0x10, %ah
	jnz	L(Exit13)
	cmp	$13, %ebx
	je	L(Exit13)
	test	$0x20, %ah
	jnz	L(Exit14)
	cmp	$14, %ebx
	je	L(Exit14)
	test	$0x40, %ah
	jnz	L(Exit15)
	cmp	$15, %ebx
	je	L(Exit15)
	jmp	L(Exit16)

	CFI_PUSH(%esi)

	.p2align 4
L(CopyFrom1To16BytesCase2OrCase3):
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)

	.p2align 4
L(CopyFrom1To16BytesCase3):
	add	$16, %ebx
	add	%esi, %edx
	add	%esi, %ecx

	POP	(%esi)

	cmp	$8, %ebx
	ja	L(ExitHigh8Case3)

L(CopyFrom1To16BytesLess8Case3):
	cmp	$4, %ebx
	ja	L(ExitHigh4Case3)

	cmp	$1, %ebx
	je	L(Exit1)
	cmp	$2, %ebx
	je	L(Exit2)
	cmp	$3, %ebx
	je	L(Exit3)
	movl	(%ecx), %eax
	movl	%eax, (%edx)
	SAVE_RESULT	(4)
	RETURN1

	.p2align 4
L(ExitHigh4Case3):
	cmp	$5, %ebx
	je	L(Exit5)
	cmp	$6, %ebx
	je	L(Exit6)
	cmp	$7, %ebx
	je	L(Exit7)
	movlpd	(%ecx), %xmm0
	movlpd	%xmm0, (%edx)
	SAVE_RESULT	(8)
	RETURN1

	.p2align 4
L(ExitHigh8Case3):
	cmp	$12, %ebx
	ja	L(ExitHigh12Case3)

	cmp	$9, %ebx
	je	L(Exit9)
	cmp	$10, %ebx
	je	L(Exit10)
	cmp	$11, %ebx
	je	L(Exit11)
	movlpd	(%ecx), %xmm0
	movl	8(%ecx), %eax
	movlpd	%xmm0, (%edx)
	movl	%eax, 8(%edx)
	SAVE_RESULT	(12)
	RETURN1

	.p2align 4
L(ExitHigh12Case3):
	cmp	$13, %ebx
	je	L(Exit13)
	cmp	$14, %ebx
	je	L(Exit14)
	cmp	$15, %ebx
	je	L(Exit15)
	movlpd	(%ecx), %xmm0
	movlpd	8(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 8(%edx)
	SAVE_RESULT	(16)
	RETURN1

# endif

	.p2align 4
L(Exit1):
	movb	(%ecx), %al
	movb	%al, (%edx)
	SAVE_RESULT	(0)
# ifdef USE_AS_STRNCPY
	sub	$1, %ebx
	lea	1(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit2):
	movw	(%ecx), %ax
	movw	%ax, (%edx)
	SAVE_RESULT	(1)
# ifdef USE_AS_STRNCPY
	sub	$2, %ebx
	lea	2(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit3):
	movw	(%ecx), %ax
	movw	%ax, (%edx)
	movb	2(%ecx), %al
	movb	%al, 2(%edx)
	SAVE_RESULT	(2)
# ifdef USE_AS_STRNCPY
	sub	$3, %ebx
	lea	3(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit5):
	movl	(%ecx), %eax
	movl	%eax, (%edx)
	movb	4(%ecx), %al
	movb	%al, 4(%edx)
	SAVE_RESULT	(4)
# ifdef USE_AS_STRNCPY
	sub	$5, %ebx
	lea	5(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit6):
	movl	(%ecx), %eax
	movl	%eax, (%edx)
	movw	4(%ecx), %ax
	movw	%ax, 4(%edx)
	SAVE_RESULT	(5)
# ifdef USE_AS_STRNCPY
	sub	$6, %ebx
	lea	6(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit7):
	movl	(%ecx), %eax
	movl	%eax, (%edx)
	movl	3(%ecx), %eax
	movl	%eax, 3(%edx)
	SAVE_RESULT	(6)
# ifdef USE_AS_STRNCPY
	sub	$7, %ebx
	lea	7(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit9):
	movlpd	(%ecx), %xmm0
	movb	8(%ecx), %al
	movlpd	%xmm0, (%edx)
	movb	%al, 8(%edx)
	SAVE_RESULT	(8)
# ifdef USE_AS_STRNCPY
	sub	$9, %ebx
	lea	9(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit10):
	movlpd	(%ecx), %xmm0
	movw	8(%ecx), %ax
	movlpd	%xmm0, (%edx)
	movw	%ax, 8(%edx)
	SAVE_RESULT	(9)
# ifdef USE_AS_STRNCPY
	sub	$10, %ebx
	lea	10(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit11):
	movlpd	(%ecx), %xmm0
	movl	7(%ecx), %eax
	movlpd	%xmm0, (%edx)
	movl	%eax, 7(%edx)
	SAVE_RESULT	(10)
# ifdef USE_AS_STRNCPY
	sub	$11, %ebx
	lea	11(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit13):
	movlpd	(%ecx), %xmm0
	movlpd	5(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 5(%edx)
	SAVE_RESULT	(12)
# ifdef USE_AS_STRNCPY
	sub	$13, %ebx
	lea	13(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit14):
	movlpd	(%ecx), %xmm0
	movlpd	6(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 6(%edx)
	SAVE_RESULT	(13)
# ifdef USE_AS_STRNCPY
	sub	$14, %ebx
	lea	14(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

	.p2align 4
L(Exit15):
	movlpd	(%ecx), %xmm0
	movlpd	7(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 7(%edx)
	SAVE_RESULT	(14)
# ifdef USE_AS_STRNCPY
	sub	$15, %ebx
	lea	15(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero1)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN1

CFI_POP	(%edi)

# ifdef USE_AS_STRNCPY
	.p2align 4
L(Fill0):
	RETURN

	.p2align 4
L(Fill1):
	movb	%dl, (%ecx)
	RETURN

	.p2align 4
L(Fill2):
	movw	%dx, (%ecx)
	RETURN

	.p2align 4
L(Fill3):
	movw	%dx, (%ecx)
	movb	%dl, 2(%ecx)
	RETURN

	.p2align 4
L(Fill4):
	movl	%edx, (%ecx)
	RETURN

	.p2align 4
L(Fill5):
	movl	%edx, (%ecx)
	movb	%dl, 4(%ecx)
	RETURN

	.p2align 4
L(Fill6):
	movl	%edx, (%ecx)
	movw	%dx, 4(%ecx)
	RETURN

	.p2align 4
L(Fill7):
	movl	%edx, (%ecx)
	movl	%edx, 3(%ecx)
	RETURN

	.p2align 4
L(Fill8):
	movlpd	%xmm0, (%ecx)
	RETURN

	.p2align 4
L(Fill9):
	movlpd	%xmm0, (%ecx)
	movb	%dl, 8(%ecx)
	RETURN

	.p2align 4
L(Fill10):
	movlpd	%xmm0, (%ecx)
	movw	%dx, 8(%ecx)
	RETURN

	.p2align 4
L(Fill11):
	movlpd	%xmm0, (%ecx)
	movl	%edx, 7(%ecx)
	RETURN

	.p2align 4
L(Fill12):
	movlpd	%xmm0, (%ecx)
	movl	%edx, 8(%ecx)
	RETURN

	.p2align 4
L(Fill13):
	movlpd	%xmm0, (%ecx)
	movlpd	%xmm0, 5(%ecx)
	RETURN

	.p2align 4
L(Fill14):
	movlpd	%xmm0, (%ecx)
	movlpd	%xmm0, 6(%ecx)
	RETURN

	.p2align 4
L(Fill15):
	movlpd	%xmm0, (%ecx)
	movlpd	%xmm0, 7(%ecx)
	RETURN

	.p2align 4
L(Fill16):
	movlpd	%xmm0, (%ecx)
	movlpd	%xmm0, 8(%ecx)
	RETURN

	.p2align 4
L(StrncpyFillExit1):
	lea	16(%ebx), %ebx
L(FillFrom1To16Bytes):
	test	%ebx, %ebx
	jz	L(Fill0)
	cmp	$16, %ebx
	je	L(Fill16)
	cmp	$8, %ebx
	je	L(Fill8)
	jg	L(FillMore8)
	cmp	$4, %ebx
	je	L(Fill4)
	jg	L(FillMore4)
	cmp	$2, %ebx
	jl	L(Fill1)
	je	L(Fill2)
	jg	L(Fill3)
L(FillMore8):	/* but less than 16 */
	cmp	$12, %ebx
	je	L(Fill12)
	jl	L(FillLess12)
	cmp	$14, %ebx
	jl	L(Fill13)
	je	L(Fill14)
	jg	L(Fill15)
L(FillMore4):	/* but less than 8 */
	cmp	$6, %ebx
	jl	L(Fill5)
	je	L(Fill6)
	jg	L(Fill7)
L(FillLess12):	/* but more than 8 */
	cmp	$10, %ebx
	jl	L(Fill9)
	je	L(Fill10)
	jmp	L(Fill11)

	CFI_PUSH(%edi)

	.p2align 4
L(StrncpyFillTailWithZero1):
	POP	(%edi)
L(StrncpyFillTailWithZero):
	pxor	%xmm0, %xmm0
	xor	%edx, %edx
	sub	$16, %ebx
	jbe	L(StrncpyFillExit1)

	movlpd	%xmm0, (%ecx)
	movlpd	%xmm0, 8(%ecx)

	lea	16(%ecx), %ecx

	mov	%ecx, %edx
	and	$0xf, %edx
	sub	%edx, %ecx
	add	%edx, %ebx
	xor	%edx, %edx
	sub	$64, %ebx
	jb	L(StrncpyFillLess64)

L(StrncpyFillLoopMovdqa):
	movdqa	%xmm0, (%ecx)
	movdqa	%xmm0, 16(%ecx)
	movdqa	%xmm0, 32(%ecx)
	movdqa	%xmm0, 48(%ecx)
	lea	64(%ecx), %ecx
	sub	$64, %ebx
	jae	L(StrncpyFillLoopMovdqa)

L(StrncpyFillLess64):
	add	$32, %ebx
	jl	L(StrncpyFillLess32)
	movdqa	%xmm0, (%ecx)
	movdqa	%xmm0, 16(%ecx)
	lea	32(%ecx), %ecx
	sub	$16, %ebx
	jl	L(StrncpyFillExit1)
	movdqa	%xmm0, (%ecx)
	lea	16(%ecx), %ecx
	jmp	L(FillFrom1To16Bytes)

L(StrncpyFillLess32):
	add	$16, %ebx
	jl	L(StrncpyFillExit1)
	movdqa	%xmm0, (%ecx)
	lea	16(%ecx), %ecx
	jmp	L(FillFrom1To16Bytes)
# endif

	.p2align 4
L(ExitTail1):
	movb	(%ecx), %al
	movb	%al, (%edx)
	SAVE_RESULT_TAIL (0)
# ifdef USE_AS_STRNCPY
	sub	$1, %ebx
	lea	1(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail2):
	movw	(%ecx), %ax
	movw	%ax, (%edx)
	SAVE_RESULT_TAIL (1)
# ifdef USE_AS_STRNCPY
	sub	$2, %ebx
	lea	2(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail3):
	movw	(%ecx), %ax
	movw	%ax, (%edx)
	movb	2(%ecx), %al
	movb	%al, 2(%edx)
	SAVE_RESULT_TAIL (2)
# ifdef USE_AS_STRNCPY
	sub	$3, %ebx
	lea	3(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail4):
	movl	(%ecx), %eax
	movl	%eax, (%edx)
	SAVE_RESULT_TAIL (3)
# ifdef USE_AS_STRNCPY
	sub	$4, %ebx
	lea	4(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail5):
	movl	(%ecx), %eax
	movl	%eax, (%edx)
	movb	4(%ecx), %al
	movb	%al, 4(%edx)
	SAVE_RESULT_TAIL (4)
# ifdef USE_AS_STRNCPY
	sub	$5, %ebx
	lea	5(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail6):
	movl	(%ecx), %eax
	movl	%eax, (%edx)
	movw	4(%ecx), %ax
	movw	%ax, 4(%edx)
	SAVE_RESULT_TAIL (5)
# ifdef USE_AS_STRNCPY
	sub	$6, %ebx
	lea	6(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail7):
	movl	(%ecx), %eax
	movl	%eax, (%edx)
	movl	3(%ecx), %eax
	movl	%eax, 3(%edx)
	SAVE_RESULT_TAIL (6)
# ifdef USE_AS_STRNCPY
	sub	$7, %ebx
	lea	7(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail8):
	movlpd	(%ecx), %xmm0
	movlpd	%xmm0, (%edx)
	SAVE_RESULT_TAIL (7)
# ifdef USE_AS_STRNCPY
	sub	$8, %ebx
	lea	8(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
# endif
	RETURN

	.p2align 4
L(ExitTail9):
	movlpd	(%ecx), %xmm0
	movb	8(%ecx), %al
	movlpd	%xmm0, (%edx)
	movb	%al, 8(%edx)
	SAVE_RESULT_TAIL (8)
# ifdef USE_AS_STRNCPY
	sub	$9, %ebx
	lea	9(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail10):
	movlpd	(%ecx), %xmm0
	movw	8(%ecx), %ax
	movlpd	%xmm0, (%edx)
	movw	%ax, 8(%edx)
	SAVE_RESULT_TAIL (9)
# ifdef USE_AS_STRNCPY
	sub	$10, %ebx
	lea	10(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail11):
	movlpd	(%ecx), %xmm0
	movl	7(%ecx), %eax
	movlpd	%xmm0, (%edx)
	movl	%eax, 7(%edx)
	SAVE_RESULT_TAIL (10)
# ifdef USE_AS_STRNCPY
	sub	$11, %ebx
	lea	11(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail12):
	movlpd	(%ecx), %xmm0
	movl	8(%ecx), %eax
	movlpd	%xmm0, (%edx)
	movl	%eax, 8(%edx)
	SAVE_RESULT_TAIL (11)
# ifdef USE_AS_STRNCPY
	sub	$12, %ebx
	lea	12(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail13):
	movlpd	(%ecx), %xmm0
	movlpd	5(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 5(%edx)
	SAVE_RESULT_TAIL (12)
# ifdef USE_AS_STRNCPY
	sub	$13, %ebx
	lea	13(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail14):
	movlpd	(%ecx), %xmm0
	movlpd	6(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 6(%edx)
	SAVE_RESULT_TAIL (13)
# ifdef USE_AS_STRNCPY
	sub	$14, %ebx
	lea	14(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
# ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN

	.p2align 4
L(ExitTail15):
	movlpd	(%ecx), %xmm0
	movlpd	7(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 7(%edx)
	SAVE_RESULT_TAIL (14)
# ifdef USE_AS_STRNCPY
	sub	$15, %ebx
	lea	15(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
# endif
	RETURN

	.p2align 4
L(ExitTail16):
	movdqu	(%ecx), %xmm0
	movdqu	%xmm0, (%edx)
	SAVE_RESULT_TAIL (15)
# ifdef USE_AS_STRNCPY
	sub	$16, %ebx
	lea	16(%edx), %ecx
	jnz	L(StrncpyFillTailWithZero)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
# endif
	RETURN
#endif

#ifdef USE_AS_STRNCPY
# if !defined(USE_AS_STRCAT) && !defined(USE_AS_STRLCPY)
	CFI_PUSH (%esi)
	CFI_PUSH (%edi)
# endif
	.p2align 4
L(StrncpyLeaveCase2OrCase3):
	test	%eax, %eax
	jnz	L(Aligned64LeaveCase2)

L(Aligned64LeaveCase3):
	add	$48, %ebx
	jle	L(CopyFrom1To16BytesCase3)
	movaps	%xmm4, -64(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase3)
	movaps	%xmm5, -48(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase3)
	movaps	%xmm6, -32(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
	jmp	L(CopyFrom1To16BytesCase3)

L(Aligned64LeaveCase2):
	pcmpeqb	%xmm4, %xmm0
	pmovmskb %xmm0, %eax
	add	$48, %ebx
	jle	L(CopyFrom1To16BytesCase2OrCase3)
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	pcmpeqb	%xmm5, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm4, -64(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase2OrCase3)
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	pcmpeqb	%xmm6, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm5, -48(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(CopyFrom1To16BytesCase2OrCase3)
	test	%eax, %eax
	jnz	L(CopyFrom1To16Bytes)

	pcmpeqb	%xmm7, %xmm0
	pmovmskb %xmm0, %eax
	movaps	%xmm6, -32(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
	jmp	L(CopyFrom1To16BytesCase2)

/*--------------------------------------------------*/
	.p2align 4
L(StrncpyExit1Case2OrCase3):
	movlpd	(%ecx), %xmm0
	movlpd	7(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 7(%edx)
	mov	$15, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit2Case2OrCase3):
	movlpd	(%ecx), %xmm0
	movlpd	6(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 6(%edx)
	mov	$14, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit3Case2OrCase3):
	movlpd	(%ecx), %xmm0
	movlpd	5(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 5(%edx)
	mov	$13, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit4Case2OrCase3):
	movlpd	(%ecx), %xmm0
	movl	8(%ecx), %esi
	movlpd	%xmm0, (%edx)
	movl	%esi, 8(%edx)
	mov	$12, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit5Case2OrCase3):
	movlpd	(%ecx), %xmm0
	movl	7(%ecx), %esi
	movlpd	%xmm0, (%edx)
	movl	%esi, 7(%edx)
	mov	$11, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit6Case2OrCase3):
	movlpd	(%ecx), %xmm0
	movl	6(%ecx), %esi
	movlpd	%xmm0, (%edx)
	movl	%esi, 6(%edx)
	mov	$10, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit7Case2OrCase3):
	movlpd	(%ecx), %xmm0
	movl	5(%ecx), %esi
	movlpd	%xmm0, (%edx)
	movl	%esi, 5(%edx)
	mov	$9, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit8Case2OrCase3):
	movlpd	(%ecx), %xmm0
	movlpd	%xmm0, (%edx)
	mov	$8, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit9Case2OrCase3):
	movlpd	(%ecx), %xmm0
	movlpd	%xmm0, (%edx)
	mov	$7, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit10Case2OrCase3):
	movlpd	-1(%ecx), %xmm0
	movlpd	%xmm0, -1(%edx)
	mov	$6, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit11Case2OrCase3):
	movlpd	-2(%ecx), %xmm0
	movlpd	%xmm0, -2(%edx)
	mov	$5, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit12Case2OrCase3):
	movl	(%ecx), %esi
	movl	%esi, (%edx)
	mov	$4, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit13Case2OrCase3):
	movl	-1(%ecx), %esi
	movl	%esi, -1(%edx)
	mov	$3, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit14Case2OrCase3):
	movl	-2(%ecx), %esi
	movl	%esi, -2(%edx)
	mov	$2, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

	.p2align 4
L(StrncpyExit15Case2OrCase3):
	movl	-3(%ecx), %esi
	movl	%esi, -3(%edx)
	mov	$1, %esi
	test	%eax, %eax
	jnz	L(CopyFrom1To16BytesCase2)
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave1):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit1)
	palignr	$1, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	31(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit1)
	palignr	$1, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit1)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit1)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit1):
	lea	15(%edx, %esi), %edx
	lea	15(%ecx, %esi), %ecx
	movdqu	-16(%ecx), %xmm0
	xor	%esi, %esi
	movdqu	%xmm0, -16(%edx)
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave2):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit2)
	palignr	$2, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	30(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit2)
	palignr	$2, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit2)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit2)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit2):
	lea	14(%edx, %esi), %edx
	lea	14(%ecx, %esi), %ecx
	movdqu	-16(%ecx), %xmm0
	xor	%esi, %esi
	movdqu	%xmm0, -16(%edx)
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave3):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit3)
	palignr	$3, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	29(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit3)
	palignr	$3, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit3)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit3)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit3):
	lea	13(%edx, %esi), %edx
	lea	13(%ecx, %esi), %ecx
	movdqu	-16(%ecx), %xmm0
	xor	%esi, %esi
	movdqu	%xmm0, -16(%edx)
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave4):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit4)
	palignr	$4, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	28(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit4)
	palignr	$4, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit4)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit4)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit4):
	lea	12(%edx, %esi), %edx
	lea	12(%ecx, %esi), %ecx
	movlpd	-12(%ecx), %xmm0
	movl	-4(%ecx), %eax
	movlpd	%xmm0, -12(%edx)
	movl	%eax, -4(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave5):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit5)
	palignr	$5, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	27(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit5)
	palignr	$5, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit5)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit5)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit5):
	lea	11(%edx, %esi), %edx
	lea	11(%ecx, %esi), %ecx
	movlpd	-11(%ecx), %xmm0
	movl	-4(%ecx), %eax
	movlpd	%xmm0, -11(%edx)
	movl	%eax, -4(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave6):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit6)
	palignr	$6, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	26(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit6)
	palignr	$6, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit6)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit6)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit6):
	lea	10(%edx, %esi), %edx
	lea	10(%ecx, %esi), %ecx

	movlpd	-10(%ecx), %xmm0
	movw	-2(%ecx), %ax
	movlpd	%xmm0, -10(%edx)
	movw	%ax, -2(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave7):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit7)
	palignr	$7, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	25(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit7)
	palignr	$7, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit7)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit7)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit7):
	lea	9(%edx, %esi), %edx
	lea	9(%ecx, %esi), %ecx

	movlpd	-9(%ecx), %xmm0
	movb	-1(%ecx), %ah
	movlpd	%xmm0, -9(%edx)
	movb	%ah, -1(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave8):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit8)
	palignr	$8, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	24(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit8)
	palignr	$8, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit8)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit8)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit8):
	lea	8(%edx, %esi), %edx
	lea	8(%ecx, %esi), %ecx
	movlpd	-8(%ecx), %xmm0
	movlpd	%xmm0, -8(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave9):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit9)
	palignr	$9, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	23(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit9)
	palignr	$9, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit9)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit9)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit9):
	lea	7(%edx, %esi), %edx
	lea	7(%ecx, %esi), %ecx

	movlpd	-8(%ecx), %xmm0
	movlpd	%xmm0, -8(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave10):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit10)
	palignr	$10, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	22(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit10)
	palignr	$10, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit10)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit10)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit10):
	lea	6(%edx, %esi), %edx
	lea	6(%ecx, %esi), %ecx

	movlpd	-8(%ecx), %xmm0
	movlpd	%xmm0, -8(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave11):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit11)
	palignr	$11, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	21(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit11)
	palignr	$11, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit11)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit11)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit11):
	lea	5(%edx, %esi), %edx
	lea	5(%ecx, %esi), %ecx
	movl	-5(%ecx), %esi
	movb	-1(%ecx), %ah
	movl	%esi, -5(%edx)
	movb	%ah, -1(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave12):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit12)
	palignr	$12, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	20(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit12)
	palignr	$12, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit12)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit12)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit12):
	lea	4(%edx, %esi), %edx
	lea	4(%ecx, %esi), %ecx
	movl	-4(%ecx), %eax
	movl	%eax, -4(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave13):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit13)
	palignr	$13, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	19(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit13)
	palignr	$13, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit13)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit13)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit13):
	lea	3(%edx, %esi), %edx
	lea	3(%ecx, %esi), %ecx

	movl	-4(%ecx), %eax
	movl	%eax, -4(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave14):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit14)
	palignr	$14, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	18(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit14)
	palignr	$14, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit14)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit14)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit14):
	lea	2(%edx, %esi), %edx
	lea	2(%ecx, %esi), %ecx
	movw	-2(%ecx), %ax
	movw	%ax, -2(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)

L(StrncpyLeave15):
	movaps	%xmm2, %xmm3
	add	$48, %ebx
	jle	L(StrncpyExit15)
	palignr	$15, %xmm1, %xmm2
	movaps	%xmm2, (%edx)
	movaps	17(%ecx), %xmm2
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit15)
	palignr	$15, %xmm3, %xmm2
	movaps	%xmm2, 16(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit15)
	movaps	%xmm4, 32(%edx)
	lea	16(%esi), %esi
	sub	$16, %ebx
	jbe	L(StrncpyExit15)
	movaps	%xmm5, 48(%edx)
	lea	16(%esi), %esi
	lea	-16(%ebx), %ebx
L(StrncpyExit15):
	lea	1(%edx, %esi), %edx
	lea	1(%ecx, %esi), %ecx
	movb	-1(%ecx), %ah
	movb	%ah, -1(%edx)
	xor	%esi, %esi
	jmp	L(CopyFrom1To16BytesCase3)
#endif

#if !defined USE_AS_STRCAT && ! defined USE_AS_STRLCPY
# ifdef USE_AS_STRNCPY
	CFI_POP (%esi)
	CFI_POP (%edi)

	.p2align 4
L(ExitTail0):
	movl	%edx, %eax
	RETURN

	.p2align 4
L(StrncpyExit15Bytes):
	cmp	$12, %ebx
	jbe	L(StrncpyExit12Bytes)
	cmpb	$0, 8(%ecx)
	jz	L(ExitTail9)
	cmpb	$0, 9(%ecx)
	jz	L(ExitTail10)
	cmpb	$0, 10(%ecx)
	jz	L(ExitTail11)
	cmpb	$0, 11(%ecx)
	jz	L(ExitTail12)
	cmp	$13, %ebx
	je	L(ExitTail13)
	cmpb	$0, 12(%ecx)
	jz	L(ExitTail13)
	cmp	$14, %ebx
	je	L(ExitTail14)
	cmpb	$0, 13(%ecx)
	jz	L(ExitTail14)
	movlpd	(%ecx), %xmm0
	movlpd	7(%ecx), %xmm1
	movlpd	%xmm0, (%edx)
	movlpd	%xmm1, 7(%edx)
#  ifdef USE_AS_STPCPY
	lea	14(%edx), %eax
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  else
	movl	%edx, %eax
#  endif
	RETURN

	.p2align 4
L(StrncpyExit12Bytes):
	cmp	$9, %ebx
	je	L(ExitTail9)
	cmpb	$0, 8(%ecx)
	jz	L(ExitTail9)
	cmp	$10, %ebx
	je	L(ExitTail10)
	cmpb	$0, 9(%ecx)
	jz	L(ExitTail10)
	cmp	$11, %ebx
	je	L(ExitTail11)
	cmpb	$0, 10(%ecx)
	jz	L(ExitTail11)
	movlpd	(%ecx), %xmm0
	movl	8(%ecx), %eax
	movlpd	%xmm0, (%edx)
	movl	%eax, 8(%edx)
	SAVE_RESULT_TAIL (11)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
	RETURN

	.p2align 4
L(StrncpyExit8Bytes):
	cmp	$4, %ebx
	jbe	L(StrncpyExit4Bytes)
	cmpb	$0, (%ecx)
	jz	L(ExitTail1)
	cmpb	$0, 1(%ecx)
	jz	L(ExitTail2)
	cmpb	$0, 2(%ecx)
	jz	L(ExitTail3)
	cmpb	$0, 3(%ecx)
	jz	L(ExitTail4)

	cmp	$5, %ebx
	je	L(ExitTail5)
	cmpb	$0, 4(%ecx)
	jz	L(ExitTail5)
	cmp	$6, %ebx
	je	L(ExitTail6)
	cmpb	$0, 5(%ecx)
	jz	L(ExitTail6)
	cmp	$7, %ebx
	je	L(ExitTail7)
	cmpb	$0, 6(%ecx)
	jz	L(ExitTail7)
	movlpd	(%ecx), %xmm0
	movlpd	%xmm0, (%edx)
#  ifdef USE_AS_STPCPY
	lea	7(%edx), %eax
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  else
	movl	%edx, %eax
#  endif
	RETURN

	.p2align 4
L(StrncpyExit4Bytes):
	test	%ebx, %ebx
	jz	L(ExitTail0)
	cmp	$1, %ebx
	je	L(ExitTail1)
	cmpb	$0, (%ecx)
	jz	L(ExitTail1)
	cmp	$2, %ebx
	je	L(ExitTail2)
	cmpb	$0, 1(%ecx)
	jz	L(ExitTail2)
	cmp	$3, %ebx
	je	L(ExitTail3)
	cmpb	$0, 2(%ecx)
	jz	L(ExitTail3)
	movl	(%ecx), %eax
	movl	%eax, (%edx)
	SAVE_RESULT_TAIL (3)
#  ifdef USE_AS_STPCPY
	cmpb	$1, (%eax)
	sbb	$-1, %eax
#  endif
	RETURN
# endif

END (STRCPY)
#endif
