	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal16,16byte_literals
	.p2align	4                               ## -- Begin function premultiply8yuv
LCPI0_0:
	.long	4294967168                      ## 0xffffff80
	.long	4294967168                      ## 0xffffff80
	.long	4294967168                      ## 0xffffff80
	.long	4294967168                      ## 0xffffff80
LCPI0_1:
	.long	1                               ## 0x1
	.long	1                               ## 0x1
	.long	1                               ## 0x1
	.long	1                               ## 0x1
LCPI0_2:
	.long	128                             ## 0x80
	.long	128                             ## 0x80
	.long	128                             ## 0x80
	.long	128                             ## 0x80
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_premultiply8yuv:                       ## @premultiply8yuv
	.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	%rdx, -64(%rbp)                 ## 8-byte Spill
	movq	%rsi, -48(%rbp)                 ## 8-byte Spill
	movq	%rdi, -56(%rbp)                 ## 8-byte Spill
	cmpl	$0, 24(%rbp)
	jle	LBB0_16
## %bb.1:
	movl	16(%rbp), %eax
	movslq	%r9d, %r15
	movl	%eax, %r9d
	movslq	%ecx, %r12
	movslq	%r8d, %r8
	movl	%eax, %r11d
	shlq	$2, %r15
	shlq	$2, %r12
	shlq	$2, %r8
	movl	%r11d, %eax
	andl	$-8, %eax
	movq	%rax, -72(%rbp)                 ## 8-byte Spill
	movq	%r11, %rax
	negq	%rax
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	leaq	(,%r11,4), %r13
	andq	$-32, %r13
	xorl	%r10d, %r10d
	movdqa	LCPI0_0(%rip), %xmm8            ## xmm8 = [4294967168,4294967168,4294967168,4294967168]
	movdqa	LCPI0_1(%rip), %xmm1            ## xmm1 = [1,1,1,1]
	movdqa	LCPI0_2(%rip), %xmm2            ## xmm2 = [128,128,128,128]
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	movq	-48(%rbp), %rsi                 ## 8-byte Reload
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	jmp	LBB0_2
	.p2align	4, 0x90
LBB0_15:                                ##   in Loop: Header=BB0_2 Depth=1
	addq	%r15, %rbx
	addq	%r12, %rdi
	addq	%r8, %rsi
	incq	%r10
	cmpl	24(%rbp), %r10d
	je	LBB0_16
LBB0_2:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_9 Depth 2
                                        ##     Child Loop BB0_14 Depth 2
	testl	%r9d, %r9d
	jle	LBB0_15
## %bb.3:                               ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$8, %r9d
	jae	LBB0_5
## %bb.4:                               ##   in Loop: Header=BB0_2 Depth=1
	xorl	%r14d, %r14d
	jmp	LBB0_11
	.p2align	4, 0x90
LBB0_5:                                 ##   in Loop: Header=BB0_2 Depth=1
	movl	%r9d, %eax
	movq	%r15, %r9
	imulq	%r10, %r9
	addq	-64(%rbp), %r9                  ## 8-byte Folded Reload
	movq	%r12, %rcx
	imulq	%r10, %rcx
	addq	-56(%rbp), %rcx                 ## 8-byte Folded Reload
	movq	%r9, %rdx
	subq	%rcx, %rdx
	cmpq	$32, %rdx
	jb	LBB0_6
## %bb.7:                               ##   in Loop: Header=BB0_2 Depth=1
	movq	%r8, %rcx
	imulq	%r10, %rcx
	addq	-48(%rbp), %rcx                 ## 8-byte Folded Reload
	subq	%rcx, %r9
	movl	$0, %r14d
	cmpq	$32, %r9
	movl	%eax, %r9d
	jb	LBB0_11
## %bb.8:                               ##   in Loop: Header=BB0_2 Depth=1
	xorl	%edx, %edx
	.p2align	4, 0x90
LBB0_9:                                 ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	(%rdi,%rdx), %xmm3
	movdqu	16(%rdi,%rdx), %xmm4
	paddd	%xmm8, %xmm3
	paddd	%xmm8, %xmm4
	movdqu	(%rsi,%rdx), %xmm5
	movdqu	16(%rsi,%rdx), %xmm0
	movdqa	%xmm5, %xmm7
	psrld	$1, %xmm7
	movdqa	%xmm0, %xmm6
	psrld	$1, %xmm6
	pand	%xmm1, %xmm7
	pand	%xmm1, %xmm6
	paddd	%xmm5, %xmm7
	pmulld	%xmm3, %xmm7
	paddd	%xmm0, %xmm6
	pmulld	%xmm4, %xmm6
	psrad	$8, %xmm7
	psrad	$8, %xmm6
	paddd	%xmm2, %xmm7
	paddd	%xmm2, %xmm6
	movdqu	%xmm7, (%rbx,%rdx)
	movdqu	%xmm6, 16(%rbx,%rdx)
	addq	$32, %rdx
	cmpq	%rdx, %r13
	jne	LBB0_9
## %bb.10:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	movq	%rax, %r14
	cmpq	%r11, %rax
	je	LBB0_15
	jmp	LBB0_11
LBB0_6:                                 ##   in Loop: Header=BB0_2 Depth=1
	xorl	%r14d, %r14d
	movl	%eax, %r9d
	.p2align	4, 0x90
LBB0_11:                                ##   in Loop: Header=BB0_2 Depth=1
	movq	%r14, %rdx
	testb	$1, %r11b
	je	LBB0_13
## %bb.12:                              ##   in Loop: Header=BB0_2 Depth=1
	movl	(%rdi,%r14,4), %ecx
	addl	$-128, %ecx
	movl	(%rsi,%r14,4), %edx
	btl	$1, %edx
	adcl	$0, %edx
	imull	%ecx, %edx
	sarl	$8, %edx
	subl	$-128, %edx
	movl	%edx, (%rbx,%r14,4)
	movq	%r14, %rdx
	orq	$1, %rdx
LBB0_13:                                ##   in Loop: Header=BB0_2 Depth=1
	notq	%r14
	cmpq	-80(%rbp), %r14                 ## 8-byte Folded Reload
	je	LBB0_15
	.p2align	4, 0x90
LBB0_14:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rdi,%rdx,4), %ecx
	addl	$-128, %ecx
	movl	(%rsi,%rdx,4), %eax
	btl	$1, %eax
	adcl	$0, %eax
	imull	%ecx, %eax
	sarl	$8, %eax
	subl	$-128, %eax
	movl	%eax, (%rbx,%rdx,4)
	movl	4(%rdi,%rdx,4), %eax
	addl	$-128, %eax
	movl	4(%rsi,%rdx,4), %ecx
	btl	$1, %ecx
	adcl	$0, %ecx
	imull	%eax, %ecx
	sarl	$8, %ecx
	subl	$-128, %ecx
	movl	%ecx, 4(%rbx,%rdx,4)
	addq	$2, %rdx
	cmpq	%rdx, %r11
	jne	LBB0_14
	jmp	LBB0_15
LBB0_16:
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.no_dead_strip	_premultiply8yuv
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function premultiply8yuv
_premultiply8yuv:                       ; @premultiply8yuv
	.cfi_startproc
; %bb.0:
	stp	x20, x19, [sp, #-16]!           ; 16-byte Folded Spill
	.cfi_def_cfa_offset 16
	.cfi_offset w19, -8
	.cfi_offset w20, -16
                                        ; kill: def $w5 killed $w5 def $x5
                                        ; kill: def $w4 killed $w4 def $x4
                                        ; kill: def $w3 killed $w3 def $x3
	cmp	w7, #1
	b.lt	LBB0_12
; %bb.1:
	mov	x8, #0
	mov	w9, w6
	sbfiz	x10, x5, #2, #32
	sbfiz	x11, x3, #2, #32
	sbfiz	x12, x4, #2, #32
	and	x13, x9, #0xfffffff0
	lsl	x14, x9, #2
	and	x14, x14, #0x3ffffffc0
	mvni.4s	v0, #127
	movi.4s	v1, #1
	mov	x15, x1
	mov	x16, x0
	mov	x17, x2
	b	LBB0_3
LBB0_2:                                 ;   in Loop: Header=BB0_3 Depth=1
	add	x8, x8, #1
	add	x17, x17, x10
	add	x16, x16, x11
	add	x15, x15, x12
	cmp	w8, w7
	b.eq	LBB0_12
LBB0_3:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_9 Depth 2
                                        ;     Child Loop BB0_11 Depth 2
	cmp	w6, #1
	b.lt	LBB0_2
; %bb.4:                                ;   in Loop: Header=BB0_3 Depth=1
	cmp	w6, #16
	b.hs	LBB0_6
; %bb.5:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x3, #0
	b	LBB0_11
LBB0_6:                                 ;   in Loop: Header=BB0_3 Depth=1
	mov	x3, #0
	madd	x4, x10, x8, x2
	madd	x5, x11, x8, x0
	sub	x5, x4, x5
	cmp	x5, #64
	b.lo	LBB0_11
; %bb.7:                                ;   in Loop: Header=BB0_3 Depth=1
	madd	x5, x12, x8, x1
	sub	x4, x4, x5
	cmp	x4, #64
	b.lo	LBB0_11
; %bb.8:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x3, #0
LBB0_9:                                 ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x4, x16, x3
	ldp	q2, q3, [x4]
	ldp	q4, q5, [x4, #32]
	add.4s	v2, v2, v0
	add.4s	v3, v3, v0
	add.4s	v4, v4, v0
	add.4s	v5, v5, v0
	add	x4, x15, x3
	ldp	q6, q7, [x4]
	ldp	q16, q17, [x4, #32]
	ushr.4s	v18, v6, #1
	ushr.4s	v19, v7, #1
	ushr.4s	v20, v16, #1
	ushr.4s	v21, v17, #1
	and.16b	v18, v18, v1
	and.16b	v19, v19, v1
	and.16b	v20, v20, v1
	and.16b	v21, v21, v1
	add.4s	v6, v18, v6
	add.4s	v7, v19, v7
	add.4s	v16, v20, v16
	add.4s	v17, v21, v17
	mul.4s	v2, v6, v2
	mul.4s	v3, v7, v3
	mul.4s	v4, v16, v4
	mul.4s	v5, v17, v5
	movi.4s	v6, #128
	ssra.4s	v6, v2, #8
	movi.4s	v2, #128
	ssra.4s	v2, v3, #8
	movi.4s	v3, #128
	ssra.4s	v3, v4, #8
	movi.4s	v4, #128
	ssra.4s	v4, v5, #8
	add	x4, x17, x3
	stp	q6, q2, [x4]
	stp	q3, q4, [x4, #32]
	add	x3, x3, #64
	cmp	x14, x3
	b.ne	LBB0_9
; %bb.10:                               ;   in Loop: Header=BB0_3 Depth=1
	mov	x3, x13
	cmp	x13, x9
	b.eq	LBB0_2
LBB0_11:                                ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	lsl	x4, x3, #2
	ldr	w5, [x16, x4]
	sub	w5, w5, #128
	ldr	w19, [x15, x4]
	ubfx	w20, w19, #1, #1
	add	w19, w20, w19
	mul	w5, w19, w5
	asr	w5, w5, #8
	add	w5, w5, #128
	str	w5, [x17, x4]
	add	x3, x3, #1
	cmp	x9, x3
	b.ne	LBB0_11
	b	LBB0_2
LBB0_12:
	ldp	x20, x19, [sp], #16             ; 16-byte Folded Reload
	ret
	.cfi_endproc
                                        ; -- End function
	.no_dead_strip	_premultiply8yuv
.subsections_via_symbols
