	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal4,4byte_literals
	.p2align	2                               ## -- Begin function sdl_render_msg
LCPI0_0:
	.long	0x3f800000                      ## float 1
	.section	__TEXT,__literal16,16byte_literals
	.p2align	4
LCPI0_1:
	.byte	255                             ## 0xff
	.byte	0                               ## 0x0
	.byte	0                               ## 0x0
	.byte	0                               ## 0x0
	.byte	255                             ## 0xff
	.byte	0                               ## 0x0
	.byte	0                               ## 0x0
	.byte	0                               ## 0x0
	.byte	255                             ## 0xff
	.byte	0                               ## 0x0
	.byte	0                               ## 0x0
	.byte	0                               ## 0x0
	.byte	255                             ## 0xff
	.byte	0                               ## 0x0
	.byte	0                               ## 0x0
	.byte	0                               ## 0x0
LCPI0_2:
	.long	256                             ## 0x100
	.long	256                             ## 0x100
	.long	256                             ## 0x100
	.long	256                             ## 0x100
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_sdl_render_msg:                        ## @sdl_render_msg
	.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	$152, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%r9, %r14
	movl	%r8d, -60(%rbp)                 ## 4-byte Spill
	movl	%ecx, -64(%rbp)                 ## 4-byte Spill
	movq	%rdx, %rbx
	movq	%rsi, -112(%rbp)                ## 8-byte Spill
	movq	%rdi, %r15
	xorl	%eax, %eax
	callq	_config_get_ptr
	movl	12(%r15), %edi
	testl	%edi, %edi
	je	LBB0_22
## %bb.1:
	movq	%rax, %r12
	movq	16(%r15), %rax
	callq	*8(%rax)
	movq	%rax, -104(%rbp)                ## 8-byte Spill
	movb	(%rbx), %al
	testb	%al, %al
	je	LBB0_22
## %bb.2:
	movl	(%r14), %edx
	movss	LCPI0_0(%rip), %xmm0            ## xmm0 = mem[0],zero,zero,zero
	subss	4(%r12), %xmm0
	movl	-60(%rbp), %ecx                 ## 4-byte Reload
	cvtsi2ss	%rcx, %xmm1
	movq	%r12, %rcx
	movl	4(%r14), %r12d
	mulss	%xmm0, %xmm1
	cvttss2si	%xmm1, %r13d
	movl	8(%r14), %esi
	movl	(%rcx), %ecx
	imull	-64(%rbp), %ecx                 ## 4-byte Folded Reload
	movl	%ecx, -56(%rbp)                 ## 4-byte Spill
	leaq	12(%r15), %rcx
	movq	%rcx, -128(%rbp)                ## 8-byte Spill
	movl	%edx, -68(%rbp)                 ## 4-byte Spill
	movd	%edx, %xmm0
	movd	%r12d, %xmm1
	movd	%esi, %xmm2
	pmovzxdq	%xmm0, %xmm9                    ## xmm9 = xmm0[0],zero,xmm0[1],zero
	pmovzxdq	%xmm1, %xmm11                   ## xmm11 = xmm1[0],zero,xmm1[1],zero
	pmovzxdq	%xmm2, %xmm12                   ## xmm12 = xmm2[0],zero,xmm2[1],zero
	movdqa	%xmm9, -192(%rbp)               ## 16-byte Spill
	movdqa	%xmm11, -176(%rbp)              ## 16-byte Spill
	movdqa	%xmm12, -160(%rbp)              ## 16-byte Spill
	movl	%r12d, -48(%rbp)                ## 4-byte Spill
	movl	%esi, -44(%rbp)                 ## 4-byte Spill
	jmp	LBB0_3
	.p2align	4, 0x90
LBB0_5:                                 ##   in Loop: Header=BB0_3 Depth=1
	movq	-80(%rbp), %rbx                 ## 8-byte Reload
	movl	-52(%rbp), %r13d                ## 4-byte Reload
LBB0_21:                                ##   in Loop: Header=BB0_3 Depth=1
	movb	1(%rbx), %al
	incq	%rbx
	testb	%al, %al
	je	LBB0_22
LBB0_3:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_9 Depth 2
                                        ##       Child Loop BB0_15 Depth 3
                                        ##       Child Loop BB0_17 Depth 3
	movq	16(%r15), %rcx
	movl	12(%r15), %edi
	movsbl	%al, %esi
	callq	*(%rcx)
	testq	%rax, %rax
	je	LBB0_21
## %bb.4:                               ##   in Loop: Header=BB0_3 Depth=1
	movq	%rbx, -80(%rbp)                 ## 8-byte Spill
	movslq	8(%rax), %rdx
	movslq	-56(%rbp), %rcx                 ## 4-byte Folded Reload
	addq	%rdx, %rcx
	movl	12(%rax), %r11d
	movl	%r13d, -52(%rbp)                ## 4-byte Spill
	addl	%r13d, %r11d
	testl	%ecx, %ecx
	movl	$0, %r13d
	cmovgl	%ecx, %r13d
	testl	%r11d, %r11d
	movl	$0, %edi
	cmovgl	%r11d, %edi
	movl	-64(%rbp), %edx                 ## 4-byte Reload
	subl	%r13d, %edx
	testl	%edx, %edx
	jle	LBB0_5
## %bb.6:                               ##   in Loop: Header=BB0_3 Depth=1
	movl	-60(%rbp), %ebx                 ## 4-byte Reload
	subl	%edi, %ebx
	testl	%ebx, %ebx
	jle	LBB0_5
## %bb.7:                               ##   in Loop: Header=BB0_3 Depth=1
	movl	%r11d, %esi
	sarl	$31, %esi
	andl	%r11d, %esi
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	addl	4(%rax), %esi
	cmpl	%ebx, %esi
	cmovgel	%ebx, %esi
	movl	%esi, -84(%rbp)                 ## 4-byte Spill
	testl	%esi, %esi
	movdqa	-192(%rbp), %xmm9               ## 16-byte Reload
	movdqa	LCPI0_1(%rip), %xmm10           ## xmm10 = [255,0,0,0,255,0,0,0,255,0,0,0,255,0,0,0]
	movdqa	-176(%rbp), %xmm11              ## 16-byte Reload
	movdqa	-160(%rbp), %xmm12              ## 16-byte Reload
	movdqa	LCPI0_2(%rip), %xmm13           ## xmm13 = [256,256,256,256]
	jle	LBB0_20
## %bb.8:                               ##   in Loop: Header=BB0_3 Depth=1
	movq	%rcx, %r10
	negq	%r10
	xorl	%esi, %esi
	testl	%ecx, %ecx
	movl	$0, %r9d
	cmovsl	%ecx, %r9d
	cmovnsq	%rsi, %r10
	movq	-96(%rbp), %r14                 ## 8-byte Reload
	addl	(%r14), %r9d
	cmpl	%edx, %r9d
	movq	-112(%rbp), %rbx                ## 8-byte Reload
	movl	(%rbx), %ecx
	cmovgel	%edx, %r9d
	movl	%ecx, %eax
	sarl	$2, %eax
	imull	%edi, %eax
	cltq
	shlq	$2, %rax
	addq	8(%rbx), %rax
	movl	-68(%rbp), %ebx                 ## 4-byte Reload
	movl	%r13d, %edx
	leaq	(%rax,%rdx,4), %r12
	movslq	16(%r14), %r8
	movq	-104(%rbp), %rax                ## 8-byte Reload
	movslq	8(%rax), %rdi
	shlq	$2, %r8
	addq	(%rax), %r8
	movslq	20(%r14), %rax
	movq	%r9, %rdx
	imulq	%rdi, %rax
	leaq	(%r8,%rax,4), %rax
	leaq	(%rax,%r10,4), %r8
	movl	%edi, %eax
	imull	%r11d, %eax
	cltq
	negq	%rax
	testl	%r11d, %r11d
	cmovnsq	%rsi, %rax
	leaq	(%r8,%rax,4), %r9
	movl	%edx, %eax
	andl	$-4, %eax
	movq	%rax, -120(%rbp)                ## 8-byte Spill
	jmp	LBB0_9
	.p2align	4, 0x90
LBB0_18:                                ##   in Loop: Header=BB0_9 Depth=2
	movq	-104(%rbp), %rax                ## 8-byte Reload
	movl	8(%rax), %edi
	movq	-112(%rbp), %rax                ## 8-byte Reload
	movl	(%rax), %ecx
	movq	-136(%rbp), %rsi                ## 8-byte Reload
LBB0_19:                                ##   in Loop: Header=BB0_9 Depth=2
	incl	%esi
	movslq	%edi, %rax
	leaq	(%r9,%rax,4), %r9
	movl	%ecx, %eax
	sarl	$2, %eax
	cltq
	leaq	(%r12,%rax,4), %r12
	cmpl	-84(%rbp), %esi                 ## 4-byte Folded Reload
	je	LBB0_20
LBB0_9:                                 ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_15 Depth 3
                                        ##       Child Loop BB0_17 Depth 3
	testl	%edx, %edx
	jle	LBB0_19
## %bb.10:                              ##   in Loop: Header=BB0_9 Depth=2
	cmpl	$4, %edx
	movq	%rsi, -136(%rbp)                ## 8-byte Spill
	jb	LBB0_11
## %bb.12:                              ##   in Loop: Header=BB0_9 Depth=2
	leaq	(%r12,%rdx,4), %rcx
	leaq	(%r9,%rdx,4), %rax
	cmpq	%rax, %r12
	setb	%dil
	cmpq	%rcx, %r9
	setb	%r8b
	cmpq	-128(%rbp), %r12                ## 8-byte Folded Reload
	setb	%al
	cmpq	%r15, %rcx
	seta	%cl
	testb	%r8b, %dil
	jne	LBB0_11
## %bb.13:                              ##   in Loop: Header=BB0_9 Depth=2
	movl	$0, %edi
	andb	%cl, %al
	movl	-48(%rbp), %r14d                ## 4-byte Reload
	movl	-44(%rbp), %r11d                ## 4-byte Reload
	jne	LBB0_17
## %bb.14:                              ##   in Loop: Header=BB0_9 Depth=2
	movd	(%r15), %xmm0                   ## xmm0 = mem[0],zero,zero,zero
	pshufd	$0, %xmm0, %xmm8                ## xmm8 = xmm0[0,0,0,0]
	movd	4(%r15), %xmm1                  ## xmm1 = mem[0],zero,zero,zero
	pshufd	$0, %xmm1, %xmm1                ## xmm1 = xmm1[0,0,0,0]
	movd	8(%r15), %xmm2                  ## xmm2 = mem[0],zero,zero,zero
	pshufd	$0, %xmm2, %xmm2                ## xmm2 = xmm2[0,0,0,0]
	xorl	%ecx, %ecx
	movq	-120(%rbp), %rax                ## 8-byte Reload
	.p2align	4, 0x90
LBB0_15:                                ##   Parent Loop BB0_3 Depth=1
                                        ##     Parent Loop BB0_9 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movdqu	(%r12,%rcx,4), %xmm4
	movdqa	%xmm4, %xmm5
	psrld	%xmm9, %xmm5
	movdqu	(%r9,%rcx,4), %xmm3
	pand	%xmm10, %xmm5
	movdqa	%xmm4, %xmm6
	psrld	%xmm11, %xmm6
	pand	%xmm10, %xmm6
	psrld	%xmm12, %xmm4
	pand	%xmm10, %xmm4
	movdqa	%xmm13, %xmm7
	psubd	%xmm3, %xmm7
	pmulld	%xmm7, %xmm5
	movdqa	%xmm8, %xmm0
	pmulld	%xmm3, %xmm0
	paddd	%xmm5, %xmm0
	psrld	$8, %xmm0
	pmulld	%xmm7, %xmm6
	movdqa	%xmm1, %xmm5
	pmulld	%xmm3, %xmm5
	paddd	%xmm6, %xmm5
	psrld	$8, %xmm5
	pmulld	%xmm4, %xmm7
	pmulld	%xmm2, %xmm3
	paddd	%xmm7, %xmm3
	pslld	%xmm9, %xmm0
	pslld	%xmm11, %xmm5
	psrld	$8, %xmm3
	por	%xmm0, %xmm5
	pslld	%xmm12, %xmm3
	por	%xmm5, %xmm3
	movdqu	%xmm3, (%r12,%rcx,4)
	addq	$4, %rcx
	cmpq	%rcx, %rax
	jne	LBB0_15
## %bb.16:                              ##   in Loop: Header=BB0_9 Depth=2
	movq	%rax, %rdi
	cmpq	%rdx, %rax
	movl	-48(%rbp), %r14d                ## 4-byte Reload
	movl	-44(%rbp), %r11d                ## 4-byte Reload
	jne	LBB0_17
	jmp	LBB0_18
	.p2align	4, 0x90
LBB0_11:                                ##   in Loop: Header=BB0_9 Depth=2
	xorl	%edi, %edi
	movl	-48(%rbp), %r14d                ## 4-byte Reload
	movl	-44(%rbp), %r11d                ## 4-byte Reload
	.p2align	4, 0x90
LBB0_17:                                ##   Parent Loop BB0_3 Depth=1
                                        ##     Parent Loop BB0_9 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movl	(%r9,%rdi,4), %r13d
	movl	(%r12,%rdi,4), %r8d
	movl	%r8d, %eax
	movl	%ebx, %ecx
	shrl	%cl, %eax
	movzbl	%al, %r10d
	movl	%r8d, %eax
	movl	%r14d, %ecx
	shrl	%cl, %eax
	movq	%r9, %rbx
	movzbl	%al, %r9d
	movl	%r11d, %ecx
	shrl	%cl, %r8d
	movl	$256, %ecx                      ## imm = 0x100
	subl	%r13d, %ecx
	imull	%ecx, %r10d
	movl	(%r15), %eax
	imull	%r13d, %eax
	addl	%r10d, %eax
	imull	%ecx, %r9d
	movl	4(%r15), %esi
	imull	%r13d, %esi
	addl	%r9d, %esi
	movq	%rbx, %r9
	movzbl	%r8b, %ebx
	imull	%ebx, %ecx
	movl	-68(%rbp), %ebx                 ## 4-byte Reload
	imull	8(%r15), %r13d
	addl	%ecx, %r13d
	shrl	$8, %eax
	shrl	$8, %esi
	movl	%ebx, %ecx
	shll	%cl, %eax
	movl	%r14d, %ecx
	shll	%cl, %esi
	orl	%eax, %esi
	shrl	$8, %r13d
	movl	%r11d, %ecx
	shll	%cl, %r13d
	orl	%esi, %r13d
	movl	%r13d, (%r12,%rdi,4)
	incq	%rdi
	cmpq	%rdi, %rdx
	jne	LBB0_17
	jmp	LBB0_18
	.p2align	4, 0x90
LBB0_20:                                ##   in Loop: Header=BB0_3 Depth=1
	movl	-56(%rbp), %eax                 ## 4-byte Reload
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	addl	32(%rcx), %eax
	movl	%eax, -56(%rbp)                 ## 4-byte Spill
	movl	-52(%rbp), %r13d                ## 4-byte Reload
	addl	24(%rcx), %r13d
	movq	-80(%rbp), %rbx                 ## 8-byte Reload
	jmp	LBB0_21
LBB0_22:
	addq	$152, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.no_dead_strip	_sdl_render_msg
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function sdl_render_msg
_sdl_render_msg:                        ; @sdl_render_msg
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #208
	.cfi_def_cfa_offset 208
	stp	x28, x27, [sp, #112]            ; 16-byte Folded Spill
	stp	x26, x25, [sp, #128]            ; 16-byte Folded Spill
	stp	x24, x23, [sp, #144]            ; 16-byte Folded Spill
	stp	x22, x21, [sp, #160]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #176]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #192]            ; 16-byte Folded Spill
	add	x29, sp, #192
	.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
	mov	x26, x5
	stp	w3, w4, [x29, #-92]             ; 8-byte Folded Spill
	mov	x21, x2
	mov	x22, x1
	mov	x23, x0
	bl	_config_get_ptr
	mov	x25, x0
	ldr	w0, [x23, #12]
	cbz	w0, LBB0_21
; %bb.1:
	ldr	x8, [x23, #16]
	ldr	x8, [x8, #8]
	blr	x8
	ldrb	w8, [x21]
	cbz	w8, LBB0_21
; %bb.2:
	mov	x24, x0
	ldp	w27, w28, [x26]
	ldr	w26, [x26, #8]
	ldr	s0, [x25, #4]
	fmov	s1, #1.00000000
	fsub	s0, s1, s0
	ldp	w10, w9, [x29, #-92]            ; 8-byte Folded Reload
	ucvtf	s1, w9
	fmul	s0, s0, s1
	fcvtzs	w9, s0
	stur	w9, [x29, #-84]                 ; 4-byte Folded Spill
	ldr	w9, [x25]
	mul	w25, w9, w10
	add	x20, x23, #12
	dup.4s	v17, w27
	dup.4s	v18, w28
	dup.4s	v19, w26
	mov	w19, #256
	neg.4s	v20, v17
	neg.4s	v22, v18
	neg.4s	v23, v19
	stp	q18, q17, [sp, #64]             ; 32-byte Folded Spill
	stp	q20, q19, [sp, #32]             ; 32-byte Folded Spill
	stp	q23, q22, [sp]                  ; 32-byte Folded Spill
	b	LBB0_5
LBB0_3:                                 ;   in Loop: Header=BB0_5 Depth=1
	ldr	w8, [x0, #32]
	add	w25, w25, w8
	ldr	w8, [x0, #24]
	ldur	w9, [x29, #-84]                 ; 4-byte Folded Reload
	add	w9, w9, w8
	stur	w9, [x29, #-84]                 ; 4-byte Folded Spill
LBB0_4:                                 ;   in Loop: Header=BB0_5 Depth=1
	ldrb	w8, [x21, #1]!
	cbz	w8, LBB0_21
LBB0_5:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_11 Depth 2
                                        ;       Child Loop BB0_17 Depth 3
                                        ;       Child Loop BB0_20 Depth 3
	ldr	x9, [x23, #16]
	ldr	x9, [x9]
	ldr	w0, [x23, #12]
	sxtb	w1, w8
	blr	x9
	cbz	x0, LBB0_4
; %bb.6:                                ;   in Loop: Header=BB0_5 Depth=1
	ldp	w8, w9, [x0, #8]
                                        ; kill: def $w8 killed $w8 def $x8
	sxtw	x8, w8
	add	x11, x8, w25, sxtw
	ldur	w8, [x29, #-84]                 ; 4-byte Folded Reload
	add	w12, w9, w8
	cmp	w11, #0
	csel	w10, w11, wzr, gt
	cmp	w12, #0
	csel	w14, w12, wzr, gt
	ldur	w8, [x29, #-92]                 ; 4-byte Folded Reload
	sub	w13, w8, w10
	ldur	w8, [x29, #-88]                 ; 4-byte Folded Reload
	sub	w8, w8, w14
	cmp	w13, #1
	ccmp	w8, #1, #8, ge
	b.lt	LBB0_4
; %bb.7:                                ;   in Loop: Header=BB0_5 Depth=1
	ldr	w9, [x0, #4]
	cmp	w12, #0
	csel	w15, w12, wzr, lt
	add	w9, w9, w15
	cmp	w9, w8
	csel	w8, w9, w8, lt
	cmp	w8, #1
	ldp	q18, q17, [sp, #64]             ; 32-byte Folded Reload
	ldp	q20, q19, [sp, #32]             ; 32-byte Folded Reload
	movi.2d	v21, #0x0000ff000000ff
	ldp	q23, q22, [sp]                  ; 32-byte Folded Reload
	movi.4s	v24, #1, lsl #8
	b.lt	LBB0_3
; %bb.8:                                ;   in Loop: Header=BB0_5 Depth=1
	mov	w9, #0
	ldr	w17, [x0]
	ldr	x16, [x22, #8]
	ldr	w15, [x22]
	asr	w1, w15, #2
	mul	w14, w1, w14
	add	x14, x16, w14, sxtw #2
	add	x10, x14, w10, uxtw #2
	ldr	x14, [x24]
	ldp	w16, w1, [x0, #16]
                                        ; kill: def $w16 killed $w16 def $x16
	sxtw	x16, w16
	add	x14, x14, x16, lsl #2
	ldr	w16, [x24, #8]
	mul	w1, w16, w1
	add	x14, x14, w1, sxtw #2
	cmp	w11, #0
	csel	w1, w11, wzr, lt
	csneg	x2, xzr, x11, ge
	add	w11, w17, w1
	cmp	w11, w13
	csel	w11, w11, w13, lt
	add	x13, x14, x2, lsl #2
	mul	w14, w16, w12
	sxtw	x14, w14
	cmp	w12, #0
	csneg	x12, xzr, x14, ge
	add	x12, x13, x12, lsl #2
	and	x13, x11, #0xfffffffc
	neg	x14, x11
	b	LBB0_11
LBB0_9:                                 ;   in Loop: Header=BB0_11 Depth=2
	ldr	w16, [x24, #8]
	ldr	w15, [x22]
LBB0_10:                                ;   in Loop: Header=BB0_11 Depth=2
	add	w9, w9, #1
	add	x12, x12, w16, sxtw #2
	asr	w17, w15, #2
	add	x10, x10, w17, sxtw #2
	cmp	w9, w8
	b.eq	LBB0_3
LBB0_11:                                ;   Parent Loop BB0_5 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_17 Depth 3
                                        ;       Child Loop BB0_20 Depth 3
	cmp	w11, #1
	b.lt	LBB0_10
; %bb.12:                               ;   in Loop: Header=BB0_11 Depth=2
	cmp	w11, #4
	b.hs	LBB0_14
; %bb.13:                               ;   in Loop: Header=BB0_11 Depth=2
	mov	x17, #0
	b	LBB0_19
LBB0_14:                                ;   in Loop: Header=BB0_11 Depth=2
	mov	x17, #0
	lsl	x15, x11, #2
	add	x16, x12, x15
	cmp	x10, x20
	add	x1, x10, x15
	ccmp	x1, x23, #0, lo
	cset	w15, hi
	cmp	x12, x1
	ccmp	x10, x16, #2, lo
	b.lo	LBB0_19
; %bb.15:                               ;   in Loop: Header=BB0_11 Depth=2
	tbnz	w15, #0, LBB0_19
; %bb.16:                               ;   in Loop: Header=BB0_11 Depth=2
	mov	x15, x23
	ld1r.4s	{ v0 }, [x15], #4
	ld1r.4s	{ v1 }, [x15]
	add	x15, x23, #8
	ld1r.4s	{ v2 }, [x15]
	mov	x15, x13
	mov	x16, x10
	mov	x17, x12
LBB0_17:                                ;   Parent Loop BB0_5 Depth=1
                                        ;     Parent Loop BB0_11 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	ldr	q3, [x17], #16
	ldr	q4, [x16]
	ushl.4s	v5, v4, v20
	and.16b	v5, v5, v21
	ushl.4s	v6, v4, v22
	and.16b	v6, v6, v21
	ushl.4s	v4, v4, v23
	and.16b	v4, v4, v21
	sub.4s	v7, v24, v3
	mul.4s	v16, v0, v3
	mla.4s	v16, v5, v7
	ushr.4s	v5, v16, #8
	mul.4s	v16, v1, v3
	mla.4s	v16, v6, v7
	ushr.4s	v6, v16, #8
	mul.4s	v4, v4, v7
	mla.4s	v4, v2, v3
	ushr.4s	v3, v4, #8
	ushl.4s	v4, v5, v17
	ushl.4s	v5, v6, v18
	orr.16b	v4, v4, v5
	ushl.4s	v3, v3, v19
	orr.16b	v3, v4, v3
	str	q3, [x16], #16
	subs	x15, x15, #4
	b.ne	LBB0_17
; %bb.18:                               ;   in Loop: Header=BB0_11 Depth=2
	mov	x17, x13
	cmp	x13, x11
	b.eq	LBB0_9
LBB0_19:                                ;   in Loop: Header=BB0_11 Depth=2
	lsl	x16, x17, #2
	add	x15, x10, x16
	add	x16, x12, x16
	add	x17, x14, x17
LBB0_20:                                ;   Parent Loop BB0_5 Depth=1
                                        ;     Parent Loop BB0_11 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	ldr	w1, [x16], #4
	ldr	w2, [x15]
	lsr	w3, w2, w27
	and	w3, w3, #0xff
	sub	w4, w19, w1
	ldp	w5, w6, [x23]
	mul	w5, w5, w1
	madd	w3, w3, w4, w5
	lsr	w5, w2, w28
	and	w5, w5, #0xff
	lsr	w2, w2, w26
	and	w2, w2, #0xff
	lsr	w3, w3, #8
	mul	w6, w6, w1
	madd	w5, w5, w4, w6
	lsr	w5, w5, #8
	mul	w2, w2, w4
	ldr	w4, [x23, #8]
	madd	w1, w4, w1, w2
	lsr	w1, w1, #8
	lsl	w2, w3, w27
	lsl	w3, w5, w28
	orr	w2, w2, w3
	lsl	w1, w1, w26
	orr	w1, w2, w1
	str	w1, [x15], #4
	adds	x17, x17, #1
	b.lo	LBB0_20
	b	LBB0_9
LBB0_21:
	ldp	x29, x30, [sp, #192]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #176]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #160]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #144]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #128]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #112]            ; 16-byte Folded Reload
	add	sp, sp, #208
	ret
	.cfi_endproc
                                        ; -- End function
	.no_dead_strip	_sdl_render_msg
.subsections_via_symbols
