	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	4, 0x90                         ## -- Begin function dequant
_dequant:                               ## @dequant
	.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
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%r9, -72(%rbp)                  ## 8-byte Spill
	movq	%r8, -64(%rbp)                  ## 8-byte Spill
	movq	%rdi, -88(%rbp)                 ## 8-byte Spill
	movq	(%rdi), %rax
	movl	%ecx, %ecx
	movq	%rcx, -80(%rbp)                 ## 8-byte Spill
	movl	(%rax,%rcx,4), %eax
	movl	%eax, -52(%rbp)                 ## 4-byte Spill
	testl	%eax, %eax
	jle	LBB0_10
## %bb.1:
	movq	-88(%rbp), %rdi                 ## 8-byte Reload
	movq	8(%rdi), %rax
	movq	16(%rdi), %rcx
	movq	-80(%rbp), %rbx                 ## 8-byte Reload
	movq	(%rax,%rbx,8), %rax
	movq	%rax, -160(%rbp)                ## 8-byte Spill
	movl	(%rcx,%rbx,4), %eax
	movl	%eax, -48(%rbp)                 ## 4-byte Spill
	movq	24(%rdi), %rax
	movl	(%rax,%rbx,4), %eax
	movl	%eax, -44(%rbp)                 ## 4-byte Spill
	movq	32(%rdi), %rax
	movq	(%rax), %rcx
	movq	8(%rax), %rax
	movq	(%rcx,%rbx,8), %rcx
	movq	%rcx, -152(%rbp)                ## 8-byte Spill
	movq	(%rax,%rbx,8), %rax
	movq	%rax, -144(%rbp)                ## 8-byte Spill
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	addq	$4, %rax
	movq	%rax, -104(%rbp)                ## 8-byte Spill
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	addq	$4, %rax
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	xorl	%r15d, %r15d
	xorl	%r9d, %r9d
	jmp	LBB0_2
	.p2align	4, 0x90
LBB0_9:                                 ##   in Loop: Header=BB0_2 Depth=1
	addq	$8, %rsi
	addl	%r15d, %r11d
	incl	%r9d
	movl	%r11d, %r15d
	cmpl	-52(%rbp), %r9d                 ## 4-byte Folded Reload
	je	LBB0_10
LBB0_2:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_6 Depth 2
	xorl	%r10d, %r10d
	cmpl	-48(%rbp), %r9d                 ## 4-byte Folded Reload
	setge	%r10b
	xorl	%r11d, %r11d
	cmpl	-44(%rbp), %r9d                 ## 4-byte Folded Reload
	setge	%r11b
	movl	(%rsi), %ecx
	movl	%ecx, %eax
	andl	$64, %eax
	negl	%eax
	movl	$0, %r8d
	sbbl	%r8d, %r8d
	orl	$1, %r8d
	movl	%ecx, %eax
	andl	$63, %eax
	movq	-152(%rbp), %rdi                ## 8-byte Reload
	cmpl	$7, (%rdi,%r11,4)
	cmovnel	%ecx, %eax
	movl	$1, %r12d
	cmovnel	%r12d, %r8d
	movl	4(%rsi), %r14d
	movl	%r14d, %ecx
	andl	$64, %ecx
	negl	%ecx
	movl	$0, %edi
	sbbl	%edi, %edi
	orl	$1, %edi
	movl	%r14d, %ecx
	andl	$63, %ecx
	movq	-144(%rbp), %rbx                ## 8-byte Reload
	cmpl	$7, (%rbx,%r11,4)
	cmovnel	%r14d, %ecx
	movq	-160(%rbp), %rbx                ## 8-byte Reload
	movl	(%rbx,%r10,4), %r11d
	cmovnel	%r12d, %edi
	testl	%r11d, %r11d
	jle	LBB0_9
## %bb.3:                               ##   in Loop: Header=BB0_2 Depth=1
	movl	16(%rbp), %ebx
	imull	%ebx, %eax
	movslq	%eax, %r14
	imull	%ebx, %ecx
	movslq	%ecx, %r12
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	movq	40(%rax), %rax
	movq	-80(%rbp), %rcx                 ## 8-byte Reload
	movq	(%rax,%rcx,8), %rcx
	movslq	%r15d, %rbx
	cmpl	$1, %r11d
	movq	%rcx, -136(%rbp)                ## 8-byte Spill
	movq	%rbx, -128(%rbp)                ## 8-byte Spill
	movq	%r14, -120(%rbp)                ## 8-byte Spill
	movq	%r12, -112(%rbp)                ## 8-byte Spill
	jne	LBB0_5
## %bb.4:                               ##   in Loop: Header=BB0_2 Depth=1
	xorl	%ebx, %ebx
	jmp	LBB0_7
	.p2align	4, 0x90
LBB0_5:                                 ##   in Loop: Header=BB0_2 Depth=1
	movl	%r11d, %r10d
	andl	$-2, %r10d
	movq	-104(%rbp), %rax                ## 8-byte Reload
	leaq	(%rax,%r14,4), %r13
	movq	-96(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%r12,4), %r14
	leaq	(%rcx,%rbx,8), %r12
	addq	$8, %r12
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_6:                                 ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	-4(%r13,%rbx,4), %ecx
	imull	%r8d, %ecx
	movl	-4(%r14,%rbx,4), %eax
	imull	%edi, %eax
	addl	%ecx, %eax
	xorps	%xmm0, %xmm0
	cvtsi2ss	%eax, %xmm0
	movq	-8(%r12,%rbx,8), %rax
	movss	%xmm0, (%rdx,%rax,4)
	movl	(%r13,%rbx,4), %eax
	imull	%r8d, %eax
	movl	(%r14,%rbx,4), %ecx
	imull	%edi, %ecx
	addl	%eax, %ecx
	xorps	%xmm0, %xmm0
	cvtsi2ss	%ecx, %xmm0
	movq	(%r12,%rbx,8), %rax
	movss	%xmm0, (%rdx,%rax,4)
	addq	$2, %rbx
	cmpq	%rbx, %r10
	jne	LBB0_6
LBB0_7:                                 ##   in Loop: Header=BB0_2 Depth=1
	testb	$1, %r11b
	je	LBB0_9
## %bb.8:                               ##   in Loop: Header=BB0_2 Depth=1
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movq	-120(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rax,%rcx,4), %r10
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	movq	-112(%rbp), %rax                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %rcx
	imull	(%r10,%rbx,4), %r8d
	imull	(%rcx,%rbx,4), %edi
	addl	%r8d, %edi
	xorps	%xmm0, %xmm0
	cvtsi2ss	%edi, %xmm0
	movq	-128(%rbp), %rcx                ## 8-byte Reload
	addq	%rbx, %rcx
	movq	-136(%rbp), %rax                ## 8-byte Reload
	movq	(%rax,%rcx,8), %rax
	movss	%xmm0, (%rdx,%rax,4)
	jmp	LBB0_9
LBB0_10:
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.no_dead_strip	_dequant
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function dequant
_dequant:                               ; @dequant
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #160
	.cfi_def_cfa_offset 160
	stp	x28, x27, [sp, #64]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #80]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #96]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #112]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #128]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #144]            ; 16-byte Folded Spill
	.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	x4, x5, [sp, #48]               ; 16-byte Folded Spill
	ldr	x8, [x0]
	ldr	w4, [x8, w3, uxtw #2]
	cmp	w4, #1
	b.lt	LBB0_11
; %bb.1:
	mov	w9, #0
	mov	w10, #0
	mov	w3, w3
	lsl	x16, x3, #3
	ldp	x12, x13, [x0, #8]
	ldr	x7, [x12, x16]
	lsl	x14, x3, #2
	ldr	w13, [x13, x14]
	ldp	x15, x17, [x0, #24]
	ldr	w14, [x15, x14]
	ldp	x15, x17, [x17]
	ldr	x15, [x15, x16]
	ldr	x16, [x17, x16]
	ldr	x8, [sp, #56]                   ; 8-byte Folded Reload
	add	x11, x8, #8
	ldr	x8, [sp, #48]                   ; 8-byte Folded Reload
	add	x8, x8, #8
	stp	x8, x11, [sp, #8]               ; 16-byte Folded Spill
	mov	w5, #1
	stp	w14, w6, [sp, #40]              ; 8-byte Folded Spill
	stp	x16, x15, [sp, #24]             ; 16-byte Folded Spill
	b	LBB0_3
LBB0_2:                                 ;   in Loop: Header=BB0_3 Depth=1
	add	x1, x1, #8
	add	w9, w19, w9
	add	w10, w10, #1
	cmp	w10, w4
	b.eq	LBB0_11
LBB0_3:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_7 Depth 2
                                        ;     Child Loop BB0_10 Depth 2
	cmp	w10, w13
	cset	w17, ge
	ldr	w19, [x7, w17, uxtw #2]
	cmp	w10, w14
	cset	w17, ge
	lsl	x21, x17, #2
	ldr	w17, [x15, x21]
	ldp	w20, w22, [x1]
	tst	w20, #0x40
	cneg	w23, w5, ne
	and	w24, w20, #0x3f
	cmp	w17, #7
	csel	w17, w24, w20, eq
	csinc	w20, w23, wzr, eq
	ldr	w21, [x16, x21]
	tst	w22, #0x40
	cneg	w24, w5, ne
	and	w23, w22, #0x3f
	cmp	w21, #7
	csel	w23, w23, w22, eq
	csinc	w21, w24, wzr, eq
	cmp	w19, #1
	b.lt	LBB0_2
; %bb.4:                                ;   in Loop: Header=BB0_3 Depth=1
	smull	x22, w17, w6
	smull	x23, w23, w6
	ldr	x17, [x0, #40]
	ldr	x24, [x17, x3, lsl #3]
	sxtw	x26, w9
	cmp	w19, #4
	b.hs	LBB0_6
; %bb.5:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x17, #0
	b	LBB0_9
LBB0_6:                                 ;   in Loop: Header=BB0_3 Depth=1
	mov	x6, x13
	mov	x16, x3
	mov	x15, x4
	mov	x14, x0
	and	x17, x19, #0xfffffffc
	ldr	x8, [sp, #16]                   ; 8-byte Folded Reload
	add	x27, x8, x23, lsl #2
	add	x25, x24, x26, lsl #3
	add	x28, x25, #16
	ldr	x8, [sp, #8]                    ; 8-byte Folded Reload
	add	x30, x8, x22, lsl #2
	mov	x25, x17
LBB0_7:                                 ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldp	w3, w11, [x30, #-8]
	ldp	w5, w4, [x30], #16
	mul	w3, w3, w20
	mul	w11, w11, w20
	mul	w5, w5, w20
	mul	w4, w4, w20
	ldp	w12, w0, [x27, #-8]
	ldp	w8, w13, [x27], #16
	madd	w12, w12, w21, w3
	madd	w11, w0, w21, w11
	madd	w8, w8, w21, w5
	madd	w13, w13, w21, w4
	scvtf	s0, w12
	scvtf	s1, w11
	scvtf	s2, w8
	scvtf	s3, w13
	ldp	x8, x11, [x28, #-16]
	ldp	x12, x13, [x28], #32
	str	s0, [x2, x8, lsl #2]
	str	s1, [x2, x11, lsl #2]
	str	s2, [x2, x12, lsl #2]
	str	s3, [x2, x13, lsl #2]
	subs	x25, x25, #4
	b.ne	LBB0_7
; %bb.8:                                ;   in Loop: Header=BB0_3 Depth=1
	cmp	x17, x19
	mov	x0, x14
	mov	x4, x15
	mov	x3, x16
	mov	x13, x6
	ldp	w14, w6, [sp, #40]              ; 8-byte Folded Reload
	ldp	x16, x15, [sp, #24]             ; 16-byte Folded Reload
	mov	w5, #1
	b.eq	LBB0_2
LBB0_9:                                 ;   in Loop: Header=BB0_3 Depth=1
	add	x8, x17, x26
	add	x24, x24, x8, lsl #3
	add	x8, x17, x23
	ldr	x11, [sp, #56]                  ; 8-byte Folded Reload
	add	x23, x11, x8, lsl #2
	add	x8, x17, x22
	sub	x17, x19, x17
	ldr	x11, [sp, #48]                  ; 8-byte Folded Reload
	add	x22, x11, x8, lsl #2
LBB0_10:                                ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w8, [x22], #4
	mul	w8, w8, w20
	ldr	w11, [x23], #4
	madd	w8, w11, w21, w8
	scvtf	s0, w8
	ldr	x8, [x24], #8
	str	s0, [x2, x8, lsl #2]
	subs	x17, x17, #1
	b.ne	LBB0_10
	b	LBB0_2
LBB0_11:
	ldp	x29, x30, [sp, #144]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #128]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #112]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #96]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #80]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #64]             ; 16-byte Folded Reload
	add	sp, sp, #160
	ret
	.cfi_endproc
                                        ; -- End function
	.no_dead_strip	_dequant
.subsections_via_symbols
