Program: blake2b

x86 assembly:
	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	_blake2b                        ## -- Begin function blake2b
	.p2align	4, 0x90
_blake2b:                               ## @blake2b
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	subq	$176, %rsp
	movb	%r8b, %al
                                        ## kill: def $cl killed $cl killed $ecx
	movq	___stack_chk_guard@GOTPCREL(%rip), %r8
	movq	(%r8), %r8
	movq	%r8, -8(%rbp)
	movq	%rdi, -48(%rbp)
	movq	%rsi, -56(%rbp)
	movq	%rdx, -64(%rbp)
	movb	%cl, -65(%rbp)
	movb	%al, -66(%rbp)
	movq	$0, -80(%rbp)
	cmpq	$0, -48(%rbp)
	jne	LBB0_2
## %bb.1:
	movq	$0, -56(%rbp)
LBB0_2:
	cmpq	$0, -64(%rbp)
	jne	LBB0_4
## %bb.3:
	movb	$0, -65(%rbp)
LBB0_4:
	movzbl	-65(%rbp), %eax
	cmpl	$64, %eax
	jge	LBB0_6
## %bb.5:
	movzbl	-65(%rbp), %eax
	movl	%eax, -140(%rbp)                ## 4-byte Spill
	jmp	LBB0_7
LBB0_6:
	movl	$64, %eax
	movl	%eax, -140(%rbp)                ## 4-byte Spill
	jmp	LBB0_7
LBB0_7:
	movl	-140(%rbp), %eax                ## 4-byte Reload
                                        ## kill: def $al killed $al killed $eax
	movb	%al, -65(%rbp)
	movzbl	-66(%rbp), %eax
	cmpl	$64, %eax
	jge	LBB0_9
## %bb.8:
	movzbl	-66(%rbp), %eax
	movl	%eax, -144(%rbp)                ## 4-byte Spill
	jmp	LBB0_10
LBB0_9:
	movl	$64, %eax
	movl	%eax, -144(%rbp)                ## 4-byte Spill
	jmp	LBB0_10
LBB0_10:
	movl	-144(%rbp), %eax                ## 4-byte Reload
                                        ## kill: def $al killed $al killed $eax
	movb	%al, -66(%rbp)
	movzbl	-65(%rbp), %eax
	movl	$128, %ecx
	cltd
	idivl	%ecx
	movl	%eax, -148(%rbp)                ## 4-byte Spill
	movzbl	-65(%rbp), %eax
	movl	$128, %ecx
	cltd
	idivl	%ecx
	movl	-148(%rbp), %eax                ## 4-byte Reload
	cmpl	$0, %edx
	setne	%cl
	andb	$1, %cl
	movzbl	%cl, %ecx
	addl	%ecx, %eax
	cltq
	movq	-56(%rbp), %rcx
	shrq	$7, %rcx
	movq	-56(%rbp), %rdx
	andq	$127, %rdx
	cmpq	$0, %rdx
	setne	%dl
	andb	$1, %dl
	movzbl	%dl, %edx
	movslq	%edx, %rdx
	addq	%rdx, %rcx
	addq	%rcx, %rax
	cmpq	$1, %rax
	jbe	LBB0_12
## %bb.11:
	movzbl	-65(%rbp), %eax
	movl	$128, %ecx
	cltd
	idivl	%ecx
	movl	%eax, -164(%rbp)                ## 4-byte Spill
	movzbl	-65(%rbp), %eax
	movl	$128, %ecx
	cltd
	idivl	%ecx
	movl	-164(%rbp), %eax                ## 4-byte Reload
	cmpl	$0, %edx
	setne	%cl
	andb	$1, %cl
	movzbl	%cl, %ecx
	addl	%ecx, %eax
	cltq
	movq	-56(%rbp), %rcx
	shrq	$7, %rcx
	movq	-56(%rbp), %rdx
	andq	$127, %rdx
	cmpq	$0, %rdx
	setne	%dl
	andb	$1, %dl
	movzbl	%dl, %edx
	movslq	%edx, %rdx
	addq	%rdx, %rcx
	addq	%rcx, %rax
	movq	%rax, -160(%rbp)                ## 8-byte Spill
	jmp	LBB0_13
LBB0_12:
	movl	$1, %eax
	movq	%rax, -160(%rbp)                ## 8-byte Spill
	jmp	LBB0_13
LBB0_13:
	movq	-160(%rbp), %rax                ## 8-byte Reload
	movq	%rax, -96(%rbp)
	movq	-96(%rbp), %rdi
	movl	$128, %esi
	callq	_libmin_calloc
	movq	%rax, -136(%rbp)
	cmpq	$0, -136(%rbp)
	jne	LBB0_15
## %bb.14:
	movq	$0, -40(%rbp)
	jmp	LBB0_26
LBB0_15:
	movzbl	-66(%rbp), %eax
	movl	%eax, %edi
	shlq	$0, %rdi
	callq	_libmin_malloc
	movq	%rax, -80(%rbp)
	cmpq	$0, -80(%rbp)
	jne	LBB0_17
## %bb.16:
	movq	-136(%rbp), %rdi
	callq	_libmin_free
	movq	$0, -40(%rbp)
	jmp	LBB0_26
LBB0_17:
	movq	$0, -112(%rbp)
LBB0_18:                                ## =>This Inner Loop Header: Depth=1
	movq	-112(%rbp), %rax
	movzbl	-65(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	cmpq	%rcx, %rax
	jae	LBB0_21
## %bb.19:                              ##   in Loop: Header=BB0_18 Depth=1
	movq	-64(%rbp), %rax
	movq	-112(%rbp), %rcx
	movzbl	(%rax,%rcx), %eax
                                        ## kill: def $rax killed $eax
	movq	%rax, -88(%rbp)
	movq	-112(%rbp), %rcx
	andq	$7, %rcx
	shlq	$3, %rcx
	movq	-88(%rbp), %rax
                                        ## kill: def $cl killed $rcx
	shlq	%cl, %rax
	movq	%rax, -88(%rbp)
	movq	-112(%rbp), %rax
	andq	$127, %rax
	shrq	$3, %rax
	movq	%rax, -128(%rbp)
	movq	-88(%rbp), %rdx
	movq	-136(%rbp), %rax
	movq	-128(%rbp), %rcx
	orq	(%rax,%rcx,8), %rdx
	movq	%rdx, (%rax,%rcx,8)
## %bb.20:                              ##   in Loop: Header=BB0_18 Depth=1
	movq	-112(%rbp), %rax
	addq	$1, %rax
	movq	%rax, -112(%rbp)
	jmp	LBB0_18
LBB0_21:
	movzbl	-65(%rbp), %edx
	xorl	%eax, %eax
	movl	$1, %ecx
	cmpl	$0, %edx
	cmovgl	%ecx, %eax
	cltq
	movq	%rax, -104(%rbp)
	movq	$0, -112(%rbp)
LBB0_22:                                ## =>This Inner Loop Header: Depth=1
	movq	-112(%rbp), %rax
	cmpq	-56(%rbp), %rax
	jae	LBB0_25
## %bb.23:                              ##   in Loop: Header=BB0_22 Depth=1
	movq	-48(%rbp), %rax
	movq	-112(%rbp), %rcx
	movzbl	(%rax,%rcx), %eax
                                        ## kill: def $rax killed $eax
	movq	%rax, -88(%rbp)
	movq	-112(%rbp), %rcx
	andq	$7, %rcx
	shlq	$3, %rcx
	movq	-88(%rbp), %rax
                                        ## kill: def $cl killed $rcx
	shlq	%cl, %rax
	movq	%rax, -88(%rbp)
	movq	-104(%rbp), %rax
	movq	-112(%rbp), %rcx
	shrq	$7, %rcx
	addq	%rcx, %rax
	movq	%rax, -120(%rbp)
	movq	-112(%rbp), %rax
	andq	$127, %rax
	shrq	$3, %rax
	movq	%rax, -128(%rbp)
	movq	-88(%rbp), %rdx
	movq	-136(%rbp), %rax
	movq	-120(%rbp), %rcx
	shlq	$7, %rcx
	addq	%rcx, %rax
	movq	-128(%rbp), %rcx
	orq	(%rax,%rcx,8), %rdx
	movq	%rdx, (%rax,%rcx,8)
## %bb.24:                              ##   in Loop: Header=BB0_22 Depth=1
	movq	-112(%rbp), %rax
	addq	$1, %rax
	movq	%rax, -112(%rbp)
	jmp	LBB0_22
LBB0_25:
	leaq	-32(%rbp), %rdi
	movq	-56(%rbp), %rsi
	callq	_u128_fill
	movq	-80(%rbp), %rdi
	movq	-136(%rbp), %rsi
	movq	-96(%rbp), %rdx
	leaq	-32(%rbp), %rcx
	movb	-65(%rbp), %al
	movzbl	%al, %r8d
	movzbl	-66(%rbp), %r9d
	callq	_BLAKE2B
	movq	-136(%rbp), %rdi
	callq	_libmin_free
	movq	-80(%rbp), %rax
	movq	%rax, -40(%rbp)
LBB0_26:
	movq	-40(%rbp), %rax
	movq	%rax, -176(%rbp)                ## 8-byte Spill
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	-8(%rbp), %rcx
	cmpq	%rcx, %rax
	jne	LBB0_28
## %bb.27:
	movq	-176(%rbp), %rax                ## 8-byte Reload
	addq	$176, %rsp
	popq	%rbp
	retq
LBB0_28:
	callq	___stack_chk_fail
	ud2
	.cfi_endproc
                                        ## -- End function
	.p2align	4, 0x90                         ## -- Begin function u128_fill
_u128_fill:                             ## @u128_fill
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	movq	%rdi, -8(%rbp)
	movq	%rsi, -16(%rbp)
	movq	-16(%rbp), %rcx
	andq	$-1, %rcx
	movq	-8(%rbp), %rax
	movq	%rcx, (%rax)
	movq	-8(%rbp), %rax
	movq	$0, 8(%rax)
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.p2align	4, 0x90                         ## -- Begin function BLAKE2B
_BLAKE2B:                               ## @BLAKE2B
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	subq	$208, %rsp
	movl	%r8d, -196(%rbp)                ## 4-byte Spill
	movq	%rcx, %rax
	movl	-196(%rbp), %ecx                ## 4-byte Reload
	movq	%rax, -192(%rbp)                ## 8-byte Spill
	movq	%rdx, %rax
	movq	-192(%rbp), %rdx                ## 8-byte Reload
	movq	%rax, -184(%rbp)                ## 8-byte Spill
	movq	%rsi, %rax
	movq	-184(%rbp), %rsi                ## 8-byte Reload
	movq	%rax, -176(%rbp)                ## 8-byte Spill
	movq	%rdi, %r8
	movq	-176(%rbp), %rdi                ## 8-byte Reload
	movb	%r9b, %al
                                        ## kill: def $cl killed $cl killed $ecx
	movq	___stack_chk_guard@GOTPCREL(%rip), %r9
	movq	(%r9), %r9
	movq	%r9, -8(%rbp)
	movq	%r8, -104(%rbp)
	movq	%rdi, -112(%rbp)
	movq	%rsi, -120(%rbp)
	movq	%rdx, -128(%rbp)
	movb	%cl, -129(%rbp)
	movb	%al, -130(%rbp)
	leaq	-96(%rbp), %rdi
	xorl	%esi, %esi
	movl	$16, %edx
	callq	_memset
	movq	$0, -144(%rbp)
LBB2_1:                                 ## =>This Inner Loop Header: Depth=1
	cmpq	$8, -144(%rbp)
	jae	LBB2_4
## %bb.2:                               ##   in Loop: Header=BB2_1 Depth=1
	movq	-144(%rbp), %rcx
	leaq	_blake2b_iv(%rip), %rax
	movq	(%rax,%rcx,8), %rcx
	movq	-144(%rbp), %rax
	movq	%rcx, -80(%rbp,%rax,8)
## %bb.3:                               ##   in Loop: Header=BB2_1 Depth=1
	movq	-144(%rbp), %rax
	addq	$1, %rax
	movq	%rax, -144(%rbp)
	jmp	LBB2_1
LBB2_4:
	movzbl	-129(%rbp), %eax
	shll	$8, %eax
	xorl	$16842752, %eax                 ## imm = 0x1010000
	movzbl	-130(%rbp), %ecx
	xorl	%ecx, %eax
	cltq
	xorq	-80(%rbp), %rax
	movq	%rax, -80(%rbp)
	cmpq	$1, -120(%rbp)
	jbe	LBB2_10
## %bb.5:
	movq	$0, -144(%rbp)
LBB2_6:                                 ## =>This Inner Loop Header: Depth=1
	movq	-144(%rbp), %rax
	movq	-120(%rbp), %rcx
	subq	$1, %rcx
	cmpq	%rcx, %rax
	jae	LBB2_9
## %bb.7:                               ##   in Loop: Header=BB2_6 Depth=1
	leaq	-96(%rbp), %rdi
	movl	$128, %esi
	callq	_u128_increment
	leaq	-80(%rbp), %rdi
	movq	-112(%rbp), %rsi
	movq	-144(%rbp), %rax
	shlq	$7, %rax
	addq	%rax, %rsi
	leaq	-96(%rbp), %rdx
	xorl	%ecx, %ecx
	callq	_F
## %bb.8:                               ##   in Loop: Header=BB2_6 Depth=1
	movq	-144(%rbp), %rax
	addq	$1, %rax
	movq	%rax, -144(%rbp)
	jmp	LBB2_6
LBB2_9:
	jmp	LBB2_10
LBB2_10:
	movzbl	-129(%rbp), %eax
	cmpl	$0, %eax
	je	LBB2_12
## %bb.11:
	movq	-128(%rbp), %rdi
	movl	$128, %esi
	callq	_u128_increment
LBB2_12:
	leaq	-80(%rbp), %rdi
	movq	-112(%rbp), %rsi
	movq	-120(%rbp), %rax
	subq	$1, %rax
	shlq	$7, %rax
	addq	%rax, %rsi
	movq	-128(%rbp), %rdx
	movl	$1, %ecx
	callq	_F
	movq	$0, -144(%rbp)
LBB2_13:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB2_16 Depth 2
	movq	-144(%rbp), %rax
	movzbl	-130(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	cmpq	%rcx, %rax
	jae	LBB2_22
## %bb.14:                              ##   in Loop: Header=BB2_13 Depth=1
	movq	-144(%rbp), %rax
	andq	$7, %rax
	cmpq	$0, %rax
	jne	LBB2_20
## %bb.15:                              ##   in Loop: Header=BB2_13 Depth=1
	movq	$0, -152(%rbp)
LBB2_16:                                ##   Parent Loop BB2_13 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	cmpq	$8, -152(%rbp)
	jae	LBB2_19
## %bb.17:                              ##   in Loop: Header=BB2_16 Depth=2
	movq	-152(%rbp), %rax
	shlq	$3, %rax
                                        ## kill: def $ax killed $ax killed $rax
	movw	%ax, -154(%rbp)
	movq	$255, -168(%rbp)
	movzwl	-154(%rbp), %ecx
	movq	-168(%rbp), %rax
	movl	%ecx, %ecx
                                        ## kill: def $rcx killed $ecx
                                        ## kill: def $cl killed $rcx
	shlq	%cl, %rax
	movq	%rax, -168(%rbp)
	movq	-144(%rbp), %rax
	shrq	$3, %rax
	movq	-80(%rbp,%rax,8), %rax
	andq	-168(%rbp), %rax
	movzwl	-154(%rbp), %ecx
	movl	%ecx, %ecx
                                        ## kill: def $rcx killed $ecx
                                        ## kill: def $cl killed $rcx
	shrq	%cl, %rax
	movb	%al, %cl
	movq	-152(%rbp), %rax
	movb	%cl, -16(%rbp,%rax)
## %bb.18:                              ##   in Loop: Header=BB2_16 Depth=2
	movq	-152(%rbp), %rax
	addq	$1, %rax
	movq	%rax, -152(%rbp)
	jmp	LBB2_16
LBB2_19:                                ##   in Loop: Header=BB2_13 Depth=1
	jmp	LBB2_20
LBB2_20:                                ##   in Loop: Header=BB2_13 Depth=1
	movq	-144(%rbp), %rax
	andq	$7, %rax
	movb	-16(%rbp,%rax), %dl
	movq	-104(%rbp), %rax
	movq	-144(%rbp), %rcx
	movb	%dl, (%rax,%rcx)
## %bb.21:                              ##   in Loop: Header=BB2_13 Depth=1
	movq	-144(%rbp), %rax
	addq	$1, %rax
	movq	%rax, -144(%rbp)
	jmp	LBB2_13
LBB2_22:
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	-8(%rbp), %rcx
	cmpq	%rcx, %rax
	jne	LBB2_24
## %bb.23:
	xorl	%eax, %eax
	addq	$208, %rsp
	popq	%rbp
	retq
LBB2_24:
	callq	___stack_chk_fail
	ud2
	.cfi_endproc
                                        ## -- End function
	.globl	_main                           ## -- Begin function main
	.p2align	4, 0x90
_main:                                  ## @main
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	subq	$16, %rsp
	movl	$0, -4(%rbp)
	callq	_test
	callq	_libmin_success
	xorl	%eax, %eax
	addq	$16, %rsp
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.p2align	4, 0x90                         ## -- Begin function u128_increment
_u128_increment:                        ## @u128_increment
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	movq	%rdi, -8(%rbp)
	movq	%rsi, -16(%rbp)
	movq	-8(%rbp), %rcx
	movq	$-1, %rax
	subq	(%rcx), %rax
	cmpq	-16(%rbp), %rax
	ja	LBB4_2
## %bb.1:
	movq	-8(%rbp), %rax
	movq	8(%rax), %rcx
	addq	$1, %rcx
	movq	%rcx, 8(%rax)
LBB4_2:
	movq	-16(%rbp), %rcx
	movq	-8(%rbp), %rax
	addq	(%rax), %rcx
	movq	%rcx, (%rax)
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.p2align	4, 0x90                         ## -- Begin function F
_F:                                     ## @F
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	subq	$192, %rsp
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	%rax, -8(%rbp)
	movq	%rdi, -152(%rbp)
	movq	%rsi, -160(%rbp)
	movq	%rdx, -168(%rbp)
	movl	%ecx, -172(%rbp)
	movl	$0, -176(%rbp)
LBB5_1:                                 ## =>This Inner Loop Header: Depth=1
	cmpl	$8, -176(%rbp)
	jge	LBB5_4
## %bb.2:                               ##   in Loop: Header=BB5_1 Depth=1
	movq	-152(%rbp), %rax
	movslq	-176(%rbp), %rcx
	movq	(%rax,%rcx,8), %rcx
	movslq	-176(%rbp), %rax
	movq	%rcx, -144(%rbp,%rax,8)
## %bb.3:                               ##   in Loop: Header=BB5_1 Depth=1
	movl	-176(%rbp), %eax
	addl	$1, %eax
	movl	%eax, -176(%rbp)
	jmp	LBB5_1
LBB5_4:
	jmp	LBB5_5
LBB5_5:                                 ## =>This Inner Loop Header: Depth=1
	cmpl	$16, -176(%rbp)
	jge	LBB5_8
## %bb.6:                               ##   in Loop: Header=BB5_5 Depth=1
	movl	-176(%rbp), %eax
	subl	$8, %eax
	movslq	%eax, %rcx
	leaq	_blake2b_iv(%rip), %rax
	movq	(%rax,%rcx,8), %rcx
	movslq	-176(%rbp), %rax
	movq	%rcx, -144(%rbp,%rax,8)
## %bb.7:                               ##   in Loop: Header=BB5_5 Depth=1
	movl	-176(%rbp), %eax
	addl	$1, %eax
	movl	%eax, -176(%rbp)
	jmp	LBB5_5
LBB5_8:
	movq	-168(%rbp), %rax
	movq	(%rax), %rax
	xorq	-48(%rbp), %rax
	movq	%rax, -48(%rbp)
	movq	-168(%rbp), %rax
	movq	8(%rax), %rax
	xorq	-40(%rbp), %rax
	movq	%rax, -40(%rbp)
	cmpl	$0, -172(%rbp)
	je	LBB5_10
## %bb.9:
	movq	-32(%rbp), %rax
	xorq	$-1, %rax
	movq	%rax, -32(%rbp)
LBB5_10:
	movl	$0, -176(%rbp)
LBB5_11:                                ## =>This Inner Loop Header: Depth=1
	cmpl	$12, -176(%rbp)
	jge	LBB5_14
## %bb.12:                              ##   in Loop: Header=BB5_11 Depth=1
	movslq	-176(%rbp), %rcx
	leaq	_blake2b_sigma(%rip), %rax
	shlq	$4, %rcx
	addq	%rcx, %rax
	movq	%rax, -184(%rbp)
	leaq	-144(%rbp), %rdi
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %r9
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	1(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	xorl	%esi, %esi
	movl	$4, %edx
	movl	$8, %ecx
	movl	$12, %r8d
	movq	%rax, (%rsp)
	callq	_G
	leaq	-144(%rbp), %rdi
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	2(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %r9
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	3(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	movl	$1, %esi
	movl	$5, %edx
	movl	$9, %ecx
	movl	$13, %r8d
	movq	%rax, (%rsp)
	callq	_G
	leaq	-144(%rbp), %rdi
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	4(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %r9
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	5(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	movl	$2, %esi
	movl	$6, %edx
	movl	$10, %ecx
	movl	$14, %r8d
	movq	%rax, (%rsp)
	callq	_G
	leaq	-144(%rbp), %rdi
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	6(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %r9
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	7(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	movl	$3, %esi
	movl	$7, %edx
	movl	$11, %ecx
	movl	$15, %r8d
	movq	%rax, (%rsp)
	callq	_G
	leaq	-144(%rbp), %rdi
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	8(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %r9
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	9(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	xorl	%esi, %esi
	movl	$5, %edx
	movl	$10, %ecx
	movl	$15, %r8d
	movq	%rax, (%rsp)
	callq	_G
	leaq	-144(%rbp), %rdi
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	10(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %r9
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	11(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	movl	$1, %esi
	movl	$6, %edx
	movl	$11, %ecx
	movl	$12, %r8d
	movq	%rax, (%rsp)
	callq	_G
	leaq	-144(%rbp), %rdi
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	12(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %r9
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	13(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	movl	$2, %esi
	movl	$7, %edx
	movl	$8, %ecx
	movl	$13, %r8d
	movq	%rax, (%rsp)
	callq	_G
	leaq	-144(%rbp), %rdi
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	14(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %r9
	movq	-160(%rbp), %rax
	movq	-184(%rbp), %rcx
	movzbl	15(%rcx), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	movl	$3, %esi
	movl	$4, %edx
	movl	$9, %ecx
	movl	$14, %r8d
	movq	%rax, (%rsp)
	callq	_G
## %bb.13:                              ##   in Loop: Header=BB5_11 Depth=1
	movl	-176(%rbp), %eax
	addl	$1, %eax
	movl	%eax, -176(%rbp)
	jmp	LBB5_11
LBB5_14:
	movl	$0, -176(%rbp)
LBB5_15:                                ## =>This Inner Loop Header: Depth=1
	cmpl	$8, -176(%rbp)
	jge	LBB5_18
## %bb.16:                              ##   in Loop: Header=BB5_15 Depth=1
	movslq	-176(%rbp), %rax
	movq	-144(%rbp,%rax,8), %rdx
	movl	-176(%rbp), %eax
	addl	$8, %eax
	cltq
	xorq	-144(%rbp,%rax,8), %rdx
	movq	-152(%rbp), %rax
	movslq	-176(%rbp), %rcx
	xorq	(%rax,%rcx,8), %rdx
	movq	%rdx, (%rax,%rcx,8)
## %bb.17:                              ##   in Loop: Header=BB5_15 Depth=1
	movl	-176(%rbp), %eax
	addl	$1, %eax
	movl	%eax, -176(%rbp)
	jmp	LBB5_15
LBB5_18:
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	-8(%rbp), %rcx
	cmpq	%rcx, %rax
	jne	LBB5_20
## %bb.19:
	addq	$192, %rsp
	popq	%rbp
	retq
LBB5_20:
	callq	___stack_chk_fail
	ud2
	.cfi_endproc
                                        ## -- End function
	.p2align	4, 0x90                         ## -- Begin function G
_G:                                     ## @G
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	movb	%r8b, %al
                                        ## kill: def $cl killed $cl killed $ecx
                                        ## kill: def $dl killed $dl killed $edx
                                        ## kill: def $sil killed $sil killed $esi
	movq	16(%rbp), %r8
	movq	%rdi, -8(%rbp)
	movb	%sil, -9(%rbp)
	movb	%dl, -10(%rbp)
	movb	%cl, -11(%rbp)
	movb	%al, -12(%rbp)
	movq	%r9, -24(%rbp)
	movq	-8(%rbp), %rax
	movzbl	-10(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rdx
	addq	-24(%rbp), %rdx
	movq	-8(%rbp), %rax
	movzbl	-9(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	addq	(%rax,%rcx,8), %rdx
	movq	%rdx, (%rax,%rcx,8)
	movq	-8(%rbp), %rax
	movzbl	-12(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rdx
	movq	-8(%rbp), %rax
	movzbl	-9(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	xorq	(%rax,%rcx,8), %rdx
	shrq	$32, %rdx
	movq	-8(%rbp), %rax
	movzbl	-12(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	movq	-8(%rbp), %rcx
	movzbl	-9(%rbp), %esi
                                        ## kill: def $rsi killed $esi
	xorq	(%rcx,%rsi,8), %rax
	shlq	$32, %rax
	xorq	%rax, %rdx
	movq	-8(%rbp), %rax
	movzbl	-12(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	%rdx, (%rax,%rcx,8)
	movq	-8(%rbp), %rax
	movzbl	-12(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rdx
	movq	-8(%rbp), %rax
	movzbl	-11(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	addq	(%rax,%rcx,8), %rdx
	movq	%rdx, (%rax,%rcx,8)
	movq	-8(%rbp), %rax
	movzbl	-10(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rdx
	movq	-8(%rbp), %rax
	movzbl	-11(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	xorq	(%rax,%rcx,8), %rdx
	shrq	$24, %rdx
	movq	-8(%rbp), %rax
	movzbl	-10(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	movq	-8(%rbp), %rcx
	movzbl	-11(%rbp), %esi
                                        ## kill: def $rsi killed $esi
	xorq	(%rcx,%rsi,8), %rax
	shlq	$40, %rax
	xorq	%rax, %rdx
	movq	-8(%rbp), %rax
	movzbl	-10(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	%rdx, (%rax,%rcx,8)
	movq	-8(%rbp), %rax
	movzbl	-10(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rdx
	addq	16(%rbp), %rdx
	movq	-8(%rbp), %rax
	movzbl	-9(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	addq	(%rax,%rcx,8), %rdx
	movq	%rdx, (%rax,%rcx,8)
	movq	-8(%rbp), %rax
	movzbl	-12(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rdx
	movq	-8(%rbp), %rax
	movzbl	-9(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	xorq	(%rax,%rcx,8), %rdx
	shrq	$16, %rdx
	movq	-8(%rbp), %rax
	movzbl	-12(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	movq	-8(%rbp), %rcx
	movzbl	-9(%rbp), %esi
                                        ## kill: def $rsi killed $esi
	xorq	(%rcx,%rsi,8), %rax
	shlq	$48, %rax
	xorq	%rax, %rdx
	movq	-8(%rbp), %rax
	movzbl	-12(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	%rdx, (%rax,%rcx,8)
	movq	-8(%rbp), %rax
	movzbl	-12(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rdx
	movq	-8(%rbp), %rax
	movzbl	-11(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	addq	(%rax,%rcx,8), %rdx
	movq	%rdx, (%rax,%rcx,8)
	movq	-8(%rbp), %rax
	movzbl	-10(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rdx
	movq	-8(%rbp), %rax
	movzbl	-11(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	xorq	(%rax,%rcx,8), %rdx
	shrq	$63, %rdx
	movq	-8(%rbp), %rax
	movzbl	-10(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	(%rax,%rcx,8), %rax
	movq	-8(%rbp), %rcx
	movzbl	-11(%rbp), %esi
                                        ## kill: def $rsi killed $esi
	xorq	(%rcx,%rsi,8), %rax
	shlq	$1, %rax
	xorq	%rax, %rdx
	movq	-8(%rbp), %rax
	movzbl	-10(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movq	%rdx, (%rax,%rcx,8)
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.p2align	4, 0x90                         ## -- Begin function test
_test:                                  ## @test
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	subq	$544, %rsp                      ## imm = 0x220
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	%rax, -8(%rbp)
	movq	$0, -536(%rbp)
	movw	l___const.test.abc(%rip), %ax
	movw	%ax, -539(%rbp)
	movb	l___const.test.abc+2(%rip), %al
	movb	%al, -537(%rbp)
	leaq	-80(%rbp), %rdi
	leaq	l___const.test.abc_answer(%rip), %rsi
	movl	$64, %edx
	callq	_memcpy
	leaq	-539(%rbp), %rdi
	movl	$3, %esi
	xorl	%eax, %eax
	movl	%eax, %edx
	xorl	%ecx, %ecx
	movl	$64, %r8d
	callq	_blake2b
	movq	%rax, -536(%rbp)
	leaq	-80(%rbp), %rdi
	movq	-536(%rbp), %rsi
	movl	$64, %edx
	callq	_assert_bytes
	movq	-536(%rbp), %rdi
	callq	_libmin_free
	leaq	-144(%rbp), %rdi
	leaq	l___const.test.key(%rip), %rsi
	movl	$64, %edx
	callq	_memcpy
	leaq	-208(%rbp), %rdi
	leaq	l___const.test.key_answer(%rip), %rsi
	movl	$64, %edx
	callq	_memcpy
	leaq	-144(%rbp), %rdx
	xorl	%eax, %eax
	movl	%eax, %esi
	movl	$64, %r8d
	movq	%rsi, %rdi
	movl	%r8d, %ecx
	callq	_blake2b
	movq	%rax, -536(%rbp)
	leaq	-208(%rbp), %rdi
	movq	-536(%rbp), %rsi
	movl	$64, %edx
	callq	_assert_bytes
	movq	-536(%rbp), %rdi
	callq	_libmin_free
	leaq	-540(%rbp), %rdi
	xorl	%esi, %esi
	movl	$1, %edx
	callq	_memset
	leaq	-272(%rbp), %rdi
	leaq	l___const.test.zero_key(%rip), %rsi
	movl	$64, %edx
	callq	_memcpy
	leaq	-336(%rbp), %rdi
	leaq	l___const.test.zero_answer(%rip), %rsi
	movl	$64, %edx
	callq	_memcpy
	leaq	-540(%rbp), %rdi
	leaq	-272(%rbp), %rdx
	movl	$1, %esi
	movl	$64, %r8d
	movl	%r8d, %ecx
	callq	_blake2b
	movq	%rax, -536(%rbp)
	leaq	-336(%rbp), %rdi
	movq	-536(%rbp), %rsi
	movl	$64, %edx
	callq	_assert_bytes
	movq	-536(%rbp), %rdi
	callq	_libmin_free
	leaq	-400(%rbp), %rdi
	leaq	l___const.test.filled(%rip), %rsi
	movl	$64, %edx
	callq	_memcpy
	leaq	-464(%rbp), %rdi
	leaq	l___const.test.filled_key(%rip), %rsi
	movl	$64, %edx
	callq	_memcpy
	leaq	-528(%rbp), %rdi
	leaq	l___const.test.filled_answer(%rip), %rsi
	movl	$64, %edx
	callq	_memcpy
	leaq	-400(%rbp), %rdi
	leaq	-464(%rbp), %rdx
	movl	$64, %esi
	movl	$64, %r8d
	movl	%r8d, %ecx
	callq	_blake2b
	movq	%rax, -536(%rbp)
	leaq	-528(%rbp), %rdi
	movq	-536(%rbp), %rsi
	movl	$64, %edx
	callq	_assert_bytes
	movq	-536(%rbp), %rdi
	callq	_libmin_free
	leaq	L_.str(%rip), %rdi
	movb	$0, %al
	callq	_libmin_printf
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	-8(%rbp), %rcx
	cmpq	%rcx, %rax
	jne	LBB7_2
## %bb.1:
	addq	$544, %rsp                      ## imm = 0x220
	popq	%rbp
	retq
LBB7_2:
	callq	___stack_chk_fail
	ud2
	.cfi_endproc
                                        ## -- End function
	.p2align	4, 0x90                         ## -- Begin function assert_bytes
_assert_bytes:                          ## @assert_bytes
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	subq	$32, %rsp
	movb	%dl, %al
	movq	%rdi, -8(%rbp)
	movq	%rsi, -16(%rbp)
	movb	%al, -17(%rbp)
	cmpq	$0, -8(%rbp)
	je	LBB8_2
## %bb.1:
	jmp	LBB8_3
LBB8_2:
	movl	$1, %edi
	callq	_libmin_fail
LBB8_3:
	cmpq	$0, -16(%rbp)
	je	LBB8_5
## %bb.4:
	jmp	LBB8_6
LBB8_5:
	movl	$1, %edi
	callq	_libmin_fail
LBB8_6:
	movzbl	-17(%rbp), %eax
	cmpl	$0, %eax
	jle	LBB8_8
## %bb.7:
	jmp	LBB8_9
LBB8_8:
	movl	$1, %edi
	callq	_libmin_fail
LBB8_9:
	movl	_testnum(%rip), %esi
	movl	%esi, %eax
	addl	$1, %eax
	movl	%eax, _testnum(%rip)
	leaq	L_.str.1(%rip), %rdi
	movb	$0, %al
	callq	_libmin_printf
	leaq	L_.str.2(%rip), %rdi
	movb	$0, %al
	callq	_libmin_printf
	movb	$0, -18(%rbp)
LBB8_10:                                ## =>This Inner Loop Header: Depth=1
	movzbl	-18(%rbp), %eax
	movzbl	-17(%rbp), %ecx
	cmpl	%ecx, %eax
	jge	LBB8_16
## %bb.11:                              ##   in Loop: Header=BB8_10 Depth=1
	movq	-16(%rbp), %rax
	movzbl	-18(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movzbl	(%rax,%rcx), %esi
	leaq	L_.str.3(%rip), %rdi
	movb	$0, %al
	callq	_libmin_printf
	movq	-8(%rbp), %rax
	movzbl	-18(%rbp), %ecx
                                        ## kill: def $rcx killed $ecx
	movzbl	(%rax,%rcx), %eax
	movq	-16(%rbp), %rcx
	movzbl	-18(%rbp), %edx
                                        ## kill: def $rdx killed $edx
	movzbl	(%rcx,%rdx), %ecx
	cmpl	%ecx, %eax
	jne	LBB8_13
## %bb.12:                              ##   in Loop: Header=BB8_10 Depth=1
	jmp	LBB8_14
LBB8_13:                                ##   in Loop: Header=BB8_10 Depth=1
	movl	$1, %edi
	callq	_libmin_fail
LBB8_14:                                ##   in Loop: Header=BB8_10 Depth=1
	jmp	LBB8_15
LBB8_15:                                ##   in Loop: Header=BB8_10 Depth=1
	movb	-18(%rbp), %al
	addb	$1, %al
	movb	%al, -18(%rbp)
	jmp	LBB8_10
LBB8_16:
	leaq	L_.str.4(%rip), %rdi
	movb	$0, %al
	callq	_libmin_printf
	addq	$32, %rsp
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.globl	_testnum                        ## @testnum
.zerofill __DATA,__common,_testnum,4,2
	.section	__TEXT,__const
	.p2align	4                               ## @blake2b_iv
_blake2b_iv:
	.quad	7640891576956012808             ## 0x6a09e667f3bcc908
	.quad	-4942790177534073029            ## 0xbb67ae8584caa73b
	.quad	4354685564936845355             ## 0x3c6ef372fe94f82b
	.quad	-6534734903238641935            ## 0xa54ff53a5f1d36f1
	.quad	5840696475078001361             ## 0x510e527fade682d1
	.quad	-7276294671716946913            ## 0x9b05688c2b3e6c1f
	.quad	2270897969802886507             ## 0x1f83d9abfb41bd6b
	.quad	6620516959819538809             ## 0x5be0cd19137e2179

	.p2align	4                               ## @blake2b_sigma
_blake2b_sigma:
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017"
	.ascii	"\016\n\004\b\t\017\r\006\001\f\000\002\013\007\005\003"
	.ascii	"\013\b\f\000\005\002\017\r\n\016\003\006\007\001\t\004"
	.ascii	"\007\t\003\001\r\f\013\016\002\006\005\n\004\000\017\b"
	.ascii	"\t\000\005\007\002\004\n\017\016\001\013\f\006\b\003\r"
	.ascii	"\002\f\006\n\000\013\b\003\004\r\007\005\017\016\001\t"
	.ascii	"\f\005\001\017\016\r\004\n\000\007\006\003\t\002\b\013"
	.ascii	"\r\013\007\016\f\001\003\t\005\000\017\004\b\006\002\n"
	.ascii	"\006\017\016\t\013\003\000\b\f\002\r\007\001\004\n\005"
	.asciz	"\n\002\b\004\007\006\001\005\017\013\t\016\003\f\r"
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017"
	.ascii	"\016\n\004\b\t\017\r\006\001\f\000\002\013\007\005\003"

l___const.test.abc:                     ## @__const.test.abc
	.ascii	"abc"

	.p2align	4                               ## @__const.test.abc_answer
l___const.test.abc_answer:
	.ascii	"\272\200\245?\230\034M\rj'\227\266\237\022\366\351L!/\024hZ\304\267K\022\273o\333\377\242\321}\207\3059*\253y-\302R\325\336E3\314\225\030\323\212\250\333\361\222Z\271#\206\355\324\000\231#"

	.p2align	4                               ## @__const.test.key
l___const.test.key:
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !\"#$%&'()*+,-./0123456789:;<=>?"

	.p2align	4                               ## @__const.test.key_answer
l___const.test.key_answer:
	.ascii	"\020\353\266w\000\261\206\216\373D\027\230z\317F\220\256\235\227/\267\245\220\302\360(qy\232\252G\206\265\351\226\350\360\364\353\230\037\302\024\260\005\364-/\364#4\2319\026S\337z\357\313\301?\305\025h"

	.p2align	4                               ## @__const.test.zero_key
l___const.test.zero_key:
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !\"#$%&'()*+,-./0123456789:;<=>?"

	.p2align	4                               ## @__const.test.zero_answer
l___const.test.zero_answer:
	.ascii	"\226\037m\321\344\3350\3669\001i\fQ.x\344\264^GB\355\031|<^E\305I\375%\362\344\030{\013\311\3760I+\026\260\320\274N\371\260\363Lp\003\372\300\232^\361S.iC\0024\316\275"

	.p2align	4                               ## @__const.test.filled
l___const.test.filled:
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !\"#$%&'()*+,-./0123456789:;<=>?"

	.p2align	4                               ## @__const.test.filled_key
l___const.test.filled_key:
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !\"#$%&'()*+,-./0123456789:;<=>?"

	.p2align	4                               ## @__const.test.filled_answer
l___const.test.filled_answer:
	.ascii	"egm\200\006\027\227/\275\207\344\271QN\034g@+z3\020\226\323\277\254\"\361\253\271St\253\311B\361n\232\260\352\323;\207\311\031h\246\345\t\341\031\377\007x{>\364\203\341\334\334\317n0\""

	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"INFO: All tests have successfully passed!\n"

L_.str.1:                               ## @.str.1
	.asciz	"Test #%d:\n"

L_.str.2:                               ## @.str.2
	.asciz	"Expected[] = { "

L_.str.3:                               ## @.str.3
	.asciz	"0x%02x "

L_.str.4:                               ## @.str.4
	.asciz	" }\n"

.subsections_via_symbols


ARM64 assembly:
	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	_blake2b                        ; -- Begin function blake2b
	.p2align	2
_blake2b:                               ; @blake2b
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #176
	.cfi_def_cfa_offset 176
	stp	x29, x30, [sp, #160]            ; 16-byte Folded Spill
	add	x29, sp, #160
	.cfi_def_cfa w29, 16
	.cfi_offset w30, -8
	.cfi_offset w29, -16
	adrp	x8, ___stack_chk_guard@GOTPAGE
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
	ldr	x8, [x8]
	stur	x8, [x29, #-8]
	stur	x0, [x29, #-40]
	stur	x1, [x29, #-48]
	stur	x2, [x29, #-56]
	sturb	w3, [x29, #-57]
	sturb	w4, [x29, #-58]
                                        ; kill: def $x8 killed $xzr
	stur	xzr, [x29, #-72]
	ldur	x8, [x29, #-40]
	subs	x8, x8, #0
	cset	w8, ne
	tbnz	w8, #0, LBB0_2
	b	LBB0_1
LBB0_1:
	stur	xzr, [x29, #-48]
	b	LBB0_2
LBB0_2:
	ldur	x8, [x29, #-56]
	subs	x8, x8, #0
	cset	w8, ne
	tbnz	w8, #0, LBB0_4
	b	LBB0_3
LBB0_3:
	sturb	wzr, [x29, #-57]
	b	LBB0_4
LBB0_4:
	ldurb	w8, [x29, #-57]
	subs	w8, w8, #64
	cset	w8, ge
	tbnz	w8, #0, LBB0_6
	b	LBB0_5
LBB0_5:
	ldurb	w8, [x29, #-57]
	str	w8, [sp, #28]                   ; 4-byte Folded Spill
	b	LBB0_7
LBB0_6:
	mov	w8, #64
	str	w8, [sp, #28]                   ; 4-byte Folded Spill
	b	LBB0_7
LBB0_7:
	ldr	w8, [sp, #28]                   ; 4-byte Folded Reload
	sturb	w8, [x29, #-57]
	ldurb	w8, [x29, #-58]
	subs	w8, w8, #64
	cset	w8, ge
	tbnz	w8, #0, LBB0_9
	b	LBB0_8
LBB0_8:
	ldurb	w8, [x29, #-58]
	str	w8, [sp, #24]                   ; 4-byte Folded Spill
	b	LBB0_10
LBB0_9:
	mov	w8, #64
	str	w8, [sp, #24]                   ; 4-byte Folded Spill
	b	LBB0_10
LBB0_10:
	ldr	w8, [sp, #24]                   ; 4-byte Folded Reload
	sturb	w8, [x29, #-58]
	ldurb	w8, [x29, #-57]
	mov	w11, #128
	sdiv	w8, w8, w11
	ldurb	w9, [x29, #-57]
	sdiv	w10, w9, w11
	mul	w10, w10, w11
	subs	w9, w9, w10
	subs	w9, w9, #0
	cset	w9, ne
	and	w9, w9, #0x1
	add	w9, w8, w9
	ldur	x8, [x29, #-48]
	mov	x12, #128
	udiv	x8, x8, x12
	ldur	x10, [x29, #-48]
	udiv	x11, x10, x12
	mul	x11, x11, x12
	subs	x10, x10, x11
	subs	x10, x10, #0
	cset	w11, ne
                                        ; implicit-def: $x10
	mov	x10, x11
	and	x10, x10, #0x1
	add	x8, x8, x10
	add	x8, x8, w9, sxtw
	subs	x8, x8, #1
	cset	w8, ls
	tbnz	w8, #0, LBB0_12
	b	LBB0_11
LBB0_11:
	ldurb	w8, [x29, #-57]
	mov	w11, #128
	sdiv	w8, w8, w11
	ldurb	w9, [x29, #-57]
	sdiv	w10, w9, w11
	mul	w10, w10, w11
	subs	w9, w9, w10
	subs	w9, w9, #0
	cset	w9, ne
	and	w9, w9, #0x1
	add	w9, w8, w9
	ldur	x8, [x29, #-48]
	mov	x12, #128
	udiv	x8, x8, x12
	ldur	x10, [x29, #-48]
	udiv	x11, x10, x12
	mul	x11, x11, x12
	subs	x10, x10, x11
	subs	x10, x10, #0
	cset	w11, ne
                                        ; implicit-def: $x10
	mov	x10, x11
	and	x10, x10, #0x1
	add	x8, x8, x10
	add	x8, x8, w9, sxtw
	str	x8, [sp, #16]                   ; 8-byte Folded Spill
	b	LBB0_13
LBB0_12:
	mov	x8, #1
	str	x8, [sp, #16]                   ; 8-byte Folded Spill
	b	LBB0_13
LBB0_13:
	ldr	x8, [sp, #16]                   ; 8-byte Folded Reload
	str	x8, [sp, #72]
	ldr	x0, [sp, #72]
	mov	x1, #128
	bl	_libmin_calloc
	str	x0, [sp, #32]
	ldr	x8, [sp, #32]
	subs	x8, x8, #0
	cset	w8, ne
	tbnz	w8, #0, LBB0_15
	b	LBB0_14
LBB0_14:
                                        ; kill: def $x8 killed $xzr
	stur	xzr, [x29, #-32]
	b	LBB0_26
LBB0_15:
	ldurb	w8, [x29, #-58]
                                        ; kill: def $x8 killed $w8
	lsr	x0, x8, #0
	bl	_libmin_malloc
	stur	x0, [x29, #-72]
	ldur	x8, [x29, #-72]
	subs	x8, x8, #0
	cset	w8, ne
	tbnz	w8, #0, LBB0_17
	b	LBB0_16
LBB0_16:
	ldr	x0, [sp, #32]
	bl	_libmin_free
                                        ; kill: def $x8 killed $xzr
	stur	xzr, [x29, #-32]
	b	LBB0_26
LBB0_17:
	str	xzr, [sp, #56]
	b	LBB0_18
LBB0_18:                                ; =>This Inner Loop Header: Depth=1
	ldr	x8, [sp, #56]
	ldurb	w9, [x29, #-57]
                                        ; kill: def $x9 killed $w9
	subs	x8, x8, x9
	cset	w8, hs
	tbnz	w8, #0, LBB0_21
	b	LBB0_19
LBB0_19:                                ;   in Loop: Header=BB0_18 Depth=1
	ldur	x8, [x29, #-56]
	ldr	x9, [sp, #56]
	ldrb	w8, [x8, x9]
                                        ; kill: def $x8 killed $w8
	str	x8, [sp, #80]
	ldr	x8, [sp, #56]
	mov	x9, #8
	udiv	x10, x8, x9
	mul	x10, x10, x9
	subs	x8, x8, x10
	mul	x10, x9, x8
	ldr	x8, [sp, #80]
	lsl	x8, x8, x10
	str	x8, [sp, #80]
	ldr	x8, [sp, #56]
	mov	x11, #128
	udiv	x10, x8, x11
	mul	x10, x10, x11
	subs	x8, x8, x10
	udiv	x8, x8, x9
	str	x8, [sp, #40]
	ldr	x10, [sp, #80]
	ldr	x8, [sp, #32]
	ldr	x9, [sp, #40]
	add	x9, x8, x9, lsl #3
	ldr	x8, [x9]
	orr	x8, x8, x10
	str	x8, [x9]
	b	LBB0_20
LBB0_20:                                ;   in Loop: Header=BB0_18 Depth=1
	ldr	x8, [sp, #56]
	add	x8, x8, #1
	str	x8, [sp, #56]
	b	LBB0_18
LBB0_21:
	ldurb	w9, [x29, #-57]
	mov	w8, #0
	subs	w9, w9, #0
	cset	w9, gt
	and	w9, w9, #0x1
	ands	w9, w9, #0x1
	csinc	w9, w8, wzr, eq
                                        ; implicit-def: $x8
	mov	x8, x9
	sxtw	x8, w8
	str	x8, [sp, #64]
	str	xzr, [sp, #56]
	b	LBB0_22
LBB0_22:                                ; =>This Inner Loop Header: Depth=1
	ldr	x8, [sp, #56]
	ldur	x9, [x29, #-48]
	subs	x8, x8, x9
	cset	w8, hs
	tbnz	w8, #0, LBB0_25
	b	LBB0_23
LBB0_23:                                ;   in Loop: Header=BB0_22 Depth=1
	ldur	x8, [x29, #-40]
	ldr	x9, [sp, #56]
	ldrb	w8, [x8, x9]
                                        ; kill: def $x8 killed $w8
	str	x8, [sp, #80]
	ldr	x8, [sp, #56]
	mov	x9, #8
	udiv	x10, x8, x9
	mul	x10, x10, x9
	subs	x8, x8, x10
	mul	x10, x9, x8
	ldr	x8, [sp, #80]
	lsl	x8, x8, x10
	str	x8, [sp, #80]
	ldr	x8, [sp, #64]
	ldr	x10, [sp, #56]
	mov	x11, #128
	udiv	x10, x10, x11
	add	x8, x8, x10
	str	x8, [sp, #48]
	ldr	x8, [sp, #56]
	udiv	x10, x8, x11
	mul	x10, x10, x11
	subs	x8, x8, x10
	udiv	x8, x8, x9
	str	x8, [sp, #40]
	ldr	x10, [sp, #80]
	ldr	x8, [sp, #32]
	ldr	x9, [sp, #48]
	add	x8, x8, x9, lsl #7
	ldr	x9, [sp, #40]
	add	x9, x8, x9, lsl #3
	ldr	x8, [x9]
	orr	x8, x8, x10
	str	x8, [x9]
	b	LBB0_24
LBB0_24:                                ;   in Loop: Header=BB0_22 Depth=1
	ldr	x8, [sp, #56]
	add	x8, x8, #1
	str	x8, [sp, #56]
	b	LBB0_22
LBB0_25:
	ldur	x1, [x29, #-48]
	sub	x0, x29, #24
	str	x0, [sp, #8]                    ; 8-byte Folded Spill
	bl	_u128_fill
	ldr	x3, [sp, #8]                    ; 8-byte Folded Reload
	ldur	x0, [x29, #-72]
	ldr	x1, [sp, #32]
	ldr	x2, [sp, #72]
	ldurb	w4, [x29, #-57]
	ldurb	w5, [x29, #-58]
	bl	_BLAKE2B
	ldr	x0, [sp, #32]
	bl	_libmin_free
	ldur	x8, [x29, #-72]
	stur	x8, [x29, #-32]
	b	LBB0_26
LBB0_26:
	ldur	x8, [x29, #-32]
	str	x8, [sp]                        ; 8-byte Folded Spill
	ldur	x9, [x29, #-8]
	adrp	x8, ___stack_chk_guard@GOTPAGE
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
	ldr	x8, [x8]
	subs	x8, x8, x9
	cset	w8, eq
	tbnz	w8, #0, LBB0_28
	b	LBB0_27
LBB0_27:
	bl	___stack_chk_fail
LBB0_28:
	ldr	x0, [sp]                        ; 8-byte Folded Reload
	ldp	x29, x30, [sp, #160]            ; 16-byte Folded Reload
	add	sp, sp, #176
	ret
	.cfi_endproc
                                        ; -- End function
	.p2align	2                               ; -- Begin function u128_fill
_u128_fill:                             ; @u128_fill
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #16
	.cfi_def_cfa_offset 16
	str	x0, [sp, #8]
	str	x1, [sp]
	ldr	x8, [sp]
	mov	x9, #-1
	and	x8, x8, x9
	ldr	x9, [sp, #8]
	str	x8, [x9]
	ldr	x8, [sp, #8]
	str	xzr, [x8, #8]
	add	sp, sp, #16
	ret
	.cfi_endproc
                                        ; -- End function
	.p2align	2                               ; -- Begin function BLAKE2B
_BLAKE2B:                               ; @BLAKE2B
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #192
	.cfi_def_cfa_offset 192
	stp	x29, x30, [sp, #176]            ; 16-byte Folded Spill
	add	x29, sp, #176
	.cfi_def_cfa w29, 16
	.cfi_offset w30, -8
	.cfi_offset w29, -16
	adrp	x8, ___stack_chk_guard@GOTPAGE
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
	ldr	x8, [x8]
	stur	x8, [x29, #-8]
	str	x0, [sp, #72]
	str	x1, [sp, #64]
	str	x2, [sp, #56]
	str	x3, [sp, #48]
	strb	w4, [sp, #47]
	strb	w5, [sp, #46]
	str	xzr, [sp, #80]
	str	xzr, [sp, #88]
	str	xzr, [sp, #32]
	b	LBB2_1
LBB2_1:                                 ; =>This Inner Loop Header: Depth=1
	ldr	x8, [sp, #32]
	subs	x8, x8, #8
	cset	w8, hs
	tbnz	w8, #0, LBB2_4
	b	LBB2_2
LBB2_2:                                 ;   in Loop: Header=BB2_1 Depth=1
	ldr	x9, [sp, #32]
	adrp	x8, _blake2b_iv@PAGE
	add	x8, x8, _blake2b_iv@PAGEOFF
	ldr	x8, [x8, x9, lsl #3]
	ldr	x10, [sp, #32]
	sub	x9, x29, #80
	str	x8, [x9, x10, lsl #3]
	b	LBB2_3
LBB2_3:                                 ;   in Loop: Header=BB2_1 Depth=1
	ldr	x8, [sp, #32]
	add	x8, x8, #1
	str	x8, [sp, #32]
	b	LBB2_1
LBB2_4:
	ldrb	w9, [sp, #47]
	mov	w8, #16842752
	eor	w8, w8, w9, lsl #8
	ldrb	w9, [sp, #46]
	eor	w9, w8, w9
                                        ; implicit-def: $x8
	mov	x8, x9
	sxtw	x9, w8
	ldur	x8, [x29, #-80]
	eor	x8, x8, x9
	stur	x8, [x29, #-80]
	ldr	x8, [sp, #56]
	subs	x8, x8, #1
	cset	w8, ls
	tbnz	w8, #0, LBB2_10
	b	LBB2_5
LBB2_5:
	str	xzr, [sp, #32]
	b	LBB2_6
LBB2_6:                                 ; =>This Inner Loop Header: Depth=1
	ldr	x8, [sp, #32]
	ldr	x9, [sp, #56]
	subs	x9, x9, #1
	subs	x8, x8, x9
	cset	w8, hs
	tbnz	w8, #0, LBB2_9
	b	LBB2_7
LBB2_7:                                 ;   in Loop: Header=BB2_6 Depth=1
	add	x0, sp, #80
	str	x0, [sp]                        ; 8-byte Folded Spill
	mov	x1, #128
	bl	_u128_increment
	ldr	x2, [sp]                        ; 8-byte Folded Reload
	ldr	x8, [sp, #64]
	ldr	x9, [sp, #32]
	add	x1, x8, x9, lsl #7
	sub	x0, x29, #80
	mov	w3, #0
	bl	_F
	b	LBB2_8
LBB2_8:                                 ;   in Loop: Header=BB2_6 Depth=1
	ldr	x8, [sp, #32]
	add	x8, x8, #1
	str	x8, [sp, #32]
	b	LBB2_6
LBB2_9:
	b	LBB2_10
LBB2_10:
	ldrb	w8, [sp, #47]
	subs	w8, w8, #0
	cset	w8, eq
	tbnz	w8, #0, LBB2_12
	b	LBB2_11
LBB2_11:
	ldr	x0, [sp, #48]
	mov	x1, #128
	bl	_u128_increment
	b	LBB2_12
LBB2_12:
	ldr	x8, [sp, #64]
	ldr	x9, [sp, #56]
	subs	x9, x9, #1
	add	x1, x8, x9, lsl #7
	ldr	x2, [sp, #48]
	sub	x0, x29, #80
	mov	w3, #1
	bl	_F
	str	xzr, [sp, #32]
	b	LBB2_13
LBB2_13:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB2_16 Depth 2
	ldr	x8, [sp, #32]
	ldrb	w9, [sp, #46]
                                        ; kill: def $x9 killed $w9
	subs	x8, x8, x9
	cset	w8, hs
	tbnz	w8, #0, LBB2_22
	b	LBB2_14
LBB2_14:                                ;   in Loop: Header=BB2_13 Depth=1
	ldr	x8, [sp, #32]
	mov	x10, #8
	udiv	x9, x8, x10
	mul	x9, x9, x10
	subs	x8, x8, x9
	subs	x8, x8, #0
	cset	w8, ne
	tbnz	w8, #0, LBB2_20
	b	LBB2_15
LBB2_15:                                ;   in Loop: Header=BB2_13 Depth=1
	str	xzr, [sp, #24]
	b	LBB2_16
LBB2_16:                                ;   Parent Loop BB2_13 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	x8, [sp, #24]
	subs	x8, x8, #8
	cset	w8, hs
	tbnz	w8, #0, LBB2_19
	b	LBB2_17
LBB2_17:                                ;   in Loop: Header=BB2_16 Depth=2
	ldr	x8, [sp, #24]
	mov	x9, #8
	mul	x8, x9, x8
                                        ; kill: def $w8 killed $w8 killed $x8
	strh	w8, [sp, #22]
	mov	x8, #255
	str	x8, [sp, #8]
	ldrh	w8, [sp, #22]
	mov	x10, x8
	ldr	x8, [sp, #8]
	lsl	x8, x8, x10
	str	x8, [sp, #8]
	ldr	x8, [sp, #32]
	udiv	x9, x8, x9
	sub	x8, x29, #80
	ldr	x8, [x8, x9, lsl #3]
	ldr	x9, [sp, #8]
	and	x8, x8, x9
	ldrh	w9, [sp, #22]
                                        ; kill: def $x9 killed $w9
	lsr	x8, x8, x9
	ldr	x10, [sp, #24]
	sub	x9, x29, #16
                                        ; kill: def $w8 killed $w8 killed $x8
	strb	w8, [x9, x10]
	b	LBB2_18
LBB2_18:                                ;   in Loop: Header=BB2_16 Depth=2
	ldr	x8, [sp, #24]
	add	x8, x8, #1
	str	x8, [sp, #24]
	b	LBB2_16
LBB2_19:                                ;   in Loop: Header=BB2_13 Depth=1
	b	LBB2_20
LBB2_20:                                ;   in Loop: Header=BB2_13 Depth=1
	ldr	x8, [sp, #32]
	mov	x10, #8
	udiv	x9, x8, x10
	mul	x9, x9, x10
	subs	x9, x8, x9
	sub	x8, x29, #16
	add	x8, x8, x9
	ldrb	w8, [x8]
	ldr	x9, [sp, #72]
	ldr	x10, [sp, #32]
	add	x9, x9, x10
	strb	w8, [x9]
	b	LBB2_21
LBB2_21:                                ;   in Loop: Header=BB2_13 Depth=1
	ldr	x8, [sp, #32]
	add	x8, x8, #1
	str	x8, [sp, #32]
	b	LBB2_13
LBB2_22:
	ldur	x9, [x29, #-8]
	adrp	x8, ___stack_chk_guard@GOTPAGE
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
	ldr	x8, [x8]
	subs	x8, x8, x9
	cset	w8, eq
	tbnz	w8, #0, LBB2_24
	b	LBB2_23
LBB2_23:
	bl	___stack_chk_fail
LBB2_24:
	mov	w0, #0
	ldp	x29, x30, [sp, #176]            ; 16-byte Folded Reload
	add	sp, sp, #192
	ret
	.cfi_endproc
                                        ; -- End function
	.globl	_main                           ; -- Begin function main
	.p2align	2
_main:                                  ; @main
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #32
	.cfi_def_cfa_offset 32
	stp	x29, x30, [sp, #16]             ; 16-byte Folded Spill
	add	x29, sp, #16
	.cfi_def_cfa w29, 16
	.cfi_offset w30, -8
	.cfi_offset w29, -16
	mov	w8, #0
	str	w8, [sp, #8]                    ; 4-byte Folded Spill
	stur	wzr, [x29, #-4]
	bl	_test
	bl	_libmin_success
	ldr	w0, [sp, #8]                    ; 4-byte Folded Reload
	ldp	x29, x30, [sp, #16]             ; 16-byte Folded Reload
	add	sp, sp, #32
	ret
	.cfi_endproc
                                        ; -- End function
	.p2align	2                               ; -- Begin function u128_increment
_u128_increment:                        ; @u128_increment
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #16
	.cfi_def_cfa_offset 16
	str	x0, [sp, #8]
	str	x1, [sp]
	ldr	x8, [sp, #8]
	ldr	x9, [x8]
	mov	x8, #-1
	subs	x8, x8, x9
	ldr	x9, [sp]
	subs	x8, x8, x9
	cset	w8, hi
	tbnz	w8, #0, LBB4_2
	b	LBB4_1
LBB4_1:
	ldr	x9, [sp, #8]
	ldr	x8, [x9, #8]
	add	x8, x8, #1
	str	x8, [x9, #8]
	b	LBB4_2
LBB4_2:
	ldr	x10, [sp]
	ldr	x9, [sp, #8]
	ldr	x8, [x9]
	add	x8, x8, x10
	str	x8, [x9]
	add	sp, sp, #16
	ret
	.cfi_endproc
                                        ; -- End function
	.p2align	2                               ; -- Begin function F
_F:                                     ; @F
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #288
	.cfi_def_cfa_offset 288
	stp	x28, x27, [sp, #256]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #272]            ; 16-byte Folded Spill
	add	x29, sp, #272
	.cfi_def_cfa w29, 16
	.cfi_offset w30, -8
	.cfi_offset w29, -16
	.cfi_offset w27, -24
	.cfi_offset w28, -32
	adrp	x8, ___stack_chk_guard@GOTPAGE
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
	ldr	x8, [x8]
	stur	x8, [x29, #-24]
	str	x0, [sp, #112]
	str	x1, [sp, #104]
	str	x2, [sp, #96]
	str	w3, [sp, #92]
	str	wzr, [sp, #88]
	b	LBB5_1
LBB5_1:                                 ; =>This Inner Loop Header: Depth=1
	ldr	w8, [sp, #88]
	subs	w8, w8, #8
	cset	w8, ge
	tbnz	w8, #0, LBB5_4
	b	LBB5_2
LBB5_2:                                 ;   in Loop: Header=BB5_1 Depth=1
	ldr	x8, [sp, #112]
	ldrsw	x9, [sp, #88]
	ldr	x8, [x8, x9, lsl #3]
	ldrsw	x10, [sp, #88]
	add	x9, sp, #120
	str	x8, [x9, x10, lsl #3]
	b	LBB5_3
LBB5_3:                                 ;   in Loop: Header=BB5_1 Depth=1
	ldr	w8, [sp, #88]
	add	w8, w8, #1
	str	w8, [sp, #88]
	b	LBB5_1
LBB5_4:
	b	LBB5_5
LBB5_5:                                 ; =>This Inner Loop Header: Depth=1
	ldr	w8, [sp, #88]
	subs	w8, w8, #16
	cset	w8, ge
	tbnz	w8, #0, LBB5_8
	b	LBB5_6
LBB5_6:                                 ;   in Loop: Header=BB5_5 Depth=1
	ldr	w8, [sp, #88]
	subs	w9, w8, #8
	adrp	x8, _blake2b_iv@PAGE
	add	x8, x8, _blake2b_iv@PAGEOFF
	ldr	x8, [x8, w9, sxtw #3]
	ldrsw	x10, [sp, #88]
	add	x9, sp, #120
	str	x8, [x9, x10, lsl #3]
	b	LBB5_7
LBB5_7:                                 ;   in Loop: Header=BB5_5 Depth=1
	ldr	w8, [sp, #88]
	add	w8, w8, #1
	str	w8, [sp, #88]
	b	LBB5_5
LBB5_8:
	ldr	x8, [sp, #96]
	ldr	x9, [x8]
	ldr	x8, [sp, #216]
	eor	x8, x8, x9
	str	x8, [sp, #216]
	ldr	x8, [sp, #96]
	ldr	x9, [x8, #8]
	ldr	x8, [sp, #224]
	eor	x8, x8, x9
	str	x8, [sp, #224]
	ldr	w8, [sp, #92]
	subs	w8, w8, #0
	cset	w8, eq
	tbnz	w8, #0, LBB5_10
	b	LBB5_9
LBB5_9:
	ldr	x8, [sp, #232]
	mvn	x8, x8
	str	x8, [sp, #232]
	b	LBB5_10
LBB5_10:
	str	wzr, [sp, #88]
	b	LBB5_11
LBB5_11:                                ; =>This Inner Loop Header: Depth=1
	ldr	w8, [sp, #88]
	subs	w8, w8, #12
	cset	w8, ge
	tbnz	w8, #0, LBB5_14
	b	LBB5_12
LBB5_12:                                ;   in Loop: Header=BB5_11 Depth=1
	ldrsw	x9, [sp, #88]
	adrp	x8, _blake2b_sigma@PAGE
	add	x8, x8, _blake2b_sigma@PAGEOFF
	add	x8, x8, x9, lsl #4
	str	x8, [sp, #80]
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9]
                                        ; kill: def $x9 killed $w9
	ldr	x5, [x8, x9, lsl #3]
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #1]
                                        ; kill: def $x9 killed $w9
	ldr	x6, [x8, x9, lsl #3]
	add	x0, sp, #120
	str	x0, [sp, #56]                   ; 8-byte Folded Spill
	mov	w1, #0
	str	w1, [sp, #8]                    ; 4-byte Folded Spill
	mov	w2, #4
	str	w2, [sp, #68]                   ; 4-byte Folded Spill
	mov	w3, #8
	str	w3, [sp, #48]                   ; 4-byte Folded Spill
	mov	w4, #12
	str	w4, [sp, #36]                   ; 4-byte Folded Spill
	bl	_G
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #2]
                                        ; kill: def $x9 killed $w9
	ldr	x5, [x8, x9, lsl #3]
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #3]
                                        ; kill: def $x9 killed $w9
	ldr	x6, [x8, x9, lsl #3]
	mov	w1, #1
	str	w1, [sp, #24]                   ; 4-byte Folded Spill
	mov	w2, #5
	str	w2, [sp, #12]                   ; 4-byte Folded Spill
	mov	w3, #9
	str	w3, [sp, #72]                   ; 4-byte Folded Spill
	mov	w4, #13
	str	w4, [sp, #52]                   ; 4-byte Folded Spill
	bl	_G
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #4]
                                        ; kill: def $x9 killed $w9
	ldr	x5, [x8, x9, lsl #3]
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #5]
                                        ; kill: def $x9 killed $w9
	ldr	x6, [x8, x9, lsl #3]
	mov	w1, #2
	str	w1, [sp, #40]                   ; 4-byte Folded Spill
	mov	w2, #6
	str	w2, [sp, #28]                   ; 4-byte Folded Spill
	mov	w3, #10
	str	w3, [sp, #16]                   ; 4-byte Folded Spill
	mov	w4, #14
	str	w4, [sp, #76]                   ; 4-byte Folded Spill
	bl	_G
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #6]
                                        ; kill: def $x9 killed $w9
	ldr	x5, [x8, x9, lsl #3]
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #7]
                                        ; kill: def $x9 killed $w9
	ldr	x6, [x8, x9, lsl #3]
	mov	w1, #3
	str	w1, [sp, #64]                   ; 4-byte Folded Spill
	mov	w2, #7
	str	w2, [sp, #44]                   ; 4-byte Folded Spill
	mov	w3, #11
	str	w3, [sp, #32]                   ; 4-byte Folded Spill
	mov	w4, #15
	str	w4, [sp, #20]                   ; 4-byte Folded Spill
	bl	_G
	ldr	w1, [sp, #8]                    ; 4-byte Folded Reload
	ldr	w2, [sp, #12]                   ; 4-byte Folded Reload
	ldr	w3, [sp, #16]                   ; 4-byte Folded Reload
	ldr	w4, [sp, #20]                   ; 4-byte Folded Reload
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #8]
                                        ; kill: def $x9 killed $w9
	ldr	x5, [x8, x9, lsl #3]
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #9]
                                        ; kill: def $x9 killed $w9
	ldr	x6, [x8, x9, lsl #3]
	bl	_G
	ldr	w1, [sp, #24]                   ; 4-byte Folded Reload
	ldr	w2, [sp, #28]                   ; 4-byte Folded Reload
	ldr	w3, [sp, #32]                   ; 4-byte Folded Reload
	ldr	w4, [sp, #36]                   ; 4-byte Folded Reload
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #10]
                                        ; kill: def $x9 killed $w9
	ldr	x5, [x8, x9, lsl #3]
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #11]
                                        ; kill: def $x9 killed $w9
	ldr	x6, [x8, x9, lsl #3]
	bl	_G
	ldr	w1, [sp, #40]                   ; 4-byte Folded Reload
	ldr	w2, [sp, #44]                   ; 4-byte Folded Reload
	ldr	w3, [sp, #48]                   ; 4-byte Folded Reload
	ldr	w4, [sp, #52]                   ; 4-byte Folded Reload
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #12]
                                        ; kill: def $x9 killed $w9
	ldr	x5, [x8, x9, lsl #3]
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #13]
                                        ; kill: def $x9 killed $w9
	ldr	x6, [x8, x9, lsl #3]
	bl	_G
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	ldr	w1, [sp, #64]                   ; 4-byte Folded Reload
	ldr	w2, [sp, #68]                   ; 4-byte Folded Reload
	ldr	w3, [sp, #72]                   ; 4-byte Folded Reload
	ldr	w4, [sp, #76]                   ; 4-byte Folded Reload
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #14]
                                        ; kill: def $x9 killed $w9
	ldr	x5, [x8, x9, lsl #3]
	ldr	x8, [sp, #104]
	ldr	x9, [sp, #80]
	ldrb	w9, [x9, #15]
                                        ; kill: def $x9 killed $w9
	ldr	x6, [x8, x9, lsl #3]
	bl	_G
	b	LBB5_13
LBB5_13:                                ;   in Loop: Header=BB5_11 Depth=1
	ldr	w8, [sp, #88]
	add	w8, w8, #1
	str	w8, [sp, #88]
	b	LBB5_11
LBB5_14:
	str	wzr, [sp, #88]
	b	LBB5_15
LBB5_15:                                ; =>This Inner Loop Header: Depth=1
	ldr	w8, [sp, #88]
	subs	w8, w8, #8
	cset	w8, ge
	tbnz	w8, #0, LBB5_18
	b	LBB5_16
LBB5_16:                                ;   in Loop: Header=BB5_15 Depth=1
	ldrsw	x8, [sp, #88]
	add	x9, sp, #120
	ldr	x8, [x9, x8, lsl #3]
	ldr	w10, [sp, #88]
	add	w10, w10, #8
	ldr	x9, [x9, w10, sxtw #3]
	eor	x10, x8, x9
	ldr	x8, [sp, #112]
	ldrsw	x9, [sp, #88]
	add	x9, x8, x9, lsl #3
	ldr	x8, [x9]
	eor	x8, x8, x10
	str	x8, [x9]
	b	LBB5_17
LBB5_17:                                ;   in Loop: Header=BB5_15 Depth=1
	ldr	w8, [sp, #88]
	add	w8, w8, #1
	str	w8, [sp, #88]
	b	LBB5_15
LBB5_18:
	ldur	x9, [x29, #-24]
	adrp	x8, ___stack_chk_guard@GOTPAGE
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
	ldr	x8, [x8]
	subs	x8, x8, x9
	cset	w8, eq
	tbnz	w8, #0, LBB5_20
	b	LBB5_19
LBB5_19:
	bl	___stack_chk_fail
LBB5_20:
	ldp	x29, x30, [sp, #272]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #256]            ; 16-byte Folded Reload
	add	sp, sp, #288
	ret
	.cfi_endproc
                                        ; -- End function
	.p2align	2                               ; -- Begin function G
_G:                                     ; @G
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #32
	.cfi_def_cfa_offset 32
	str	x0, [sp, #24]
	strb	w1, [sp, #23]
	strb	w2, [sp, #22]
	strb	w3, [sp, #21]
	strb	w4, [sp, #20]
	str	x5, [sp, #8]
	str	x6, [sp]
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #22]
                                        ; kill: def $x9 killed $w9
	ldr	x8, [x8, x9, lsl #3]
	ldr	x9, [sp, #8]
	add	x10, x8, x9
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #23]
                                        ; kill: def $x9 killed $w9
	add	x9, x8, x9, lsl #3
	ldr	x8, [x9]
	add	x8, x8, x10
	str	x8, [x9]
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #20]
                                        ; kill: def $x9 killed $w9
	ldr	x8, [x8, x9, lsl #3]
	ldr	x9, [sp, #24]
	ldrb	w10, [sp, #23]
                                        ; kill: def $x10 killed $w10
	ldr	x9, [x9, x10, lsl #3]
	eor	x9, x8, x9
	ldr	x8, [sp, #24]
	ldrb	w10, [sp, #20]
                                        ; kill: def $x10 killed $w10
	ldr	x8, [x8, x10, lsl #3]
	ldr	x10, [sp, #24]
	ldrb	w11, [sp, #23]
                                        ; kill: def $x11 killed $w11
	ldr	x10, [x10, x11, lsl #3]
	eor	x8, x8, x10
	lsl	x8, x8, #32
	eor	x8, x8, x9, lsr #32
	ldr	x9, [sp, #24]
	ldrb	w10, [sp, #20]
                                        ; kill: def $x10 killed $w10
	str	x8, [x9, x10, lsl #3]
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #20]
                                        ; kill: def $x9 killed $w9
	ldr	x10, [x8, x9, lsl #3]
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #21]
                                        ; kill: def $x9 killed $w9
	add	x9, x8, x9, lsl #3
	ldr	x8, [x9]
	add	x8, x8, x10
	str	x8, [x9]
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #22]
                                        ; kill: def $x9 killed $w9
	ldr	x8, [x8, x9, lsl #3]
	ldr	x9, [sp, #24]
	ldrb	w10, [sp, #21]
                                        ; kill: def $x10 killed $w10
	ldr	x9, [x9, x10, lsl #3]
	eor	x9, x8, x9
	ldr	x8, [sp, #24]
	ldrb	w10, [sp, #22]
                                        ; kill: def $x10 killed $w10
	ldr	x8, [x8, x10, lsl #3]
	ldr	x10, [sp, #24]
	ldrb	w11, [sp, #21]
                                        ; kill: def $x11 killed $w11
	ldr	x10, [x10, x11, lsl #3]
	eor	x8, x8, x10
	lsl	x8, x8, #40
	eor	x8, x8, x9, lsr #24
	ldr	x9, [sp, #24]
	ldrb	w10, [sp, #22]
                                        ; kill: def $x10 killed $w10
	str	x8, [x9, x10, lsl #3]
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #22]
                                        ; kill: def $x9 killed $w9
	ldr	x8, [x8, x9, lsl #3]
	ldr	x9, [sp]
	add	x10, x8, x9
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #23]
                                        ; kill: def $x9 killed $w9
	add	x9, x8, x9, lsl #3
	ldr	x8, [x9]
	add	x8, x8, x10
	str	x8, [x9]
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #20]
                                        ; kill: def $x9 killed $w9
	ldr	x8, [x8, x9, lsl #3]
	ldr	x9, [sp, #24]
	ldrb	w10, [sp, #23]
                                        ; kill: def $x10 killed $w10
	ldr	x9, [x9, x10, lsl #3]
	eor	x9, x8, x9
	ldr	x8, [sp, #24]
	ldrb	w10, [sp, #20]
                                        ; kill: def $x10 killed $w10
	ldr	x8, [x8, x10, lsl #3]
	ldr	x10, [sp, #24]
	ldrb	w11, [sp, #23]
                                        ; kill: def $x11 killed $w11
	ldr	x10, [x10, x11, lsl #3]
	eor	x8, x8, x10
	lsl	x8, x8, #48
	eor	x8, x8, x9, lsr #16
	ldr	x9, [sp, #24]
	ldrb	w10, [sp, #20]
                                        ; kill: def $x10 killed $w10
	str	x8, [x9, x10, lsl #3]
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #20]
                                        ; kill: def $x9 killed $w9
	ldr	x10, [x8, x9, lsl #3]
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #21]
                                        ; kill: def $x9 killed $w9
	add	x9, x8, x9, lsl #3
	ldr	x8, [x9]
	add	x8, x8, x10
	str	x8, [x9]
	ldr	x8, [sp, #24]
	ldrb	w9, [sp, #22]
                                        ; kill: def $x9 killed $w9
	ldr	x8, [x8, x9, lsl #3]
	ldr	x9, [sp, #24]
	ldrb	w10, [sp, #21]
                                        ; kill: def $x10 killed $w10
	ldr	x9, [x9, x10, lsl #3]
	eor	x9, x8, x9
	ldr	x8, [sp, #24]
	ldrb	w10, [sp, #22]
                                        ; kill: def $x10 killed $w10
	ldr	x8, [x8, x10, lsl #3]
	ldr	x10, [sp, #24]
	ldrb	w11, [sp, #21]
                                        ; kill: def $x11 killed $w11
	ldr	x10, [x10, x11, lsl #3]
	eor	x8, x8, x10
	lsl	x8, x8, #1
	eor	x8, x8, x9, lsr #63
	ldr	x9, [sp, #24]
	ldrb	w10, [sp, #22]
                                        ; kill: def $x10 killed $w10
	str	x8, [x9, x10, lsl #3]
	add	sp, sp, #32
	ret
	.cfi_endproc
                                        ; -- End function
	.p2align	2                               ; -- Begin function test
_test:                                  ; @test
	.cfi_startproc
; %bb.0:
	stp	x28, x27, [sp, #-32]!           ; 16-byte Folded Spill
	.cfi_def_cfa_offset 32
	stp	x29, x30, [sp, #16]             ; 16-byte Folded Spill
	add	x29, sp, #16
	.cfi_def_cfa w29, 16
	.cfi_offset w30, -8
	.cfi_offset w29, -16
	.cfi_offset w27, -24
	.cfi_offset w28, -32
	sub	sp, sp, #640
	adrp	x8, ___stack_chk_guard@GOTPAGE
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
	ldr	x8, [x8]
	stur	x8, [x29, #-24]
	mov	x8, #0
	str	x8, [sp, #16]                   ; 8-byte Folded Spill
	str	xzr, [sp, #112]
	adrp	x8, l___const.test.abc@PAGE
	add	x8, x8, l___const.test.abc@PAGEOFF
	ldrh	w9, [x8]
	add	x10, sp, #108
	str	x10, [sp]                       ; 8-byte Folded Spill
	strh	w9, [sp, #108]
	ldrb	w8, [x8, #2]
	strb	w8, [sp, #110]
	sub	x0, x29, #88
	str	x0, [sp, #8]                    ; 8-byte Folded Spill
	adrp	x1, l___const.test.abc_answer@PAGE
	add	x1, x1, l___const.test.abc_answer@PAGEOFF
	mov	x2, #64
	str	x2, [sp, #72]                   ; 8-byte Folded Spill
	bl	_memcpy
	ldr	x0, [sp]                        ; 8-byte Folded Reload
	ldr	x2, [sp, #16]                   ; 8-byte Folded Reload
	mov	x1, #3
	mov	w3, #0
	mov	w4, #64
	str	w4, [sp, #92]                   ; 4-byte Folded Spill
	bl	_blake2b
	ldr	w2, [sp, #92]                   ; 4-byte Folded Reload
	mov	x8, x0
	ldr	x0, [sp, #8]                    ; 8-byte Folded Reload
	str	x8, [sp, #112]
	ldr	x1, [sp, #112]
	bl	_assert_bytes
	ldr	x0, [sp, #112]
	bl	_libmin_free
	ldr	x2, [sp, #72]                   ; 8-byte Folded Reload
	sub	x0, x29, #152
	str	x0, [sp, #24]                   ; 8-byte Folded Spill
	adrp	x1, l___const.test.key@PAGE
	add	x1, x1, l___const.test.key@PAGEOFF
	bl	_memcpy
	ldr	x2, [sp, #72]                   ; 8-byte Folded Reload
	sub	x0, x29, #216
	str	x0, [sp, #32]                   ; 8-byte Folded Spill
	adrp	x1, l___const.test.key_answer@PAGE
	add	x1, x1, l___const.test.key_answer@PAGEOFF
	bl	_memcpy
	ldr	x0, [sp, #16]                   ; 8-byte Folded Reload
	ldr	x2, [sp, #24]                   ; 8-byte Folded Reload
	ldr	w4, [sp, #92]                   ; 4-byte Folded Reload
	mov	x1, #0
	mov	x3, x4
	bl	_blake2b
	ldr	w2, [sp, #92]                   ; 4-byte Folded Reload
	mov	x8, x0
	ldr	x0, [sp, #32]                   ; 8-byte Folded Reload
	str	x8, [sp, #112]
	ldr	x1, [sp, #112]
	bl	_assert_bytes
	ldr	x0, [sp, #112]
	bl	_libmin_free
	ldr	x2, [sp, #72]                   ; 8-byte Folded Reload
	add	x8, sp, #107
	str	x8, [sp, #40]                   ; 8-byte Folded Spill
	strb	wzr, [sp, #107]
	add	x0, sp, #376
	str	x0, [sp, #48]                   ; 8-byte Folded Spill
	adrp	x1, l___const.test.zero_key@PAGE
	add	x1, x1, l___const.test.zero_key@PAGEOFF
	bl	_memcpy
	ldr	x2, [sp, #72]                   ; 8-byte Folded Reload
	add	x0, sp, #312
	str	x0, [sp, #56]                   ; 8-byte Folded Spill
	adrp	x1, l___const.test.zero_answer@PAGE
	add	x1, x1, l___const.test.zero_answer@PAGEOFF
	bl	_memcpy
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	ldr	x2, [sp, #48]                   ; 8-byte Folded Reload
	ldr	w4, [sp, #92]                   ; 4-byte Folded Reload
	mov	x1, #1
	mov	x3, x4
	bl	_blake2b
	ldr	w2, [sp, #92]                   ; 4-byte Folded Reload
	mov	x8, x0
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	str	x8, [sp, #112]
	ldr	x1, [sp, #112]
	bl	_assert_bytes
	ldr	x0, [sp, #112]
	bl	_libmin_free
	ldr	x2, [sp, #72]                   ; 8-byte Folded Reload
	add	x0, sp, #248
	str	x0, [sp, #64]                   ; 8-byte Folded Spill
	adrp	x1, l___const.test.filled@PAGE
	add	x1, x1, l___const.test.filled@PAGEOFF
	bl	_memcpy
	ldr	x2, [sp, #72]                   ; 8-byte Folded Reload
	add	x0, sp, #184
	str	x0, [sp, #80]                   ; 8-byte Folded Spill
	adrp	x1, l___const.test.filled_key@PAGE
	add	x1, x1, l___const.test.filled_key@PAGEOFF
	bl	_memcpy
	ldr	x2, [sp, #72]                   ; 8-byte Folded Reload
	add	x0, sp, #120
	str	x0, [sp, #96]                   ; 8-byte Folded Spill
	adrp	x1, l___const.test.filled_answer@PAGE
	add	x1, x1, l___const.test.filled_answer@PAGEOFF
	bl	_memcpy
	ldr	x0, [sp, #64]                   ; 8-byte Folded Reload
	ldr	x1, [sp, #72]                   ; 8-byte Folded Reload
	ldr	x2, [sp, #80]                   ; 8-byte Folded Reload
	ldr	w4, [sp, #92]                   ; 4-byte Folded Reload
	mov	x3, x4
	bl	_blake2b
	ldr	w2, [sp, #92]                   ; 4-byte Folded Reload
	mov	x8, x0
	ldr	x0, [sp, #96]                   ; 8-byte Folded Reload
	str	x8, [sp, #112]
	ldr	x1, [sp, #112]
	bl	_assert_bytes
	ldr	x0, [sp, #112]
	bl	_libmin_free
	adrp	x0, l_.str@PAGE
	add	x0, x0, l_.str@PAGEOFF
	bl	_libmin_printf
	ldur	x9, [x29, #-24]
	adrp	x8, ___stack_chk_guard@GOTPAGE
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
	ldr	x8, [x8]
	subs	x8, x8, x9
	cset	w8, eq
	tbnz	w8, #0, LBB7_2
	b	LBB7_1
LBB7_1:
	bl	___stack_chk_fail
LBB7_2:
	add	sp, sp, #640
	ldp	x29, x30, [sp, #16]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp], #32             ; 16-byte Folded Reload
	ret
	.cfi_endproc
                                        ; -- End function
	.p2align	2                               ; -- Begin function assert_bytes
_assert_bytes:                          ; @assert_bytes
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #48
	.cfi_def_cfa_offset 48
	stp	x29, x30, [sp, #32]             ; 16-byte Folded Spill
	add	x29, sp, #32
	.cfi_def_cfa w29, 16
	.cfi_offset w30, -8
	.cfi_offset w29, -16
	stur	x0, [x29, #-8]
	str	x1, [sp, #16]
	strb	w2, [sp, #15]
	ldur	x8, [x29, #-8]
	subs	x8, x8, #0
	cset	w8, eq
	tbnz	w8, #0, LBB8_2
	b	LBB8_1
LBB8_1:
	b	LBB8_3
LBB8_2:
	mov	w0, #1
	bl	_libmin_fail
	b	LBB8_3
LBB8_3:
	ldr	x8, [sp, #16]
	subs	x8, x8, #0
	cset	w8, eq
	tbnz	w8, #0, LBB8_5
	b	LBB8_4
LBB8_4:
	b	LBB8_6
LBB8_5:
	mov	w0, #1
	bl	_libmin_fail
	b	LBB8_6
LBB8_6:
	ldrb	w8, [sp, #15]
	subs	w8, w8, #0
	cset	w8, le
	tbnz	w8, #0, LBB8_8
	b	LBB8_7
LBB8_7:
	b	LBB8_9
LBB8_8:
	mov	w0, #1
	bl	_libmin_fail
	b	LBB8_9
LBB8_9:
	adrp	x10, _testnum@PAGE
	ldr	w9, [x10, _testnum@PAGEOFF]
                                        ; implicit-def: $x8
	mov	x8, x9
	mov	x9, x8
	add	w9, w9, #1
	str	w9, [x10, _testnum@PAGEOFF]
	mov	x9, sp
	str	x8, [x9]
	adrp	x0, l_.str.1@PAGE
	add	x0, x0, l_.str.1@PAGEOFF
	bl	_libmin_printf
	adrp	x0, l_.str.2@PAGE
	add	x0, x0, l_.str.2@PAGEOFF
	bl	_libmin_printf
	strb	wzr, [sp, #14]
	b	LBB8_10
LBB8_10:                                ; =>This Inner Loop Header: Depth=1
	ldrb	w8, [sp, #14]
	ldrb	w9, [sp, #15]
	subs	w8, w8, w9
	cset	w8, ge
	tbnz	w8, #0, LBB8_16
	b	LBB8_11
LBB8_11:                                ;   in Loop: Header=BB8_10 Depth=1
	ldr	x8, [sp, #16]
	ldrb	w9, [sp, #14]
                                        ; kill: def $x9 killed $w9
	ldrb	w10, [x8, x9]
	mov	x9, sp
                                        ; implicit-def: $x8
	mov	x8, x10
	str	x8, [x9]
	adrp	x0, l_.str.3@PAGE
	add	x0, x0, l_.str.3@PAGEOFF
	bl	_libmin_printf
	ldur	x8, [x29, #-8]
	ldrb	w9, [sp, #14]
                                        ; kill: def $x9 killed $w9
	ldrb	w8, [x8, x9]
	ldr	x9, [sp, #16]
	ldrb	w10, [sp, #14]
                                        ; kill: def $x10 killed $w10
	ldrb	w9, [x9, x10]
	subs	w8, w8, w9
	cset	w8, ne
	tbnz	w8, #0, LBB8_13
	b	LBB8_12
LBB8_12:                                ;   in Loop: Header=BB8_10 Depth=1
	b	LBB8_14
LBB8_13:                                ;   in Loop: Header=BB8_10 Depth=1
	mov	w0, #1
	bl	_libmin_fail
	b	LBB8_14
LBB8_14:                                ;   in Loop: Header=BB8_10 Depth=1
	b	LBB8_15
LBB8_15:                                ;   in Loop: Header=BB8_10 Depth=1
	ldrb	w8, [sp, #14]
	add	w8, w8, #1
	strb	w8, [sp, #14]
	b	LBB8_10
LBB8_16:
	adrp	x0, l_.str.4@PAGE
	add	x0, x0, l_.str.4@PAGEOFF
	bl	_libmin_printf
	ldp	x29, x30, [sp, #32]             ; 16-byte Folded Reload
	add	sp, sp, #48
	ret
	.cfi_endproc
                                        ; -- End function
	.globl	_testnum                        ; @testnum
.zerofill __DATA,__common,_testnum,4,2
	.section	__TEXT,__const
	.p2align	3                               ; @blake2b_iv
_blake2b_iv:
	.quad	7640891576956012808             ; 0x6a09e667f3bcc908
	.quad	-4942790177534073029            ; 0xbb67ae8584caa73b
	.quad	4354685564936845355             ; 0x3c6ef372fe94f82b
	.quad	-6534734903238641935            ; 0xa54ff53a5f1d36f1
	.quad	5840696475078001361             ; 0x510e527fade682d1
	.quad	-7276294671716946913            ; 0x9b05688c2b3e6c1f
	.quad	2270897969802886507             ; 0x1f83d9abfb41bd6b
	.quad	6620516959819538809             ; 0x5be0cd19137e2179

_blake2b_sigma:                         ; @blake2b_sigma
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017"
	.ascii	"\016\n\004\b\t\017\r\006\001\f\000\002\013\007\005\003"
	.ascii	"\013\b\f\000\005\002\017\r\n\016\003\006\007\001\t\004"
	.ascii	"\007\t\003\001\r\f\013\016\002\006\005\n\004\000\017\b"
	.ascii	"\t\000\005\007\002\004\n\017\016\001\013\f\006\b\003\r"
	.ascii	"\002\f\006\n\000\013\b\003\004\r\007\005\017\016\001\t"
	.ascii	"\f\005\001\017\016\r\004\n\000\007\006\003\t\002\b\013"
	.ascii	"\r\013\007\016\f\001\003\t\005\000\017\004\b\006\002\n"
	.ascii	"\006\017\016\t\013\003\000\b\f\002\r\007\001\004\n\005"
	.asciz	"\n\002\b\004\007\006\001\005\017\013\t\016\003\f\r"
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017"
	.ascii	"\016\n\004\b\t\017\r\006\001\f\000\002\013\007\005\003"

l___const.test.abc:                     ; @__const.test.abc
	.ascii	"abc"

l___const.test.abc_answer:              ; @__const.test.abc_answer
	.ascii	"\272\200\245?\230\034M\rj'\227\266\237\022\366\351L!/\024hZ\304\267K\022\273o\333\377\242\321}\207\3059*\253y-\302R\325\336E3\314\225\030\323\212\250\333\361\222Z\271#\206\355\324\000\231#"

l___const.test.key:                     ; @__const.test.key
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !\"#$%&'()*+,-./0123456789:;<=>?"

l___const.test.key_answer:              ; @__const.test.key_answer
	.ascii	"\020\353\266w\000\261\206\216\373D\027\230z\317F\220\256\235\227/\267\245\220\302\360(qy\232\252G\206\265\351\226\350\360\364\353\230\037\302\024\260\005\364-/\364#4\2319\026S\337z\357\313\301?\305\025h"

l___const.test.zero_key:                ; @__const.test.zero_key
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !\"#$%&'()*+,-./0123456789:;<=>?"

l___const.test.zero_answer:             ; @__const.test.zero_answer
	.ascii	"\226\037m\321\344\3350\3669\001i\fQ.x\344\264^GB\355\031|<^E\305I\375%\362\344\030{\013\311\3760I+\026\260\320\274N\371\260\363Lp\003\372\300\232^\361S.iC\0024\316\275"

l___const.test.filled:                  ; @__const.test.filled
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !\"#$%&'()*+,-./0123456789:;<=>?"

l___const.test.filled_key:              ; @__const.test.filled_key
	.ascii	"\000\001\002\003\004\005\006\007\b\t\n\013\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !\"#$%&'()*+,-./0123456789:;<=>?"

l___const.test.filled_answer:           ; @__const.test.filled_answer
	.ascii	"egm\200\006\027\227/\275\207\344\271QN\034g@+z3\020\226\323\277\254\"\361\253\271St\253\311B\361n\232\260\352\323;\207\311\031h\246\345\t\341\031\377\007x{>\364\203\341\334\334\317n0\""

	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.asciz	"INFO: All tests have successfully passed!\n"

l_.str.1:                               ; @.str.1
	.asciz	"Test #%d:\n"

l_.str.2:                               ; @.str.2
	.asciz	"Expected[] = { "

l_.str.3:                               ; @.str.3
	.asciz	"0x%02x "

l_.str.4:                               ; @.str.4
	.asciz	" }\n"

.subsections_via_symbols