	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	4, 0x90                         ## -- Begin function calc_combed_score
_calc_combed_score:                     ## @calc_combed_score
	.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	$216, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%rsi, -128(%rbp)                ## 8-byte Spill
	movq	%rdi, %r12
	movl	(%rdi), %r15d
	leal	(%r15,%r15), %eax
	leal	(%rax,%rax,2), %eax
	movl	%eax, -64(%rbp)                 ## 4-byte Spill
	xorl	%r11d, %r11d
	movq	%rdi, -152(%rbp)                ## 8-byte Spill
	jmp	LBB0_1
	.p2align	4, 0x90
LBB0_2:                                 ##   in Loop: Header=BB0_1 Depth=1
	movl	-88(%rbp), %esi                 ## 4-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx
	movl	$255, %r8d
	callq	_fill_buf
	movq	-96(%rbp), %r11                 ## 8-byte Reload
LBB0_19:                                ##   in Loop: Header=BB0_1 Depth=1
	incq	%r11
	movq	48(%r12), %rax
	xorl	%ecx, %ecx
	testq	%rax, %rax
	setne	%cl
	addq	%rcx, %rcx
	incq	%rcx
	cmpq	%rcx, %r11
	jae	LBB0_20
LBB0_1:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_23 Depth 2
                                        ##     Child Loop BB0_28 Depth 2
                                        ##     Child Loop BB0_35 Depth 2
                                        ##       Child Loop BB0_37 Depth 3
                                        ##     Child Loop BB0_9 Depth 2
                                        ##     Child Loop BB0_15 Depth 2
	movq	-128(%rbp), %rbx                ## 8-byte Reload
	movq	(%rbx), %rax
	movq	8(%rbx), %rcx
	movq	%r11, %r13
	movq	(%rax,%r11,8), %r14
	movslq	(%rcx,%r11,4), %rax
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	movq	%r12, %rdi
	movq	%rbx, %rsi
	movl	%r13d, %edx
	callq	_get_width
	movl	%eax, -88(%rbp)                 ## 4-byte Spill
	movq	%r12, %rdi
	movq	%rbx, %rsi
	movl	%r13d, %edx
	callq	_get_height
	movl	%eax, %edx
	movq	8(%r12), %rax
	movq	16(%r12), %rcx
	movq	(%rax,%r13,8), %rdi
	movq	%r13, -96(%rbp)                 ## 8-byte Spill
	movslq	(%rcx,%r13,4), %rcx
	testl	%r15d, %r15d
	js	LBB0_2
## %bb.3:                               ##   in Loop: Header=BB0_1 Depth=1
	movq	%rdi, -48(%rbp)                 ## 8-byte Spill
	movl	-88(%rbp), %ebx                 ## 4-byte Reload
	movl	%ebx, %esi
	movl	%edx, %r12d
	movq	%rcx, -104(%rbp)                ## 8-byte Spill
                                        ## kill: def $ecx killed $ecx killed $rcx
	xorl	%r8d, %r8d
	callq	_fill_buf
	movl	%ebx, %r11d
	testl	%ebx, %ebx
	jle	LBB0_4
## %bb.22:                              ##   in Loop: Header=BB0_1 Depth=1
	movl	%r12d, -56(%rbp)                ## 4-byte Spill
	movq	-80(%rbp), %r13                 ## 8-byte Reload
	movq	%r13, %r8
	addq	%r13, %r8
	leaq	(%r14,%r13,8), %r9
	leaq	(%r14,%r13,4), %rdx
	xorl	%esi, %esi
	movq	-48(%rbp), %r10                 ## 8-byte Reload
	jmp	LBB0_23
	.p2align	4, 0x90
LBB0_26:                                ##   in Loop: Header=BB0_23 Depth=2
	incq	%rsi
	cmpq	%rsi, %r11
	je	LBB0_27
LBB0_23:                                ##   Parent Loop BB0_1 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r14,%rsi,4), %edi
	movl	(%rdx,%rsi,4), %ebx
	movl	%edi, %eax
	subl	%ebx, %eax
	movl	%eax, %ecx
	negl	%ecx
	cmovsl	%eax, %ecx
	cmpl	%r15d, %ecx
	jle	LBB0_26
## %bb.24:                              ##   in Loop: Header=BB0_23 Depth=2
	shll	$2, %edi
	addl	%ebx, %ebx
	leal	(%rbx,%rbx,2), %eax
	subl	%eax, %edi
	movl	(%r9,%rsi,4), %eax
	leal	(%rdi,%rax,2), %eax
	movl	%eax, %ecx
	negl	%ecx
	cmovsl	%eax, %ecx
	cmpl	-64(%rbp), %ecx                 ## 4-byte Folded Reload
	jle	LBB0_26
## %bb.25:                              ##   in Loop: Header=BB0_23 Depth=2
	movl	$255, (%r10,%rsi,4)
	jmp	LBB0_26
	.p2align	4, 0x90
LBB0_27:                                ##   in Loop: Header=BB0_1 Depth=1
	movq	-104(%rbp), %rax                ## 8-byte Reload
	leaq	(%r10,%rax,4), %rax
	shlq	$2, %r8
	leaq	(%r8,%r13,4), %r9
	movq	%r11, %rdx
	movq	%r14, %rsi
	jmp	LBB0_28
	.p2align	4, 0x90
LBB0_32:                                ##   in Loop: Header=BB0_28 Depth=2
	addq	$4, %rsi
	addq	$4, %rax
	decq	%rdx
	je	LBB0_33
LBB0_28:                                ##   Parent Loop BB0_1 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rsi,%r13,4), %edi
	movl	(%rsi), %r8d
	movl	%edi, %ebx
	subl	%r8d, %ebx
	movl	%ebx, %ecx
	negl	%ecx
	cmovsl	%ebx, %ecx
	cmpl	%r15d, %ecx
	jle	LBB0_32
## %bb.29:                              ##   in Loop: Header=BB0_28 Depth=2
	movl	(%rsi,%r13,8), %r10d
	movl	%edi, %ecx
	subl	%r10d, %ecx
	movl	%ecx, %ebx
	negl	%ebx
	cmovsl	%ecx, %ebx
	cmpl	%r15d, %ebx
	jle	LBB0_32
## %bb.30:                              ##   in Loop: Header=BB0_28 Depth=2
	shll	$2, %edi
	addl	%r8d, %r10d
	leal	(%r10,%r10,2), %ecx
	subl	%ecx, %edi
	movl	(%rsi,%r9), %ecx
	leal	(%rdi,%rcx,2), %ecx
	movl	%ecx, %edi
	negl	%edi
	cmovsl	%ecx, %edi
	cmpl	-64(%rbp), %edi                 ## 4-byte Folded Reload
	jle	LBB0_32
## %bb.31:                              ##   in Loop: Header=BB0_28 Depth=2
	movl	$255, (%rax)
	jmp	LBB0_32
	.p2align	4, 0x90
LBB0_33:                                ##   in Loop: Header=BB0_1 Depth=1
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	movl	-56(%rbp), %r12d                ## 4-byte Reload
	jmp	LBB0_5
	.p2align	4, 0x90
LBB0_4:                                 ##   in Loop: Header=BB0_1 Depth=1
	movq	-80(%rbp), %r13                 ## 8-byte Reload
	movq	-104(%rbp), %rdi                ## 8-byte Reload
LBB0_5:                                 ##   in Loop: Header=BB0_1 Depth=1
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%rdi,4), %rax
	leaq	(%r14,%r13,4), %rsi
	leaq	(%rsi,%r13,4), %rcx
	leaq	(%rax,%rdi,4), %rax
	movq	%rax, -48(%rbp)                 ## 8-byte Spill
	cmpl	$5, %r12d
	movq	%r11, -72(%rbp)                 ## 8-byte Spill
	movq	%r13, -80(%rbp)                 ## 8-byte Spill
	jl	LBB0_6
## %bb.34:                              ##   in Loop: Header=BB0_1 Depth=1
	leal	(%r13,%r13), %eax
	cltq
	addl	$-3, %r12d
	movl	%r12d, -56(%rbp)                ## 4-byte Spill
	movq	%r13, %rdx
	addq	%r13, %rdx
	leaq	(%rax,%r13,2), %rax
	leaq	(%r14,%rax,4), %r9
	leaq	(,%r13,4), %rax
	movq	%rax, -144(%rbp)                ## 8-byte Spill
	subq	%r13, %rdx
	subq	%r13, %rdx
	movq	%r11, %rax
	leaq	(%r14,%rdx,4), %r11
	leaq	(,%r13,2), %rdx
	addq	%r13, %rdx
	leaq	(%r14,%rdx,4), %rbx
	leaq	(,%rdi,4), %rdx
	movq	%rdx, -136(%rbp)                ## 8-byte Spill
	leaq	(,%rax,4), %rdx
	movl	$2, %r14d
	movl	-88(%rbp), %eax                 ## 4-byte Reload
	jmp	LBB0_35
	.p2align	4, 0x90
LBB0_42:                                ##   in Loop: Header=BB0_35 Depth=2
	leal	1(%r14), %r8d
	movq	-144(%rbp), %rdi                ## 8-byte Reload
	addq	%rdi, %rcx
	movq	-136(%rbp), %rax                ## 8-byte Reload
	addq	%rax, -48(%rbp)                 ## 8-byte Folded Spill
	addq	%rdi, %r9
	addq	%rdi, %r11
	addq	%rdi, %rbx
	addq	%rdi, %rsi
	cmpl	-56(%rbp), %r14d                ## 4-byte Folded Reload
	movl	%r8d, %r14d
	movl	-88(%rbp), %eax                 ## 4-byte Reload
	je	LBB0_7
LBB0_35:                                ##   Parent Loop BB0_1 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_37 Depth 3
	testl	%eax, %eax
	jle	LBB0_42
## %bb.36:                              ##   in Loop: Header=BB0_35 Depth=2
	xorl	%r12d, %r12d
	jmp	LBB0_37
	.p2align	4, 0x90
LBB0_41:                                ##   in Loop: Header=BB0_37 Depth=3
	addq	$4, %r12
	cmpq	%r12, %rdx
	je	LBB0_42
LBB0_37:                                ##   Parent Loop BB0_1 Depth=1
                                        ##     Parent Loop BB0_35 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movl	(%rcx,%r12), %r10d
	movl	(%rsi,%r12), %r13d
	movl	%r10d, %eax
	subl	%r13d, %eax
	movl	%eax, %edi
	negl	%edi
	cmovsl	%eax, %edi
	cmpl	%r15d, %edi
	jle	LBB0_41
## %bb.38:                              ##   in Loop: Header=BB0_37 Depth=3
	movl	(%rbx,%r12), %r8d
	movl	%r10d, %eax
	subl	%r8d, %eax
	movl	%eax, %edi
	negl	%edi
	cmovsl	%eax, %edi
	cmpl	%r15d, %edi
	jle	LBB0_41
## %bb.39:                              ##   in Loop: Header=BB0_37 Depth=3
	shll	$2, %r10d
	addl	%r13d, %r8d
	leal	(%r8,%r8,2), %eax
	subl	%eax, %r10d
	addl	(%r11,%r12), %r10d
	addl	(%r9,%r12), %r10d
	movl	%r10d, %eax
	negl	%eax
	cmovsl	%r10d, %eax
	cmpl	-64(%rbp), %eax                 ## 4-byte Folded Reload
	jle	LBB0_41
## %bb.40:                              ##   in Loop: Header=BB0_37 Depth=3
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	movl	$255, (%rax,%r12)
	jmp	LBB0_41
	.p2align	4, 0x90
LBB0_6:                                 ##   in Loop: Header=BB0_1 Depth=1
	movl	-88(%rbp), %eax                 ## 4-byte Reload
LBB0_7:                                 ##   in Loop: Header=BB0_1 Depth=1
	testl	%eax, %eax
	movq	-152(%rbp), %r12                ## 8-byte Reload
	movq	-96(%rbp), %r11                 ## 8-byte Reload
	jle	LBB0_19
## %bb.8:                               ##   in Loop: Header=BB0_1 Depth=1
	movq	%r12, %r13
	movq	-80(%rbp), %rdx                 ## 8-byte Reload
	movl	%edx, %eax
	addl	%edx, %eax
	negl	%eax
	movslq	%eax, %r9
	leaq	(%rcx,%r9,4), %r10
	leaq	(%rcx,%rdx,4), %r14
	leaq	(,%rdx,4), %r8
	movq	%rcx, %r11
	subq	%r8, %r11
	xorl	%eax, %eax
	jmp	LBB0_9
	.p2align	4, 0x90
LBB0_13:                                ##   in Loop: Header=BB0_9 Depth=2
	incq	%rax
	cmpq	%rax, -72(%rbp)                 ## 8-byte Folded Reload
	je	LBB0_14
LBB0_9:                                 ##   Parent Loop BB0_1 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rcx,%rax,4), %edx
	movl	(%r11,%rax,4), %edi
	movl	%edx, %ebx
	subl	%edi, %ebx
	movl	%ebx, %esi
	negl	%esi
	cmovsl	%ebx, %esi
	cmpl	%r15d, %esi
	jle	LBB0_13
## %bb.10:                              ##   in Loop: Header=BB0_9 Depth=2
	movl	(%r14,%rax,4), %r12d
	movl	%edx, %esi
	subl	%r12d, %esi
	movl	%esi, %ebx
	negl	%ebx
	cmovsl	%esi, %ebx
	cmpl	%r15d, %ebx
	jle	LBB0_13
## %bb.11:                              ##   in Loop: Header=BB0_9 Depth=2
	shll	$2, %edx
	addl	%edi, %r12d
	leal	(%r12,%r12,2), %esi
	subl	%esi, %edx
	movl	(%r10,%rax,4), %esi
	leal	(%rdx,%rsi,2), %edx
	movl	%edx, %esi
	negl	%esi
	cmovsl	%edx, %esi
	cmpl	-64(%rbp), %esi                 ## 4-byte Folded Reload
	jle	LBB0_13
## %bb.12:                              ##   in Loop: Header=BB0_9 Depth=2
	movq	-48(%rbp), %rdx                 ## 8-byte Reload
	movl	$255, (%rdx,%rax,4)
	jmp	LBB0_13
	.p2align	4, 0x90
LBB0_14:                                ##   in Loop: Header=BB0_1 Depth=1
	movq	-104(%rbp), %rax                ## 8-byte Reload
	movq	-48(%rbp), %rdx                 ## 8-byte Reload
	leaq	(%rdx,%rax,4), %r10
	shlq	$2, %r9
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	leaq	(%r9,%rax,4), %r9
	movq	-96(%rbp), %r11                 ## 8-byte Reload
	movq	-72(%rbp), %rdx                 ## 8-byte Reload
	movq	%r13, %r12
	jmp	LBB0_15
	.p2align	4, 0x90
LBB0_18:                                ##   in Loop: Header=BB0_15 Depth=2
	addq	$4, %rcx
	addq	$4, %r10
	decq	%rdx
	je	LBB0_19
LBB0_15:                                ##   Parent Loop BB0_1 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rcx,%r8), %edi
	movl	(%rcx), %esi
	movl	%edi, %eax
	subl	%esi, %eax
	movl	%eax, %ebx
	negl	%ebx
	cmovsl	%eax, %ebx
	cmpl	%r15d, %ebx
	jle	LBB0_18
## %bb.16:                              ##   in Loop: Header=BB0_15 Depth=2
	shll	$2, %edi
	addl	%esi, %esi
	leal	(%rsi,%rsi,2), %eax
	subl	%eax, %edi
	movl	(%rcx,%r9), %eax
	leal	(%rdi,%rax,2), %eax
	movl	%eax, %esi
	negl	%esi
	cmovsl	%eax, %esi
	cmpl	-64(%rbp), %esi                 ## 4-byte Folded Reload
	jle	LBB0_18
## %bb.17:                              ##   in Loop: Header=BB0_15 Depth=2
	movl	$255, (%r10)
	jmp	LBB0_18
LBB0_20:
	testq	%rax, %rax
	je	LBB0_21
## %bb.43:
	movq	8(%r12), %rax
	movq	(%rax), %rcx
	movq	%rcx, -64(%rbp)                 ## 8-byte Spill
	movq	%r12, %r15
	movq	8(%rax), %r12
	movq	16(%rax), %rbx
	movq	-128(%rbp), %r14                ## 8-byte Reload
	movl	16(%r14), %edi
	movl	44(%r15), %esi
	callq	_AV_CEIL_RSHIFT
	movl	%eax, %r13d
	movl	20(%r14), %edi
	movl	40(%r15), %esi
	callq	_AV_CEIL_RSHIFT
	movq	16(%r15), %rcx
	cmpl	$3, %eax
	jl	LBB0_44
## %bb.45:
	movl	(%rcx), %edx
	addl	%edx, %edx
	movslq	%edx, %r10
	movq	%rcx, -136(%rbp)                ## 8-byte Spill
	movslq	8(%rcx), %r14
	movq	-64(%rbp), %r15                 ## 8-byte Reload
	leaq	(%r15,%r10,4), %rdx
	movl	%r10d, %ecx
	sarl	%ecx
	movslq	%ecx, %rcx
	leaq	(,%rcx,4), %r8
	movq	%r13, %rsi
	movq	%r13, -48(%rbp)                 ## 8-byte Spill
	leal	-1(%r13), %r9d
	addl	$-2, %eax
	movl	%eax, -72(%rbp)                 ## 4-byte Spill
	leaq	(,%r14,4), %rax
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	leaq	(%r12,%r14,4), %rdi
	addq	$8, %rdi
	leaq	(%r12,%r14,8), %r11
	addq	$8, %r11
	leaq	(%rbx,%r14,8), %r13
	addq	$8, %r13
	leaq	(%rbx,%r14,4), %rsi
	addq	$8, %rsi
	addq	%r10, %rcx
	leaq	(%r15,%rcx,4), %rcx
	addq	$4, %rcx
	subq	%r8, %r15
	movq	%r10, -88(%rbp)                 ## 8-byte Spill
	leaq	(,%r10,4), %rax
	leaq	-4(,%r9,4), %r14
	movl	$1, %r9d
	movq	%r15, %r10
	movq	%rax, -144(%rbp)                ## 8-byte Spill
	jmp	LBB0_46
	.p2align	4, 0x90
LBB0_68:                                ##   in Loop: Header=BB0_46 Depth=1
	movq	%r10, %r8
	leal	1(%r9), %r10d
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	addq	%rdx, %rbx
	addq	%rdx, %r12
	addq	%rdx, %rdi
	addq	%rdx, %r11
	addq	%rdx, %r13
	addq	%rdx, %rsi
	movq	-144(%rbp), %rax                ## 8-byte Reload
	addq	%rax, %rcx
	movq	-64(%rbp), %rdx                 ## 8-byte Reload
	cmpl	-72(%rbp), %r9d                 ## 4-byte Folded Reload
	movl	%r10d, %r9d
	movq	%r8, %r10
	je	LBB0_69
LBB0_46:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_48 Depth 2
	addq	%rdx, %rax
	movq	%rax, -64(%rbp)                 ## 8-byte Spill
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	leaq	(%r10,%rax,4), %r10
	cmpl	$3, -48(%rbp)                   ## 4-byte Folded Reload
	jl	LBB0_68
## %bb.47:                              ##   in Loop: Header=BB0_46 Depth=1
	testb	$1, %r9b
	movq	%r10, %r15
	cmoveq	-64(%rbp), %r15                 ## 8-byte Folded Reload
	xorl	%r8d, %r8d
	jmp	LBB0_48
	.p2align	4, 0x90
LBB0_66:                                ##   in Loop: Header=BB0_48 Depth=2
	movl	$65535, 4(%rdx,%r8)             ## imm = 0xFFFF
	movl	$65535, (%rcx,%r8)              ## imm = 0xFFFF
	movl	$65535, 4(%r15,%r8)             ## imm = 0xFFFF
LBB0_67:                                ##   in Loop: Header=BB0_48 Depth=2
	addq	$4, %r8
	cmpq	%r8, %r14
	je	LBB0_68
LBB0_48:                                ##   Parent Loop BB0_46 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	cmpl	$255, -4(%rsi,%r8)
	jne	LBB0_57
## %bb.49:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, (%rbx,%r8)
	je	LBB0_66
## %bb.50:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, 4(%rbx,%r8)
	je	LBB0_66
## %bb.51:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, 8(%rbx,%r8)
	je	LBB0_66
## %bb.52:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, -8(%rsi,%r8)
	je	LBB0_66
## %bb.53:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, (%rsi,%r8)
	je	LBB0_66
## %bb.54:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, -8(%r13,%r8)
	je	LBB0_66
## %bb.55:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, -4(%r13,%r8)
	je	LBB0_66
## %bb.56:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, (%r13,%r8)
	je	LBB0_66
	.p2align	4, 0x90
LBB0_57:                                ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, -4(%rdi,%r8)
	jne	LBB0_67
## %bb.58:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, (%r12,%r8)
	je	LBB0_66
## %bb.59:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, 4(%r12,%r8)
	je	LBB0_66
## %bb.60:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, 8(%r12,%r8)
	je	LBB0_66
## %bb.61:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, -8(%rdi,%r8)
	je	LBB0_66
## %bb.62:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, (%rdi,%r8)
	je	LBB0_66
## %bb.63:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, -8(%r11,%r8)
	je	LBB0_66
## %bb.64:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, -4(%r11,%r8)
	je	LBB0_66
## %bb.65:                              ##   in Loop: Header=BB0_48 Depth=2
	cmpl	$255, (%r11,%r8)
	je	LBB0_66
	jmp	LBB0_67
LBB0_21:
	movq	16(%r12), %rcx
	jmp	LBB0_70
LBB0_44:
	movq	%r15, %r12
	jmp	LBB0_70
LBB0_69:
	movq	-152(%rbp), %r12                ## 8-byte Reload
	movq	-136(%rbp), %rcx                ## 8-byte Reload
LBB0_70:
	movl	24(%r12), %r15d
	movl	28(%r12), %eax
	movl	%r15d, %r9d
	shrl	$31, %r9d
	addl	%r15d, %r9d
	sarl	%r9d
	movq	%r12, %r11
	movl	%eax, %r12d
	shrl	$31, %r12d
	addl	%eax, %r12d
	movl	%eax, %edi
	movl	%eax, -72(%rbp)                 ## 4-byte Spill
	sarl	%r12d
	movslq	(%rcx), %rax
	movq	%rax, -120(%rbp)                ## 8-byte Spill
	movq	8(%r11), %rax
	movq	(%rax), %r14
	movq	-128(%rbp), %rax                ## 8-byte Reload
	movslq	16(%rax), %r10
	movl	20(%rax), %ebx
	leal	(%r10,%r9), %eax
	cltd
	idivl	%r15d
	movl	%eax, %r8d
	movl	%eax, %esi
	incl	%esi
	leal	(%rbx,%r12), %eax
	cltd
	idivl	%edi
	movl	%eax, %ecx
	incl	%ecx
	imull	%esi, %ecx
	movq	32(%r11), %rdi
	movq	%rdi, -96(%rbp)                 ## 8-byte Spill
	movl	%ebx, %eax
	cltd
	idivl	%r12d
	movl	%edx, %esi
	movl	%r10d, %eax
	cltd
	movq	%r9, -176(%rbp)                 ## 8-byte Spill
	idivl	%r9d
	movl	%edx, %r13d
	testl	%esi, %esi
	cmovel	%r12d, %esi
	movl	%ebx, %eax
	subl	%esi, %eax
	movq	%rax, -208(%rbp)                ## 8-byte Spill
	leal	4(,%r8,4), %eax
	movl	%eax, -108(%rbp)                ## 4-byte Spill
	movl	%ecx, -156(%rbp)                ## 4-byte Spill
	shll	$4, %ecx
	movq	%r10, -80(%rbp)                 ## 8-byte Spill
	movl	%r10d, %eax
	movq	%rax, -168(%rbp)                ## 8-byte Spill
	xorl	%esi, %esi
	movl	%ecx, %edx
	callq	_memset
	movq	-120(%rbp), %rdx                ## 8-byte Reload
	leaq	(%r14,%rdx,4), %rax
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	cmpl	$4, -72(%rbp)                   ## 4-byte Folded Reload
	movq	%rbx, -184(%rbp)                ## 8-byte Spill
	movl	%r13d, -48(%rbp)                ## 4-byte Spill
	jl	LBB0_80
## %bb.71:
	cmpl	$3, %r12d
	movl	$2, %eax
	cmovgel	%r12d, %eax
	movl	%eax, -64(%rbp)                 ## 4-byte Spill
	leaq	(,%rdx,4), %r13
	movl	$1, %r9d
	movq	-168(%rbp), %rcx                ## 8-byte Reload
	movq	-96(%rbp), %r10                 ## 8-byte Reload
	jmp	LBB0_72
	.p2align	4, 0x90
LBB0_79:                                ##   in Loop: Header=BB0_72 Depth=1
	incl	%r9d
	movq	-120(%rbp), %rax                ## 8-byte Reload
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	leaq	(%rdx,%rax,4), %rdx
	movq	%rdx, -56(%rbp)                 ## 8-byte Spill
	addq	%r13, %r14
	cmpl	-64(%rbp), %r9d                 ## 4-byte Folded Reload
	je	LBB0_80
LBB0_72:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_74 Depth 2
	movl	%r9d, %eax
	cltd
	movl	-72(%rbp), %esi                 ## 4-byte Reload
	idivl	%esi
	movl	%eax, %r8d
	leal	(%r9,%r12), %eax
	cltd
	idivl	%esi
	testl	%ecx, %ecx
	jle	LBB0_79
## %bb.73:                              ##   in Loop: Header=BB0_72 Depth=1
	movl	%eax, %r11d
	movl	-108(%rbp), %eax                ## 4-byte Reload
	imull	%eax, %r8d
	imull	%eax, %r11d
	xorl	%esi, %esi
	movq	%rcx, %rdi
	movq	%r14, %rbx
	jmp	LBB0_74
	.p2align	4, 0x90
LBB0_78:                                ##   in Loop: Header=BB0_74 Depth=2
	incl	%esi
	addq	$4, %rbx
	decq	%rdi
	je	LBB0_79
LBB0_74:                                ##   Parent Loop BB0_72 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	cmpl	$255, (%rbx)
	jne	LBB0_78
## %bb.75:                              ##   in Loop: Header=BB0_74 Depth=2
	cmpl	$255, (%rbx,%r13)
	jne	LBB0_78
## %bb.76:                              ##   in Loop: Header=BB0_74 Depth=2
	movq	-120(%rbp), %rax                ## 8-byte Reload
	cmpl	$255, (%rbx,%rax,8)
	jne	LBB0_78
## %bb.77:                              ##   in Loop: Header=BB0_74 Depth=2
	movl	%esi, %eax
	cltd
	idivl	%r15d
	movl	%eax, %ecx
	movq	-176(%rbp), %rax                ## 8-byte Reload
	addl	%esi, %eax
	cltd
	idivl	%r15d
                                        ## kill: def $eax killed $eax def $rax
	leal	(%r8,%rcx,4), %edx
	movslq	%edx, %rdx
	incl	(%r10,%rdx,4)
	leal	(%r8,%rax,4), %edx
	orl	$1, %edx
	movslq	%edx, %rdx
	incl	(%r10,%rdx,4)
	leal	(%r11,%rcx,4), %ecx
	orl	$2, %ecx
	movslq	%ecx, %rcx
	incl	(%r10,%rcx,4)
	movq	-168(%rbp), %rcx                ## 8-byte Reload
	leal	(%r11,%rax,4), %eax
	orl	$3, %eax
	cltq
	incl	(%r10,%rax,4)
	jmp	LBB0_78
LBB0_80:
	movq	-208(%rbp), %rcx                ## 8-byte Reload
	cmpl	%ecx, %r12d
	jge	LBB0_95
## %bb.81:
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	movl	%eax, %edx
	subl	-48(%rbp), %edx                 ## 4-byte Folded Reload
	movq	-120(%rbp), %rcx                ## 8-byte Reload
	movl	%ecx, %eax
	negl	%eax
	cltq
	movq	%rax, -240(%rbp)                ## 8-byte Spill
	movslq	%r12d, %rsi
	imulq	%rcx, %rsi
	movq	-176(%rbp), %rax                ## 8-byte Reload
	movslq	%eax, %rbx
	movq	%rbx, -136(%rbp)                ## 8-byte Spill
	movl	%edx, -160(%rbp)                ## 4-byte Spill
	movslq	%edx, %rbx
	movl	%eax, %r13d
	movl	-72(%rbp), %eax                 ## 4-byte Reload
	andl	$-2, %eax
	movl	%eax, -196(%rbp)                ## 4-byte Spill
	movl	%r12d, %eax
	andl	$-2, %eax
	movl	%eax, -192(%rbp)                ## 4-byte Spill
	shlq	$2, %rsi
	movq	%rsi, -232(%rbp)                ## 8-byte Spill
	leaq	(,%rcx,4), %r11
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	movq	%rdx, %rax
	subq	%r11, %rax
	movq	%rax, -152(%rbp)                ## 8-byte Spill
	leaq	(%rbx,%rcx,2), %rax
	leaq	(%rdx,%rax,4), %rax
	movq	%rax, -88(%rbp)                 ## 8-byte Spill
	leaq	(%rcx,%rbx), %rax
	leaq	(%rdx,%rax,4), %rdi
	movq	%rbx, %rax
	subq	%rcx, %rax
	leaq	(%rdx,%rax,4), %rax
	movq	%rax, -64(%rbp)                 ## 8-byte Spill
	leaq	(%rdx,%rcx,4), %rax
	movq	%rax, -224(%rbp)                ## 8-byte Spill
	movq	%rbx, -144(%rbp)                ## 8-byte Spill
	leaq	(%rdx,%rbx,4), %r9
	leaq	(,%rcx,8), %r14
	xorl	%eax, %eax
	movq	%rax, -216(%rbp)                ## 8-byte Spill
	movl	%r12d, %esi
	movq	%rdi, -48(%rbp)                 ## 8-byte Spill
	movq	%r14, -248(%rbp)                ## 8-byte Spill
	jmp	LBB0_82
	.p2align	4, 0x90
LBB0_129:                               ##   in Loop: Header=BB0_82 Depth=1
	movq	-232(%rbp), %rax                ## 8-byte Reload
	addq	%rax, -56(%rbp)                 ## 8-byte Folded Spill
	addq	%rax, -224(%rbp)                ## 8-byte Folded Spill
	addq	%rax, -152(%rbp)                ## 8-byte Folded Spill
	addq	%rax, -216(%rbp)                ## 8-byte Folded Spill
	movq	-208(%rbp), %rcx                ## 8-byte Reload
	movl	-188(%rbp), %esi                ## 4-byte Reload
	cmpl	%ecx, %esi
	jge	LBB0_95
LBB0_82:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_84 Depth 2
                                        ##       Child Loop BB0_86 Depth 3
                                        ##         Child Loop BB0_88 Depth 4
                                        ##     Child Loop BB0_110 Depth 2
                                        ##       Child Loop BB0_114 Depth 3
	movl	%esi, %eax
	cltd
	movl	-72(%rbp), %ebx                 ## 4-byte Reload
	idivl	%ebx
                                        ## kill: def $eax killed $eax def $rax
	movl	-108(%rbp), %ecx                ## 4-byte Reload
	imull	%ecx, %eax
	movq	%rax, -104(%rbp)                ## 8-byte Spill
	addl	%r12d, %esi
	movl	%esi, -188(%rbp)                ## 4-byte Spill
	movl	%esi, %eax
	cltd
	idivl	%ebx
                                        ## kill: def $eax killed $eax def $rax
	imull	%ecx, %eax
	movq	%rax, -128(%rbp)                ## 8-byte Spill
	cmpl	$0, -160(%rbp)                  ## 4-byte Folded Reload
	jle	LBB0_109
## %bb.83:                              ##   in Loop: Header=BB0_82 Depth=1
	xorl	%r8d, %r8d
	jmp	LBB0_84
	.p2align	4, 0x90
LBB0_94:                                ##   in Loop: Header=BB0_84 Depth=2
	addq	-136(%rbp), %r8                 ## 8-byte Folded Reload
	cmpq	-144(%rbp), %r8                 ## 8-byte Folded Reload
	jge	LBB0_109
LBB0_84:                                ##   Parent Loop BB0_82 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_86 Depth 3
                                        ##         Child Loop BB0_88 Depth 4
	cmpl	$2, -72(%rbp)                   ## 4-byte Folded Reload
	jl	LBB0_94
## %bb.85:                              ##   in Loop: Header=BB0_84 Depth=2
	movq	-224(%rbp), %rax                ## 8-byte Reload
	leaq	(%rax,%r8,4), %rax
	movq	-152(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%r8,4), %rdx
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	leaq	(%rcx,%r8,4), %rsi
	xorl	%ebx, %ebx
	xorl	%edi, %edi
	jmp	LBB0_86
	.p2align	4, 0x90
LBB0_92:                                ##   in Loop: Header=BB0_86 Depth=3
	incl	%edi
	addq	%r11, %rax
	addq	%r11, %rdx
	addq	%r11, %rsi
	cmpl	%r12d, %edi
	je	LBB0_93
LBB0_86:                                ##   Parent Loop BB0_82 Depth=1
                                        ##     Parent Loop BB0_84 Depth=2
                                        ## =>    This Loop Header: Depth=3
                                        ##         Child Loop BB0_88 Depth 4
	cmpl	$2, %r15d
	jl	LBB0_92
## %bb.87:                              ##   in Loop: Header=BB0_86 Depth=3
	xorl	%ecx, %ecx
	jmp	LBB0_88
	.p2align	4, 0x90
LBB0_91:                                ##   in Loop: Header=BB0_88 Depth=4
	incq	%rcx
	cmpq	%rcx, %r13
	je	LBB0_92
LBB0_88:                                ##   Parent Loop BB0_82 Depth=1
                                        ##     Parent Loop BB0_84 Depth=2
                                        ##       Parent Loop BB0_86 Depth=3
                                        ## =>      This Inner Loop Header: Depth=4
	cmpl	$255, (%rdx,%rcx,4)
	jne	LBB0_91
## %bb.89:                              ##   in Loop: Header=BB0_88 Depth=4
	cmpl	$255, (%rsi,%rcx,4)
	jne	LBB0_91
## %bb.90:                              ##   in Loop: Header=BB0_88 Depth=4
	xorl	%r10d, %r10d
	cmpl	$255, (%rax,%rcx,4)
	sete	%r10b
	addl	%r10d, %ebx
	jmp	LBB0_91
	.p2align	4, 0x90
LBB0_93:                                ##   in Loop: Header=BB0_84 Depth=2
	testl	%ebx, %ebx
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
	je	LBB0_94
## %bb.107:                             ##   in Loop: Header=BB0_84 Depth=2
	movl	%r8d, %eax
	cltd
	idivl	%r15d
	movl	%eax, %esi
	addq	-136(%rbp), %r8                 ## 8-byte Folded Reload
	movl	%r8d, %eax
	cltd
	idivl	%r15d
                                        ## kill: def $eax killed $eax def $rax
	movq	-104(%rbp), %r10                ## 8-byte Reload
	leal	(%r10,%rsi,4), %ecx
	movslq	%ecx, %rcx
	movq	-96(%rbp), %rdx                 ## 8-byte Reload
	addl	%ebx, (%rdx,%rcx,4)
	leal	(%r10,%rax,4), %ecx
	movq	-248(%rbp), %r14                ## 8-byte Reload
	orl	$1, %ecx
	movslq	%ecx, %rcx
	addl	%ebx, (%rdx,%rcx,4)
	movq	-128(%rbp), %r10                ## 8-byte Reload
	leal	(%r10,%rsi,4), %ecx
	orl	$2, %ecx
	movslq	%ecx, %rcx
	addl	%ebx, (%rdx,%rcx,4)
	leal	(%r10,%rax,4), %eax
	orl	$3, %eax
	cltq
	addl	%ebx, (%rdx,%rax,4)
	cmpq	-144(%rbp), %r8                 ## 8-byte Folded Reload
	jl	LBB0_84
	.p2align	4, 0x90
LBB0_109:                               ##   in Loop: Header=BB0_82 Depth=1
	movq	-216(%rbp), %rbx                ## 8-byte Reload
	movq	-144(%rbp), %rcx                ## 8-byte Reload
	movl	-160(%rbp), %eax                ## 4-byte Reload
	cmpl	-80(%rbp), %eax                 ## 4-byte Folded Reload
	jl	LBB0_110
	jmp	LBB0_129
	.p2align	4, 0x90
LBB0_128:                               ##   in Loop: Header=BB0_110 Depth=2
	incq	%rcx
	addq	$4, %rbx
	cmpq	-80(%rbp), %rcx                 ## 8-byte Folded Reload
	je	LBB0_129
LBB0_110:                               ##   Parent Loop BB0_82 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_114 Depth 3
	cmpl	$2, -72(%rbp)                   ## 4-byte Folded Reload
	jl	LBB0_128
## %bb.111:                             ##   in Loop: Header=BB0_110 Depth=2
	cmpl	$2, -196(%rbp)                  ## 4-byte Folded Reload
	jne	LBB0_113
## %bb.112:                             ##   in Loop: Header=BB0_110 Depth=2
	xorl	%r8d, %r8d
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%rcx,4), %rax
	testb	$1, %r12b
	jne	LBB0_123
	jmp	LBB0_126
	.p2align	4, 0x90
LBB0_113:                               ##   in Loop: Header=BB0_110 Depth=2
	xorl	%r8d, %r8d
	movl	-192(%rbp), %edx                ## 4-byte Reload
	movq	%rbx, %rax
	jmp	LBB0_114
	.p2align	4, 0x90
LBB0_120:                               ##   in Loop: Header=BB0_114 Depth=3
	addq	%r14, %rax
	addl	$-2, %edx
	je	LBB0_121
LBB0_114:                               ##   Parent Loop BB0_82 Depth=1
                                        ##     Parent Loop BB0_110 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	cmpl	$255, (%rsi,%rax)
	jne	LBB0_117
## %bb.115:                             ##   in Loop: Header=BB0_114 Depth=3
	cmpl	$255, (%r9,%rax)
	jne	LBB0_117
## %bb.116:                             ##   in Loop: Header=BB0_114 Depth=3
	xorl	%esi, %esi
	cmpl	$255, (%rdi,%rax)
	sete	%sil
	addl	%esi, %r8d
LBB0_117:                               ##   in Loop: Header=BB0_114 Depth=3
	cmpl	$255, (%r9,%rax)
	jne	LBB0_120
## %bb.118:                             ##   in Loop: Header=BB0_114 Depth=3
	cmpl	$255, (%rdi,%rax)
	jne	LBB0_120
## %bb.119:                             ##   in Loop: Header=BB0_114 Depth=3
	xorl	%esi, %esi
	movq	-88(%rbp), %rdi                 ## 8-byte Reload
	cmpl	$255, (%rdi,%rax)
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
	sete	%sil
	addl	%esi, %r8d
	jmp	LBB0_120
	.p2align	4, 0x90
LBB0_121:                               ##   in Loop: Header=BB0_110 Depth=2
	addq	%r9, %rax
	testb	$1, %r12b
	je	LBB0_126
LBB0_123:                               ##   in Loop: Header=BB0_110 Depth=2
	movq	-240(%rbp), %rdx                ## 8-byte Reload
	cmpl	$255, (%rax,%rdx,4)
	jne	LBB0_126
## %bb.124:                             ##   in Loop: Header=BB0_110 Depth=2
	cmpl	$255, (%rax)
	jne	LBB0_126
## %bb.125:                             ##   in Loop: Header=BB0_110 Depth=2
	xorl	%edx, %edx
	movq	-120(%rbp), %rsi                ## 8-byte Reload
	cmpl	$255, (%rax,%rsi,4)
	sete	%dl
	addl	%edx, %r8d
	.p2align	4, 0x90
LBB0_126:                               ##   in Loop: Header=BB0_110 Depth=2
	testl	%r8d, %r8d
	je	LBB0_128
## %bb.127:                             ##   in Loop: Header=BB0_110 Depth=2
	movl	%ecx, %eax
	cltd
	idivl	%r15d
	movl	%eax, %r10d
	movq	-176(%rbp), %rax                ## 8-byte Reload
	addl	%ecx, %eax
	cltd
	idivl	%r15d
                                        ## kill: def $eax killed $eax def $rax
	movq	-104(%rbp), %rsi                ## 8-byte Reload
	leal	(%rsi,%r10,4), %edx
	movslq	%edx, %rdx
	movq	-96(%rbp), %rdi                 ## 8-byte Reload
	addl	%r8d, (%rdi,%rdx,4)
	leal	(%rsi,%rax,4), %edx
	orl	$1, %edx
	movslq	%edx, %rdx
	addl	%r8d, (%rdi,%rdx,4)
	movq	-128(%rbp), %rsi                ## 8-byte Reload
	leal	(%rsi,%r10,4), %edx
	orl	$2, %edx
	movslq	%edx, %rdx
	addl	%r8d, (%rdi,%rdx,4)
	leal	(%rsi,%rax,4), %eax
	orl	$3, %eax
	cltq
	addl	%r8d, (%rdi,%rax,4)
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
	jmp	LBB0_128
LBB0_95:
	shll	$2, -156(%rbp)                  ## 4-byte Folded Spill
	movq	-184(%rbp), %rax                ## 8-byte Reload
	decl	%eax
	movq	%rax, -184(%rbp)                ## 8-byte Spill
	cmpl	%eax, %ecx
	movq	-96(%rbp), %r11                 ## 8-byte Reload
	movq	-120(%rbp), %r14                ## 8-byte Reload
	jge	LBB0_105
## %bb.96:
	movl	-176(%rbp), %r9d                ## 4-byte Reload
	movq	-56(%rbp), %rsi                 ## 8-byte Reload
	leaq	(%rsi,%r14,4), %rbx
	shlq	$2, %r14
	subq	%r14, %rsi
	jmp	LBB0_97
	.p2align	4, 0x90
LBB0_104:                               ##   in Loop: Header=BB0_97 Depth=1
	movq	%r13, %rcx
	incl	%ecx
	addq	%r14, %rbx
	addq	%r14, %rsi
	addq	%r14, -56(%rbp)                 ## 8-byte Folded Spill
	cmpl	-184(%rbp), %ecx                ## 4-byte Folded Reload
	je	LBB0_105
LBB0_97:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_99 Depth 2
	movl	%ecx, %eax
	cltd
	movl	-72(%rbp), %edi                 ## 4-byte Reload
	idivl	%edi
	movl	%eax, %r8d
	movq	%rcx, %r13
	leal	(%rcx,%r12), %eax
	cltd
	idivl	%edi
	movq	-168(%rbp), %rcx                ## 8-byte Reload
	testl	%ecx, %ecx
	jle	LBB0_104
## %bb.98:                              ##   in Loop: Header=BB0_97 Depth=1
	movl	%eax, %r10d
	movl	-108(%rbp), %eax                ## 4-byte Reload
	imull	%eax, %r8d
	imull	%eax, %r10d
	xorl	%edi, %edi
	jmp	LBB0_99
	.p2align	4, 0x90
LBB0_103:                               ##   in Loop: Header=BB0_99 Depth=2
	incq	%rdi
	cmpq	%rdi, %rcx
	je	LBB0_104
LBB0_99:                                ##   Parent Loop BB0_97 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	cmpl	$255, (%rsi,%rdi,4)
	jne	LBB0_103
## %bb.100:                             ##   in Loop: Header=BB0_99 Depth=2
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	cmpl	$255, (%rax,%rdi,4)
	jne	LBB0_103
## %bb.101:                             ##   in Loop: Header=BB0_99 Depth=2
	cmpl	$255, (%rbx,%rdi,4)
	jne	LBB0_103
## %bb.102:                             ##   in Loop: Header=BB0_99 Depth=2
	movl	%edi, %eax
	cltd
	idivl	%r15d
	movl	%eax, %ecx
	leal	(%r9,%rdi), %eax
	cltd
	idivl	%r15d
                                        ## kill: def $eax killed $eax def $rax
	leal	(%r8,%rcx,4), %edx
	movslq	%edx, %rdx
	incl	(%r11,%rdx,4)
	leal	(%r8,%rax,4), %edx
	orl	$1, %edx
	movslq	%edx, %rdx
	incl	(%r11,%rdx,4)
	leal	(%r10,%rcx,4), %ecx
	orl	$2, %ecx
	movslq	%ecx, %rcx
	incl	(%r11,%rcx,4)
	movq	-168(%rbp), %rcx                ## 8-byte Reload
	leal	(%r10,%rax,4), %eax
	orl	$3, %eax
	cltq
	incl	(%r11,%rax,4)
	jmp	LBB0_103
LBB0_105:
	movl	-156(%rbp), %eax                ## 4-byte Reload
	testl	%eax, %eax
	jle	LBB0_106
## %bb.130:
	movl	%eax, %ecx
	cmpl	$8, %eax
	jae	LBB0_132
## %bb.131:
	xorl	%edx, %edx
	xorl	%eax, %eax
	jmp	LBB0_140
LBB0_106:
	xorl	%eax, %eax
	jmp	LBB0_141
LBB0_132:
	movl	%ecx, %edx
	andl	$-8, %edx
	leaq	-8(%rdx), %rsi
	movq	%rsi, %rdi
	shrq	$3, %rdi
	incq	%rdi
	movl	%edi, %eax
	andl	$3, %eax
	cmpq	$24, %rsi
	jae	LBB0_134
## %bb.133:
	pxor	%xmm0, %xmm0
	xorl	%esi, %esi
	pxor	%xmm1, %xmm1
	jmp	LBB0_136
LBB0_134:
	andq	$-4, %rdi
	pxor	%xmm0, %xmm0
	xorl	%esi, %esi
	pxor	%xmm1, %xmm1
	.p2align	4, 0x90
LBB0_135:                               ## =>This Inner Loop Header: Depth=1
	movdqu	(%r11,%rsi,4), %xmm2
	pmaxsd	%xmm0, %xmm2
	movdqu	16(%r11,%rsi,4), %xmm0
	pmaxsd	%xmm1, %xmm0
	movdqu	32(%r11,%rsi,4), %xmm1
	movdqu	48(%r11,%rsi,4), %xmm3
	movdqu	64(%r11,%rsi,4), %xmm4
	pmaxsd	%xmm1, %xmm4
	pmaxsd	%xmm2, %xmm4
	movdqu	80(%r11,%rsi,4), %xmm2
	pmaxsd	%xmm3, %xmm2
	pmaxsd	%xmm0, %xmm2
	movdqu	96(%r11,%rsi,4), %xmm0
	pmaxsd	%xmm4, %xmm0
	movdqu	112(%r11,%rsi,4), %xmm1
	pmaxsd	%xmm2, %xmm1
	addq	$32, %rsi
	addq	$-4, %rdi
	jne	LBB0_135
LBB0_136:
	testq	%rax, %rax
	je	LBB0_139
## %bb.137:
	leaq	(%r11,%rsi,4), %rsi
	addq	$16, %rsi
	shlq	$5, %rax
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_138:                               ## =>This Inner Loop Header: Depth=1
	movdqu	-16(%rsi,%rdi), %xmm2
	pmaxsd	%xmm2, %xmm0
	movdqu	(%rsi,%rdi), %xmm2
	pmaxsd	%xmm2, %xmm1
	addq	$32, %rdi
	cmpq	%rdi, %rax
	jne	LBB0_138
LBB0_139:
	pmaxsd	%xmm1, %xmm0
	pshufd	$238, %xmm0, %xmm1              ## xmm1 = xmm0[2,3,2,3]
	pmaxsd	%xmm0, %xmm1
	pshufd	$85, %xmm1, %xmm0               ## xmm0 = xmm1[1,1,1,1]
	pmaxsd	%xmm1, %xmm0
	movd	%xmm0, %eax
	cmpq	%rcx, %rdx
	je	LBB0_141
	.p2align	4, 0x90
LBB0_140:                               ## =>This Inner Loop Header: Depth=1
	movl	(%r11,%rdx,4), %esi
	cmpl	%eax, %esi
	cmovgl	%esi, %eax
	incq	%rdx
	cmpq	%rdx, %rcx
	jne	LBB0_140
LBB0_141:
	addq	$216, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.no_dead_strip	_calc_combed_score
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function calc_combed_score
_calc_combed_score:                     ; @calc_combed_score
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #144
	.cfi_def_cfa_offset 144
	stp	x28, x27, [sp, #48]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #64]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #80]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #96]             ; 16-byte Folded Spill
	stp	x20, x19, [sp, #112]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #128]            ; 16-byte Folded Spill
	add	x29, sp, #128
	.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
	stp	x0, x1, [sp, #24]               ; 16-byte Folded Spill
	mov	x30, x0
	mov	x21, #0
	ldr	w26, [x0]
	add	w8, w26, w26, lsl #1
	lsl	w27, w8, #1
	mov	w28, #255
	b	LBB0_3
LBB0_1:                                 ;   in Loop: Header=BB0_3 Depth=1
	mov	x0, x25
	mov	x1, x23
	mov	x2, x24
	mov	x3, x20
	mov	w4, #255
	bl	_fill_buf
	ldr	x30, [sp, #24]                  ; 8-byte Folded Reload
LBB0_2:                                 ;   in Loop: Header=BB0_3 Depth=1
	add	x21, x21, #1
	ldr	x8, [x30, #48]
	cmp	x8, #0
	mov	w9, #3
	csinc	x9, x9, xzr, ne
	cmp	x21, x9
	b.hs	LBB0_40
LBB0_3:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_7 Depth 2
                                        ;     Child Loop BB0_12 Depth 2
                                        ;     Child Loop BB0_20 Depth 2
                                        ;       Child Loop BB0_23 Depth 3
                                        ;     Child Loop BB0_31 Depth 2
                                        ;     Child Loop BB0_37 Depth 2
	lsl	x25, x21, #3
	ldr	x24, [sp, #32]                  ; 8-byte Folded Reload
	ldp	x8, x9, [x24]
	ldr	x8, [x8, x25]
	str	x8, [sp, #40]                   ; 8-byte Folded Spill
	lsl	x20, x21, #2
	ldrsw	x19, [x9, x20]
	mov	x0, x30
	mov	x1, x24
	mov	x2, x21
	mov	x22, x30
	bl	_get_width
	mov	x23, x0
	mov	x0, x22
	mov	x1, x24
	mov	x2, x21
	bl	_get_height
	mov	x24, x0
	ldp	x8, x9, [x22, #8]
	ldr	x25, [x8, x25]
	ldrsw	x20, [x9, x20]
	tbnz	w26, #31, LBB0_1
; %bb.4:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x0, x25
	mov	x1, x23
	mov	x2, x24
	mov	x3, x20
	mov	w4, #0
	bl	_fill_buf
	mov	w8, w23
	cmp	w23, #0
	b.le	LBB0_16
; %bb.5:                                ;   in Loop: Header=BB0_3 Depth=1
	lsl	x10, x19, #1
	mov	x9, x8
	mov	x11, x25
	ldr	x2, [sp, #40]                   ; 8-byte Folded Reload
	mov	x12, x2
	mov	w7, #-6
	b	LBB0_7
LBB0_6:                                 ;   in Loop: Header=BB0_7 Depth=2
	add	x12, x12, #4
	add	x11, x11, #4
	subs	x9, x9, #1
	b.eq	LBB0_10
LBB0_7:                                 ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w13, [x12]
	ldr	w14, [x12, x19, lsl #2]
	subs	w15, w13, w14
	cneg	w15, w15, mi
	cmp	w15, w26
	b.le	LBB0_6
; %bb.8:                                ;   in Loop: Header=BB0_7 Depth=2
	mul	w14, w14, w7
	add	w13, w14, w13, lsl #2
	ldr	w14, [x12, x10, lsl #2]
	add	w13, w13, w14, lsl #1
	cmp	w13, #0
	cneg	w13, w13, mi
	cmp	w13, w27
	b.le	LBB0_6
; %bb.9:                                ;   in Loop: Header=BB0_7 Depth=2
	str	w28, [x11]
	b	LBB0_6
LBB0_10:                                ;   in Loop: Header=BB0_3 Depth=1
	add	x9, x25, x20, lsl #2
	lsl	x11, x19, #2
	lsl	x12, x19, #3
	mov	x13, x8
	mov	x14, x2
	add	x10, x11, x10, lsl #2
	b	LBB0_12
LBB0_11:                                ;   in Loop: Header=BB0_12 Depth=2
	add	x14, x14, #4
	add	x9, x9, #4
	subs	x13, x13, #1
	b.eq	LBB0_17
LBB0_12:                                ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w15, [x14, x11]
	ldr	w16, [x14]
	subs	w17, w15, w16
	cneg	w17, w17, mi
	cmp	w17, w26
	b.le	LBB0_11
; %bb.13:                               ;   in Loop: Header=BB0_12 Depth=2
	ldr	w17, [x14, x12]
	subs	w0, w15, w17
	cneg	w0, w0, mi
	cmp	w0, w26
	b.le	LBB0_11
; %bb.14:                               ;   in Loop: Header=BB0_12 Depth=2
	add	w16, w17, w16
	sub	w16, w16, w16, lsl #2
	add	w15, w16, w15, lsl #2
	ldr	w16, [x14, x10]
	add	w15, w15, w16, lsl #1
	cmp	w15, #0
	cneg	w15, w15, mi
	cmp	w15, w27
	b.le	LBB0_11
; %bb.15:                               ;   in Loop: Header=BB0_12 Depth=2
	str	w28, [x9]
	b	LBB0_11
LBB0_16:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	w7, #-6
	ldr	x2, [sp, #40]                   ; 8-byte Folded Reload
LBB0_17:                                ;   in Loop: Header=BB0_3 Depth=1
	lsl	x12, x20, #2
	lsl	x9, x19, #2
	add	x13, x2, x9
	add	x10, x13, x9
	add	x11, x25, x12
	add	x11, x11, x12
	cmp	w24, #5
	b.lt	LBB0_27
; %bb.18:                               ;   in Loop: Header=BB0_3 Depth=1
	lsl	w15, w19, #1
	sub	w14, w24, #3
	lsl	x16, x19, #1
	add	x15, x16, w15, sxtw
	add	x15, x2, x15, lsl #2
	sub	x0, x16, x19, lsl #1
	mov	w16, #12
	madd	x16, x19, x16, x2
	lsl	x17, x8, #2
	mov	w1, #2
	add	x0, x2, x0, lsl #2
	ldr	x30, [sp, #24]                  ; 8-byte Folded Reload
	b	LBB0_20
LBB0_19:                                ;   in Loop: Header=BB0_20 Depth=2
	add	w2, w1, #1
	add	x10, x10, x9
	add	x11, x11, x12
	add	x15, x15, x9
	add	x0, x0, x9
	add	x16, x16, x9
	add	x13, x13, x9
	cmp	w1, w14
	mov	x1, x2
	b.eq	LBB0_28
LBB0_20:                                ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_23 Depth 3
	cmp	w23, #1
	b.lt	LBB0_19
; %bb.21:                               ;   in Loop: Header=BB0_20 Depth=2
	mov	x2, #0
	b	LBB0_23
LBB0_22:                                ;   in Loop: Header=BB0_23 Depth=3
	add	x2, x2, #4
	cmp	x17, x2
	b.eq	LBB0_19
LBB0_23:                                ;   Parent Loop BB0_3 Depth=1
                                        ;     Parent Loop BB0_20 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	ldr	w3, [x10, x2]
	ldr	w4, [x13, x2]
	subs	w5, w3, w4
	cneg	w5, w5, mi
	cmp	w5, w26
	b.le	LBB0_22
; %bb.24:                               ;   in Loop: Header=BB0_23 Depth=3
	ldr	w5, [x16, x2]
	subs	w6, w3, w5
	cneg	w6, w6, mi
	cmp	w6, w26
	b.le	LBB0_22
; %bb.25:                               ;   in Loop: Header=BB0_23 Depth=3
	add	w4, w5, w4
	ldr	w5, [x0, x2]
	ldr	w6, [x15, x2]
	sub	w4, w4, w4, lsl #2
	add	w3, w4, w3, lsl #2
	add	w3, w3, w5
	adds	w3, w3, w6
	cneg	w3, w3, mi
	cmp	w3, w27
	b.le	LBB0_22
; %bb.26:                               ;   in Loop: Header=BB0_23 Depth=3
	str	w28, [x11, x2]
	b	LBB0_22
LBB0_27:                                ;   in Loop: Header=BB0_3 Depth=1
	ldr	x30, [sp, #24]                  ; 8-byte Folded Reload
LBB0_28:                                ;   in Loop: Header=BB0_3 Depth=1
	cmp	w23, #1
	b.lt	LBB0_2
; %bb.29:                               ;   in Loop: Header=BB0_3 Depth=1
	neg	w12, w19, lsl #1
	sxtw	x12, w12
	neg	x13, x19, lsl #2
	mov	x14, x8
	mov	x15, x11
	mov	x16, x10
	b	LBB0_31
LBB0_30:                                ;   in Loop: Header=BB0_31 Depth=2
	add	x16, x16, #4
	add	x15, x15, #4
	subs	x14, x14, #1
	b.eq	LBB0_35
LBB0_31:                                ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w17, [x16]
	ldr	w0, [x16, x13]
	subs	w1, w17, w0
	cneg	w1, w1, mi
	cmp	w1, w26
	b.le	LBB0_30
; %bb.32:                               ;   in Loop: Header=BB0_31 Depth=2
	ldr	w1, [x16, x19, lsl #2]
	subs	w2, w17, w1
	cneg	w2, w2, mi
	cmp	w2, w26
	b.le	LBB0_30
; %bb.33:                               ;   in Loop: Header=BB0_31 Depth=2
	add	w0, w1, w0
	sub	w0, w0, w0, lsl #2
	add	w17, w0, w17, lsl #2
	ldr	w0, [x16, x12, lsl #2]
	add	w17, w17, w0, lsl #1
	cmp	w17, #0
	cneg	w17, w17, mi
	cmp	w17, w27
	b.le	LBB0_30
; %bb.34:                               ;   in Loop: Header=BB0_31 Depth=2
	str	w28, [x15]
	b	LBB0_30
LBB0_35:                                ;   in Loop: Header=BB0_3 Depth=1
	add	x11, x11, x20, lsl #2
	add	x12, x9, x12, lsl #2
	b	LBB0_37
LBB0_36:                                ;   in Loop: Header=BB0_37 Depth=2
	add	x10, x10, #4
	add	x11, x11, #4
	subs	x8, x8, #1
	b.eq	LBB0_2
LBB0_37:                                ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w13, [x10, x9]
	ldr	w14, [x10]
	subs	w15, w13, w14
	cneg	w15, w15, mi
	cmp	w15, w26
	b.le	LBB0_36
; %bb.38:                               ;   in Loop: Header=BB0_37 Depth=2
	mul	w14, w14, w7
	add	w13, w14, w13, lsl #2
	ldr	w14, [x10, x12]
	add	w13, w13, w14, lsl #1
	cmp	w13, #0
	cneg	w13, w13, mi
	cmp	w13, w27
	b.le	LBB0_36
; %bb.39:                               ;   in Loop: Header=BB0_37 Depth=2
	str	w28, [x11]
	b	LBB0_36
LBB0_40:
	cbz	x8, LBB0_66
; %bb.41:
	ldr	x8, [x30, #8]
	ldp	x22, x19, [x8]
	ldr	x20, [x8, #16]
	ldr	x23, [sp, #32]                  ; 8-byte Folded Reload
	ldr	w0, [x23, #16]
	ldr	w1, [x30, #44]
	mov	x24, x30
	bl	_AV_CEIL_RSHIFT
	mov	x21, x0
	ldr	w0, [x23, #20]
	ldr	w1, [x24, #40]
	bl	_AV_CEIL_RSHIFT
	mov	x30, x24
	ldr	x8, [x24, #16]
	cmp	w0, #3
	b.lt	LBB0_67
; %bb.42:
	ldr	w9, [x8]
	lsl	w9, w9, #1
	sxtw	x9, w9
	ldrsw	x1, [x8, #8]
	lsl	x10, x9, #2
	add	x4, x22, x10
	asr	w16, w9, #1
	sub	x11, x22, w16, sxtw #2
	sub	w13, w21, #1
	sub	w12, w0, #2
	lsl	x13, x13, #2
	sub	x13, x13, #4
	lsl	x14, x1, #2
	add	x15, x20, x14
	add	x16, x9, w16, sxtw
	add	x16, x22, x16, lsl #2
	add	x16, x16, #4
	add	x17, x19, x14
	lsl	x1, x1, #3
	add	x0, x19, x1
	add	x1, x20, x1
	mov	w2, #1
	mov	w3, #65535
	b	LBB0_44
LBB0_43:                                ;   in Loop: Header=BB0_44 Depth=1
	add	w6, w2, #1
	add	x15, x15, x14
	add	x16, x16, x10
	add	x17, x17, x14
	add	x19, x19, x14
	add	x0, x0, x14
	add	x1, x1, x14
	add	x20, x20, x14
	mov	x4, x5
	cmp	w2, w12
	mov	x2, x6
	b.eq	LBB0_67
LBB0_44:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_48 Depth 2
	add	x11, x11, x9, lsl #2
	add	x5, x4, x10
	cmp	w21, #3
	b.lt	LBB0_43
; %bb.45:                               ;   in Loop: Header=BB0_44 Depth=1
	mov	x6, #0
	tst	w2, #0x1
	csel	x7, x5, x11, eq
	add	x7, x7, #4
	b	LBB0_48
LBB0_46:                                ;   in Loop: Header=BB0_48 Depth=2
	add	x22, x4, x6
	str	w3, [x22, #4]
	str	w3, [x16, x6]
	str	w3, [x7, x6]
LBB0_47:                                ;   in Loop: Header=BB0_48 Depth=2
	add	x6, x6, #4
	cmp	x13, x6
	b.eq	LBB0_43
LBB0_48:                                ;   Parent Loop BB0_44 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x22, x15, x6
	ldr	w22, [x22, #4]
	cmp	w22, #255
	b.ne	LBB0_57
; %bb.49:                               ;   in Loop: Header=BB0_48 Depth=2
	ldr	w22, [x20, x6]
	cmp	w22, #255
	b.eq	LBB0_46
; %bb.50:                               ;   in Loop: Header=BB0_48 Depth=2
	add	x22, x20, x6
	ldr	w23, [x22, #4]
	cmp	w23, #255
	b.eq	LBB0_46
; %bb.51:                               ;   in Loop: Header=BB0_48 Depth=2
	ldr	w22, [x22, #8]
	cmp	w22, #255
	b.eq	LBB0_46
; %bb.52:                               ;   in Loop: Header=BB0_48 Depth=2
	ldr	w22, [x15, x6]
	cmp	w22, #255
	b.eq	LBB0_46
; %bb.53:                               ;   in Loop: Header=BB0_48 Depth=2
	add	x22, x15, x6
	ldr	w22, [x22, #8]
	cmp	w22, #255
	b.eq	LBB0_46
; %bb.54:                               ;   in Loop: Header=BB0_48 Depth=2
	ldr	w22, [x1, x6]
	cmp	w22, #255
	b.eq	LBB0_46
; %bb.55:                               ;   in Loop: Header=BB0_48 Depth=2
	add	x22, x1, x6
	ldr	w23, [x22, #4]
	cmp	w23, #255
	b.eq	LBB0_46
; %bb.56:                               ;   in Loop: Header=BB0_48 Depth=2
	ldr	w22, [x22, #8]
	cmp	w22, #255
	b.eq	LBB0_46
LBB0_57:                                ;   in Loop: Header=BB0_48 Depth=2
	add	x22, x17, x6
	ldr	w22, [x22, #4]
	cmp	w22, #255
	b.ne	LBB0_47
; %bb.58:                               ;   in Loop: Header=BB0_48 Depth=2
	ldr	w22, [x19, x6]
	cmp	w22, #255
	b.eq	LBB0_46
; %bb.59:                               ;   in Loop: Header=BB0_48 Depth=2
	add	x22, x19, x6
	ldr	w23, [x22, #4]
	cmp	w23, #255
	b.eq	LBB0_46
; %bb.60:                               ;   in Loop: Header=BB0_48 Depth=2
	ldr	w22, [x22, #8]
	cmp	w22, #255
	b.eq	LBB0_46
; %bb.61:                               ;   in Loop: Header=BB0_48 Depth=2
	ldr	w22, [x17, x6]
	cmp	w22, #255
	b.eq	LBB0_46
; %bb.62:                               ;   in Loop: Header=BB0_48 Depth=2
	add	x22, x17, x6
	ldr	w22, [x22, #8]
	cmp	w22, #255
	b.eq	LBB0_46
; %bb.63:                               ;   in Loop: Header=BB0_48 Depth=2
	ldr	w22, [x0, x6]
	cmp	w22, #255
	b.eq	LBB0_46
; %bb.64:                               ;   in Loop: Header=BB0_48 Depth=2
	add	x22, x0, x6
	ldr	w23, [x22, #4]
	cmp	w23, #255
	b.eq	LBB0_46
; %bb.65:                               ;   in Loop: Header=BB0_48 Depth=2
	ldr	w22, [x22, #8]
	cmp	w22, #255
	b.eq	LBB0_46
	b	LBB0_47
LBB0_66:
	ldr	x8, [x30, #16]
LBB0_67:
	ldp	w21, w22, [x30, #24]
	cmp	w21, #0
	cinc	w9, w21, lt
	asr	w23, w9, #1
	cmp	w22, #0
	cinc	w9, w22, lt
	asr	w25, w9, #1
	ldrsw	x24, [x8]
	ldr	x8, [x30, #8]
	ldr	x27, [x8]
	ldr	x8, [sp, #32]                   ; 8-byte Folded Reload
	ldp	w28, w10, [x8, #16]
                                        ; kill: def $w28 killed $w28 def $x28
	sxtw	x28, w28
	and	x20, x28, #0xffffffff
	add	w8, w28, w23
	sdiv	w8, w8, w21
	add	w8, w8, #1
	lsl	w9, w8, #2
	str	w9, [sp, #32]                   ; 4-byte Folded Spill
	add	w9, w10, w25
	sdiv	w9, w9, w22
	ldr	x19, [x30, #32]
	madd	w9, w8, w9, w8
	sdiv	w8, w10, w25
	msub	w8, w8, w25, w10
	cmp	w8, #0
	csel	w8, w25, w8, eq
	stp	w9, w10, [sp, #8]               ; 8-byte Folded Spill
	sub	w8, w10, w8
	str	w8, [sp, #24]                   ; 4-byte Folded Spill
	lsl	w2, w9, #4
	mov	x0, x19
	mov	w1, #0
	bl	_memset
	mov	x17, x24
	add	x8, x27, x24, lsl #2
	cmp	w22, #3
	str	x24, [sp, #16]                  ; 8-byte Folded Spill
	b.le	LBB0_77
; %bb.68:
	mov	w9, #2
	cmp	w25, #2
	csel	w9, w25, w9, gt
	lsl	x10, x17, #3
	lsl	x11, x17, #2
	mov	w12, #1
	ldr	w4, [sp, #32]                   ; 4-byte Folded Reload
	ldr	w5, [sp, #24]                   ; 4-byte Folded Reload
	b	LBB0_70
LBB0_69:                                ;   in Loop: Header=BB0_70 Depth=1
	add	w12, w12, #1
	ldr	x17, [sp, #16]                  ; 8-byte Folded Reload
	add	x8, x8, x17, lsl #2
	add	x27, x27, x11
	cmp	w12, w9
	b.eq	LBB0_78
LBB0_70:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_73 Depth 2
	cmp	w20, #1
	b.lt	LBB0_69
; %bb.71:                               ;   in Loop: Header=BB0_70 Depth=1
	mov	w13, #0
	sdiv	w14, w12, w22
	mul	w14, w14, w4
	add	w15, w12, w25
	sdiv	w15, w15, w22
	mul	w15, w15, w4
	mov	x16, x20
	mov	x17, x27
	b	LBB0_73
LBB0_72:                                ;   in Loop: Header=BB0_73 Depth=2
	add	w13, w13, #1
	add	x17, x17, #4
	subs	x16, x16, #1
	b.eq	LBB0_69
LBB0_73:                                ;   Parent Loop BB0_70 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w0, [x17]
	cmp	w0, #255
	b.ne	LBB0_72
; %bb.74:                               ;   in Loop: Header=BB0_73 Depth=2
	ldr	w0, [x17, x11]
	cmp	w0, #255
	b.ne	LBB0_72
; %bb.75:                               ;   in Loop: Header=BB0_73 Depth=2
	ldr	w0, [x17, x10]
	cmp	w0, #255
	b.ne	LBB0_72
; %bb.76:                               ;   in Loop: Header=BB0_73 Depth=2
	sdiv	w0, w13, w21
	lsl	w0, w0, #2
	add	w1, w23, w13
	sdiv	w1, w1, w21
	add	w2, w0, w14
	sbfiz	x2, x2, #2, #32
	ldr	w3, [x19, x2]
	lsl	w1, w1, #2
	add	w3, w3, #1
	str	w3, [x19, x2]
	add	w2, w1, w14
	orr	w2, w2, #0x1
	sbfiz	x2, x2, #2, #32
	ldr	w3, [x19, x2]
	add	w3, w3, #1
	str	w3, [x19, x2]
	add	w0, w0, w15
	orr	w0, w0, #0x2
	sbfiz	x0, x0, #2, #32
	ldr	w2, [x19, x0]
	add	w2, w2, #1
	str	w2, [x19, x0]
	add	w0, w1, w15
	orr	w0, w0, #0x3
	sbfiz	x0, x0, #2, #32
	ldr	w1, [x19, x0]
	add	w1, w1, #1
	str	w1, [x19, x0]
	b	LBB0_72
LBB0_77:
	ldr	w4, [sp, #32]                   ; 4-byte Folded Reload
	ldr	w5, [sp, #24]                   ; 4-byte Folded Reload
LBB0_78:
	cmp	w25, w5
	b.ge	LBB0_105
; %bb.79:
	sdiv	w9, w28, w23
	mul	w9, w9, w23
	mov	x10, x23
	sxtw	x10, w10
	sxtw	x11, w9
	lsl	x12, x17, #2
	mul	w13, w17, w25
	sbfiz	x13, x13, #2, #32
	add	x14, x8, x12
	sub	x15, x8, x12
	sub	x16, x11, x17
	add	x16, x8, x16, lsl #2
	add	x17, x17, x11
	add	x17, x8, x17, lsl #2
	str	x9, [sp, #40]                   ; 8-byte Folded Spill
	add	x0, x8, w9, sxtw #2
	mov	x1, x25
	b	LBB0_81
LBB0_80:                                ;   in Loop: Header=BB0_81 Depth=1
	add	x8, x8, x13
	add	x14, x14, x13
	add	x15, x15, x13
	add	x16, x16, x13
	add	x17, x17, x13
	add	x0, x0, x13
	ldr	w5, [sp, #24]                   ; 4-byte Folded Reload
	cmp	w1, w5
	ldr	w4, [sp, #32]                   ; 4-byte Folded Reload
	b.ge	LBB0_105
LBB0_81:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_84 Depth 2
                                        ;       Child Loop BB0_87 Depth 3
                                        ;         Child Loop BB0_90 Depth 4
                                        ;     Child Loop BB0_97 Depth 2
                                        ;       Child Loop BB0_100 Depth 3
	sdiv	w2, w1, w22
	mul	w2, w2, w4
	add	w1, w1, w25
	sdiv	w3, w1, w22
	mul	w3, w3, w4
	ldr	x9, [sp, #40]                   ; 8-byte Folded Reload
	cmp	w9, #1
	b.lt	LBB0_95
; %bb.82:                               ;   in Loop: Header=BB0_81 Depth=1
	mov	x4, #0
	b	LBB0_84
LBB0_83:                                ;   in Loop: Header=BB0_84 Depth=2
	add	x4, x4, x10
	cmp	x4, x11
	b.ge	LBB0_95
LBB0_84:                                ;   Parent Loop BB0_81 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_87 Depth 3
                                        ;         Child Loop BB0_90 Depth 4
	cmp	w22, #2
	b.lt	LBB0_83
; %bb.85:                               ;   in Loop: Header=BB0_84 Depth=2
	mov	w5, #0
	mov	w6, #0
	lsl	x24, x4, #2
	add	x7, x14, x24
	add	x27, x15, x24
	add	x30, x8, x24
	b	LBB0_87
LBB0_86:                                ;   in Loop: Header=BB0_87 Depth=3
	add	w6, w6, #1
	add	x7, x7, x12
	add	x27, x27, x12
	add	x30, x30, x12
	cmp	w6, w25
	b.eq	LBB0_93
LBB0_87:                                ;   Parent Loop BB0_81 Depth=1
                                        ;     Parent Loop BB0_84 Depth=2
                                        ; =>    This Loop Header: Depth=3
                                        ;         Child Loop BB0_90 Depth 4
	cmp	w21, #2
	b.lt	LBB0_86
; %bb.88:                               ;   in Loop: Header=BB0_87 Depth=3
	mov	x24, #0
	b	LBB0_90
LBB0_89:                                ;   in Loop: Header=BB0_90 Depth=4
	add	x24, x24, #1
	cmp	x23, x24
	b.eq	LBB0_86
LBB0_90:                                ;   Parent Loop BB0_81 Depth=1
                                        ;     Parent Loop BB0_84 Depth=2
                                        ;       Parent Loop BB0_87 Depth=3
                                        ; =>      This Inner Loop Header: Depth=4
	ldr	w9, [x27, x24, lsl #2]
	cmp	w9, #255
	b.ne	LBB0_89
; %bb.91:                               ;   in Loop: Header=BB0_90 Depth=4
	ldr	w9, [x30, x24, lsl #2]
	cmp	w9, #255
	b.ne	LBB0_89
; %bb.92:                               ;   in Loop: Header=BB0_90 Depth=4
	ldr	w9, [x7, x24, lsl #2]
	cmp	w9, #255
	cinc	w5, w5, eq
	b	LBB0_89
LBB0_93:                                ;   in Loop: Header=BB0_84 Depth=2
	cbz	w5, LBB0_83
; %bb.94:                               ;   in Loop: Header=BB0_84 Depth=2
	sdiv	w9, w4, w21
	lsl	w9, w9, #2
	add	x4, x4, x10
	sdiv	w6, w4, w21
	add	w7, w9, w2
	sbfiz	x7, x7, #2, #32
	ldr	w24, [x19, x7]
	lsl	w6, w6, #2
	add	w24, w24, w5
	str	w24, [x19, x7]
	add	w7, w6, w2
	orr	w7, w7, #0x1
	sbfiz	x7, x7, #2, #32
	ldr	w24, [x19, x7]
	add	w24, w24, w5
	str	w24, [x19, x7]
	add	w9, w9, w3
	orr	w9, w9, #0x2
	sbfiz	x9, x9, #2, #32
	ldr	w7, [x19, x9]
	add	w7, w7, w5
	str	w7, [x19, x9]
	add	w9, w6, w3
	orr	w9, w9, #0x3
	sbfiz	x9, x9, #2, #32
	ldr	w6, [x19, x9]
	add	w5, w6, w5
	str	w5, [x19, x9]
	cmp	x4, x11
	b.lt	LBB0_84
LBB0_95:                                ;   in Loop: Header=BB0_81 Depth=1
	mov	x4, x0
	mov	x5, x17
	mov	x6, x16
	mov	x7, x11
	ldr	x9, [sp, #40]                   ; 8-byte Folded Reload
	cmp	w9, w28
	b.lt	LBB0_97
	b	LBB0_80
LBB0_96:                                ;   in Loop: Header=BB0_97 Depth=2
	add	x7, x7, #1
	add	x6, x6, #4
	add	x5, x5, #4
	add	x4, x4, #4
	cmp	x7, x28
	b.eq	LBB0_80
LBB0_97:                                ;   Parent Loop BB0_81 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_100 Depth 3
	cmp	w22, #2
	b.lt	LBB0_96
; %bb.98:                               ;   in Loop: Header=BB0_97 Depth=2
	mov	x30, #0
	mov	w27, #0
	mov	x24, x25
	b	LBB0_100
LBB0_99:                                ;   in Loop: Header=BB0_100 Depth=3
	add	x30, x30, x12
	subs	w24, w24, #1
	b.eq	LBB0_103
LBB0_100:                               ;   Parent Loop BB0_81 Depth=1
                                        ;     Parent Loop BB0_97 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	ldr	w9, [x6, x30]
	cmp	w9, #255
	b.ne	LBB0_99
; %bb.101:                              ;   in Loop: Header=BB0_100 Depth=3
	ldr	w9, [x4, x30]
	cmp	w9, #255
	b.ne	LBB0_99
; %bb.102:                              ;   in Loop: Header=BB0_100 Depth=3
	ldr	w9, [x5, x30]
	cmp	w9, #255
	cinc	w27, w27, eq
	b	LBB0_99
LBB0_103:                               ;   in Loop: Header=BB0_97 Depth=2
	cbz	w27, LBB0_96
; %bb.104:                              ;   in Loop: Header=BB0_97 Depth=2
	sdiv	w9, w7, w21
	lsl	w9, w9, #2
	add	w24, w23, w7
	sdiv	w24, w24, w21
	add	w30, w9, w2
	sbfiz	x30, x30, #2, #32
	ldr	w26, [x19, x30]
	lsl	w24, w24, #2
	add	w26, w26, w27
	str	w26, [x19, x30]
	add	w26, w24, w2
	orr	w26, w26, #0x1
	sbfiz	x26, x26, #2, #32
	ldr	w30, [x19, x26]
	add	w30, w30, w27
	str	w30, [x19, x26]
	add	w9, w9, w3
	orr	w9, w9, #0x2
	sbfiz	x9, x9, #2, #32
	ldr	w26, [x19, x9]
	add	w26, w26, w27
	str	w26, [x19, x9]
	add	w9, w24, w3
	orr	w9, w9, #0x3
	sbfiz	x9, x9, #2, #32
	ldr	w24, [x19, x9]
	add	w24, w24, w27
	str	w24, [x19, x9]
	b	LBB0_96
LBB0_105:
	ldp	w9, w10, [sp, #8]               ; 8-byte Folded Reload
	lsl	w9, w9, #2
	sub	w10, w10, #1
	cmp	w5, w10
	b.ge	LBB0_115
; %bb.106:
	ldr	x11, [sp, #16]                  ; 8-byte Folded Reload
	lsl	x11, x11, #2
	add	x12, x8, x11
	sub	x13, x8, x11
	b	LBB0_108
LBB0_107:                               ;   in Loop: Header=BB0_108 Depth=1
	add	w5, w5, #1
	add	x12, x12, x11
	add	x13, x13, x11
	add	x8, x8, x11
	cmp	w5, w10
	b.eq	LBB0_115
LBB0_108:                               ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_111 Depth 2
	cmp	w20, #1
	b.lt	LBB0_107
; %bb.109:                              ;   in Loop: Header=BB0_108 Depth=1
	mov	x14, #0
	sdiv	w15, w5, w22
	mul	w15, w15, w4
	add	w16, w5, w25
	sdiv	w16, w16, w22
	mul	w16, w16, w4
	b	LBB0_111
LBB0_110:                               ;   in Loop: Header=BB0_111 Depth=2
	add	x14, x14, #1
	cmp	x20, x14
	b.eq	LBB0_107
LBB0_111:                               ;   Parent Loop BB0_108 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w17, [x13, x14, lsl #2]
	cmp	w17, #255
	b.ne	LBB0_110
; %bb.112:                              ;   in Loop: Header=BB0_111 Depth=2
	ldr	w17, [x8, x14, lsl #2]
	cmp	w17, #255
	b.ne	LBB0_110
; %bb.113:                              ;   in Loop: Header=BB0_111 Depth=2
	ldr	w17, [x12, x14, lsl #2]
	cmp	w17, #255
	b.ne	LBB0_110
; %bb.114:                              ;   in Loop: Header=BB0_111 Depth=2
	sdiv	w17, w14, w21
	lsl	w17, w17, #2
	add	w0, w23, w14
	sdiv	w0, w0, w21
	add	w1, w17, w15
	sbfiz	x1, x1, #2, #32
	ldr	w2, [x19, x1]
	lsl	w0, w0, #2
	add	w2, w2, #1
	str	w2, [x19, x1]
	add	w1, w0, w15
	orr	w1, w1, #0x1
	sbfiz	x1, x1, #2, #32
	ldr	w2, [x19, x1]
	add	w2, w2, #1
	str	w2, [x19, x1]
	add	w17, w17, w16
	orr	w17, w17, #0x2
	sbfiz	x17, x17, #2, #32
	ldr	w1, [x19, x17]
	add	w1, w1, #1
	str	w1, [x19, x17]
	add	w17, w0, w16
	orr	w17, w17, #0x3
	sbfiz	x17, x17, #2, #32
	ldr	w0, [x19, x17]
	add	w0, w0, #1
	str	w0, [x19, x17]
	b	LBB0_110
LBB0_115:
	cmp	w9, #1
	b.lt	LBB0_118
; %bb.116:
	cmp	w9, #16
	b.hs	LBB0_119
; %bb.117:
	mov	x8, #0
	mov	w0, #0
	b	LBB0_122
LBB0_118:
	mov	w0, #0
	b	LBB0_124
LBB0_119:
	and	x8, x9, #0xfffffff0
	add	x10, x19, #32
	movi.2d	v0, #0000000000000000
	mov	x11, x8
	movi.2d	v1, #0000000000000000
	movi.2d	v2, #0000000000000000
	movi.2d	v3, #0000000000000000
LBB0_120:                               ; =>This Inner Loop Header: Depth=1
	ldp	q4, q5, [x10, #-32]
	ldp	q6, q7, [x10], #64
	smax.4s	v0, v4, v0
	smax.4s	v1, v5, v1
	smax.4s	v2, v6, v2
	smax.4s	v3, v7, v3
	subs	x11, x11, #16
	b.ne	LBB0_120
; %bb.121:
	smax.4s	v0, v0, v1
	smax.4s	v0, v0, v2
	smax.4s	v0, v0, v3
	smaxv.4s	s0, v0
	fmov	w0, s0
	cmp	x8, x9
	b.eq	LBB0_124
LBB0_122:
	add	x10, x19, x8, lsl #2
	sub	x8, x9, x8
LBB0_123:                               ; =>This Inner Loop Header: Depth=1
	ldr	w9, [x10], #4
	cmp	w9, w0
	csel	w0, w9, w0, gt
	subs	x8, x8, #1
	b.ne	LBB0_123
LBB0_124:
	ldp	x29, x30, [sp, #128]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #112]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #96]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #80]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #64]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #48]             ; 16-byte Folded Reload
	add	sp, sp, #144
	ret
	.cfi_endproc
                                        ; -- End function
	.no_dead_strip	_calc_combed_score
.subsections_via_symbols
