	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	4, 0x90                         ## -- Begin function sp_setup_tbl
_sp_setup_tbl:                          ## @sp_setup_tbl
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	pushq	%r15
	pushq	%r14
	pushq	%r13
	pushq	%r12
	pushq	%rbx
	subq	$424, %rsp                      ## imm = 0x1A8
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	%rax, -48(%rbp)
	movq	16(%rdi), %rax
	movq	(%rdi), %rcx
	movq	%rdi, -328(%rbp)                ## 8-byte Spill
	movq	8(%rdi), %rdx
	movq	(%rax), %rax
	movq	%rax, -352(%rbp)                ## 8-byte Spill
	movq	(%rcx), %rax
	movq	%rax, -312(%rbp)                ## 8-byte Spill
	movq	8(%rcx), %rax
	movq	%rax, -368(%rbp)                ## 8-byte Spill
	movq	16(%rcx), %rax
	movq	%rax, -392(%rbp)                ## 8-byte Spill
	movq	(%rdx), %rax
	movq	%rax, -408(%rbp)                ## 8-byte Spill
	movq	8(%rdx), %rax
	movq	%rax, -416(%rbp)                ## 8-byte Spill
	movq	_SP_ROOT_CNT@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	movl	$8, %esi
	callq	_hccalloc
	movq	%rax, %r15
	movq	_SP_PW_MAX@GOTPCREL(%rip), %r14
	movl	(%r14), %ebx
	leaq	(,%rbx,8), %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, %r13
	testl	%ebx, %ebx
	jle	LBB0_8
## %bb.1:
	movq	_CHARSIZ@GOTPCREL(%rip), %rax
	movslq	(%rax), %r9
	leaq	-1(%rbx), %rax
	movl	%ebx, %ecx
	andl	$7, %ecx
	cmpq	$7, %rax
	jae	LBB0_3
## %bb.2:
	xorl	%esi, %esi
	movq	%r15, %rax
	testq	%rcx, %rcx
	jne	LBB0_6
	jmp	LBB0_8
LBB0_3:
	andl	$-8, %ebx
	movq	%r9, %r8
	shlq	$6, %r8
	leaq	(,%r9,8), %rdi
	xorl	%esi, %esi
	movq	%r15, %rdx
	.p2align	4, 0x90
LBB0_4:                                 ## =>This Inner Loop Header: Depth=1
	movq	%rdx, %rax
	movq	%rdx, (%r13,%rsi,8)
	addq	%rdi, %rdx
	movq	%rdx, 8(%r13,%rsi,8)
	addq	%rdi, %rdx
	movq	%rdx, 16(%r13,%rsi,8)
	addq	%rdi, %rdx
	movq	%rdx, 24(%r13,%rsi,8)
	addq	%rdi, %rdx
	movq	%rdx, 32(%r13,%rsi,8)
	addq	%rdi, %rdx
	movq	%rdx, 40(%r13,%rsi,8)
	addq	%rdi, %rdx
	movq	%rdx, 48(%r13,%rsi,8)
	addq	%rdi, %rdx
	movq	%rdx, 56(%r13,%rsi,8)
	addq	$8, %rsi
	addq	%rdi, %rdx
	cmpq	%rsi, %rbx
	jne	LBB0_4
## %bb.5:
	addq	%r8, %rax
	testq	%rcx, %rcx
	je	LBB0_8
LBB0_6:
	leaq	(,%rsi,8), %rdx
	addq	%r13, %rdx
	shlq	$3, %r9
	xorl	%esi, %esi
	.p2align	4, 0x90
LBB0_7:                                 ## =>This Inner Loop Header: Depth=1
	movq	%rax, (%rdx,%rsi,8)
	incq	%rsi
	addq	%r9, %rax
	cmpq	%rsi, %rcx
	jne	LBB0_7
LBB0_8:
	movq	%r15, -376(%rbp)                ## 8-byte Spill
	movq	_SP_MARKOV_CNT@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	movl	$8, %esi
	callq	_hccalloc
	movq	%rax, -384(%rbp)                ## 8-byte Spill
	movl	(%r14), %r15d
	movq	_CHARSIZ@GOTPCREL(%rip), %rax
	movl	(%rax), %ebx
	movq	%rbx, %rax
	imulq	%r15, %rax
	shlq	$3, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -400(%rbp)                ## 8-byte Spill
	testl	%r15d, %r15d
	movq	%rbx, -344(%rbp)                ## 8-byte Spill
	jle	LBB0_20
## %bb.9:
	movslq	%ebx, %rax
	leaq	-1(%rbx), %r8
	movl	%ebx, %edx
	andl	$7, %edx
	movl	%ebx, %esi
	andl	$-8, %esi
	movq	-400(%rbp), %r11                ## 8-byte Reload
	leaq	56(%r11), %rdi
	leaq	(,%rbx,8), %r10
	movq	%rax, %rcx
	shlq	$6, %rcx
	movq	%rcx, -336(%rbp)                ## 8-byte Spill
	shlq	$3, %rax
	xorl	%r9d, %r9d
	movq	-384(%rbp), %rcx                ## 8-byte Reload
	jmp	LBB0_12
	.p2align	4, 0x90
LBB0_10:                                ##   in Loop: Header=BB0_12 Depth=1
	movq	%rcx, %r14
LBB0_11:                                ##   in Loop: Header=BB0_12 Depth=1
	incq	%r9
	addq	%r10, %rdi
	addq	%r10, %r11
	movq	%r14, %rcx
	cmpq	%r15, %r9
	movq	-344(%rbp), %rbx                ## 8-byte Reload
	je	LBB0_20
LBB0_12:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_16 Depth 2
                                        ##     Child Loop BB0_19 Depth 2
	testl	%ebx, %ebx
	jle	LBB0_10
## %bb.13:                              ##   in Loop: Header=BB0_12 Depth=1
	cmpq	$7, %r8
	jae	LBB0_15
## %bb.14:                              ##   in Loop: Header=BB0_12 Depth=1
                                        ## implicit-def: $r14
	xorl	%r12d, %r12d
	testq	%rdx, %rdx
	jne	LBB0_18
	jmp	LBB0_11
	.p2align	4, 0x90
LBB0_15:                                ##   in Loop: Header=BB0_12 Depth=1
	xorl	%r12d, %r12d
	.p2align	4, 0x90
LBB0_16:                                ##   Parent Loop BB0_12 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	%rcx, %r14
	movq	%rcx, -56(%rdi,%r12,8)
	addq	%rax, %rcx
	movq	%rcx, -48(%rdi,%r12,8)
	addq	%rax, %rcx
	movq	%rcx, -40(%rdi,%r12,8)
	addq	%rax, %rcx
	movq	%rcx, -32(%rdi,%r12,8)
	addq	%rax, %rcx
	movq	%rcx, -24(%rdi,%r12,8)
	addq	%rax, %rcx
	movq	%rcx, -16(%rdi,%r12,8)
	addq	%rax, %rcx
	movq	%rcx, -8(%rdi,%r12,8)
	addq	%rax, %rcx
	movq	%rcx, (%rdi,%r12,8)
	addq	$8, %r12
	addq	%rax, %rcx
	cmpq	%r12, %rsi
	jne	LBB0_16
## %bb.17:                              ##   in Loop: Header=BB0_12 Depth=1
	addq	-336(%rbp), %r14                ## 8-byte Folded Reload
	movq	%r14, %rcx
	testq	%rdx, %rdx
	je	LBB0_11
LBB0_18:                                ##   in Loop: Header=BB0_12 Depth=1
	leaq	(%r11,%r12,8), %rbx
	movq	%rcx, %r14
	xorl	%ecx, %ecx
	.p2align	4, 0x90
LBB0_19:                                ##   Parent Loop BB0_12 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	%r14, (%rbx,%rcx,8)
	incq	%rcx
	addq	%rax, %r14
	cmpq	%rcx, %rdx
	jne	LBB0_19
	jmp	LBB0_11
LBB0_20:
	movq	-312(%rbp), %rbx                ## 8-byte Reload
	testq	%rbx, %rbx
	jne	LBB0_22
## %bb.21:
	leaq	-304(%rbp), %rbx
	movq	_SP_HCSTAT@GOTPCREL(%rip), %rax
	movq	(%rax), %r8
	leaq	L_.str(%rip), %rdx
	movq	%rbx, %rdi
	movl	$256, %esi                      ## imm = 0x100
	movq	-352(%rbp), %rcx                ## 8-byte Reload
	callq	_snprintf
LBB0_22:
	leaq	-456(%rbp), %rsi
	movq	%rbx, %rdi
	callq	_stat
	cmpl	$-1, %eax
	je	LBB0_36
## %bb.23:
	leaq	L_.str.2(%rip), %rdx
	leaq	-356(%rbp), %rdi
	movq	%rbx, %rsi
	callq	_hc_fopen
	testl	%eax, %eax
	je	LBB0_36
## %bb.24:
	movq	-456(%rbp), %r14
	movq	%r14, %rdi
	callq	_hcmalloc
	movq	%rax, %r15
	leaq	-356(%rbp), %rcx
	movq	%rax, %rdi
	movl	$1, %esi
	movq	%r14, %rdx
	callq	_hc_fread
	movq	%rax, -448(%rbp)
	cmpq	%r14, %rax
	jne	LBB0_37
## %bb.25:
	movq	%rbx, -312(%rbp)                ## 8-byte Spill
	leaq	-356(%rbp), %rdi
	callq	_hc_fclose
	movq	_SP_FILESZ@GOTPCREL(%rip), %r14
	movq	(%r14), %rdi
	callq	_hcmalloc
	movq	%rax, %rbx
	movq	(%r14), %rax
	movq	%rax, -424(%rbp)
	movb	$28, -313(%rbp)
	leaq	-448(%rbp), %rsi
	leaq	-424(%rbp), %rcx
	leaq	-313(%rbp), %r8
	movq	%r15, %rdi
	movq	%rbx, %rdx
	callq	_hc_lzma2_decompress
	movq	_SZ_OK@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_38
## %bb.26:
	movq	-424(%rbp), %rax
	cmpq	(%r14), %rax
	jne	LBB0_38
## %bb.27:
	leaq	16(%rbx), %rsi
	movq	(%rbx), %rax
	movq	%rax, -352(%rbp)                ## 8-byte Spill
	movq	8(%rbx), %rax
	movq	%rax, -336(%rbp)                ## 8-byte Spill
	movq	_SP_ROOT_CNT@GOTPCREL(%rip), %r14
	movl	(%r14), %edx
	shll	$3, %edx
	movq	-376(%rbp), %r12                ## 8-byte Reload
	movq	%r12, %rdi
	callq	_memcpy
	movslq	(%r14), %rax
	leaq	(%rbx,%rax,8), %rsi
	addq	$16, %rsi
	movq	_SP_MARKOV_CNT@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	shll	$3, %edx
	movq	-384(%rbp), %rdi                ## 8-byte Reload
	callq	_memcpy
	movq	%r15, %rdi
	callq	_hcfree
	movq	%rbx, %rdi
	callq	_hcfree
	movq	-352(%rbp), %rdi                ## 8-byte Reload
	callq	_byte_swap_64
	movq	%rax, %r15
	movq	-336(%rbp), %rdi                ## 8-byte Reload
	callq	_byte_swap_64
	movq	%rax, -336(%rbp)                ## 8-byte Spill
	cmpl	$0, (%r14)
	jle	LBB0_30
## %bb.28:
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_29:                                ## =>This Inner Loop Header: Depth=1
	movq	(%r12,%rbx,8), %rdi
	callq	_byte_swap_64
	movq	%rax, (%r12,%rbx,8)
	incq	%rbx
	movslq	(%r14), %rax
	cmpq	%rax, %rbx
	jl	LBB0_29
LBB0_30:
	movq	_SP_MARKOV_CNT@GOTPCREL(%rip), %r14
	cmpl	$0, (%r14)
	movq	-384(%rbp), %r12                ## 8-byte Reload
	jle	LBB0_33
## %bb.31:
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_32:                                ## =>This Inner Loop Header: Depth=1
	movq	(%r12,%rbx,8), %rdi
	callq	_byte_swap_64
	movq	%rax, (%r12,%rbx,8)
	incq	%rbx
	movslq	(%r14), %rax
	cmpq	%rax, %rbx
	jl	LBB0_32
LBB0_33:
	movq	_SP_VERSION@GOTPCREL(%rip), %rax
	cmpq	(%rax), %r15
	jne	LBB0_35
## %bb.34:
	cmpq	$0, -336(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_43
LBB0_35:
	leaq	L_.str.5(%rip), %rsi
	movq	-328(%rbp), %rdi                ## 8-byte Reload
	movq	-312(%rbp), %rdx                ## 8-byte Reload
	xorl	%eax, %eax
	callq	_event_log_error
	jmp	LBB0_40
LBB0_36:
	movq	_errno@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	callq	_strerror
	leaq	L_.str.1(%rip), %rsi
	movq	-328(%rbp), %rdi                ## 8-byte Reload
	movq	%rbx, %rdx
	movl	%eax, %ecx
	xorl	%eax, %eax
	callq	_event_log_error
	jmp	LBB0_40
LBB0_37:
	leaq	L_.str.3(%rip), %rsi
	movq	-328(%rbp), %rdi                ## 8-byte Reload
	movq	%rbx, %rdx
	xorl	%eax, %eax
	callq	_event_log_error
	leaq	-356(%rbp), %rdi
	callq	_hc_fclose
	movq	%r15, %rdi
	jmp	LBB0_39
LBB0_38:
	leaq	L_.str.4(%rip), %rsi
	movq	-328(%rbp), %rdi                ## 8-byte Reload
	movq	-312(%rbp), %rdx                ## 8-byte Reload
	xorl	%eax, %eax
	callq	_event_log_error
	movq	%r15, %rdi
	callq	_hcfree
	movq	%rbx, %rdi
LBB0_39:
	callq	_hcfree
LBB0_40:
	movl	$-1, %eax
LBB0_41:
	movq	___stack_chk_guard@GOTPCREL(%rip), %rcx
	movq	(%rcx), %rcx
	cmpq	-48(%rbp), %rcx
	jne	LBB0_150
## %bb.42:
	leaq	-40(%rbp), %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_43:
	cmpq	$0, -392(%rbp)                  ## 8-byte Folded Reload
	movq	-376(%rbp), %r15                ## 8-byte Reload
	movq	_SP_ROOT_CNT@GOTPCREL(%rip), %r12
	je	LBB0_45
## %bb.44:
	movl	(%r12), %edx
	shll	$3, %edx
	movq	%r15, %rdi
	xorl	%esi, %esi
	callq	_memset
	movl	(%r14), %edx
	shll	$3, %edx
	movq	-384(%rbp), %rdi                ## 8-byte Reload
	xorl	%esi, %esi
	callq	_memset
LBB0_45:
	movq	_SP_PW_MAX@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	cmpq	$0, -368(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_101
## %bb.46:
	cmpl	$2, %ecx
	jl	LBB0_101
## %bb.47:
	movabsq	$9223372036854775806, %rax      ## imm = 0x7FFFFFFFFFFFFFFE
	movq	%rax, -328(%rbp)                ## 8-byte Spill
	movabsq	$8589934588, %r12               ## imm = 0x1FFFFFFFC
	movq	(%r13), %r8
	movq	_CHARSIZ@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	leal	-1(%rdx), %esi
	leaq	8(%r8,%rsi,8), %rax
	movq	%rax, -312(%rbp)                ## 8-byte Spill
	leaq	1(%rsi), %r14
	movq	%r14, %rax
	andq	$-4, %rax
	leaq	-4(%rax), %rdi
	movq	%rdi, -352(%rbp)                ## 8-byte Spill
	shrq	$2, %rdi
	incq	%rdi
	movq	%rax, -336(%rbp)                ## 8-byte Spill
	leaq	(%r8,%rax,8), %rax
	movq	%rax, -432(%rbp)                ## 8-byte Spill
	movq	%rdi, %rax
	movq	%rdi, -368(%rbp)                ## 8-byte Spill
	andq	$-2, %rdi
	movq	%rdi, -440(%rbp)                ## 8-byte Spill
	movl	$1, %r15d
	movq	%rcx, -392(%rbp)                ## 8-byte Spill
	jmp	LBB0_49
LBB0_48:                                ##   in Loop: Header=BB0_49 Depth=1
	incq	%r15
	movq	-392(%rbp), %rcx                ## 8-byte Reload
	cmpq	%rcx, %r15
	je	LBB0_70
LBB0_49:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_57 Depth 2
                                        ##     Child Loop BB0_65 Depth 2
                                        ##     Child Loop BB0_69 Depth 2
	testl	%edx, %edx
	jle	LBB0_48
## %bb.50:                              ##   in Loop: Header=BB0_49 Depth=1
	xorl	%r11d, %r11d
	movq	(%r13,%r15,8), %r10
	cmpl	$3, %esi
	jb	LBB0_51
## %bb.52:                              ##   in Loop: Header=BB0_49 Depth=1
	leaq	(%r10,%r14,8), %rax
	cmpq	%rax, %r8
	jae	LBB0_55
## %bb.53:                              ##   in Loop: Header=BB0_49 Depth=1
	cmpq	-312(%rbp), %r10                ## 8-byte Folded Reload
	jae	LBB0_55
LBB0_51:                                ##   in Loop: Header=BB0_49 Depth=1
	movq	%r8, %rax
LBB0_63:                                ##   in Loop: Header=BB0_49 Depth=1
	movl	%edx, %edi
	subl	%r11d, %edi
	movl	%r11d, %ecx
	notl	%ecx
	addl	%edx, %ecx
	andl	$3, %edi
	je	LBB0_67
## %bb.64:                              ##   in Loop: Header=BB0_49 Depth=1
	negl	%edi
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_65:                                ##   Parent Loop BB0_49 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r10), %r9
	addq	%r9, (%rax)
	addq	$8, %r10
	addq	$8, %rax
	decl	%ebx
	cmpl	%ebx, %edi
	jne	LBB0_65
## %bb.66:                              ##   in Loop: Header=BB0_49 Depth=1
	subl	%ebx, %r11d
LBB0_67:                                ##   in Loop: Header=BB0_49 Depth=1
	cmpl	$3, %ecx
	jb	LBB0_48
## %bb.68:                              ##   in Loop: Header=BB0_49 Depth=1
	movl	%edx, %ecx
	subl	%r11d, %ecx
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_69:                                ##   Parent Loop BB0_49 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r10,%rdi,8), %rbx
	addq	%rbx, (%rax,%rdi,8)
	movq	8(%r10,%rdi,8), %rbx
	addq	%rbx, 8(%rax,%rdi,8)
	movq	16(%r10,%rdi,8), %rbx
	addq	%rbx, 16(%rax,%rdi,8)
	movq	24(%r10,%rdi,8), %rbx
	addq	%rbx, 24(%rax,%rdi,8)
	addq	$4, %rdi
	cmpl	%edi, %ecx
	jne	LBB0_69
	jmp	LBB0_48
LBB0_55:                                ##   in Loop: Header=BB0_49 Depth=1
	cmpq	$0, -352(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_58
## %bb.56:                              ##   in Loop: Header=BB0_49 Depth=1
	movq	-440(%rbp), %rcx                ## 8-byte Reload
	xorl	%eax, %eax
	.p2align	4, 0x90
LBB0_57:                                ##   Parent Loop BB0_49 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	(%r10,%rax,8), %xmm0
	movdqu	16(%r10,%rax,8), %xmm1
	movdqu	(%r8,%rax,8), %xmm2
	paddq	%xmm0, %xmm2
	movdqu	16(%r8,%rax,8), %xmm0
	paddq	%xmm1, %xmm0
	movdqu	32(%r8,%rax,8), %xmm1
	movdqu	48(%r8,%rax,8), %xmm3
	movdqu	%xmm2, (%r8,%rax,8)
	movdqu	%xmm0, 16(%r8,%rax,8)
	movdqu	32(%r10,%rax,8), %xmm0
	paddq	%xmm1, %xmm0
	movdqu	48(%r10,%rax,8), %xmm1
	paddq	%xmm3, %xmm1
	movdqu	%xmm0, 32(%r8,%rax,8)
	movdqu	%xmm1, 48(%r8,%rax,8)
	addq	$8, %rax
	addq	$-2, %rcx
	jne	LBB0_57
	jmp	LBB0_59
LBB0_58:                                ##   in Loop: Header=BB0_49 Depth=1
	xorl	%eax, %eax
LBB0_59:                                ##   in Loop: Header=BB0_49 Depth=1
	testb	$1, -368(%rbp)                  ## 1-byte Folded Reload
	je	LBB0_61
## %bb.60:                              ##   in Loop: Header=BB0_49 Depth=1
	movdqu	(%r10,%rax,8), %xmm0
	movdqu	16(%r10,%rax,8), %xmm1
	movdqu	(%r8,%rax,8), %xmm2
	paddq	%xmm0, %xmm2
	movdqu	16(%r8,%rax,8), %xmm0
	paddq	%xmm1, %xmm0
	movdqu	%xmm2, (%r8,%rax,8)
	movdqu	%xmm0, 16(%r8,%rax,8)
LBB0_61:                                ##   in Loop: Header=BB0_49 Depth=1
	cmpq	-336(%rbp), %r14                ## 8-byte Folded Reload
	je	LBB0_48
## %bb.62:                              ##   in Loop: Header=BB0_49 Depth=1
	movq	-336(%rbp), %rax                ## 8-byte Reload
	leaq	(%r10,%rax,8), %r10
	movl	%eax, %r11d
	movq	-432(%rbp), %rax                ## 8-byte Reload
	jmp	LBB0_63
LBB0_70:
	movq	-400(%rbp), %rax                ## 8-byte Reload
	movq	(%rax), %rax
	movq	%rax, -368(%rbp)                ## 8-byte Spill
	movq	_CHARSIZ@GOTPCREL(%rip), %rax
	movl	(%rax), %r15d
	leal	-1(%r15), %r10d
	leaq	1(%r10), %r11
	andq	%r11, %r12
	leaq	-4(%r12), %rax
	movq	%rax, -336(%rbp)                ## 8-byte Spill
	shrq	$2, %rax
	incq	%rax
	movq	%rax, %rcx
	movq	%rax, -312(%rbp)                ## 8-byte Spill
	andq	%rax, -328(%rbp)                ## 8-byte Folded Spill
	movl	$1, %eax
	movq	%rax, -352(%rbp)                ## 8-byte Spill
	jmp	LBB0_72
LBB0_71:                                ##   in Loop: Header=BB0_72 Depth=1
	movq	-352(%rbp), %rax                ## 8-byte Reload
	incq	%rax
	movq	%rax, -352(%rbp)                ## 8-byte Spill
	cmpq	-392(%rbp), %rax                ## 8-byte Folded Reload
	je	LBB0_95
LBB0_72:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_75 Depth 2
                                        ##       Child Loop BB0_82 Depth 3
                                        ##       Child Loop BB0_88 Depth 3
                                        ##       Child Loop BB0_92 Depth 3
	testl	%r15d, %r15d
	jle	LBB0_71
## %bb.73:                              ##   in Loop: Header=BB0_72 Depth=1
	movq	-352(%rbp), %rax                ## 8-byte Reload
	imulq	-344(%rbp), %rax                ## 8-byte Folded Reload
	movq	-400(%rbp), %rcx                ## 8-byte Reload
	movq	(%rcx,%rax,8), %rdx
	xorl	%eax, %eax
	movq	-368(%rbp), %r8                 ## 8-byte Reload
	jmp	LBB0_75
	.p2align	4, 0x90
LBB0_74:                                ##   in Loop: Header=BB0_75 Depth=2
	incl	%eax
	cmpl	%r15d, %eax
	je	LBB0_71
LBB0_75:                                ##   Parent Loop BB0_72 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_82 Depth 3
                                        ##       Child Loop BB0_88 Depth 3
                                        ##       Child Loop BB0_92 Depth 3
	cmpl	$3, %r10d
	jb	LBB0_76
## %bb.77:                              ##   in Loop: Header=BB0_75 Depth=2
	leaq	(%rdx,%r11,8), %rcx
	cmpq	%rcx, %r8
	jae	LBB0_80
## %bb.78:                              ##   in Loop: Header=BB0_75 Depth=2
	leaq	(%r8,%r11,8), %rcx
	cmpq	%rcx, %rdx
	jae	LBB0_80
LBB0_76:                                ##   in Loop: Header=BB0_75 Depth=2
	xorl	%r14d, %r14d
LBB0_86:                                ##   in Loop: Header=BB0_75 Depth=2
	movl	%r15d, %ecx
	subl	%r14d, %ecx
	movl	%r14d, %r9d
	notl	%r9d
	addl	%r15d, %r9d
	andl	$3, %ecx
	je	LBB0_90
## %bb.87:                              ##   in Loop: Header=BB0_75 Depth=2
	negl	%ecx
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_88:                                ##   Parent Loop BB0_72 Depth=1
                                        ##     Parent Loop BB0_75 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movq	(%rdx), %rbx
	addq	%rbx, (%r8)
	addq	$8, %rdx
	addq	$8, %r8
	decl	%edi
	cmpl	%edi, %ecx
	jne	LBB0_88
## %bb.89:                              ##   in Loop: Header=BB0_75 Depth=2
	subl	%edi, %r14d
LBB0_90:                                ##   in Loop: Header=BB0_75 Depth=2
	cmpl	$3, %r9d
	jb	LBB0_74
## %bb.91:                              ##   in Loop: Header=BB0_75 Depth=2
	movl	%r15d, %edi
	subl	%r14d, %edi
	xorl	%ecx, %ecx
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_92:                                ##   Parent Loop BB0_72 Depth=1
                                        ##     Parent Loop BB0_75 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movq	(%rdx,%rbx,8), %rsi
	addq	%rsi, (%r8,%rbx,8)
	movq	8(%rdx,%rbx,8), %rsi
	addq	%rsi, 8(%r8,%rbx,8)
	movq	16(%rdx,%rbx,8), %rsi
	addq	%rsi, 16(%r8,%rbx,8)
	movq	24(%rdx,%rbx,8), %rsi
	addq	%rsi, 24(%r8,%rbx,8)
	addq	$4, %rbx
	addq	$-32, %rcx
	cmpl	%ebx, %edi
	jne	LBB0_92
## %bb.93:                              ##   in Loop: Header=BB0_75 Depth=2
	subq	%rcx, %rdx
	subq	%rcx, %r8
	jmp	LBB0_74
	.p2align	4, 0x90
LBB0_80:                                ##   in Loop: Header=BB0_75 Depth=2
	cmpq	$0, -336(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_94
## %bb.81:                              ##   in Loop: Header=BB0_75 Depth=2
	movq	-328(%rbp), %rdi                ## 8-byte Reload
	xorl	%ecx, %ecx
	.p2align	4, 0x90
LBB0_82:                                ##   Parent Loop BB0_72 Depth=1
                                        ##     Parent Loop BB0_75 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movdqu	(%rdx,%rcx,8), %xmm0
	movdqu	16(%rdx,%rcx,8), %xmm1
	movdqu	(%r8,%rcx,8), %xmm2
	paddq	%xmm0, %xmm2
	movdqu	16(%r8,%rcx,8), %xmm0
	paddq	%xmm1, %xmm0
	movdqu	32(%r8,%rcx,8), %xmm1
	movdqu	48(%r8,%rcx,8), %xmm3
	movdqu	%xmm2, (%r8,%rcx,8)
	movdqu	%xmm0, 16(%r8,%rcx,8)
	movdqu	32(%rdx,%rcx,8), %xmm0
	paddq	%xmm1, %xmm0
	movdqu	48(%rdx,%rcx,8), %xmm1
	paddq	%xmm3, %xmm1
	movdqu	%xmm0, 32(%r8,%rcx,8)
	movdqu	%xmm1, 48(%r8,%rcx,8)
	addq	$8, %rcx
	addq	$-2, %rdi
	jne	LBB0_82
## %bb.83:                              ##   in Loop: Header=BB0_75 Depth=2
	testb	$1, -312(%rbp)                  ## 1-byte Folded Reload
	je	LBB0_85
LBB0_84:                                ##   in Loop: Header=BB0_75 Depth=2
	movdqu	(%rdx,%rcx,8), %xmm0
	movdqu	16(%rdx,%rcx,8), %xmm1
	movdqu	(%r8,%rcx,8), %xmm2
	paddq	%xmm0, %xmm2
	movdqu	16(%r8,%rcx,8), %xmm0
	paddq	%xmm1, %xmm0
	movdqu	%xmm2, (%r8,%rcx,8)
	movdqu	%xmm0, 16(%r8,%rcx,8)
LBB0_85:                                ##   in Loop: Header=BB0_75 Depth=2
	leaq	(%rdx,%r12,8), %rdx
	leaq	(%r8,%r12,8), %r8
	movl	%r12d, %r14d
	cmpq	%r12, %r11
	je	LBB0_74
	jmp	LBB0_86
LBB0_94:                                ##   in Loop: Header=BB0_75 Depth=2
	xorl	%ecx, %ecx
	testb	$1, -312(%rbp)                  ## 1-byte Folded Reload
	jne	LBB0_84
	jmp	LBB0_85
LBB0_95:
	movq	(%r13), %r14
	movl	$1, %ebx
	movq	_SP_PW_MAX@GOTPCREL(%rip), %r15
	movq	_CHARSIZ@GOTPCREL(%rip), %r12
LBB0_96:                                ## =>This Inner Loop Header: Depth=1
	movq	(%r13,%rbx,8), %rdi
	movl	(%r12), %edx
	shll	$3, %edx
	movq	%r14, %rsi
	callq	_memcpy
	incq	%rbx
	movslq	(%r15), %rcx
	cmpq	%rcx, %rbx
	jl	LBB0_96
## %bb.97:
	cmpl	$2, %ecx
	movq	-376(%rbp), %r15                ## 8-byte Reload
	movq	%r12, %r13
	movq	_SP_ROOT_CNT@GOTPCREL(%rip), %r12
	jl	LBB0_102
## %bb.98:
	movq	-400(%rbp), %rax                ## 8-byte Reload
	movq	(%rax), %r14
	movq	-344(%rbp), %r13                ## 8-byte Reload
	leaq	(%rax,%r13,8), %r15
	shlq	$3, %r13
	movl	$1, %ebx
	movq	_SP_PW_MAX@GOTPCREL(%rip), %r12
LBB0_99:                                ## =>This Inner Loop Header: Depth=1
	movq	(%r15), %rdi
	movq	_CHARSIZ@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	imull	%edx, %edx
	shll	$3, %edx
	movq	%r14, %rsi
	callq	_memcpy
	incq	%rbx
	movslq	(%r12), %rcx
	addq	%r13, %r15
	cmpq	%rcx, %rbx
	jl	LBB0_99
## %bb.100:
	movq	-376(%rbp), %r15                ## 8-byte Reload
	movq	_SP_ROOT_CNT@GOTPCREL(%rip), %r12
LBB0_101:
	movq	_CHARSIZ@GOTPCREL(%rip), %r13
LBB0_102:
	movl	%ecx, %r14d
	leaq	(,%r14,8), %rax
	movq	%rcx, %rbx
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, %rax
	movslq	(%r13), %rcx
	movq	%rcx, -312(%rbp)                ## 8-byte Spill
	movl	%ecx, %r9d
	testl	%ebx, %ebx
	movq	%r9, -344(%rbp)                 ## 8-byte Spill
	movq	%rax, -328(%rbp)                ## 8-byte Spill
	jle	LBB0_105
## %bb.103:
	leaq	-1(%r14), %rcx
	movl	%r14d, %r10d
	andl	$3, %r10d
	cmpq	$3, %rcx
	movq	-416(%rbp), %r11                ## 8-byte Reload
	jae	LBB0_106
## %bb.104:
	xorl	%edx, %edx
	movq	%r11, %rdi
	jmp	LBB0_109
LBB0_105:
	imulq	%r9, %r14
	shlq	$3, %r14
	movq	%r14, %rax
	callq	____chkstk_darwin
	movq	-344(%rbp), %rdi                ## 8-byte Reload
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, %r14
	movq	-416(%rbp), %r9                 ## 8-byte Reload
	jmp	LBB0_124
LBB0_106:
	movl	%r14d, %esi
	andl	$-4, %esi
	movq	-312(%rbp), %rbx                ## 8-byte Reload
	movq	%rbx, %r8
	shlq	$6, %r8
	shlq	$4, %rbx
	xorl	%edx, %edx
	movq	%r11, %rcx
LBB0_107:                               ## =>This Inner Loop Header: Depth=1
	movq	%rcx, %rdi
	movq	%rcx, (%rax,%rdx,8)
	addq	%rbx, %rcx
	movq	%rcx, 8(%rax,%rdx,8)
	addq	%rbx, %rcx
	movq	%rcx, 16(%rax,%rdx,8)
	addq	%rbx, %rcx
	movq	%rcx, 24(%rax,%rdx,8)
	addq	$4, %rdx
	addq	%rbx, %rcx
	cmpq	%rdx, %rsi
	jne	LBB0_107
## %bb.108:
	addq	%r8, %rdi
LBB0_109:
	testq	%r10, %r10
	je	LBB0_112
## %bb.110:
	leaq	(%rax,%rdx,8), %rcx
	movq	-312(%rbp), %rdx                ## 8-byte Reload
	shlq	$4, %rdx
	xorl	%esi, %esi
LBB0_111:                               ## =>This Inner Loop Header: Depth=1
	movq	%rdi, (%rcx,%rsi,8)
	incq	%rsi
	addq	%rdx, %rdi
	cmpq	%rsi, %r10
	jne	LBB0_111
LBB0_112:
	movq	%r9, %rax
	movq	%r14, %r13
	imulq	%r14, %rax
	shlq	$3, %rax
	callq	____chkstk_darwin
	movq	-344(%rbp), %rdi                ## 8-byte Reload
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, %r14
	leaq	-1(%rdi), %rax
	movq	%rax, -336(%rbp)                ## 8-byte Spill
	movl	%edi, %ecx
	andl	$3, %ecx
	movl	%edi, %edx
	andl	$-4, %edx
	movq	%r14, %rsi
	addq	$24, %rsi
	leaq	(,%rdi,8), %r10
	movq	-312(%rbp), %rbx                ## 8-byte Reload
	movq	%rbx, %r15
	shlq	$6, %r15
	movq	%rbx, %rax
	shlq	$4, %rax
	xorl	%r12d, %r12d
	movq	%r14, %r11
	movq	-408(%rbp), %rbx                ## 8-byte Reload
	jmp	LBB0_115
LBB0_113:                               ##   in Loop: Header=BB0_115 Depth=1
	movq	%rbx, %r8
LBB0_114:                               ##   in Loop: Header=BB0_115 Depth=1
	incq	%r12
	addq	%r10, %rsi
	addq	%r10, %r11
	movq	%r8, %rbx
	cmpq	%r13, %r12
	movq	-344(%rbp), %rdi                ## 8-byte Reload
	je	LBB0_123
LBB0_115:                               ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_119 Depth 2
                                        ##     Child Loop BB0_122 Depth 2
	testl	%edi, %edi
	jle	LBB0_113
## %bb.116:                             ##   in Loop: Header=BB0_115 Depth=1
	cmpq	$3, -336(%rbp)                  ## 8-byte Folded Reload
	jae	LBB0_118
## %bb.117:                             ##   in Loop: Header=BB0_115 Depth=1
                                        ## implicit-def: $r8
	xorl	%r9d, %r9d
	testq	%rcx, %rcx
	jne	LBB0_121
	jmp	LBB0_114
LBB0_118:                               ##   in Loop: Header=BB0_115 Depth=1
	xorl	%r9d, %r9d
	.p2align	4, 0x90
LBB0_119:                               ##   Parent Loop BB0_115 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	%rbx, %r8
	movq	%rbx, -24(%rsi,%r9,8)
	addq	%rax, %rbx
	movq	%rbx, -16(%rsi,%r9,8)
	addq	%rax, %rbx
	movq	%rbx, -8(%rsi,%r9,8)
	addq	%rax, %rbx
	movq	%rbx, (%rsi,%r9,8)
	addq	$4, %r9
	addq	%rax, %rbx
	cmpq	%r9, %rdx
	jne	LBB0_119
## %bb.120:                             ##   in Loop: Header=BB0_115 Depth=1
	addq	%r15, %r8
	movq	%r8, %rbx
	testq	%rcx, %rcx
	je	LBB0_114
LBB0_121:                               ##   in Loop: Header=BB0_115 Depth=1
	leaq	(%r11,%r9,8), %rdi
	movq	%rbx, %r8
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_122:                               ##   Parent Loop BB0_115 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	%r8, (%rdi,%rbx,8)
	incq	%rbx
	addq	%rax, %r8
	cmpq	%rbx, %rcx
	jne	LBB0_122
	jmp	LBB0_114
LBB0_123:
	movq	_SP_ROOT_CNT@GOTPCREL(%rip), %r12
	movq	-416(%rbp), %r9                 ## 8-byte Reload
	movq	-376(%rbp), %r15                ## 8-byte Reload
LBB0_124:
	movl	(%r12), %r8d
	testl	%r8d, %r8d
	jle	LBB0_131
## %bb.125:
	cmpl	$1, %r8d
	jne	LBB0_127
## %bb.126:
	xorl	%ecx, %ecx
	jmp	LBB0_129
LBB0_127:
	movl	%r8d, %esi
	andl	$-2, %esi
	leaq	24(%r9), %rbx
	xorl	%ecx, %ecx
LBB0_128:                               ## =>This Inner Loop Header: Depth=1
	movl	%ecx, %eax
	cltd
	idivl	%edi
                                        ## kill: def $edx killed $edx def $rdx
	movq	%rdx, -16(%rbx)
	movq	(%r15,%rcx,8), %rax
	movq	%rax, -24(%rbx)
	leal	1(%rcx), %eax
	cltd
	idivl	%edi
                                        ## kill: def $edx killed $edx def $rdx
	movq	%rdx, (%rbx)
	movq	8(%r15,%rcx,8), %rax
	movq	%rax, -8(%rbx)
	addq	$2, %rcx
	addq	$32, %rbx
	cmpq	%rsi, %rcx
	jne	LBB0_128
LBB0_129:
	testb	$1, %r8b
	je	LBB0_131
## %bb.130:
	movl	%ecx, %eax
	cltd
	idivl	-312(%rbp)                      ## 4-byte Folded Reload
                                        ## kill: def $edx killed $edx def $rdx
	movq	%rcx, %rax
	shlq	$4, %rax
	movq	%rdx, 8(%r9,%rax)
	movq	(%r15,%rcx,8), %rcx
	movq	%rcx, (%r9,%rax)
LBB0_131:
	movq	_SP_MARKOV_CNT@GOTPCREL(%rip), %rax
	movl	(%rax), %r8d
	testl	%r8d, %r8d
	movq	-384(%rbp), %r12                ## 8-byte Reload
	jle	LBB0_138
## %bb.132:
	cmpl	$1, %r8d
	jne	LBB0_134
## %bb.133:
	xorl	%ecx, %ecx
	jmp	LBB0_136
LBB0_134:
	movl	%r8d, %esi
	andl	$-2, %esi
	movq	-408(%rbp), %rax                ## 8-byte Reload
	leaq	24(%rax), %rbx
	xorl	%ecx, %ecx
LBB0_135:                               ## =>This Inner Loop Header: Depth=1
	movl	%ecx, %eax
	cltd
	idivl	%edi
                                        ## kill: def $edx killed $edx def $rdx
	movq	%rdx, -16(%rbx)
	movq	(%r12,%rcx,8), %rax
	movq	%rax, -24(%rbx)
	leal	1(%rcx), %eax
	cltd
	idivl	%edi
                                        ## kill: def $edx killed $edx def $rdx
	movq	%rdx, (%rbx)
	movq	8(%r12,%rcx,8), %rax
	movq	%rax, -8(%rbx)
	addq	$2, %rcx
	addq	$32, %rbx
	cmpq	%rsi, %rcx
	jne	LBB0_135
LBB0_136:
	testb	$1, %r8b
	je	LBB0_138
## %bb.137:
	movl	%ecx, %eax
	cltd
	idivl	-312(%rbp)                      ## 4-byte Folded Reload
                                        ## kill: def $edx killed $edx def $rdx
	movq	%rcx, %rax
	shlq	$4, %rax
	movq	-408(%rbp), %rsi                ## 8-byte Reload
	movq	%rdx, 8(%rsi,%rax)
	movq	(%r12,%rcx,8), %rcx
	movq	%rcx, (%rsi,%rax)
LBB0_138:
	movq	%r15, %rdi
	callq	_hcfree
	movq	%r12, %rdi
	callq	_hcfree
	movq	_SP_PW_MAX@GOTPCREL(%rip), %rax
	cmpl	$0, (%rax)
	jle	LBB0_149
## %bb.139:
	xorl	%ebx, %ebx
	movq	_sp_comp_val@GOTPCREL(%rip), %r12
	movq	_CHARSIZ@GOTPCREL(%rip), %r13
	movq	-328(%rbp), %r15                ## 8-byte Reload
LBB0_140:                               ## =>This Inner Loop Header: Depth=1
	movq	(%r15,%rbx,8), %rdi
	movl	(%r13), %esi
	movl	(%r12), %ecx
	movl	$16, %edx
	callq	_qsort
	incq	%rbx
	movq	_SP_PW_MAX@GOTPCREL(%rip), %rax
	movslq	(%rax), %rcx
	cmpq	%rcx, %rbx
	jl	LBB0_140
## %bb.141:
	testl	%ecx, %ecx
	jle	LBB0_149
## %bb.142:
	movq	_CHARSIZ@GOTPCREL(%rip), %rax
	movl	(%rax), %esi
	movq	-344(%rbp), %rdi                ## 8-byte Reload
	shlq	$3, %rdi
	xorl	%r15d, %r15d
	movq	%rdi, -344(%rbp)                ## 8-byte Spill
	jmp	LBB0_144
LBB0_143:                               ##   in Loop: Header=BB0_144 Depth=1
	incq	%r15
	movslq	%ecx, %rdx
	addq	%rdi, %r14
	xorl	%eax, %eax
	cmpq	%rdx, %r15
	jge	LBB0_41
LBB0_144:                               ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_146 Depth 2
	testl	%esi, %esi
	jle	LBB0_143
## %bb.145:                             ##   in Loop: Header=BB0_144 Depth=1
	xorl	%ebx, %ebx
	movq	_CHARSIZ@GOTPCREL(%rip), %r13
	.p2align	4, 0x90
LBB0_146:                               ##   Parent Loop BB0_144 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r14,%rbx,8), %rdi
	movl	(%r12), %ecx
                                        ## kill: def $esi killed $esi killed $rsi
	movl	$16, %edx
	callq	_qsort
	incq	%rbx
	movslq	(%r13), %rsi
	cmpq	%rsi, %rbx
	jl	LBB0_146
## %bb.147:                             ##   in Loop: Header=BB0_144 Depth=1
	movq	_SP_PW_MAX@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movq	-344(%rbp), %rdi                ## 8-byte Reload
	jmp	LBB0_143
LBB0_149:
	xorl	%eax, %eax
	jmp	LBB0_41
LBB0_150:
	callq	___stack_chk_fail
	.cfi_endproc
                                        ## -- End function
	.comm	_SP_ROOT_CNT,4,2                ## @SP_ROOT_CNT
	.comm	_SP_PW_MAX,4,2                  ## @SP_PW_MAX
	.comm	_CHARSIZ,4,2                    ## @CHARSIZ
	.comm	_SP_MARKOV_CNT,4,2              ## @SP_MARKOV_CNT
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"%s/%s"

	.comm	_SP_HCSTAT,8,3                  ## @SP_HCSTAT
L_.str.1:                               ## @.str.1
	.asciz	"%s: %s"

	.comm	_errno,4,2                      ## @errno
L_.str.2:                               ## @.str.2
	.asciz	"rb"

L_.str.3:                               ## @.str.3
	.asciz	"%s: Could not read data."

	.comm	_SP_FILESZ,8,3                  ## @SP_FILESZ
	.comm	_SZ_OK,8,3                      ## @SZ_OK
L_.str.4:                               ## @.str.4
	.asciz	"%s: Could not uncompress data."

	.comm	_SP_VERSION,8,3                 ## @SP_VERSION
L_.str.5:                               ## @.str.5
	.asciz	"%s: Invalid header"

	.comm	_sp_comp_val,4,2                ## @sp_comp_val
	.no_dead_strip	_sp_setup_tbl
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal8,8byte_literals
	.p2align	3                               ; -- Begin function sp_setup_tbl
lCPI0_0:
	.long	0                               ; 0x0
	.long	1                               ; 0x1
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	2
_sp_setup_tbl:                          ; @sp_setup_tbl
	.cfi_startproc
; %bb.0:
	stp	x28, x27, [sp, #-96]!           ; 16-byte Folded Spill
	.cfi_def_cfa_offset 96
	stp	x26, x25, [sp, #16]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #32]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #48]             ; 16-byte Folded Spill
	stp	x20, x19, [sp, #64]             ; 16-byte Folded Spill
	stp	x29, x30, [sp, #80]             ; 16-byte Folded Spill
	add	x29, sp, #80
	.cfi_def_cfa w29, 16
	.cfi_offset w30, -8
	.cfi_offset w29, -16
	.cfi_offset w19, -24
	.cfi_offset w20, -32
	.cfi_offset w21, -40
	.cfi_offset w22, -48
	.cfi_offset w23, -56
	.cfi_offset w24, -64
	.cfi_offset w25, -72
	.cfi_offset w26, -80
	.cfi_offset w27, -88
	.cfi_offset w28, -96
	sub	sp, sp, #384
	mov	x19, sp
	mov	x23, x0
Lloh0:
	adrp	x8, ___stack_chk_guard@GOTPAGE
Lloh1:
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
Lloh2:
	ldr	x8, [x8]
	stur	x8, [x29, #-96]
	ldp	x9, x8, [x0, #8]
	ldr	x10, [x0]
	ldr	x24, [x8]
	ldr	x11, [x10, #16]
	ldp	x22, x8, [x10]
	stp	x11, x8, [x19, #40]             ; 16-byte Folded Spill
	ldp	x21, x8, [x9]
	str	x8, [x19, #56]                  ; 8-byte Folded Spill
Lloh3:
	adrp	x8, _SP_ROOT_CNT@GOTPAGE
Lloh4:
	ldr	x8, [x8, _SP_ROOT_CNT@GOTPAGEOFF]
Lloh5:
	ldr	w0, [x8]
	mov	w1, #8
	bl	_hccalloc
	mov	x26, x0
Lloh6:
	adrp	x20, _SP_PW_MAX@GOTPAGE
Lloh7:
	ldr	x20, [x20, _SP_PW_MAX@GOTPAGEOFF]
	ldr	w12, [x20]
	lsl	x8, x12, #3
	mov	x9, x8
Lloh8:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh9:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	add	x8, x8, #15
	and	x8, x8, #0xffffffff0
	sub	x27, x9, x8
	mov	sp, x27
Lloh10:
	adrp	x25, _CHARSIZ@GOTPAGE
Lloh11:
	ldr	x25, [x25, _CHARSIZ@GOTPAGEOFF]
	cmp	w12, #1
	b.lt	LBB0_3
; %bb.1:
	ldrsw	x8, [x25]
	lsl	x8, x8, #3
	mov	x9, x26
	mov	x10, x27
LBB0_2:                                 ; =>This Inner Loop Header: Depth=1
	str	x9, [x10], #8
	add	x9, x9, x8
	subs	x12, x12, #1
	b.ne	LBB0_2
LBB0_3:
Lloh12:
	adrp	x8, _SP_MARKOV_CNT@GOTPAGE
Lloh13:
	ldr	x8, [x8, _SP_MARKOV_CNT@GOTPAGEOFF]
Lloh14:
	ldr	w0, [x8]
	mov	w1, #8
	bl	_hccalloc
	ldr	w8, [x20]
	ldr	w28, [x25]
	mul	x9, x28, x8
	lsl	x9, x9, #3
	add	x10, x9, #15
	and	x12, x10, #0xfffffffffffffff0
Lloh15:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh16:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x20, x9, x12
	mov	sp, x20
	cmp	w8, #1
	b.lt	LBB0_8
; %bb.4:
	mov	x9, #0
	sxtw	x10, w28
	lsl	x11, x28, #3
	lsl	x12, x10, #3
	mov	x13, x20
	mov	x14, x0
	b	LBB0_6
LBB0_5:                                 ;   in Loop: Header=BB0_6 Depth=1
	add	x9, x9, #1
	add	x13, x13, x11
	cmp	x9, x8
	b.eq	LBB0_8
LBB0_6:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_7 Depth 2
	mov	x15, x28
	mov	x16, x13
	cmp	w10, #1
	b.lt	LBB0_5
LBB0_7:                                 ;   Parent Loop BB0_6 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	str	x14, [x16], #8
	add	x14, x14, x12
	subs	x15, x15, #1
	b.ne	LBB0_7
	b	LBB0_5
LBB0_8:
	str	x0, [x19, #64]                  ; 8-byte Folded Spill
	cbnz	x22, LBB0_10
; %bb.9:
	add	x22, x19, #112
Lloh17:
	adrp	x8, _SP_HCSTAT@GOTPAGE
Lloh18:
	ldr	x8, [x8, _SP_HCSTAT@GOTPAGEOFF]
Lloh19:
	ldr	x4, [x8]
Lloh20:
	adrp	x2, l_.str@PAGE
Lloh21:
	add	x2, x2, l_.str@PAGEOFF
	add	x0, x19, #112
	mov	w1, #256
	mov	x3, x24
	bl	_snprintf
LBB0_10:
	add	x1, x19, #104
	mov	x0, x22
	bl	_stat
	cmn	w0, #1
	b.eq	LBB0_24
; %bb.11:
Lloh22:
	adrp	x2, l_.str.2@PAGE
Lloh23:
	add	x2, x2, l_.str.2@PAGEOFF
	add	x0, x19, #100
	mov	x1, x22
	bl	_hc_fopen
	cbz	w0, LBB0_24
; %bb.12:
	ldr	x25, [x19, #104]
	mov	x0, x25
	bl	_hcmalloc
	mov	x24, x0
	add	x3, x19, #100
	mov	w1, #1
	mov	x2, x25
	bl	_hc_fread
	str	x0, [x19, #88]
	cmp	x0, x25
	b.ne	LBB0_25
; %bb.13:
	str	x26, [x19, #32]                 ; 8-byte Folded Spill
	add	x0, x19, #100
	bl	_hc_fclose
Lloh24:
	adrp	x26, _SP_FILESZ@GOTPAGE
Lloh25:
	ldr	x26, [x26, _SP_FILESZ@GOTPAGEOFF]
	ldr	x0, [x26]
	bl	_hcmalloc
	mov	x25, x0
	ldr	x8, [x26]
	str	x8, [x19, #80]
	mov	w8, #28
	strb	w8, [x19, #79]
	add	x1, x19, #88
	add	x3, x19, #80
	add	x4, x19, #79
	mov	x0, x24
	mov	x2, x25
	bl	_hc_lzma2_decompress
Lloh26:
	adrp	x8, _SZ_OK@GOTPAGE
Lloh27:
	ldr	x8, [x8, _SZ_OK@GOTPAGEOFF]
Lloh28:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_26
; %bb.14:
	ldr	x8, [x19, #80]
	ldr	x9, [x26]
	cmp	x8, x9
	b.ne	LBB0_26
; %bb.15:
	stp	x27, x21, [x19, #16]            ; 16-byte Folded Spill
	add	x26, x25, #16
	ldr	x9, [x25]
	ldr	x8, [x25, #8]
	stp	x9, x8, [x19]                   ; 16-byte Folded Spill
Lloh29:
	adrp	x27, _SP_ROOT_CNT@GOTPAGE
Lloh30:
	ldr	x27, [x27, _SP_ROOT_CNT@GOTPAGEOFF]
	ldr	w8, [x27]
	lsl	w2, w8, #3
	ldr	x21, [x19, #32]                 ; 8-byte Folded Reload
	mov	x0, x21
	mov	x1, x26
	bl	_memcpy
	ldrsw	x8, [x27]
	add	x1, x26, x8, lsl #3
Lloh31:
	adrp	x8, _SP_MARKOV_CNT@GOTPAGE
Lloh32:
	ldr	x8, [x8, _SP_MARKOV_CNT@GOTPAGEOFF]
Lloh33:
	ldr	w8, [x8]
	lsl	w2, w8, #3
	ldr	x0, [x19, #64]                  ; 8-byte Folded Reload
	bl	_memcpy
	mov	x0, x24
	bl	_hcfree
	mov	x0, x25
	bl	_hcfree
	ldr	x0, [x19]                       ; 8-byte Folded Reload
	bl	_byte_swap_64
	mov	x24, x0
	ldr	x0, [x19, #8]                   ; 8-byte Folded Reload
	bl	_byte_swap_64
	str	x0, [x19, #8]                   ; 8-byte Folded Spill
	ldr	w8, [x27]
	cmp	w8, #1
	b.lt	LBB0_18
; %bb.16:
	mov	x26, #0
LBB0_17:                                ; =>This Inner Loop Header: Depth=1
	lsl	x25, x26, #3
	ldr	x0, [x21, x25]
	bl	_byte_swap_64
	str	x0, [x21, x25]
	add	x26, x26, #1
	ldrsw	x8, [x27]
	cmp	x26, x8
	b.lt	LBB0_17
LBB0_18:
Lloh34:
	adrp	x25, _SP_MARKOV_CNT@GOTPAGE
Lloh35:
	ldr	x25, [x25, _SP_MARKOV_CNT@GOTPAGEOFF]
	ldr	w8, [x25]
	cmp	w8, #1
	ldr	x21, [x19, #24]                 ; 8-byte Folded Reload
	b.lt	LBB0_21
; %bb.19:
	mov	x26, #0
LBB0_20:                                ; =>This Inner Loop Header: Depth=1
	lsl	x25, x26, #3
	ldr	x8, [x19, #64]                  ; 8-byte Folded Reload
	ldr	x0, [x8, x25]
	bl	_byte_swap_64
	ldr	x8, [x19, #64]                  ; 8-byte Folded Reload
	str	x0, [x8, x25]
Lloh36:
	adrp	x25, _SP_MARKOV_CNT@GOTPAGE
Lloh37:
	ldr	x25, [x25, _SP_MARKOV_CNT@GOTPAGEOFF]
	add	x26, x26, #1
	ldrsw	x8, [x25]
	cmp	x26, x8
	b.lt	LBB0_20
LBB0_21:
Lloh38:
	adrp	x8, _SP_VERSION@GOTPAGE
Lloh39:
	ldr	x8, [x8, _SP_VERSION@GOTPAGEOFF]
Lloh40:
	ldr	x8, [x8]
	cmp	x24, x8
	ldr	x27, [x19, #16]                 ; 8-byte Folded Reload
	b.ne	LBB0_23
; %bb.22:
	ldr	x8, [x19, #8]                   ; 8-byte Folded Reload
	cbz	x8, LBB0_31
LBB0_23:
Lloh41:
	adrp	x1, l_.str.5@PAGE
Lloh42:
	add	x1, x1, l_.str.5@PAGEOFF
	mov	x0, x23
	mov	x2, x22
	bl	_event_log_error
	b	LBB0_28
LBB0_24:
Lloh43:
	adrp	x8, _errno@GOTPAGE
Lloh44:
	ldr	x8, [x8, _errno@GOTPAGEOFF]
Lloh45:
	ldr	w0, [x8]
	bl	_strerror
                                        ; kill: def $w0 killed $w0 def $x0
	str	x0, [sp, #-16]!
Lloh46:
	adrp	x1, l_.str.1@PAGE
Lloh47:
	add	x1, x1, l_.str.1@PAGEOFF
	mov	x0, x23
	mov	x2, x22
	bl	_event_log_error
	add	sp, sp, #16
	b	LBB0_28
LBB0_25:
Lloh48:
	adrp	x1, l_.str.3@PAGE
Lloh49:
	add	x1, x1, l_.str.3@PAGEOFF
	mov	x0, x23
	mov	x2, x22
	bl	_event_log_error
	add	x0, x19, #100
	bl	_hc_fclose
	mov	x0, x24
	b	LBB0_27
LBB0_26:
Lloh50:
	adrp	x1, l_.str.4@PAGE
Lloh51:
	add	x1, x1, l_.str.4@PAGEOFF
	mov	x0, x23
	mov	x2, x22
	bl	_event_log_error
	mov	x0, x24
	bl	_hcfree
	mov	x0, x25
LBB0_27:
	bl	_hcfree
LBB0_28:
	mov	w0, #-1
LBB0_29:
	ldur	x8, [x29, #-96]
Lloh52:
	adrp	x9, ___stack_chk_guard@GOTPAGE
Lloh53:
	ldr	x9, [x9, ___stack_chk_guard@GOTPAGEOFF]
Lloh54:
	ldr	x9, [x9]
	cmp	x9, x8
	b.ne	LBB0_103
; %bb.30:
	sub	sp, x29, #80
	ldp	x29, x30, [sp, #80]             ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #64]             ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #48]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #32]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #16]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp], #96             ; 16-byte Folded Reload
	ret
LBB0_31:
Lloh55:
	adrp	x24, _SP_ROOT_CNT@GOTPAGE
Lloh56:
	ldr	x24, [x24, _SP_ROOT_CNT@GOTPAGEOFF]
	ldr	x8, [x19, #40]                  ; 8-byte Folded Reload
	cbz	x8, LBB0_33
; %bb.32:
	ldr	w8, [x24]
	lsl	w2, w8, #3
	ldr	x0, [x19, #32]                  ; 8-byte Folded Reload
	mov	w1, #0
	bl	_memset
	ldr	w8, [x25]
	lsl	w2, w8, #3
	ldr	x0, [x19, #64]                  ; 8-byte Folded Reload
	mov	w1, #0
	bl	_memset
LBB0_33:
Lloh57:
	adrp	x25, _SP_PW_MAX@GOTPAGE
Lloh58:
	ldr	x25, [x25, _SP_PW_MAX@GOTPAGEOFF]
	ldr	w12, [x25]
Lloh59:
	adrp	x26, _CHARSIZ@GOTPAGE
Lloh60:
	ldr	x26, [x26, _CHARSIZ@GOTPAGEOFF]
	ldr	x8, [x19, #48]                  ; 8-byte Folded Reload
	cbz	x8, LBB0_65
; %bb.34:
	cmp	w12, #1
	b.le	LBB0_65
; %bb.35:
	ldr	x8, [x27]
	ldr	w9, [x26]
	sub	w10, w9, #1
	add	x11, x10, #1
	add	x13, x8, x11, lsl #3
	and	x14, x11, #0x1fffffff8
	add	x15, x8, x14, lsl #3
	add	x16, x8, #32
	mov	w17, #1
	b	LBB0_37
LBB0_36:                                ;   in Loop: Header=BB0_37 Depth=1
	add	x17, x17, #1
	cmp	x17, x12
	b.eq	LBB0_46
LBB0_37:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_41 Depth 2
                                        ;     Child Loop BB0_45 Depth 2
	cmp	w9, #1
	b.lt	LBB0_36
; %bb.38:                               ;   in Loop: Header=BB0_37 Depth=1
	ldr	x0, [x27, x17, lsl #3]
	cmp	w10, #7
	b.lo	LBB0_43
; %bb.39:                               ;   in Loop: Header=BB0_37 Depth=1
	add	x1, x0, x11, lsl #3
	cmp	x8, x1
	ccmp	x0, x13, #2, lo
	b.lo	LBB0_43
; %bb.40:                               ;   in Loop: Header=BB0_37 Depth=1
	add	x1, x0, #32
	mov	x2, x16
	mov	x3, x14
	add	x0, x0, x14, lsl #3
LBB0_41:                                ;   Parent Loop BB0_37 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldp	q0, q1, [x1, #-32]
	ldp	q2, q3, [x1], #64
	ldp	q4, q5, [x2, #-32]
	ldp	q6, q7, [x2]
	add.2d	v0, v4, v0
	add.2d	v1, v5, v1
	add.2d	v2, v6, v2
	add.2d	v3, v7, v3
	stp	q0, q1, [x2, #-32]
	stp	q2, q3, [x2], #64
	subs	x3, x3, #8
	b.ne	LBB0_41
; %bb.42:                               ;   in Loop: Header=BB0_37 Depth=1
	mov	x2, x14
	mov	x1, x15
	cmp	x11, x14
	b.eq	LBB0_36
	b	LBB0_44
LBB0_43:                                ;   in Loop: Header=BB0_37 Depth=1
	mov	w2, #0
	mov	x1, x8
LBB0_44:                                ;   in Loop: Header=BB0_37 Depth=1
	sub	w2, w9, w2
LBB0_45:                                ;   Parent Loop BB0_37 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	x3, [x0], #8
	ldr	x4, [x1]
	add	x3, x4, x3
	str	x3, [x1], #8
	subs	w2, w2, #1
	b.ne	LBB0_45
	b	LBB0_36
LBB0_46:
	ldr	x8, [x20]
	ldr	w9, [x26]
	sub	w10, w9, #1
	add	x11, x10, #1
	and	x13, x11, #0x1fffffff8
	mov	w14, #1
	lsl	x15, x11, #3
	b	LBB0_48
LBB0_47:                                ;   in Loop: Header=BB0_48 Depth=1
	add	x14, x14, #1
	cmp	x14, x12
	b.eq	LBB0_59
LBB0_48:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_51 Depth 2
                                        ;       Child Loop BB0_54 Depth 3
                                        ;       Child Loop BB0_58 Depth 3
	cmp	w9, #1
	b.lt	LBB0_47
; %bb.49:                               ;   in Loop: Header=BB0_48 Depth=1
	mov	w16, #0
	mul	x17, x14, x28
	ldr	x1, [x20, x17, lsl #3]
	mov	x2, x8
	b	LBB0_51
LBB0_50:                                ;   in Loop: Header=BB0_51 Depth=2
	add	w16, w16, #1
	mov	x1, x17
	mov	x2, x0
	cmp	w16, w9
	b.eq	LBB0_47
LBB0_51:                                ;   Parent Loop BB0_48 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_54 Depth 3
                                        ;       Child Loop BB0_58 Depth 3
	cmp	w10, #7
	b.lo	LBB0_56
; %bb.52:                               ;   in Loop: Header=BB0_51 Depth=2
	add	x17, x2, x15
	add	x0, x1, x15
	cmp	x2, x0
	ccmp	x1, x17, #2, lo
	b.lo	LBB0_56
; %bb.53:                               ;   in Loop: Header=BB0_51 Depth=2
	lsl	x0, x13, #3
	add	x17, x1, x0
	add	x0, x2, x0
	add	x1, x1, #32
	add	x2, x2, #32
	mov	x3, x13
LBB0_54:                                ;   Parent Loop BB0_48 Depth=1
                                        ;     Parent Loop BB0_51 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	ldp	q0, q1, [x1, #-32]
	ldp	q2, q3, [x1], #64
	ldp	q4, q5, [x2, #-32]
	ldp	q6, q7, [x2]
	add.2d	v0, v4, v0
	add.2d	v1, v5, v1
	add.2d	v2, v6, v2
	add.2d	v3, v7, v3
	stp	q0, q1, [x2, #-32]
	stp	q2, q3, [x2], #64
	subs	x3, x3, #8
	b.ne	LBB0_54
; %bb.55:                               ;   in Loop: Header=BB0_51 Depth=2
	mov	x3, x13
	cmp	x11, x13
	b.eq	LBB0_50
	b	LBB0_57
LBB0_56:                                ;   in Loop: Header=BB0_51 Depth=2
	mov	w3, #0
	mov	x17, x1
	mov	x0, x2
LBB0_57:                                ;   in Loop: Header=BB0_51 Depth=2
	sub	w1, w9, w3
LBB0_58:                                ;   Parent Loop BB0_48 Depth=1
                                        ;     Parent Loop BB0_51 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	ldr	x2, [x17], #8
	ldr	x3, [x0]
	add	x2, x3, x2
	str	x2, [x0], #8
	subs	w1, w1, #1
	b.ne	LBB0_58
	b	LBB0_50
LBB0_59:
	ldr	x22, [x27]
	mov	w23, #1
LBB0_60:                                ; =>This Inner Loop Header: Depth=1
	ldr	x0, [x27, x23, lsl #3]
	ldr	w8, [x26]
	lsl	w2, w8, #3
	mov	x1, x22
	bl	_memcpy
	add	x23, x23, #1
	ldrsw	x8, [x25]
	cmp	x23, x8
	b.lt	LBB0_60
; %bb.61:
	mov	x12, x8
	cmp	w8, #2
	b.lt	LBB0_65
; %bb.62:
	ldr	x22, [x20]
	lsl	x23, x28, #3
	add	x20, x20, x23
	mov	w24, #1
LBB0_63:                                ; =>This Inner Loop Header: Depth=1
	ldr	x0, [x20]
	ldr	w8, [x26]
	mul	w8, w8, w8
	lsl	w2, w8, #3
	mov	x1, x22
	bl	_memcpy
	add	x24, x24, #1
	ldrsw	x12, [x25]
	add	x20, x20, x23
	cmp	x24, x12
	b.lt	LBB0_63
; %bb.64:
                                        ; kill: def $w12 killed $w12 killed $x12 def $x12
Lloh61:
	adrp	x24, _SP_ROOT_CNT@GOTPAGE
Lloh62:
	ldr	x24, [x24, _SP_ROOT_CNT@GOTPAGEOFF]
LBB0_65:
	mov	w13, w12
	lsl	x8, x13, #3
	mov	x9, x8
Lloh63:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh64:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	add	x8, x8, #15
	and	x8, x8, #0xffffffff0
	sub	x23, x9, x8
	mov	sp, x23
	ldrsw	x8, [x26]
	and	x22, x8, #0xffffffff
	cmp	w12, #1
	b.lt	LBB0_72
; %bb.66:
	lsl	x12, x8, #4
	ldp	x7, x17, [x19, #56]             ; 16-byte Folded Reload
	mov	x9, x7
	mov	x10, x13
	mov	x11, x23
LBB0_67:                                ; =>This Inner Loop Header: Depth=1
	str	x9, [x11], #8
	add	x9, x9, x12
	subs	x10, x10, #1
	b.ne	LBB0_67
; %bb.68:
	mul	x9, x22, x13
	lsl	x9, x9, #3
	add	x10, x9, #15
	and	x14, x10, #0xfffffffffffffff0
Lloh65:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh66:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x20, x9, x14
	mov	sp, x20
	mov	x9, #0
	lsl	x10, x22, #3
	mov	x11, x20
	mov	x14, x21
	b	LBB0_70
LBB0_69:                                ;   in Loop: Header=BB0_70 Depth=1
	add	x9, x9, #1
	add	x11, x11, x10
	cmp	x9, x13
	b.eq	LBB0_73
LBB0_70:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_71 Depth 2
	mov	x15, x22
	mov	x16, x11
	cmp	w22, #1
	b.lt	LBB0_69
LBB0_71:                                ;   Parent Loop BB0_70 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	str	x14, [x16], #8
	add	x14, x14, x12
	subs	x15, x15, #1
	b.ne	LBB0_71
	b	LBB0_69
LBB0_72:
	mul	x9, x22, x13
	lsl	x9, x9, #3
	add	x10, x9, #15
	and	x12, x10, #0xfffffffffffffff0
Lloh67:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh68:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x20, x9, x12
	mov	sp, x20
	ldp	x7, x17, [x19, #56]             ; 16-byte Folded Reload
LBB0_73:
	ldr	w9, [x24]
	cmp	w9, #1
	b.lt	LBB0_83
; %bb.74:
	cmp	w9, #8
	b.hs	LBB0_76
; %bb.75:
	mov	x10, #0
	ldr	x13, [x19, #32]                 ; 8-byte Folded Reload
	b	LBB0_81
LBB0_76:
	add	x10, x7, x9, lsl #4
	sub	x10, x10, #8
	ldr	x13, [x19, #32]                 ; 8-byte Folded Reload
	add	x11, x13, x9, lsl #3
	cmp	x7, x11
	ccmp	x13, x10, #2, lo
	b.lo	LBB0_80
; %bb.77:
	dup.2s	v0, w22
	dup.2s	v1, w8
	dup.2s	v2, w22
	and	x10, x9, #0xfffffff8
	add	x12, x7, #64
Lloh69:
	adrp	x11, lCPI0_0@PAGE
Lloh70:
	ldr	d3, [x11, lCPI0_0@PAGEOFF]
	add	x11, x13, #32
	movi.2s	v4, #2
	movi.2s	v5, #4
	movi.2s	v6, #6
	mov.s	w13, v0[1]
	mov.s	w14, v1[1]
	mov.s	w15, v2[1]
	mov.s	w16, v0[1]
	movi.2s	v7, #8
	mov	x17, x10
LBB0_78:                                ; =>This Inner Loop Header: Depth=1
	add.2s	v16, v3, v4
	add.2s	v17, v3, v5
	fmov	w0, s0
	fmov	w1, s3
	sdiv	w2, w1, w0
	msub	w0, w2, w0, w1
	mov.s	w1, v16[1]
	fmov	w2, s1
	fmov	w3, s16
	sdiv	w4, w3, w2
	msub	w2, w4, w2, w3
	mov.s	w3, v17[1]
	fmov	w4, s2
	fmov	w5, s17
	sdiv	w6, w5, w4
	msub	w4, w6, w4, w5
	mov.s	w5, v3[1]
	sdiv	w6, w5, w13
	msub	w5, w6, w13, w5
	sdiv	w6, w1, w14
	fmov	s16, w0
	msub	w0, w6, w14, w1
	add.2s	v17, v3, v6
	fmov	s18, w2
	sdiv	w1, w3, w15
	mov.s	v16[1], w5
	msub	w1, w1, w15, w3
	fmov	s19, w4
	mov.s	w2, v17[1]
	mov.s	v18[1], w0
	sdiv	w0, w2, w16
	msub	w0, w0, w16, w2
	fmov	w2, s0
	fmov	w3, s17
	mov.s	v19[1], w1
	sdiv	w1, w3, w2
	msub	w1, w1, w2, w3
	fmov	s17, w1
	mov.s	v17[1], w0
	ushll.2d	v21, v16, #0
	ushll.2d	v23, v18, #0
	ushll.2d	v19, v19, #0
	ushll.2d	v17, v17, #0
	ldp	q20, q22, [x11, #-32]
	ldp	q18, q16, [x11], #64
	sub	x0, x12, #64
	st2.2d	{ v20, v21 }, [x0]
	sub	x0, x12, #32
	st2.2d	{ v22, v23 }, [x0]
	add	x0, x12, #128
	st2.2d	{ v18, v19 }, [x12], #32
	st2.2d	{ v16, v17 }, [x12]
	add.2s	v3, v3, v7
	mov	x12, x0
	subs	x17, x17, #8
	b.ne	LBB0_78
; %bb.79:
	cmp	x10, x9
	ldr	x13, [x19, #32]                 ; 8-byte Folded Reload
	ldr	x17, [x19, #64]                 ; 8-byte Folded Reload
	b.ne	LBB0_81
	b	LBB0_83
LBB0_80:
	mov	x10, #0
LBB0_81:
	add	x11, x7, x10, lsl #4
	add	x11, x11, #8
LBB0_82:                                ; =>This Inner Loop Header: Depth=1
	sdiv	w12, w10, w8
	msub	w12, w12, w8, w10
	str	x12, [x11]
	ldr	x12, [x13, x10, lsl #3]
	stur	x12, [x11, #-8]
	add	x10, x10, #1
	add	x11, x11, #16
	cmp	x9, x10
	b.ne	LBB0_82
LBB0_83:
Lloh71:
	adrp	x9, _SP_MARKOV_CNT@GOTPAGE
Lloh72:
	ldr	x9, [x9, _SP_MARKOV_CNT@GOTPAGEOFF]
Lloh73:
	ldr	w9, [x9]
	cmp	w9, #1
	b.lt	LBB0_92
; %bb.84:
	cmp	w9, #8
	b.lo	LBB0_89
; %bb.85:
	add	x10, x21, x9, lsl #4
	sub	x10, x10, #8
	add	x11, x17, x9, lsl #3
	cmp	x21, x11
	ccmp	x17, x10, #2, lo
	b.lo	LBB0_89
; %bb.86:
	dup.2s	v0, w8
	dup.2s	v1, w22
	dup.2s	v2, w22
	and	x8, x9, #0xfffffff8
	add	x11, x21, #64
Lloh74:
	adrp	x10, lCPI0_0@PAGE
Lloh75:
	ldr	d3, [x10, lCPI0_0@PAGEOFF]
	add	x10, x17, #32
	movi.2s	v4, #2
	movi.2s	v5, #4
	movi.2s	v6, #6
	mov.s	w12, v0[1]
	mov.s	w13, v1[1]
	mov.s	w14, v0[1]
	mov.s	w15, v2[1]
	movi.2s	v7, #8
	mov	x16, x8
LBB0_87:                                ; =>This Inner Loop Header: Depth=1
	add.2s	v16, v3, v4
	add.2s	v17, v3, v5
	fmov	w17, s0
	fmov	w0, s3
	sdiv	w1, w0, w17
	msub	w17, w1, w17, w0
	mov.s	w0, v16[1]
	fmov	w1, s1
	fmov	w2, s16
	sdiv	w3, w2, w1
	msub	w1, w3, w1, w2
	mov.s	w2, v17[1]
	fmov	w3, s0
	fmov	w4, s17
	sdiv	w5, w4, w3
	msub	w3, w5, w3, w4
	mov.s	w4, v3[1]
	sdiv	w5, w4, w12
	msub	w4, w5, w12, w4
	sdiv	w5, w0, w13
	fmov	s16, w17
	msub	w17, w5, w13, w0
	add.2s	v17, v3, v6
	fmov	s18, w1
	sdiv	w0, w2, w14
	mov.s	v16[1], w4
	msub	w0, w0, w14, w2
	fmov	s19, w3
	mov.s	w1, v17[1]
	mov.s	v18[1], w17
	sdiv	w17, w1, w15
	msub	w17, w17, w15, w1
	fmov	w1, s2
	fmov	w2, s17
	mov.s	v19[1], w0
	sdiv	w0, w2, w1
	msub	w0, w0, w1, w2
	fmov	s17, w0
	mov.s	v17[1], w17
	ushll.2d	v21, v16, #0
	ushll.2d	v23, v18, #0
	ushll.2d	v19, v19, #0
	ushll.2d	v17, v17, #0
	ldp	q20, q22, [x10, #-32]
	ldp	q18, q16, [x10], #64
	sub	x17, x11, #64
	st2.2d	{ v20, v21 }, [x17]
	sub	x17, x11, #32
	st2.2d	{ v22, v23 }, [x17]
	add	x17, x11, #128
	st2.2d	{ v18, v19 }, [x11], #32
	st2.2d	{ v16, v17 }, [x11]
	add.2s	v3, v3, v7
	mov	x11, x17
	subs	x16, x16, #8
	b.ne	LBB0_87
; %bb.88:
	cmp	x8, x9
	ldr	x17, [x19, #64]                 ; 8-byte Folded Reload
	b.ne	LBB0_90
	b	LBB0_92
LBB0_89:
	mov	x8, #0
LBB0_90:
	add	x10, x21, x8, lsl #4
	add	x10, x10, #8
LBB0_91:                                ; =>This Inner Loop Header: Depth=1
	sdiv	w11, w8, w22
	msub	w11, w11, w22, w8
	str	x11, [x10]
	ldr	x11, [x17, x8, lsl #3]
	stur	x11, [x10, #-8]
	add	x8, x8, #1
	add	x10, x10, #16
	cmp	x9, x8
	b.ne	LBB0_91
LBB0_92:
	mov	x21, x17
	ldr	x0, [x19, #32]                  ; 8-byte Folded Reload
	bl	_hcfree
	mov	x0, x21
	bl	_hcfree
	ldr	w8, [x25]
	cmp	w8, #1
	b.lt	LBB0_102
; %bb.93:
	mov	x24, #0
Lloh76:
	adrp	x21, _sp_comp_val@GOTPAGE
Lloh77:
	ldr	x21, [x21, _sp_comp_val@GOTPAGEOFF]
LBB0_94:                                ; =>This Inner Loop Header: Depth=1
	ldr	x0, [x23, x24, lsl #3]
	ldr	w1, [x26]
	ldr	w3, [x21]
	mov	w2, #16
	bl	_qsort
	add	x24, x24, #1
	ldrsw	x8, [x25]
	cmp	x24, x8
	b.lt	LBB0_94
; %bb.95:
	cmp	w8, #1
	b.lt	LBB0_102
; %bb.96:
	mov	x23, #0
	ldr	w1, [x26]
	lsl	x22, x22, #3
	b	LBB0_98
LBB0_97:                                ;   in Loop: Header=BB0_98 Depth=1
	mov	w0, #0
	add	x23, x23, #1
	add	x20, x20, x22
	cmp	x23, w8, sxtw
	b.ge	LBB0_29
LBB0_98:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_100 Depth 2
	cmp	w1, #1
	b.lt	LBB0_97
; %bb.99:                               ;   in Loop: Header=BB0_98 Depth=1
	mov	x24, #0
LBB0_100:                               ;   Parent Loop BB0_98 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	x0, [x20, x24, lsl #3]
	ldr	w3, [x21]
                                        ; kill: def $w1 killed $w1 killed $x1
	mov	w2, #16
	bl	_qsort
	add	x24, x24, #1
	ldrsw	x1, [x26]
	cmp	x24, x1
	b.lt	LBB0_100
; %bb.101:                              ;   in Loop: Header=BB0_98 Depth=1
	ldr	w8, [x25]
	b	LBB0_97
LBB0_102:
	mov	w0, #0
	b	LBB0_29
LBB0_103:
	bl	___stack_chk_fail
	.loh AdrpLdrGot	Lloh10, Lloh11
	.loh AdrpLdrGot	Lloh8, Lloh9
	.loh AdrpLdrGot	Lloh6, Lloh7
	.loh AdrpLdrGotLdr	Lloh3, Lloh4, Lloh5
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.loh AdrpLdrGot	Lloh15, Lloh16
	.loh AdrpLdrGotLdr	Lloh12, Lloh13, Lloh14
	.loh AdrpAdd	Lloh20, Lloh21
	.loh AdrpLdrGotLdr	Lloh17, Lloh18, Lloh19
	.loh AdrpAdd	Lloh22, Lloh23
	.loh AdrpLdrGotLdr	Lloh26, Lloh27, Lloh28
	.loh AdrpLdrGot	Lloh24, Lloh25
	.loh AdrpLdrGotLdr	Lloh31, Lloh32, Lloh33
	.loh AdrpLdrGot	Lloh29, Lloh30
	.loh AdrpLdrGot	Lloh34, Lloh35
	.loh AdrpLdrGot	Lloh36, Lloh37
	.loh AdrpLdrGotLdr	Lloh38, Lloh39, Lloh40
	.loh AdrpAdd	Lloh41, Lloh42
	.loh AdrpAdd	Lloh46, Lloh47
	.loh AdrpLdrGotLdr	Lloh43, Lloh44, Lloh45
	.loh AdrpAdd	Lloh48, Lloh49
	.loh AdrpAdd	Lloh50, Lloh51
	.loh AdrpLdrGotLdr	Lloh52, Lloh53, Lloh54
	.loh AdrpLdrGot	Lloh55, Lloh56
	.loh AdrpLdrGot	Lloh59, Lloh60
	.loh AdrpLdrGot	Lloh57, Lloh58
	.loh AdrpLdrGot	Lloh61, Lloh62
	.loh AdrpLdrGot	Lloh63, Lloh64
	.loh AdrpLdrGot	Lloh65, Lloh66
	.loh AdrpLdrGot	Lloh67, Lloh68
	.loh AdrpLdr	Lloh69, Lloh70
	.loh AdrpLdrGotLdr	Lloh71, Lloh72, Lloh73
	.loh AdrpLdr	Lloh74, Lloh75
	.loh AdrpLdrGot	Lloh76, Lloh77
	.cfi_endproc
                                        ; -- End function
	.comm	_SP_ROOT_CNT,4,2                ; @SP_ROOT_CNT
	.comm	_SP_PW_MAX,4,2                  ; @SP_PW_MAX
	.comm	_CHARSIZ,4,2                    ; @CHARSIZ
	.comm	_SP_MARKOV_CNT,4,2              ; @SP_MARKOV_CNT
	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.asciz	"%s/%s"

	.comm	_SP_HCSTAT,8,3                  ; @SP_HCSTAT
l_.str.1:                               ; @.str.1
	.asciz	"%s: %s"

	.comm	_errno,4,2                      ; @errno
l_.str.2:                               ; @.str.2
	.asciz	"rb"

l_.str.3:                               ; @.str.3
	.asciz	"%s: Could not read data."

	.comm	_SP_FILESZ,8,3                  ; @SP_FILESZ
	.comm	_SZ_OK,8,3                      ; @SZ_OK
l_.str.4:                               ; @.str.4
	.asciz	"%s: Could not uncompress data."

	.comm	_SP_VERSION,8,3                 ; @SP_VERSION
l_.str.5:                               ; @.str.5
	.asciz	"%s: Invalid header"

	.comm	_sp_comp_val,4,2                ; @sp_comp_val
	.no_dead_strip	_sp_setup_tbl
.subsections_via_symbols
