
########## gcc ##########

===== copy_generic_ptr =====
copy_generic_ptr:
.LFB2399:
	.cfi_startproc
	endbr64
	cmpq	%rsi, %rdi
	jne	.L3
	jmp	.L4
	.p2align 5
	.p2align 4,,10
	.p2align 3
.L8:
	movl	(%rdi), %eax
	addq	$4, %rdi
	addq	$4, %rdx
	movl	%eax, -4(%rdx)
	cmpq	%rdi, %rsi
	je	.L4
.L3:
	cmpq	%rdx, %rcx
	jne	.L8
	movq	%rcx, %rax
	ret
	.p2align 4,,10
	.p2align 3
.L4:
	movq	%rdx, %rax
	ret
	.cfi_endproc
.LFE2399:
	.size	copy_generic_ptr, .-copy_generic_ptr
	.p2align 4
	.globl	copy_both_ra
	.type	copy_both_ra, @function

===== copy_both_ra =====
copy_both_ra:
.LFB2400:
	.cfi_startproc
	endbr64
	subq	%rdx, %rcx
	subq	%rdi, %rsi
	movq	%rdx, %rax
	movq	%rcx, %r8
	movq	%rsi, %rdx
	sarq	$2, %r8
	sarq	$2, %rdx
	cmpq	%rcx, %rsi
	movq	%r8, %rcx
	cmovl	%rdx, %rcx
	salq	$2, %rcx
	leaq	(%rdi,%rcx), %r10
	cmpq	%r10, %rdi
	je	.L9
	leaq	-4(%rcx), %rdx
	cmpq	$8, %rdx
	jbe	.L20
	leaq	-4(%rax), %rsi
	subq	%rdi, %rsi
	cmpq	$8, %rsi
	jbe	.L20
	shrq	$2, %rdx
	leaq	1(%rdx), %r8
	xorl	%edx, %edx
	movq	%r8, %r9
	shrq	$2, %r9
	movq	%r9, %rsi
	salq	$4, %rsi
	.p2align 5
	.p2align 4
	.p2align 3
.L14:
	movdqu	(%rdi,%rdx), %xmm0
	movups	%xmm0, (%rax,%rdx)
	addq	$16, %rdx
	cmpq	%rdx, %rsi
	jne	.L14
	salq	$2, %r9
	cmpq	%r9, %r8
	je	.L16
	addq	%rsi, %rdi
	movl	(%rdi), %edx
	movl	%edx, (%rax,%rsi)
	leaq	4(%rdi), %rdx
	cmpq	%rdx, %r10
	je	.L16
	movl	4(%rdi), %edx
	movl	%edx, 4(%rax,%rsi)
	leaq	8(%rdi), %rdx
	cmpq	%rdx, %r10
	je	.L16

===== copy_ra_dst_list_src =====
copy_ra_dst_list_src:
.LFB2401:
	.cfi_startproc
	endbr64
	cmpq	%rdx, %rcx
	je	.L27
	subq	%rdx, %rcx
	movq	%rdx, %rax
	sarq	$2, %rcx
	jmp	.L26
	.p2align 5
	.p2align 4,,10
	.p2align 3
.L30:
	movl	(%rdi), %edx
	addq	$4, %rax
	movq	8(%rdi), %rdi
	movl	%edx, -4(%rax)
	subq	$1, %rcx
	je	.L29
.L26:
	cmpq	%rdi, %rsi
	jne	.L30
	ret
	.p2align 4,,10
	.p2align 3
.L29:
	ret
.L27:
	movq	%rcx, %rax
	ret
	.cfi_endproc
.LFE2401:
	.size	copy_ra_dst_list_src, .-copy_ra_dst_list_src
	.p2align 4
	.globl	copy_generic_list_src
	.type	copy_generic_list_src, @function

===== copy_generic_list_src =====
copy_generic_list_src:
.LFB2402:
	.cfi_startproc
	endbr64
	movq	%rsi, %rax
	movq	%rdi, %rsi
	cmpq	%rax, %rdi
	jne	.L33
	jmp	.L34
	.p2align 5
	.p2align 4,,10
	.p2align 3
.L37:
	movl	(%rsi), %edi
	movq	8(%rsi), %rsi
	addq	$4, %rdx
	movl	%edi, -4(%rdx)
	cmpq	%rax, %rsi
	je	.L34
.L33:
	cmpq	%rdx, %rcx
	jne	.L37
	movq	%rcx, %rax
	ret
	.p2align 4,,10
	.p2align 3
.L34:
	movq	%rdx, %rax
	ret
	.cfi_endproc
.LFE2402:
	.size	copy_generic_list_src, .-copy_generic_list_src
	.p2align 4
	.globl	copy_ra_src_list_dst
	.type	copy_ra_src_list_dst, @function

===== copy_ra_src_list_dst =====
copy_ra_src_list_dst:
.LFB2403:
	.cfi_startproc
	endbr64
	movq	%rdx, %rax
	cmpq	%rdi, %rsi
	je	.L39
	subq	%rdi, %rsi
	sarq	$2, %rsi
	jmp	.L40
	.p2align 5
	.p2align 4,,10
	.p2align 3
.L42:
	movl	(%rdi), %edx
	addq	$4, %rdi
	movl	%edx, (%rax)
	movq	8(%rax), %rax
	subq	$1, %rsi
	je	.L39
.L40:
	cmpq	%rax, %rcx
	jne	.L42
.L39:
	ret
	.cfi_endproc
.LFE2403:
	.size	copy_ra_src_list_dst, .-copy_ra_src_list_dst
	.p2align 4
	.globl	copy_generic_list_dst
	.type	copy_generic_list_dst, @function

===== copy_generic_list_dst =====
copy_generic_list_dst:
.LFB2404:
	.cfi_startproc
	endbr64
	movq	%rdx, %rax
	cmpq	%rsi, %rdi
	jne	.L45
	ret
	.p2align 5
	.p2align 4,,10
	.p2align 3
.L47:
	movl	(%rdi), %edx
	addq	$4, %rdi
	movl	%edx, (%rax)
	movq	8(%rax), %rax
	cmpq	%rdi, %rsi
	je	.L44
.L45:
	cmpq	%rax, %rcx
	jne	.L47
.L44:
	ret
	.cfi_endproc
.LFE2404:
	.size	copy_generic_list_dst, .-copy_generic_list_dst
	.p2align 4
	.globl	copy_ra_src_unbounded
	.type	copy_ra_src_unbounded, @function

===== copy_ra_src_unbounded =====
copy_ra_src_unbounded:
.LFB2405:
	.cfi_startproc
	endbr64
	movq	%rsi, %r9
	movq	%rdx, %rax
	cmpq	%rsi, %rdi
	je	.L48
	movq	%rsi, %r8
	subq	%rdi, %r8
	leaq	-4(%r8), %rdx
	cmpq	$8, %rdx
	jbe	.L57
	leaq	-4(%rax), %rcx
	subq	%rdi, %rcx
	cmpq	$8, %rcx
	jbe	.L57
	shrq	$2, %rdx
	leaq	1(%rdx), %rsi
	xorl	%edx, %edx
	movq	%rsi, %r10
	shrq	$2, %r10
	movq	%r10, %rcx
	salq	$4, %rcx
	.p2align 5
	.p2align 4
	.p2align 3
.L53:
	movdqu	(%rdi,%rdx), %xmm0
	movups	%xmm0, (%rax,%rdx)
	addq	$16, %rdx
	cmpq	%rcx, %rdx
	jne	.L53
	salq	$2, %r10
	cmpq	%r10, %rsi
	je	.L55
	addq	%rdx, %rdi
	movl	(%rdi), %ecx
	movl	%ecx, (%rax,%rdx)
	leaq	4(%rdi), %rcx
	cmpq	%rcx, %r9
	je	.L55
	movl	4(%rdi), %ecx
	movl	%ecx, 4(%rax,%rdx)
	leaq	8(%rdi), %rcx
	cmpq	%rcx, %r9
	je	.L55
	movl	8(%rdi), %ecx
	movl	%ecx, 8(%rax,%rdx)
.L55:
	addq	%r8, %rax
	ret
	.p2align 4,,10
	.p2align 3
.L48:

===== equal_generic_ptr =====
equal_generic_ptr:
.LFB2411:
	.cfi_startproc
	endbr64
	cmpq	%rsi, %rdi
	jne	.L245
	jmp	.L249
	.p2align 4,,10
	.p2align 3
.L247:
	movl	(%rdx), %eax
	cmpl	%eax, (%rdi)
	jne	.L248
	addq	$4, %rdi
	addq	$4, %rdx
	cmpq	%rdi, %rsi
	je	.L249
.L245:
	cmpq	%rdx, %rcx
	jne	.L247
.L248:
	xorl	%eax, %eax
	ret
	.p2align 4,,10
	.p2align 3
.L249:
	movl	$1, %eax
	ret
	.cfi_endproc
.LFE2411:
	.size	equal_generic_ptr, .-equal_generic_ptr
	.p2align 4
	.globl	equal_both_ra
	.type	equal_both_ra, @function

===== equal_both_ra =====
equal_both_ra:
.LFB2412:
	.cfi_startproc
	endbr64
	subq	%rdx, %rcx
	movq	%rsi, %r8
	subq	%rdi, %rsi
	movq	%rcx, %r9
	movq	%rsi, %rax
	sarq	$2, %r9
	sarq	$2, %rax
	cmpq	%rcx, %rsi
	cmovge	%r9, %rax
	leaq	(%rdi,%rax,4), %rax
	cmpq	%rax, %rdi
	jne	.L257
	jmp	.L255
	.p2align 5
	.p2align 4,,10
	.p2align 3
.L261:
	addq	$4, %rdi
	addq	$4, %rdx
	cmpq	%rdi, %rax
	je	.L255
.L257:
	movl	(%rdx), %esi
	cmpl	%esi, (%rdi)
	je	.L261
	xorl	%eax, %eax
	ret
	.p2align 4,,10
	.p2align 3
.L255:
	cmpq	%rdi, %r8
	sete	%al
	ret
	.cfi_endproc
.LFE2412:
	.size	equal_both_ra, .-equal_both_ra
	.p2align 4
	.globl	equal_ra_a_list_b
	.type	equal_ra_a_list_b, @function

===== equal_ra_a_list_b =====
equal_ra_a_list_b:
.LFB2413:
	.cfi_startproc
	endbr64
	movq	%rsi, %rax
	subq	%rdi, %rax
	sarq	$2, %rax
	cmpq	%rdi, %rsi
	jne	.L267
	jmp	.L268
	.p2align 4,,10
	.p2align 3
.L265:
	movl	(%rdx), %esi
	cmpl	%esi, (%rdi)
	jne	.L266
	movq	8(%rdx), %rdx
	addq	$4, %rdi
	subq	$1, %rax
	je	.L268
.L267:
	cmpq	%rdx, %rcx
	jne	.L265
.L266:
	xorl	%eax, %eax
	ret
	.p2align 4,,10
	.p2align 3
.L268:
	movl	$1, %eax
	ret
	.cfi_endproc
.LFE2413:
	.size	equal_ra_a_list_b, .-equal_ra_a_list_b
	.p2align 4
	.globl	equal_list_a_ra_b
	.type	equal_list_a_ra_b, @function

===== equal_generic_list_b =====
equal_generic_list_b:
.LFB2415:
	.cfi_startproc
	endbr64
	cmpq	%rsi, %rdi
	jne	.L287
	jmp	.L288
	.p2align 4,,10
	.p2align 3
.L285:
	movl	(%rdx), %eax
	cmpl	%eax, (%rdi)
	jne	.L286
	addq	$4, %rdi
	movq	8(%rdx), %rdx
	cmpq	%rdi, %rsi
	je	.L288
.L287:
	cmpq	%rdx, %rcx
	jne	.L285
.L286:
	xorl	%eax, %eax
	ret
	.p2align 4,,10
	.p2align 3
.L288:
	movl	$1, %eax
	ret
	.cfi_endproc
.LFE2415:
	.size	equal_generic_list_b, .-equal_generic_list_b
	.section	.text.startup,"ax",@progbits
	.p2align 4
	.globl	main
	.type	main, @function

===== copy_if_both_ra =====
copy_if_both_ra:
.LFB2408:
	.cfi_startproc
	endbr64
	movq	%rdx, %rax
	movq	%rcx, %r8
	cmpq	%rcx, %rdx
	je	.L70
	subq	%rdi, %rsi
	movq	%rsi, %rdx
	sarq	$2, %rdx
	cmpq	$60, %rsi
	jg	.L72
	jmp	.L73
	.p2align 4,,10
	.p2align 3
.L91:
	movl	(%rdi), %ecx
	subq	$16, %rdx
	testb	$1, %cl
	je	.L74
	movl	%ecx, (%rax)
	addq	$4, %rax
.L74:
	movl	4(%rdi), %ecx
	testb	$1, %cl
	je	.L75
	movl	%ecx, (%rax)
	addq	$4, %rax
.L75:
	movl	8(%rdi), %ecx
	testb	$1, %cl
	je	.L76
	movl	%ecx, (%rax)
	addq	$4, %rax
.L76:
	movl	12(%rdi), %ecx
	testb	$1, %cl
	je	.L77
	movl	%ecx, (%rax)
	addq	$4, %rax
.L77:
	movl	16(%rdi), %ecx
	testb	$1, %cl
	je	.L78
	movl	%ecx, (%rax)
	addq	$4, %rax
.L78:
	movl	20(%rdi), %ecx
	testb	$1, %cl
	je	.L79
	movl	%ecx, (%rax)
	addq	$4, %rax
.L79:
	movl	24(%rdi), %ecx

===== copy_if_ra_dst_list_src =====
copy_if_ra_dst_list_src:
.LFB2409:
	.cfi_startproc
	endbr64
	movq	%rdi, %r8
	movq	%rdx, %rax
	movq	%rcx, %rdi
	cmpq	%rcx, %rdx
	je	.L154
	subq	%rax, %rcx
	movq	%r8, %rdx
	cmpq	$60, %rcx
	jg	.L156
	jmp	.L157
	.p2align 4,,10
	.p2align 3
.L235:
	movl	(%rdx), %ecx
	testb	$1, %cl
	je	.L159
	movl	%ecx, (%rax)
	addq	$4, %rax
.L159:
	movq	8(%rdx), %rdx
	cmpq	%rdx, %rsi
	je	.L160
	movl	(%rdx), %ecx
	testb	$1, %cl
	je	.L161
	movl	%ecx, (%rax)
	addq	$4, %rax
.L161:
	movq	8(%rdx), %rdx
	cmpq	%rdx, %rsi
	je	.L160
	movl	(%rdx), %ecx
	testb	$1, %cl
	je	.L162
	movl	%ecx, (%rax)
	addq	$4, %rax
.L162:
	movq	8(%rdx), %rdx
	cmpq	%rdx, %rsi
	je	.L160
	movl	(%rdx), %ecx
	testb	$1, %cl
	je	.L163
	movl	%ecx, (%rax)
	addq	$4, %rax
.L163:
	movq	8(%rdx), %rdx
	cmpq	%rdx, %rsi
	je	.L160
	movl	(%rdx), %ecx
	testb	$1, %cl


########## clang ##########

===== copy_generic_ptr =====
copy_generic_ptr:                       # @copy_generic_ptr
	.cfi_startproc
# %bb.0:
	cmpq	%rsi, %rdi
	je	.LBB0_1
# %bb.3:
	cmpq	%rcx, %rdx
	je	.LBB0_1
# %bb.4:
	movq	%rcx, %rax
	subq	%rdx, %rax
	addq	$-4, %rax
	shrq	$2, %rax
	movq	%rsi, %r8
	subq	%rdi, %r8
	addq	$-4, %r8
	shrq	$2, %r8
	cmpq	%r8, %rax
	cmovbq	%rax, %r8
	cmpq	$19, %r8
	jb	.LBB0_5
# %bb.6:
	movl	%esi, %eax
	subl	%edi, %eax
	movl	%ecx, %r9d
	subl	%edx, %r9d
	orl	%eax, %r9d
	testb	$3, %r9b
	setne	%al
	movq	%rdx, %r9
	subq	%rdi, %r9
	cmpq	$32, %r9
	setb	%r9b
	orb	%al, %r9b
	je	.LBB0_7
.LBB0_5:
	movq	%rdi, %r9
	movq	%rdx, %rax
.LBB0_10:
	addq	$4, %r9
	.p2align	4
.LBB0_11:                               # =>This Inner Loop Header: Depth=1
	movl	-4(%r9), %edx
	movl	%edx, (%rax)
	addq	$4, %rax
	cmpq	%rsi, %r9
	je	.LBB0_2
# %bb.12:                               #   in Loop: Header=BB0_11 Depth=1
	addq	$4, %r9
	cmpq	%rcx, %rax
	jne	.LBB0_11
.LBB0_2:
	retq
.LBB0_1:
	movq	%rdx, %rax

===== copy_both_ra =====
copy_both_ra:                           # @copy_both_ra
	.cfi_startproc
# %bb.0:
	subq	%rdi, %rsi
	sarq	$2, %rsi
	subq	%rdx, %rcx
	sarq	$2, %rcx
	cmpq	%rcx, %rsi
	cmovlq	%rsi, %rcx
	testq	%rcx, %rcx
	je	.LBB1_1
# %bb.3:
	leaq	(,%rcx,4), %r8
	addq	$-4, %r8
	cmpq	$28, %r8
	setb	%al
	movq	%rdx, %rsi
	subq	%rdi, %rsi
	cmpq	$32, %rsi
	setb	%sil
	orb	%al, %sil
	je	.LBB1_5
# %bb.4:
	movq	%rdi, %rsi
	movq	%rdx, %rax
	jmp	.LBB1_8
.LBB1_1:
	movq	%rdx, %rax
	retq
.LBB1_5:
	shrq	$2, %r8
	incq	%r8
	movq	%r8, %r9
	andq	$-8, %r9
	leaq	(%rdi,%r9,4), %rsi
	leaq	(%rdx,%r9,4), %rax
	xorl	%r10d, %r10d
	.p2align	4
.LBB1_6:                                # =>This Inner Loop Header: Depth=1
	movups	(%rdi,%r10,4), %xmm0
	movups	16(%rdi,%r10,4), %xmm1
	movups	%xmm0, (%rdx,%r10,4)
	movups	%xmm1, 16(%rdx,%r10,4)
	addq	$8, %r10
	cmpq	%r10, %r9
	jne	.LBB1_6
# %bb.7:
	cmpq	%r9, %r8
	je	.LBB1_2
.LBB1_8:
	leaq	(%rdi,%rcx,4), %rcx
	.p2align	4
.LBB1_9:                                # =>This Inner Loop Header: Depth=1
	movl	(%rsi), %edx
	movl	%edx, (%rax)

===== copy_ra_dst_list_src =====
copy_ra_dst_list_src:                   # @copy_ra_dst_list_src
	.cfi_startproc
# %bb.0:
	movq	%rdx, %rax
	subq	%rdx, %rcx
	setne	%dl
	cmpq	%rsi, %rdi
	setne	%r8b
	andb	%dl, %r8b
	cmpb	$1, %r8b
	jne	.LBB2_4
# %bb.1:
	sarq	$2, %rcx
	decq	%rcx
	.p2align	4
.LBB2_2:                                # =>This Inner Loop Header: Depth=1
	movl	(%rdi), %edx
	movl	%edx, (%rax)
	addq	$4, %rax
	addq	$-1, %rcx
	jae	.LBB2_4
# %bb.3:                                #   in Loop: Header=BB2_2 Depth=1
	movq	8(%rdi), %rdi
	cmpq	%rsi, %rdi
	jne	.LBB2_2
.LBB2_4:
	retq
.Lfunc_end2:
	.size	copy_ra_dst_list_src, .Lfunc_end2-copy_ra_dst_list_src
	.cfi_endproc
                                        # -- End function
	.globl	copy_generic_list_src           # -- Begin function copy_generic_list_src
	.p2align	4
	.type	copy_generic_list_src,@function

===== copy_generic_list_src =====
copy_generic_list_src:                  # @copy_generic_list_src
	.cfi_startproc
# %bb.0:
	movq	%rdx, %rax
	cmpq	%rsi, %rdi
	je	.LBB3_4
	.p2align	4
.LBB3_2:                                # =>This Inner Loop Header: Depth=1
	cmpq	%rcx, %rax
	je	.LBB3_4
# %bb.3:                                #   in Loop: Header=BB3_2 Depth=1
	movl	(%rdi), %edx
	movl	%edx, (%rax)
	addq	$4, %rax
	movq	8(%rdi), %rdi
	cmpq	%rsi, %rdi
	jne	.LBB3_2
.LBB3_4:
	retq
.Lfunc_end3:
	.size	copy_generic_list_src, .Lfunc_end3-copy_generic_list_src
	.cfi_endproc
                                        # -- End function
	.globl	copy_ra_src_list_dst            # -- Begin function copy_ra_src_list_dst
	.p2align	4
	.type	copy_ra_src_list_dst,@function

===== copy_ra_src_list_dst =====
copy_ra_src_list_dst:                   # @copy_ra_src_list_dst
	.cfi_startproc
# %bb.0:
	movq	%rdx, %rax
	subq	%rdi, %rsi
	setne	%dl
	cmpq	%rcx, %rax
	setne	%r8b
	andb	%dl, %r8b
	cmpb	$1, %r8b
	jne	.LBB4_4
# %bb.1:
	sarq	$2, %rsi
	decq	%rsi
	xorl	%edx, %edx
	.p2align	4
.LBB4_2:                                # =>This Inner Loop Header: Depth=1
	movl	(%rdi,%rdx,4), %r8d
	movl	%r8d, (%rax)
	movq	8(%rax), %rax
	cmpq	%rdx, %rsi
	je	.LBB4_4
# %bb.3:                                #   in Loop: Header=BB4_2 Depth=1
	incq	%rdx
	cmpq	%rcx, %rax
	jne	.LBB4_2
.LBB4_4:
	retq
.Lfunc_end4:
	.size	copy_ra_src_list_dst, .Lfunc_end4-copy_ra_src_list_dst
	.cfi_endproc
                                        # -- End function
	.globl	copy_generic_list_dst           # -- Begin function copy_generic_list_dst
	.p2align	4
	.type	copy_generic_list_dst,@function

===== copy_generic_list_dst =====
copy_generic_list_dst:                  # @copy_generic_list_dst
	.cfi_startproc
# %bb.0:
	movq	%rdx, %rax
	cmpq	%rsi, %rdi
	je	.LBB5_5
# %bb.1:
	cmpq	%rcx, %rax
	je	.LBB5_5
# %bb.2:
	addq	$4, %rdi
	.p2align	4
.LBB5_3:                                # =>This Inner Loop Header: Depth=1
	movl	-4(%rdi), %edx
	movl	%edx, (%rax)
	movq	8(%rax), %rax
	cmpq	%rsi, %rdi
	je	.LBB5_5
# %bb.4:                                #   in Loop: Header=BB5_3 Depth=1
	addq	$4, %rdi
	cmpq	%rcx, %rax
	jne	.LBB5_3
.LBB5_5:
	retq
.Lfunc_end5:
	.size	copy_generic_list_dst, .Lfunc_end5-copy_generic_list_dst
	.cfi_endproc
                                        # -- End function
	.globl	copy_ra_src_unbounded           # -- Begin function copy_ra_src_unbounded
	.p2align	4
	.type	copy_ra_src_unbounded,@function

===== copy_ra_src_unbounded =====
copy_ra_src_unbounded:                  # @copy_ra_src_unbounded
	.cfi_startproc
# %bb.0:
	cmpq	%rsi, %rdi
	je	.LBB6_1
# %bb.3:
	movq	%rsi, %r8
	subq	%rdi, %r8
	addq	$-4, %r8
	cmpq	$28, %r8
	setb	%al
	movq	%rdx, %rcx
	subq	%rdi, %rcx
	cmpq	$32, %rcx
	setb	%cl
	orb	%al, %cl
	je	.LBB6_5
# %bb.4:
	movq	%rdx, %rax
	movq	%rdi, %rcx
	jmp	.LBB6_8
.LBB6_1:
	movq	%rdx, %rax
	retq
.LBB6_5:
	shrq	$2, %r8
	incq	%r8
	movq	%r8, %r9
	andq	$-8, %r9
	leaq	(%rdx,%r9,4), %rax
	leaq	(%rdi,%r9,4), %rcx
	xorl	%r10d, %r10d
	.p2align	4
.LBB6_6:                                # =>This Inner Loop Header: Depth=1
	movups	(%rdi,%r10,4), %xmm0
	movups	16(%rdi,%r10,4), %xmm1
	movups	%xmm0, (%rdx,%r10,4)
	movups	%xmm1, 16(%rdx,%r10,4)
	addq	$8, %r10
	cmpq	%r10, %r9
	jne	.LBB6_6
# %bb.7:
	cmpq	%r9, %r8
	je	.LBB6_2
	.p2align	4
.LBB6_8:                                # =>This Inner Loop Header: Depth=1
	movl	(%rcx), %edx
	movl	%edx, (%rax)
	addq	$4, %rcx
	addq	$4, %rax
	cmpq	%rsi, %rcx
	jne	.LBB6_8
.LBB6_2:
	retq
.Lfunc_end6:

===== equal_generic_ptr =====
equal_generic_ptr:                      # @equal_generic_ptr
	.cfi_startproc
# %bb.0:
	cmpq	%rsi, %rdi
	sete	%al
	je	.LBB11_7
# %bb.1:
	cmpq	%rcx, %rdx
	je	.LBB11_7
# %bb.2:
	addq	$4, %rdx
	addq	$4, %rdi
	.p2align	4
.LBB11_3:                               # =>This Inner Loop Header: Depth=1
	movl	-4(%rdi), %eax
	cmpl	-4(%rdx), %eax
	jne	.LBB11_4
# %bb.5:                                #   in Loop: Header=BB11_3 Depth=1
	cmpq	%rsi, %rdi
	sete	%al
	je	.LBB11_7
# %bb.6:                                #   in Loop: Header=BB11_3 Depth=1
	addq	$4, %rdi
	cmpq	%rcx, %rdx
	leaq	4(%rdx), %rdx
	jne	.LBB11_3
.LBB11_7:
                                        # kill: def $al killed $al killed $eax
	retq
.LBB11_4:
	xorl	%eax, %eax
                                        # kill: def $al killed $al killed $eax
	retq
.Lfunc_end11:
	.size	equal_generic_ptr, .Lfunc_end11-equal_generic_ptr
	.cfi_endproc
                                        # -- End function
	.globl	equal_both_ra                   # -- Begin function equal_both_ra
	.p2align	4
	.type	equal_both_ra,@function

===== equal_both_ra =====
equal_both_ra:                          # @equal_both_ra
	.cfi_startproc
# %bb.0:
	movq	%rsi, %rax
	subq	%rdi, %rax
	sarq	$2, %rax
	subq	%rdx, %rcx
	sarq	$2, %rcx
	cmpq	%rcx, %rax
	cmovlq	%rax, %rcx
	testq	%rcx, %rcx
	je	.LBB12_6
# %bb.1:
	leaq	(%rdi,%rcx,4), %rax
	shlq	$2, %rcx
	xorl	%r8d, %r8d
	.p2align	4
.LBB12_2:                               # =>This Inner Loop Header: Depth=1
	movl	(%rdi,%r8), %r9d
	cmpl	(%rdx,%r8), %r9d
	jne	.LBB12_3
# %bb.4:                                #   in Loop: Header=BB12_2 Depth=1
	addq	$4, %r8
	cmpq	%r8, %rcx
	jne	.LBB12_2
# %bb.5:
	movq	%rax, %rdi
.LBB12_6:
	cmpq	%rsi, %rdi
	sete	%al
                                        # kill: def $al killed $al killed $eax
	retq
.LBB12_3:
	xorl	%eax, %eax
                                        # kill: def $al killed $al killed $eax
	retq
.Lfunc_end12:
	.size	equal_both_ra, .Lfunc_end12-equal_both_ra
	.cfi_endproc
                                        # -- End function
	.globl	equal_ra_a_list_b               # -- Begin function equal_ra_a_list_b
	.p2align	4
	.type	equal_ra_a_list_b,@function

===== equal_ra_a_list_b =====
equal_ra_a_list_b:                      # @equal_ra_a_list_b
	.cfi_startproc
# %bb.0:
	subq	%rdi, %rsi
	sete	%al
	je	.LBB13_7
# %bb.1:
	cmpq	%rcx, %rdx
	je	.LBB13_7
# %bb.2:
	sarq	$2, %rsi
	decq	%rsi
	xorl	%r8d, %r8d
	.p2align	4
.LBB13_3:                               # =>This Inner Loop Header: Depth=1
	movl	(%rdi,%r8,4), %eax
	cmpl	(%rdx), %eax
	jne	.LBB13_4
# %bb.5:                                #   in Loop: Header=BB13_3 Depth=1
	cmpq	%r8, %rsi
	sete	%al
	je	.LBB13_7
# %bb.6:                                #   in Loop: Header=BB13_3 Depth=1
	movq	8(%rdx), %rdx
	incq	%r8
	cmpq	%rcx, %rdx
	jne	.LBB13_3
.LBB13_7:
                                        # kill: def $al killed $al killed $eax
	retq
.LBB13_4:
	xorl	%eax, %eax
                                        # kill: def $al killed $al killed $eax
	retq
.Lfunc_end13:
	.size	equal_ra_a_list_b, .Lfunc_end13-equal_ra_a_list_b
	.cfi_endproc
                                        # -- End function
	.globl	equal_list_a_ra_b               # -- Begin function equal_list_a_ra_b
	.p2align	4
	.type	equal_list_a_ra_b,@function

===== equal_generic_list_b =====
equal_generic_list_b:                   # @equal_generic_list_b
	.cfi_startproc
# %bb.0:
	cmpq	%rsi, %rdi
	sete	%al
	je	.LBB15_7
# %bb.1:
	cmpq	%rcx, %rdx
	je	.LBB15_7
# %bb.2:
	addq	$4, %rdi
	.p2align	4
.LBB15_3:                               # =>This Inner Loop Header: Depth=1
	movl	-4(%rdi), %eax
	cmpl	(%rdx), %eax
	jne	.LBB15_4
# %bb.5:                                #   in Loop: Header=BB15_3 Depth=1
	cmpq	%rsi, %rdi
	sete	%al
	je	.LBB15_7
# %bb.6:                                #   in Loop: Header=BB15_3 Depth=1
	movq	8(%rdx), %rdx
	addq	$4, %rdi
	cmpq	%rcx, %rdx
	jne	.LBB15_3
.LBB15_7:
                                        # kill: def $al killed $al killed $eax
	retq
.LBB15_4:
	xorl	%eax, %eax
                                        # kill: def $al killed $al killed $eax
	retq
.Lfunc_end15:
	.size	equal_generic_list_b, .Lfunc_end15-equal_generic_list_b
	.cfi_endproc
                                        # -- End function
	.globl	main                            # -- Begin function main
	.p2align	4
	.type	main,@function

===== copy_if_both_ra =====
copy_if_both_ra:                        # @copy_if_both_ra
	.cfi_startproc
# %bb.0:
	movq	%rdx, %rax
	cmpq	%rcx, %rdx
	je	.LBB8_43
# %bb.1:
	subq	%rdi, %rsi
	sarq	$2, %rsi
	cmpq	$16, %rsi
	setl	%dl
	movq	%rcx, %r8
	subq	%rax, %r8
	cmpq	$61, %r8
	setl	%r8b
	orb	%dl, %r8b
	jne	.LBB8_2
	.p2align	4
.LBB8_3:                                # =>This Inner Loop Header: Depth=1
	movl	(%rdi), %edx
	testb	$1, %dl
	jne	.LBB8_4
# %bb.5:                                #   in Loop: Header=BB8_3 Depth=1
	movl	4(%rdi), %edx
	testb	$1, %dl
	jne	.LBB8_6
.LBB8_7:                                #   in Loop: Header=BB8_3 Depth=1
	movl	8(%rdi), %edx
	testb	$1, %dl
	jne	.LBB8_8
.LBB8_9:                                #   in Loop: Header=BB8_3 Depth=1
	movl	12(%rdi), %edx
	testb	$1, %dl
	jne	.LBB8_10
.LBB8_11:                               #   in Loop: Header=BB8_3 Depth=1
	movl	16(%rdi), %edx
	testb	$1, %dl
	jne	.LBB8_12
.LBB8_13:                               #   in Loop: Header=BB8_3 Depth=1
	movl	20(%rdi), %edx
	testb	$1, %dl
	jne	.LBB8_14
.LBB8_15:                               #   in Loop: Header=BB8_3 Depth=1
	movl	24(%rdi), %edx
	testb	$1, %dl
	jne	.LBB8_16
.LBB8_17:                               #   in Loop: Header=BB8_3 Depth=1
	movl	28(%rdi), %edx
	testb	$1, %dl
	jne	.LBB8_18
.LBB8_19:                               #   in Loop: Header=BB8_3 Depth=1
	movl	32(%rdi), %edx
	testb	$1, %dl
	jne	.LBB8_20
.LBB8_21:                               #   in Loop: Header=BB8_3 Depth=1

===== copy_if_ra_dst_list_src =====
copy_if_ra_dst_list_src:                # @copy_if_ra_dst_list_src
	.cfi_startproc
# %bb.0:
	movq	%rdx, %rax
	cmpq	%rcx, %rdx
	je	.LBB9_13
# %bb.1:
	movq	%rcx, %rdx
	subq	%rax, %rdx
	cmpq	$61, %rdx
	setge	%dl
	cmpq	%rsi, %rdi
	setne	%r8b
	andb	%dl, %r8b
	cmpb	$1, %r8b
	jne	.LBB9_8
# %bb.2:
	movl	$16, %edx
	.p2align	4
.LBB9_5:                                # =>This Inner Loop Header: Depth=1
	movl	(%rdi), %r8d
	testb	$1, %r8b
	je	.LBB9_7
# %bb.6:                                #   in Loop: Header=BB9_5 Depth=1
	movl	%r8d, (%rax)
	addq	$4, %rax
.LBB9_7:                                #   in Loop: Header=BB9_5 Depth=1
	decq	%rdx
	movq	8(%rdi), %rdi
	setne	%r8b
	cmpq	%rsi, %rdi
	setne	%r9b
	testb	%r9b, %r8b
	jne	.LBB9_5
# %bb.3:                                #   in Loop: Header=BB9_5 Depth=1
	movq	%rcx, %rdx
	subq	%rax, %rdx
	cmpq	$61, %rdx
	jl	.LBB9_8
# %bb.4:                                #   in Loop: Header=BB9_5 Depth=1
	movl	$16, %edx
	cmpq	%rsi, %rdi
	jne	.LBB9_5
.LBB9_8:
	cmpq	%rcx, %rax
	jne	.LBB9_9
	jmp	.LBB9_13
	.p2align	4
.LBB9_12:                               #   in Loop: Header=BB9_9 Depth=1
	movq	8(%rdi), %rdi
.LBB9_9:                                # =>This Inner Loop Header: Depth=1
	cmpq	%rsi, %rdi
	je	.LBB9_13
# %bb.10:                               #   in Loop: Header=BB9_9 Depth=1
	movl	(%rdi), %edx

