	.text
	.file	"avx512vltest.cpp"
	.section	.rodata.cst8,"aM",@progbits,8
	.p2align	3               # -- Begin function _Z7loopdacllPjl
.LCPI0_0:
	.quad	3                       # 0x3
.LCPI0_1:
	.quad	2                       # 0x2
.LCPI0_2:
	.quad	1                       # 0x1
	.text
	.globl	_Z7loopdacllPjl
	.p2align	4, 0x90
	.type	_Z7loopdacllPjl,@function
_Z7loopdacllPjl:                        # @_Z7loopdacllPjl
	.cfi_startproc
# %bb.0:                                # %entry
	subq	$248, %rsp
	.cfi_def_cfa_offset 256
	movq	%rsi, %rax
	subq	%rdi, %rax
	cmpq	$1, %rax
	movq	%rdi, %rcx
	movq	%rdx, 240(%rsp)         # 8-byte Spill
	vmovups	%zmm0, 128(%rsp)        # 64-byte Spill
	movq	%rsi, 120(%rsp)         # 8-byte Spill
	movq	%rdi, 112(%rsp)         # 8-byte Spill
	movq	%rax, 104(%rsp)         # 8-byte Spill
	movq	%rcx, 96(%rsp)          # 8-byte Spill
	jle	.LBB0_5
# %bb.1:                                # %if.then.preheader
	movq	104(%rsp), %rax         # 8-byte Reload
	movq	112(%rsp), %rcx         # 8-byte Reload
	movq	%rax, 88(%rsp)          # 8-byte Spill
	movq	%rcx, 80(%rsp)          # 8-byte Spill
	jmp	.LBB0_2
.LBB0_2:                                # %if.then
                                        # =>This Inner Loop Header: Depth=1
	movq	80(%rsp), %rax          # 8-byte Reload
	movq	88(%rsp), %rcx          # 8-byte Reload
	shrq	$1, %rcx
	addq	%rax, %rcx
	movq	%rax, 72(%rsp)          # 8-byte Spill
	movq	%rcx, 64(%rsp)          # 8-byte Spill
# %bb.3:                                # %if.then.split
                                        #   in Loop: Header=BB0_2 Depth=1
	movq	72(%rsp), %rdi          # 8-byte Reload
	movq	64(%rsp), %rsi          # 8-byte Reload
	vmovups	128(%rsp), %zmm0        # 64-byte Reload
	movq	240(%rsp), %rdx         # 8-byte Reload
	callq	_Z7loopdacllPjl
# %bb.4:                                # %cont
                                        #   in Loop: Header=BB0_2 Depth=1
	movq	120(%rsp), %rax         # 8-byte Reload
	movq	64(%rsp), %rcx          # 8-byte Reload
	subq	%rcx, %rax
	cmpq	$1, %rax
	movq	64(%rsp), %rdx          # 8-byte Reload
	movq	%rax, 88(%rsp)          # 8-byte Spill
	movq	%rcx, 80(%rsp)          # 8-byte Spill
	movq	%rdx, 96(%rsp)          # 8-byte Spill
	jg	.LBB0_2
.LBB0_5:                                # %if.end
	movq	96(%rsp), %rax          # 8-byte Reload
	xorl	%ecx, %ecx
	movl	%ecx, %edx
	shlq	$11, %rax
	movq	%rax, 56(%rsp)          # 8-byte Spill
	movq	%rdx, 48(%rsp)          # 8-byte Spill
.LBB0_6:                                # %vector.body
                                        # =>This Inner Loop Header: Depth=1
	movq	48(%rsp), %rax          # 8-byte Reload
	movq	%rax, %rcx
	movq	56(%rsp), %rdx          # 8-byte Reload
	addq	%rdx, %rcx
	movq	240(%rsp), %rsi         # 8-byte Reload
	vpmovzxdq	(%rsi,%rcx,4), %zmm0 # zmm0 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero,mem[4],zero,mem[5],zero,mem[6],zero,mem[7],zero
	vmovups	128(%rsp), %zmm1        # 64-byte Reload
	vpcmpgtq	%zmm0, %zmm1, %k1
	vpsubq	%zmm1, %zmm0, %zmm2
	vpbroadcastq	.LCPI0_0(%rip), %zmm3 # zmm3 = [3,3,3,3,3,3,3,3]
	vpmullq	%zmm3, %zmm2, %zmm2
	vpbroadcastq	.LCPI0_1(%rip), %zmm4 # zmm4 = [2,2,2,2,2,2,2,2]
	vpaddq	%zmm4, %zmm2, %zmm2
	vpmuludq	%zmm3, %zmm0, %zmm0
	vpbroadcastq	.LCPI0_2(%rip), %zmm5 # zmm5 = [1,1,1,1,1,1,1,1]
	vpaddq	%zmm5, %zmm0, %zmm2 {%k1}
	vpmovqd	%zmm2, (%rsi,%rcx,4)
	movq	%rax, %rcx
	orq	$8, %rcx
	addq	%rdx, %rcx
	movq	%rcx, %rdi
	vpmovzxdq	(%rsi,%rcx,4), %zmm0 # zmm0 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero,mem[4],zero,mem[5],zero,mem[6],zero,mem[7],zero
	vpcmpgtq	%zmm0, %zmm1, %k1
	vpsubq	%zmm1, %zmm0, %zmm2
	vpmullq	%zmm3, %zmm2, %zmm2
	vpaddq	%zmm4, %zmm2, %zmm2
	vpmuludq	%zmm3, %zmm0, %zmm0
	vpaddq	%zmm5, %zmm0, %zmm2 {%k1}
	vpmovqd	%zmm2, %ymm6
	vmovdqu64	%ymm6, (%rsi,%rdi,4)
	addq	$16, %rax
	cmpq	$2048, %rax             # imm = 0x800
	movq	%rax, 48(%rsp)          # 8-byte Spill
	jne	.LBB0_6
# %bb.7:                                # %for.cond.cleanup
	addq	$248, %rsp
	.cfi_def_cfa_offset 8
	vzeroupper
	retq
.Lfunc_end0:
	.size	_Z7loopdacllPjl, .Lfunc_end0-_Z7loopdacllPjl
	.cfi_endproc
                                        # -- End function
	.section	.rodata.cst32,"aM",@progbits,32
	.p2align	5               # -- Begin function main
.LCPI1_0:
	.long	0                       # 0x0
	.long	1                       # 0x1
	.long	2                       # 0x2
	.long	3                       # 0x3
	.long	4                       # 0x4
	.long	5                       # 0x5
	.long	6                       # 0x6
	.long	7                       # 0x7
	.section	.rodata.cst4,"aM",@progbits,4
	.p2align	2
.LCPI1_1:
	.long	8                       # 0x8
.LCPI1_2:
	.long	16                      # 0x10
.LCPI1_3:
	.long	24                      # 0x18
.LCPI1_4:
	.long	32                      # 0x20
.LCPI1_5:
	.long	40                      # 0x28
.LCPI1_6:
	.long	48                      # 0x30
.LCPI1_7:
	.long	56                      # 0x38
.LCPI1_8:
	.long	64                      # 0x40
.LCPI1_9:
	.long	72                      # 0x48
.LCPI1_10:
	.long	80                      # 0x50
.LCPI1_11:
	.long	88                      # 0x58
.LCPI1_12:
	.long	96                      # 0x60
.LCPI1_13:
	.long	104                     # 0x68
.LCPI1_14:
	.long	112                     # 0x70
.LCPI1_15:
	.long	120                     # 0x78
.LCPI1_16:
	.long	128                     # 0x80
	.section	.rodata.cst8,"aM",@progbits,8
	.p2align	3
.LCPI1_17:
	.quad	3                       # 0x3
.LCPI1_18:
	.quad	2                       # 0x2
.LCPI1_19:
	.quad	1                       # 0x1
	.text
	.globl	main
	.p2align	4, 0x90
	.type	main,@function
main:                                   # @main
	.cfi_startproc
# %bb.0:                                # %entry
	subq	$760, %rsp              # imm = 0x2F8
	.cfi_def_cfa_offset 768
	movq	n12, %rax
	movq	%rax, %rcx
	shlq	$2, %rcx
	movl	%edi, 756(%rsp)         # 4-byte Spill
	movq	%rcx, %rdi
	movq	%rsi, 744(%rsp)         # 8-byte Spill
	movq	%rax, 736(%rsp)         # 8-byte Spill
	movq	%rcx, 728(%rsp)         # 8-byte Spill
	callq	malloc
	movq	%rax, %rcx
	movq	728(%rsp), %rdi         # 8-byte Reload
	movq	%rax, 720(%rsp)         # 8-byte Spill
	movq	%rcx, 712(%rsp)         # 8-byte Spill
	callq	malloc
	movq	%rax, %rcx
	movq	736(%rsp), %rdx         # 8-byte Reload
	cmpq	$0, %rdx
	setg	%r8b
	testb	$1, %r8b
	movq	%rax, 704(%rsp)         # 8-byte Spill
	movq	%rcx, 696(%rsp)         # 8-byte Spill
	movb	%r8b, 695(%rsp)         # 1-byte Spill
	jne	.LBB1_1
	jmp	.LBB1_9
.LBB1_1:                                # %for.body.preheader
	xorl	%eax, %eax
	movl	%eax, %ecx
	movq	736(%rsp), %rdx         # 8-byte Reload
	cmpq	$32, %rdx
	movq	%rcx, 680(%rsp)         # 8-byte Spill
	jae	.LBB1_3
.LBB1_2:                                # %for.body.preheader171
	movq	680(%rsp), %rax         # 8-byte Reload
	movq	%rax, 672(%rsp)         # 8-byte Spill
	jmp	.LBB1_18
.LBB1_3:                                # %vector.ph
	movq	736(%rsp), %rax         # 8-byte Reload
	andq	$-32, %rax
	movq	%rax, %rcx
	addq	$-32, %rcx
	movq	%rcx, %rdx
	shrq	$5, %rdx
	incq	%rdx
	movl	%edx, %esi
	andl	$3, %esi
	movl	%esi, %edi
	vmovdqa64	.LCPI1_0(%rip), %ymm0 # ymm0 = [0,1,2,3,4,5,6,7]
	xorl	%esi, %esi
	movl	%esi, %r8d
	subq	$96, %rcx
	movq	%rax, 664(%rsp)         # 8-byte Spill
	movq	%rdx, 656(%rsp)         # 8-byte Spill
	movq	%rdi, 648(%rsp)         # 8-byte Spill
	movq	%r8, 640(%rsp)          # 8-byte Spill
	vmovups	%ymm0, 608(%rsp)        # 32-byte Spill
	jb	.LBB1_6
	jmp	.LBB1_4
.LBB1_4:                                # %vector.ph.new
	movq	656(%rsp), %rax         # 8-byte Reload
	movq	648(%rsp), %rcx         # 8-byte Reload
	subq	%rcx, %rax
	vmovdqa64	.LCPI1_0(%rip), %ymm0 # ymm0 = [0,1,2,3,4,5,6,7]
	xorl	%edx, %edx
	movl	%edx, %esi
	movq	%rsi, 600(%rsp)         # 8-byte Spill
	vmovups	%ymm0, 544(%rsp)        # 32-byte Spill
	movq	%rax, 536(%rsp)         # 8-byte Spill
	jmp	.LBB1_5
.LBB1_5:                                # %vector.body
                                        # =>This Inner Loop Header: Depth=1
	movq	536(%rsp), %rax         # 8-byte Reload
	vmovups	544(%rsp), %ymm0        # 32-byte Reload
	movq	600(%rsp), %rcx         # 8-byte Reload
	vpbroadcastd	.LCPI1_1(%rip), %ymm1 # ymm1 = [8,8,8,8,8,8,8,8]
	vpaddd	%ymm1, %ymm0, %ymm1
	vpbroadcastd	.LCPI1_2(%rip), %ymm2 # ymm2 = [16,16,16,16,16,16,16,16]
	vpaddd	%ymm2, %ymm0, %ymm2
	vpbroadcastd	.LCPI1_3(%rip), %ymm3 # ymm3 = [24,24,24,24,24,24,24,24]
	vpaddd	%ymm3, %ymm0, %ymm3
	movq	%rcx, %rdx
	shlq	$2, %rdx
	movq	712(%rsp), %rsi         # 8-byte Reload
	vmovdqu64	%ymm0, (%rsi,%rcx,4)
	vmovdqu64	%ymm1, 32(%rsi,%rcx,4)
	vmovdqu64	%ymm2, 64(%rsi,%rcx,4)
	vmovdqu64	%ymm3, 96(%rsi,%rcx,4)
	vpbroadcastd	.LCPI1_4(%rip), %ymm1 # ymm1 = [32,32,32,32,32,32,32,32]
	vpaddd	%ymm1, %ymm0, %ymm1
	vpbroadcastd	.LCPI1_5(%rip), %ymm2 # ymm2 = [40,40,40,40,40,40,40,40]
	vpaddd	%ymm2, %ymm0, %ymm2
	vpbroadcastd	.LCPI1_6(%rip), %ymm3 # ymm3 = [48,48,48,48,48,48,48,48]
	vpaddd	%ymm3, %ymm0, %ymm3
	vpbroadcastd	.LCPI1_7(%rip), %ymm4 # ymm4 = [56,56,56,56,56,56,56,56]
	vpaddd	%ymm4, %ymm0, %ymm4
	movq	%rdx, %rdi
	orq	$128, %rdi
	vmovdqu64	%ymm1, (%rsi,%rdi)
	vmovdqu64	%ymm2, 32(%rsi,%rdi)
	vmovdqu64	%ymm3, 64(%rsi,%rdi)
	vmovdqu64	%ymm4, 96(%rsi,%rdi)
	vpbroadcastd	.LCPI1_8(%rip), %ymm1 # ymm1 = [64,64,64,64,64,64,64,64]
	vpaddd	%ymm1, %ymm0, %ymm1
	vpbroadcastd	.LCPI1_9(%rip), %ymm2 # ymm2 = [72,72,72,72,72,72,72,72]
	vpaddd	%ymm2, %ymm0, %ymm2
	vpbroadcastd	.LCPI1_10(%rip), %ymm3 # ymm3 = [80,80,80,80,80,80,80,80]
	vpaddd	%ymm3, %ymm0, %ymm3
	vpbroadcastd	.LCPI1_11(%rip), %ymm4 # ymm4 = [88,88,88,88,88,88,88,88]
	vpaddd	%ymm4, %ymm0, %ymm4
	movq	%rdx, %rdi
	orq	$256, %rdi              # imm = 0x100
	vmovdqu64	%ymm1, (%rsi,%rdi)
	vmovdqu64	%ymm2, 32(%rsi,%rdi)
	vmovdqu64	%ymm3, 64(%rsi,%rdi)
	vmovdqu64	%ymm4, 96(%rsi,%rdi)
	vpbroadcastd	.LCPI1_12(%rip), %ymm1 # ymm1 = [96,96,96,96,96,96,96,96]
	vpaddd	%ymm1, %ymm0, %ymm1
	vpbroadcastd	.LCPI1_13(%rip), %ymm2 # ymm2 = [104,104,104,104,104,104,104,104]
	vpaddd	%ymm2, %ymm0, %ymm2
	vpbroadcastd	.LCPI1_14(%rip), %ymm3 # ymm3 = [112,112,112,112,112,112,112,112]
	vpaddd	%ymm3, %ymm0, %ymm3
	vpbroadcastd	.LCPI1_15(%rip), %ymm4 # ymm4 = [120,120,120,120,120,120,120,120]
	vpaddd	%ymm4, %ymm0, %ymm4
	orq	$384, %rdx              # imm = 0x180
	vmovdqu64	%ymm1, (%rsi,%rdx)
	vmovdqu64	%ymm2, 32(%rsi,%rdx)
	vmovdqu64	%ymm3, 64(%rsi,%rdx)
	vmovdqu64	%ymm4, 96(%rsi,%rdx)
	subq	$-128, %rcx
	vpbroadcastd	.LCPI1_16(%rip), %ymm1 # ymm1 = [128,128,128,128,128,128,128,128]
	vpaddd	%ymm1, %ymm0, %ymm0
	addq	$-4, %rax
	cmpq	$0, %rax
	movq	%rcx, %rdx
	vmovaps	%ymm0, %ymm1
	movq	%rax, 536(%rsp)         # 8-byte Spill
	vmovups	%ymm1, 544(%rsp)        # 32-byte Spill
	movq	%rdx, 600(%rsp)         # 8-byte Spill
	movq	%rcx, 640(%rsp)         # 8-byte Spill
	vmovups	%ymm0, 608(%rsp)        # 32-byte Spill
	jne	.LBB1_5
.LBB1_6:                                # %middle.block.unr-lcssa
	vmovups	608(%rsp), %ymm0        # 32-byte Reload
	movq	640(%rsp), %rax         # 8-byte Reload
	movq	648(%rsp), %rcx         # 8-byte Reload
	cmpq	$0, %rcx
	movq	%rax, 528(%rsp)         # 8-byte Spill
	vmovups	%ymm0, 480(%rsp)        # 32-byte Spill
	movq	%rcx, 472(%rsp)         # 8-byte Spill
	je	.LBB1_8
.LBB1_7:                                # %vector.body.epil
                                        # =>This Inner Loop Header: Depth=1
	movq	472(%rsp), %rax         # 8-byte Reload
	vmovups	480(%rsp), %ymm0        # 32-byte Reload
	movq	528(%rsp), %rcx         # 8-byte Reload
	vpbroadcastd	.LCPI1_1(%rip), %ymm1 # ymm1 = [8,8,8,8,8,8,8,8]
	vpaddd	%ymm1, %ymm0, %ymm1
	vpbroadcastd	.LCPI1_2(%rip), %ymm2 # ymm2 = [16,16,16,16,16,16,16,16]
	vpaddd	%ymm2, %ymm0, %ymm2
	vpbroadcastd	.LCPI1_3(%rip), %ymm3 # ymm3 = [24,24,24,24,24,24,24,24]
	vpaddd	%ymm3, %ymm0, %ymm3
	movq	712(%rsp), %rdx         # 8-byte Reload
	vmovdqu64	%ymm0, (%rdx,%rcx,4)
	vmovdqu64	%ymm1, 32(%rdx,%rcx,4)
	vmovdqu64	%ymm2, 64(%rdx,%rcx,4)
	vmovdqu64	%ymm3, 96(%rdx,%rcx,4)
	addq	$32, %rcx
	vpbroadcastd	.LCPI1_4(%rip), %ymm1 # ymm1 = [32,32,32,32,32,32,32,32]
	vpaddd	%ymm1, %ymm0, %ymm0
	addq	$-1, %rax
	cmpq	$0, %rax
	movq	%rax, 472(%rsp)         # 8-byte Spill
	vmovups	%ymm0, 480(%rsp)        # 32-byte Spill
	movq	%rcx, 528(%rsp)         # 8-byte Spill
	jne	.LBB1_7
.LBB1_8:                                # %middle.block
	movq	736(%rsp), %rax         # 8-byte Reload
	movq	664(%rsp), %rcx         # 8-byte Reload
	cmpq	%rcx, %rax
	movq	%rcx, 680(%rsp)         # 8-byte Spill
	je	.LBB1_10
	jmp	.LBB1_2
.LBB1_9:                                # %for.cond7.preheader.for.cond.cleanup9_crit_edge
	movq	n1, %rax
	movq	%rax, 464(%rsp)         # 8-byte Spill
	jmp	.LBB1_19
.LBB1_10:                               # %for.body10.lr.ph
	xorl	%eax, %eax
	movl	%eax, %ecx
	movq	n1, %rdx
	movq	736(%rsp), %rsi         # 8-byte Reload
	cmpq	$8, %rsi
	movq	%rdx, 456(%rsp)         # 8-byte Spill
	movq	%rcx, 448(%rsp)         # 8-byte Spill
	jae	.LBB1_12
.LBB1_11:                               # %for.body10.preheader
	movq	448(%rsp), %rax         # 8-byte Reload
	movq	%rax, 440(%rsp)         # 8-byte Spill
	jmp	.LBB1_28
.LBB1_12:                               # %vector.ph142
	xorl	%eax, %eax
	movl	%eax, %ecx
	movq	736(%rsp), %rdx         # 8-byte Reload
	andq	$-8, %rdx
	movq	456(%rsp), %rsi         # 8-byte Reload
	vpbroadcastq	%rsi, %ymm0
	vmovaps	%ymm0, %ymm1
	movq	%rdx, %rdi
	addq	$-8, %rdi
	movq	%rdi, %r8
	shrq	$3, %r8
	addq	$1, %r8
	movq	%r8, %r9
	andq	$3, %r9
	cmpq	$24, %rdi
	movq	%rdx, 432(%rsp)         # 8-byte Spill
	vmovups	%ymm0, 384(%rsp)        # 32-byte Spill
	vmovups	%ymm1, 352(%rsp)        # 32-byte Spill
	movq	%r8, 344(%rsp)          # 8-byte Spill
	movq	%r9, 336(%rsp)          # 8-byte Spill
	movq	%rcx, 328(%rsp)         # 8-byte Spill
	jb	.LBB1_15
# %bb.13:                               # %vector.ph142.new
	xorl	%eax, %eax
	movl	%eax, %ecx
	movq	344(%rsp), %rdx         # 8-byte Reload
	movq	336(%rsp), %rsi         # 8-byte Reload
	subq	%rsi, %rdx
	movq	%rcx, 320(%rsp)         # 8-byte Spill
	movq	%rdx, 312(%rsp)         # 8-byte Spill
.LBB1_14:                               # %vector.body140
                                        # =>This Inner Loop Header: Depth=1
	movq	312(%rsp), %rax         # 8-byte Reload
	movq	320(%rsp), %rcx         # 8-byte Reload
	movq	%rcx, %rdx
	shlq	$2, %rdx
	movq	712(%rsp), %rsi         # 8-byte Reload
	vpmovzxdq	(%rsi,%rcx,4), %ymm0 # ymm0 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpmovzxdq	16(%rsi,%rcx,4), %ymm1 # ymm1 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vmovups	384(%rsp), %ymm2        # 32-byte Reload
	vpcmpgtq	%ymm1, %ymm2, %k1
	vmovups	352(%rsp), %ymm3        # 32-byte Reload
	vpcmpgtq	%ymm0, %ymm3, %k2
	vpsubq	%ymm2, %ymm1, %ymm4
	vpsubq	%ymm3, %ymm0, %ymm5
	vpbroadcastq	.LCPI1_17(%rip), %ymm6 # ymm6 = [3,3,3,3]
	vpmullq	%ymm6, %ymm5, %ymm5
	vpmullq	%ymm6, %ymm4, %ymm4
	vpbroadcastq	.LCPI1_18(%rip), %ymm7 # ymm7 = [2,2,2,2]
	vpaddq	%ymm7, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm5, %ymm5
	vpmuludq	%ymm6, %ymm1, %ymm1
	vpmuludq	%ymm6, %ymm0, %ymm0
	vpbroadcastq	.LCPI1_19(%rip), %ymm8 # ymm8 = [1,1,1,1]
	vpaddq	%ymm8, %ymm0, %ymm5 {%k2}
	vpaddq	%ymm8, %ymm1, %ymm4 {%k1}
	movq	696(%rsp), %rdi         # 8-byte Reload
	vpmovqd	%ymm4, 16(%rdi,%rcx,4)
	vpmovqd	%ymm5, (%rdi,%rcx,4)
	movq	%rdx, %r8
	orq	$32, %r8
	vpmovzxdq	(%rsi,%r8), %ymm0 # ymm0 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpmovzxdq	16(%rsi,%r8), %ymm1 # ymm1 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpcmpgtq	%ymm1, %ymm2, %k1
	vpcmpgtq	%ymm0, %ymm3, %k2
	vpsubq	%ymm2, %ymm1, %ymm4
	vpsubq	%ymm3, %ymm0, %ymm5
	vpmullq	%ymm6, %ymm5, %ymm5
	vpmullq	%ymm6, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm5, %ymm5
	vpmuludq	%ymm6, %ymm1, %ymm1
	vpmuludq	%ymm6, %ymm0, %ymm0
	vpaddq	%ymm8, %ymm0, %ymm5 {%k2}
	vpaddq	%ymm8, %ymm1, %ymm4 {%k1}
	vpmovqd	%ymm4, 16(%rdi,%r8)
	vpmovqd	%ymm5, (%rdi,%r8)
	orq	$64, %rdx
	vpmovzxdq	(%rsi,%rdx), %ymm0 # ymm0 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpmovzxdq	16(%rsi,%rdx), %ymm1 # ymm1 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpcmpgtq	%ymm1, %ymm2, %k1
	vpcmpgtq	%ymm0, %ymm3, %k2
	vpsubq	%ymm2, %ymm1, %ymm4
	vpsubq	%ymm3, %ymm0, %ymm5
	vpmullq	%ymm6, %ymm5, %ymm5
	vpmullq	%ymm6, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm5, %ymm5
	vpmuludq	%ymm6, %ymm1, %ymm1
	vpmuludq	%ymm6, %ymm0, %ymm0
	vpaddq	%ymm8, %ymm0, %ymm5 {%k2}
	vpaddq	%ymm8, %ymm1, %ymm4 {%k1}
	vpmovqd	%ymm4, 16(%rdi,%rdx)
	vpmovqd	%ymm5, (%rdi,%rdx)
	movq	%rcx, %rdx
	orq	$24, %rdx
	movq	%rdx, %r8
	vpmovzxdq	16(%rsi,%rdx,4), %ymm0 # ymm0 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpmovzxdq	(%rsi,%rdx,4), %ymm1 # ymm1 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpcmpgtq	%ymm1, %ymm3, %k1
	vpcmpgtq	%ymm0, %ymm2, %k2
	vpsubq	%ymm3, %ymm1, %ymm4
	vpsubq	%ymm2, %ymm0, %ymm5
	vpmullq	%ymm6, %ymm5, %ymm5
	vpmullq	%ymm6, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm5, %ymm5
	vpmuludq	%ymm6, %ymm1, %ymm1
	vpmuludq	%ymm6, %ymm0, %ymm0
	vpaddq	%ymm8, %ymm0, %ymm5 {%k2}
	vpaddq	%ymm8, %ymm1, %ymm4 {%k1}
	vpmovqd	%ymm4, %xmm9
                                        # implicit-def: $ymm0
	vmovaps	%xmm9, %xmm0
	vpmovqd	%ymm5, %xmm9
	vinserti32x4	$1, %xmm9, %ymm0, %ymm0
	vmovdqu64	%ymm0, (%rdi,%r8,4)
	addq	$32, %rcx
	addq	$-4, %rax
	cmpq	$0, %rax
	movq	%rcx, %rdx
	movq	%rax, 312(%rsp)         # 8-byte Spill
	movq	%rdx, 320(%rsp)         # 8-byte Spill
	movq	%rcx, 328(%rsp)         # 8-byte Spill
	jne	.LBB1_14
.LBB1_15:                               # %middle.block138.unr-lcssa
	movq	328(%rsp), %rax         # 8-byte Reload
	movq	336(%rsp), %rcx         # 8-byte Reload
	cmpq	$0, %rcx
	movq	%rax, 304(%rsp)         # 8-byte Spill
	movq	%rcx, 296(%rsp)         # 8-byte Spill
	je	.LBB1_17
.LBB1_16:                               # %vector.body140.epil
                                        # =>This Inner Loop Header: Depth=1
	movq	296(%rsp), %rax         # 8-byte Reload
	movq	304(%rsp), %rcx         # 8-byte Reload
	movq	712(%rsp), %rdx         # 8-byte Reload
	vpmovzxdq	16(%rdx,%rcx,4), %ymm0 # ymm0 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpmovzxdq	(%rdx,%rcx,4), %ymm1 # ymm1 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vmovups	352(%rsp), %ymm2        # 32-byte Reload
	vpcmpgtq	%ymm1, %ymm2, %k1
	vmovups	384(%rsp), %ymm3        # 32-byte Reload
	vpcmpgtq	%ymm0, %ymm3, %k2
	vpsubq	%ymm2, %ymm1, %ymm4
	vpsubq	%ymm3, %ymm0, %ymm5
	vpbroadcastq	.LCPI1_17(%rip), %ymm6 # ymm6 = [3,3,3,3]
	vpmullq	%ymm6, %ymm5, %ymm5
	vpmullq	%ymm6, %ymm4, %ymm4
	vpbroadcastq	.LCPI1_18(%rip), %ymm7 # ymm7 = [2,2,2,2]
	vpaddq	%ymm7, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm5, %ymm5
	vpmuludq	%ymm6, %ymm1, %ymm1
	vpmuludq	%ymm6, %ymm0, %ymm0
	vpbroadcastq	.LCPI1_19(%rip), %ymm6 # ymm6 = [1,1,1,1]
	vpaddq	%ymm6, %ymm0, %ymm5 {%k2}
	vpaddq	%ymm6, %ymm1, %ymm4 {%k1}
	vpmovqd	%ymm4, %xmm8
                                        # implicit-def: $ymm0
	vmovaps	%xmm8, %xmm0
	vpmovqd	%ymm5, %xmm8
	vinserti32x4	$1, %xmm8, %ymm0, %ymm0
	movq	696(%rsp), %rsi         # 8-byte Reload
	vmovdqu64	%ymm0, (%rsi,%rcx,4)
	addq	$8, %rcx
	addq	$-1, %rax
	cmpq	$0, %rax
	movq	%rax, 296(%rsp)         # 8-byte Spill
	movq	%rcx, 304(%rsp)         # 8-byte Spill
	jne	.LBB1_16
.LBB1_17:                               # %middle.block138
	movq	736(%rsp), %rax         # 8-byte Reload
	movq	432(%rsp), %rcx         # 8-byte Reload
	cmpq	%rcx, %rax
	movq	456(%rsp), %rdx         # 8-byte Reload
	movq	%rcx, 448(%rsp)         # 8-byte Spill
	movq	%rdx, 464(%rsp)         # 8-byte Spill
	je	.LBB1_19
	jmp	.LBB1_11
.LBB1_18:                               # %for.body
                                        # =>This Inner Loop Header: Depth=1
	movq	672(%rsp), %rax         # 8-byte Reload
	movl	%eax, %ecx
	movq	712(%rsp), %rdx         # 8-byte Reload
	movl	%ecx, (%rdx,%rax,4)
	addq	$1, %rax
	movq	736(%rsp), %rsi         # 8-byte Reload
	cmpq	%rsi, %rax
	movq	%rax, 672(%rsp)         # 8-byte Spill
	je	.LBB1_10
	jmp	.LBB1_18
.LBB1_19:                               # %for.cond.cleanup9
	movq	464(%rsp), %rax         # 8-byte Reload
	xorl	%ecx, %ecx
	movl	%ecx, %edx
	movq	736(%rsp), %rsi         # 8-byte Reload
	addq	$2047, %rsi             # imm = 0x7FF
	movq	736(%rsp), %rdi         # 8-byte Reload
	testq	%rdi, %rdi
	cmovsq	%rsi, %rdi
	movq	%rdi, %rsi
	andq	$-2048, %rsi            # imm = 0xF800
	movq	736(%rsp), %r8          # 8-byte Reload
	subq	%rsi, %r8
	sarq	$11, %rdi
	vpbroadcastq	%rax, %ymm0
	vmovaps	%ymm0, %ymm1
	xorl	%ecx, %ecx
	movl	%ecx, %esi
	movq	%rdi, 288(%rsp)         # 8-byte Spill
	movq	%rsi, %rdi
	movq	288(%rsp), %rsi         # 8-byte Reload
	vmovups	%ymm0, 256(%rsp)        # 32-byte Spill
	vmovaps	%ymm1, %ymm0
	vmovups	256(%rsp), %ymm1        # 32-byte Reload
	movq	712(%rsp), %r9          # 8-byte Reload
	movq	%rdx, 248(%rsp)         # 8-byte Spill
	movq	%r9, %rdx
	movq	%rax, 240(%rsp)         # 8-byte Spill
	movq	%r8, 232(%rsp)          # 8-byte Spill
	callq	_Z7loopdacllPjl
	movq	232(%rsp), %rax         # 8-byte Reload
	cmpq	$0, %rax
	jle	.LBB1_29
# %bb.20:                               # %for.body35.preheader
	movq	736(%rsp), %rax         # 8-byte Reload
	movq	232(%rsp), %rcx         # 8-byte Reload
	subq	%rcx, %rax
	movq	736(%rsp), %rdx         # 8-byte Reload
	addq	$1, %rdx
	subq	%rcx, %rdx
	movq	736(%rsp), %rsi         # 8-byte Reload
	cmpq	%rdx, %rsi
	cmovgq	%rsi, %rdx
	subq	%rsi, %rcx
	addq	%rcx, %rdx
	cmpq	$8, %rdx
	movq	%rax, %rcx
	movq	%rax, 224(%rsp)         # 8-byte Spill
	movq	%rdx, 216(%rsp)         # 8-byte Spill
	movq	%rcx, 208(%rsp)         # 8-byte Spill
	jae	.LBB1_22
.LBB1_21:                               # %for.body35.preheader170
	movq	208(%rsp), %rax         # 8-byte Reload
	movq	%rax, 200(%rsp)         # 8-byte Spill
	jmp	.LBB1_30
.LBB1_22:                               # %vector.ph155
	xorl	%eax, %eax
	movl	%eax, %ecx
	movq	216(%rsp), %rdx         # 8-byte Reload
	andq	$-8, %rdx
	movq	%rdx, %rsi
	movq	224(%rsp), %rdi         # 8-byte Reload
	addq	%rdi, %rsi
	movq	240(%rsp), %r8          # 8-byte Reload
	vpbroadcastq	%r8, %ymm0
	vmovaps	%ymm0, %ymm1
	movq	%rdx, %r9
	addq	$-8, %r9
	movq	%r9, %r10
	shrq	$3, %r10
	addq	$1, %r10
	movq	%r10, %r11
	andq	$1, %r11
	cmpq	$0, %r9
	movq	%rdx, 192(%rsp)         # 8-byte Spill
	movq	%rsi, 184(%rsp)         # 8-byte Spill
	vmovups	%ymm0, 128(%rsp)        # 32-byte Spill
	vmovups	%ymm1, 96(%rsp)         # 32-byte Spill
	movq	%r10, 88(%rsp)          # 8-byte Spill
	movq	%r11, 80(%rsp)          # 8-byte Spill
	movq	%rcx, 72(%rsp)          # 8-byte Spill
	je	.LBB1_25
# %bb.23:                               # %vector.ph155.new
	xorl	%eax, %eax
	movl	%eax, %ecx
	movq	88(%rsp), %rdx          # 8-byte Reload
	movq	80(%rsp), %rsi          # 8-byte Reload
	subq	%rsi, %rdx
	movq	%rcx, 64(%rsp)          # 8-byte Spill
	movq	%rdx, 56(%rsp)          # 8-byte Spill
.LBB1_24:                               # %vector.body153
                                        # =>This Inner Loop Header: Depth=1
	movq	56(%rsp), %rax          # 8-byte Reload
	movq	64(%rsp), %rcx          # 8-byte Reload
	movq	%rcx, %rdx
	movq	224(%rsp), %rsi         # 8-byte Reload
	addq	%rsi, %rdx
	movq	712(%rsp), %rdi         # 8-byte Reload
	vpmovzxdq	(%rdi,%rdx,4), %ymm0 # ymm0 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpmovzxdq	16(%rdi,%rdx,4), %ymm1 # ymm1 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vmovups	128(%rsp), %ymm2        # 32-byte Reload
	vpcmpgtq	%ymm1, %ymm2, %k1
	vmovups	96(%rsp), %ymm3         # 32-byte Reload
	vpcmpgtq	%ymm0, %ymm3, %k2
	vpsubq	%ymm2, %ymm1, %ymm4
	vpsubq	%ymm3, %ymm0, %ymm5
	vpbroadcastq	.LCPI1_17(%rip), %ymm6 # ymm6 = [3,3,3,3]
	vpmullq	%ymm6, %ymm5, %ymm5
	vpmullq	%ymm6, %ymm4, %ymm4
	vpbroadcastq	.LCPI1_18(%rip), %ymm7 # ymm7 = [2,2,2,2]
	vpaddq	%ymm7, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm5, %ymm5
	vpmuludq	%ymm6, %ymm1, %ymm1
	vpmuludq	%ymm6, %ymm0, %ymm0
	vpbroadcastq	.LCPI1_19(%rip), %ymm8 # ymm8 = [1,1,1,1]
	vpaddq	%ymm8, %ymm0, %ymm5 {%k2}
	vpaddq	%ymm8, %ymm1, %ymm4 {%k1}
	vpmovqd	%ymm4, 16(%rdi,%rdx,4)
	vpmovqd	%ymm5, (%rdi,%rdx,4)
	movq	%rcx, %rdx
	orq	$8, %rdx
	addq	%rsi, %rdx
	movq	%rdx, %r8
	vpmovzxdq	16(%rdi,%rdx,4), %ymm0 # ymm0 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpmovzxdq	(%rdi,%rdx,4), %ymm1 # ymm1 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpcmpgtq	%ymm1, %ymm3, %k1
	vpcmpgtq	%ymm0, %ymm2, %k2
	vpsubq	%ymm3, %ymm1, %ymm4
	vpsubq	%ymm2, %ymm0, %ymm5
	vpmullq	%ymm6, %ymm5, %ymm5
	vpmullq	%ymm6, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm5, %ymm5
	vpmuludq	%ymm6, %ymm1, %ymm1
	vpmuludq	%ymm6, %ymm0, %ymm0
	vpaddq	%ymm8, %ymm0, %ymm5 {%k2}
	vpaddq	%ymm8, %ymm1, %ymm4 {%k1}
	vpmovqd	%ymm4, %xmm9
                                        # implicit-def: $ymm0
	vmovaps	%xmm9, %xmm0
	vpmovqd	%ymm5, %xmm9
	vinserti32x4	$1, %xmm9, %ymm0, %ymm0
	vmovdqu64	%ymm0, (%rdi,%r8,4)
	addq	$16, %rcx
	addq	$-2, %rax
	cmpq	$0, %rax
	movq	%rcx, %rdx
	movq	%rax, 56(%rsp)          # 8-byte Spill
	movq	%rdx, 64(%rsp)          # 8-byte Spill
	movq	%rcx, 72(%rsp)          # 8-byte Spill
	jne	.LBB1_24
.LBB1_25:                               # %middle.block151.unr-lcssa
	movq	72(%rsp), %rax          # 8-byte Reload
	movq	80(%rsp), %rcx          # 8-byte Reload
	cmpq	$0, %rcx
	movq	%rax, 48(%rsp)          # 8-byte Spill
	je	.LBB1_27
# %bb.26:                               # %vector.body153.epil
	movq	48(%rsp), %rax          # 8-byte Reload
	movq	224(%rsp), %rcx         # 8-byte Reload
	addq	%rcx, %rax
	movq	%rax, %rdx
	movq	712(%rsp), %rsi         # 8-byte Reload
	vpmovzxdq	16(%rsi,%rax,4), %ymm0 # ymm0 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vpmovzxdq	(%rsi,%rax,4), %ymm1 # ymm1 = mem[0],zero,mem[1],zero,mem[2],zero,mem[3],zero
	vmovups	96(%rsp), %ymm2         # 32-byte Reload
	vpcmpgtq	%ymm1, %ymm2, %k1
	vmovups	128(%rsp), %ymm3        # 32-byte Reload
	vpcmpgtq	%ymm0, %ymm3, %k2
	vpsubq	%ymm2, %ymm1, %ymm4
	vpsubq	%ymm3, %ymm0, %ymm5
	vpbroadcastq	.LCPI1_17(%rip), %ymm6 # ymm6 = [3,3,3,3]
	vpmullq	%ymm6, %ymm5, %ymm5
	vpmullq	%ymm6, %ymm4, %ymm4
	vpbroadcastq	.LCPI1_18(%rip), %ymm7 # ymm7 = [2,2,2,2]
	vpaddq	%ymm7, %ymm4, %ymm4
	vpaddq	%ymm7, %ymm5, %ymm5
	vpmuludq	%ymm6, %ymm1, %ymm1
	vpmuludq	%ymm6, %ymm0, %ymm0
	vpbroadcastq	.LCPI1_19(%rip), %ymm6 # ymm6 = [1,1,1,1]
	vpaddq	%ymm6, %ymm0, %ymm5 {%k2}
	vpaddq	%ymm6, %ymm1, %ymm4 {%k1}
	vpmovqd	%ymm4, %xmm8
                                        # implicit-def: $ymm0
	vmovaps	%xmm8, %xmm0
	vpmovqd	%ymm5, %xmm8
	vinserti32x4	$1, %xmm8, %ymm0, %ymm0
	vmovdqu64	%ymm0, (%rsi,%rdx,4)
.LBB1_27:                               # %middle.block151
	movq	216(%rsp), %rax         # 8-byte Reload
	movq	192(%rsp), %rcx         # 8-byte Reload
	cmpq	%rcx, %rax
	movq	184(%rsp), %rdx         # 8-byte Reload
	movq	%rdx, 208(%rsp)         # 8-byte Spill
	je	.LBB1_29
	jmp	.LBB1_21
.LBB1_28:                               # %for.body10
                                        # =>This Inner Loop Header: Depth=1
	movq	440(%rsp), %rax         # 8-byte Reload
	xorl	%ecx, %ecx
	movl	%ecx, %edx
	movq	712(%rsp), %rsi         # 8-byte Reload
	movl	(%rsi,%rax,4), %ecx
	movl	%ecx, %edi
	movq	456(%rsp), %r8          # 8-byte Reload
	cmpq	%rdi, %r8
	cmovgq	%rdx, %r8
	movq	%rdi, %rdx
	subq	%r8, %rdx
	movq	456(%rsp), %r8          # 8-byte Reload
	cmpq	%rdi, %r8
	movl	$1, %edi
	movl	$2, %r9d
	cmovgq	%rdi, %r9
	imulq	$3, %rdx, %rdx
	addq	%r9, %rdx
                                        # kill: def $edx killed $edx killed $rdx
	movq	696(%rsp), %rdi         # 8-byte Reload
	movl	%edx, (%rdi,%rax,4)
	addq	$1, %rax
	movq	736(%rsp), %r9          # 8-byte Reload
	cmpq	%r9, %rax
	movq	%rax, 440(%rsp)         # 8-byte Spill
	movq	%r8, 464(%rsp)          # 8-byte Spill
	je	.LBB1_19
	jmp	.LBB1_28
.LBB1_29:                               # %for.cond55.preheader
	xorl	%eax, %eax
	movl	%eax, %ecx
	xorl	%eax, %eax
                                        # kill: def $al killed $al killed $eax
	movb	695(%rsp), %dl          # 1-byte Reload
	testb	$1, %dl
	movq	%rcx, 40(%rsp)          # 8-byte Spill
	movb	%al, 39(%rsp)           # 1-byte Spill
	jne	.LBB1_32
	jmp	.LBB1_31
.LBB1_30:                               # %for.body35
                                        # =>This Inner Loop Header: Depth=1
	movq	200(%rsp), %rax         # 8-byte Reload
	xorl	%ecx, %ecx
	movl	%ecx, %edx
	movq	712(%rsp), %rsi         # 8-byte Reload
	movl	(%rsi,%rax,4), %ecx
	movl	%ecx, %edi
	movq	240(%rsp), %r8          # 8-byte Reload
	cmpq	%rdi, %r8
	cmovgq	%rdx, %r8
	movq	%rdi, %rdx
	subq	%r8, %rdx
	movq	240(%rsp), %r8          # 8-byte Reload
	cmpq	%rdi, %r8
	movl	$1, %edi
	movl	$2, %r9d
	cmovgq	%rdi, %r9
	imulq	$3, %rdx, %rdx
	addq	%r9, %rdx
                                        # kill: def $edx killed $edx killed $rdx
	movl	%edx, (%rsi,%rax,4)
	addq	$1, %rax
	movq	736(%rsp), %rdi         # 8-byte Reload
	cmpq	%rdi, %rax
	movq	%rax, 200(%rsp)         # 8-byte Spill
	jl	.LBB1_30
	jmp	.LBB1_29
.LBB1_31:                               # %for.cond.cleanup57
	movq	720(%rsp), %rdi         # 8-byte Reload
	vzeroupper
	callq	free
	movq	704(%rsp), %rdi         # 8-byte Reload
	callq	free
	xorl	%eax, %eax
	addq	$760, %rsp              # imm = 0x2F8
	.cfi_def_cfa_offset 8
	retq
.LBB1_32:                               # %for.body58
                                        # =>This Inner Loop Header: Depth=1
	.cfi_def_cfa_offset 768
	movb	39(%rsp), %al           # 1-byte Reload
	movq	40(%rsp), %rcx          # 8-byte Reload
	movq	696(%rsp), %rdx         # 8-byte Reload
	movl	(%rdx,%rcx,4), %esi
	movq	712(%rsp), %rdi         # 8-byte Reload
	movl	(%rdi,%rcx,4), %r8d
	cmpl	%r8d, %esi
	movb	%al, 38(%rsp)           # 1-byte Spill
	movq	%rcx, 24(%rsp)          # 8-byte Spill
	movl	%esi, 20(%rsp)          # 4-byte Spill
	movl	%r8d, 16(%rsp)          # 4-byte Spill
	je	.LBB1_34
# %bb.33:                               # %if.then
                                        #   in Loop: Header=BB1_32 Depth=1
	movq	stderr, %rdi
	movabsq	$.L.str.1, %rsi
	movq	24(%rsp), %rdx          # 8-byte Reload
	movl	16(%rsp), %ecx          # 4-byte Reload
	movl	20(%rsp), %r8d          # 4-byte Reload
	movb	$0, %al
	vzeroupper
	callq	fprintf
	movb	$1, %r9b
	movb	%r9b, 15(%rsp)          # 1-byte Spill
	jmp	.LBB1_36
.LBB1_34:                               # %if.else
                                        #   in Loop: Header=BB1_32 Depth=1
	movb	38(%rsp), %al           # 1-byte Reload
	andb	$1, %al
	cmpb	$0, %al
	movb	38(%rsp), %al           # 1-byte Reload
	movb	%al, 15(%rsp)           # 1-byte Spill
	je	.LBB1_36
# %bb.35:                               # %if.then65
                                        #   in Loop: Header=BB1_32 Depth=1
	movq	stderr, %rdi
	movabsq	$.L.str.2, %rsi
	movq	24(%rsp), %rdx          # 8-byte Reload
	movl	20(%rsp), %ecx          # 4-byte Reload
	movb	$0, %al
	vzeroupper
	callq	fprintf
	movb	38(%rsp), %r8b          # 1-byte Reload
	movb	%r8b, 15(%rsp)          # 1-byte Spill
.LBB1_36:                               # %for.inc69
                                        #   in Loop: Header=BB1_32 Depth=1
	movb	15(%rsp), %al           # 1-byte Reload
	movq	24(%rsp), %rcx          # 8-byte Reload
	addq	$1, %rcx
	cmpq	n12, %rcx
	movq	%rcx, 40(%rsp)          # 8-byte Spill
	movb	%al, 39(%rsp)           # 1-byte Spill
	jl	.LBB1_32
	jmp	.LBB1_31
.Lfunc_end1:
	.size	main, .Lfunc_end1-main
	.cfi_endproc
                                        # -- End function
	.type	n1,@object              # @n1
	.data
	.globl	n1
	.p2align	3
n1:
	.quad	6584363                 # 0x64782b
	.size	n1, 8

	.type	n12,@object             # @n12
	.globl	n12
	.p2align	3
n12:
	.quad	13168658                # 0xc8f012
	.size	n12, 8

	.type	.L.str,@object          # @.str
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str:
	.asciz	"n1 = %ld\n"
	.size	.L.str, 10

	.type	.L.str.1,@object        # @.str.1
.L.str.1:
	.asciz	"bad value: i = %ld, SA12[i] = %d, SA12tmp[i] = %d\n"
	.size	.L.str.1, 51

	.type	.L.str.2,@object        # @.str.2
.L.str.2:
	.asciz	"ok value: i = %ld, SA12[i] = %d\n"
	.size	.L.str.2, 33

	.section	".note.GNU-stack","",@progbits
	.addrsig
