	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal8,8byte_literals
	.p2align	3                               ## -- Begin function choose_kernel
LCPI0_0:
	.quad	0x40af400000000000              ## double 4000
	.section	__TEXT,__text,regular,pure_instructions
	.globl	_choose_kernel
	.p2align	4, 0x90
_choose_kernel:                         ## @choose_kernel
	.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	$168, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movl	%ecx, %ebx
	movq	%rsi, %r15
	movq	%rdi, %r14
	movq	(%rdi), %rsi
	cmpl	$1, (%rsi)
	jne	LBB0_1
## %bb.99:
	movq	%r14, %rdi
	movq	%r15, %rsi
	movl	%ebx, %edx
	addq	$168, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	jmp	_process_stdout                 ## TAILCALL
LBB0_1:
	movl	%edx, %r13d
	movq	32(%r14), %rdx
	movq	(%rdx), %rax
	movq	_ATTACK_EXEC_INSIDE_KERNEL@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_22
## %bb.2:
	movl	%r8d, %r12d
	movq	8(%rsi), %rax
	movq	_ATTACK_MODE_BF@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_14
## %bb.3:
	cmpl	$1, 16(%rsi)
	je	LBB0_14
## %bb.4:
	movq	_OPTS_TYPE_PT_BITSLICE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	testl	%eax, 8(%rdx)
	je	LBB0_14
## %bb.5:
	movq	%rdx, -72(%rbp)                 ## 8-byte Spill
	movq	%rbx, -48(%rbp)                 ## 8-byte Spill
	movl	(%r15), %ebx
	cmpl	$1, 4(%r15)
	jne	LBB0_7
## %bb.6:
	movl	112(%r15), %edx
	movq	%r14, %rdi
	movq	%r15, %rsi
	movl	%ebx, %ecx
	callq	_run_cuda_kernel_bzero
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_7:
	cmpl	$1, 8(%r15)
	jne	LBB0_9
## %bb.8:
	movl	108(%r15), %edx
	movq	%r14, %rdi
	movq	%r15, %rsi
	movl	%ebx, %ecx
	callq	_run_opencl_kernel_bzero
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_9:
	movq	%r14, %rdi
	movq	%r15, %rsi
	callq	_run_kernel_tm
	movl	$-1, %ecx
	cmpl	$-1, %eax
	je	LBB0_98
## %bb.10:
	cmpl	$1, 4(%r15)
	jne	LBB0_12
## %bb.11:
	movl	112(%r15), %edx
	movl	116(%r15), %esi
	movq	%r14, %rdi
	movl	%ebx, %ecx
	callq	_hc_cuMemcpyDtoD
	movl	$-1, %ecx
	cmpl	$-1, %eax
	je	LBB0_98
LBB0_12:
	movl	%ebx, %eax
	cmpl	$1, 8(%r15)
	movq	-48(%rbp), %rbx                 ## 8-byte Reload
	movq	-72(%rbp), %rdx                 ## 8-byte Reload
	jne	LBB0_14
## %bb.13:
	movl	108(%r15), %edx
	movl	80(%r15), %esi
	movl	104(%r15), %ecx
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movl	%eax, (%rsp)
	movl	$0, 8(%rsp)
	movq	%r14, %rdi
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	_hc_clEnqueueCopyBuffer
	movl	$-1, %ecx
	movq	-72(%rbp), %rdx                 ## 8-byte Reload
	movq	-48(%rbp), %rbx                 ## 8-byte Reload
	cmpl	$-1, %eax
	je	LBB0_98
LBB0_14:
	movq	_OPTI_TYPE_OPTIMIZED_KERNEL@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	testl	%eax, 12(%rdx)
	je	LBB0_21
## %bb.15:
	cmpl	$15, %r13d
	jg	LBB0_18
## %bb.16:
	movq	_KERN_RUN_1@GOTPCREL(%rip), %rax
	jmp	LBB0_17
LBB0_22:
	movl	%r9d, -52(%rbp)                 ## 4-byte Spill
	movq	%rdx, -72(%rbp)                 ## 8-byte Spill
	movq	24(%r14), %r12
	movq	16(%r14), %rax
	movq	%rax, -112(%rbp)                ## 8-byte Spill
	movq	8(%r14), %rax
	movq	%rax, -128(%rbp)                ## 8-byte Spill
	cmpl	$1, 4(%r15)
	movq	%rsi, -88(%rbp)                 ## 8-byte Spill
	jne	LBB0_24
## %bb.23:
	movl	96(%r15), %edx
	movl	100(%r15), %esi
	leal	(,%rbx,4), %ecx
	movq	%r14, %rdi
	callq	_hc_cuMemcpyDtoD
	movq	-88(%rbp), %rsi                 ## 8-byte Reload
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_24:
	cmpl	$1, 8(%r15)
	jne	LBB0_26
## %bb.25:
	movl	92(%r15), %edx
	movl	80(%r15), %esi
	movl	88(%r15), %ecx
	leal	(,%rbx,4), %eax
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movl	%eax, (%rsp)
	movl	$0, 8(%rsp)
	movq	%r14, %rdi
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	_hc_clEnqueueCopyBuffer
	movq	-88(%rbp), %rsi                 ## 8-byte Reload
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_26:
	cmpl	$1, 16(%rsi)
	je	LBB0_28
## %bb.27:
	movq	%r14, %rdi
	movq	%r15, %rsi
	movl	%ebx, %edx
	callq	_run_kernel_amp
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_28:
	movq	_KERN_RUN_1@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	movq	%r14, %rdi
	movq	%r15, %rsi
	movq	%rbx, -48(%rbp)                 ## 8-byte Spill
	movl	%ebx, %ecx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	_run_kernel
	movl	$-1, %ecx
	cmpl	$-1, %eax
	je	LBB0_98
## %bb.29:
	movq	_OPTS_TYPE_HOOK12@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	testl	%eax, 8(%rcx)
	movq	%r15, -64(%rbp)                 ## 8-byte Spill
	je	LBB0_41
## %bb.30:
	movq	_KERN_RUN_12@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	movq	%r14, %rdi
	movq	%r15, %rsi
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	_run_kernel
	cmpl	$-1, %eax
	je	LBB0_97
## %bb.31:
	cmpl	$1, 4(%r15)
	jne	LBB0_33
## %bb.32:
	movl	76(%r15), %esi
	movl	12(%r15), %ecx
	movl	72(%r15), %edx
	movq	%r14, %rdi
	callq	_hc_cuMemcpyDtoH
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_33:
	cmpl	$1, 8(%r15)
	jne	LBB0_35
## %bb.34:
	movl	80(%r15), %esi
	movl	12(%r15), %r9d
	movl	68(%r15), %edx
	movq	_CL_TRUE@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movl	76(%r15), %eax
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movl	%eax, (%rsp)
	movl	$0, 8(%rsp)
	movq	%r14, %rdi
	xorl	%r8d, %r8d
	callq	_hc_clEnqueueReadBuffer
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_35:
	movq	%r12, -104(%rbp)                ## 8-byte Spill
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	movq	24(%rax), %r12
	movl	%r12d, %edi
	movl	$48, %esi
	callq	_hccalloc
	movq	%rax, %r13
	testl	%r12d, %r12d
	movq	%r14, -80(%rbp)                 ## 8-byte Spill
	jle	LBB0_36
## %bb.48:
	movl	%r12d, %r14d
	movq	-104(%rbp), %rax                ## 8-byte Reload
	movl	8(%rax), %r8d
	xorl	%ecx, %ecx
	movq	%r13, -120(%rbp)                ## 8-byte Spill
	movq	-48(%rbp), %rsi                 ## 8-byte Reload
	movl	-52(%rbp), %edi                 ## 4-byte Reload
	movq	-112(%rbp), %rbx                ## 8-byte Reload
	movq	-128(%rbp), %rax                ## 8-byte Reload
	.p2align	4, 0x90
LBB0_49:                                ## =>This Inner Loop Header: Depth=1
	movl	%ecx, (%r13)
	movl	%r12d, 4(%r13)
	movq	%rbx, 40(%r13)
	movq	%rax, 32(%r13)
	movq	%r15, 24(%r13)
	movl	%r8d, 16(%r13)
	movl	%edi, 8(%r13)
	movl	%esi, 12(%r13)
	incq	%rcx
	addq	$48, %r13
	cmpq	%rcx, %r14
	jne	LBB0_49
## %bb.50:
	movq	%r12, -136(%rbp)                ## 8-byte Spill
	movl	%r12d, %edi
	movl	$48, %esi
	callq	_calloc
	movq	%rax, %r15
	shlq	$4, %r14
	leaq	(%r14,%r14,2), %r14
	xorl	%ebx, %ebx
	movq	_hook12_thread@GOTPCREL(%rip), %r12
	movq	-120(%rbp), %r13                ## 8-byte Reload
	.p2align	4, 0x90
LBB0_51:                                ## =>This Inner Loop Header: Depth=1
	leaq	(%rbx,%r13), %rsi
	movl	(%r12), %edi
	movups	(%r15,%rbx), %xmm0
	movupd	16(%r15,%rbx), %xmm1
	movups	32(%r15,%rbx), %xmm2
	movups	%xmm2, 32(%rsp)
	movupd	%xmm1, 16(%rsp)
	movups	%xmm0, (%rsp)
	callq	_hc_thread_create
	addq	$48, %rbx
	cmpq	%rbx, %r14
	jne	LBB0_51
## %bb.52:
	movq	-136(%rbp), %r12                ## 8-byte Reload
	jmp	LBB0_37
LBB0_21:
	movq	_KERN_RUN_4@GOTPCREL(%rip), %rax
	jmp	LBB0_17
LBB0_18:
	cmpl	$31, %r13d
	ja	LBB0_20
## %bb.19:
	movq	_KERN_RUN_2@GOTPCREL(%rip), %rax
	jmp	LBB0_17
LBB0_20:
	movq	_KERN_RUN_3@GOTPCREL(%rip), %rax
LBB0_17:
	movl	(%rax), %edx
	movq	%r14, %rdi
	movq	%r15, %rsi
	movl	%ebx, %ecx
	movl	$1, %r8d
	movl	%r12d, %r9d
	callq	_run_kernel
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_95:
	xorl	%ecx, %ecx
	jmp	LBB0_98
LBB0_36:
	movl	%r12d, %edi
	movl	$48, %esi
	callq	_calloc
	movq	%rax, %r15
LBB0_37:
	movl	%r12d, %edi
	movq	%r15, %rsi
	callq	_hc_thread_wait
	movq	%r15, %rdi
	callq	_hcfree
	movq	%r13, %rdi
	callq	_hcfree
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	cmpl	$1, 4(%rbx)
	movq	-80(%rbp), %r14                 ## 8-byte Reload
	jne	LBB0_39
## %bb.38:
	movl	12(%rbx), %ecx
	movl	72(%rbx), %esi
	movl	76(%rbx), %edx
	movq	%r14, %rdi
	callq	_hc_cuMemcpyHtoD
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_39:
	cmpl	$1, 8(%rbx)
	movq	-104(%rbp), %r12                ## 8-byte Reload
	jne	LBB0_41
## %bb.40:
	movl	80(%rbx), %esi
	movl	12(%rbx), %r9d
	movl	68(%rbx), %edx
	movq	_CL_TRUE@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movl	76(%rbx), %eax
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movl	%eax, (%rsp)
	movl	$0, 8(%rsp)
	movq	%r14, %rdi
	xorl	%r8d, %r8d
	callq	_hc_clEnqueueWriteBuffer
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_41:
	movq	%r14, -80(%rbp)                 ## 8-byte Spill
	movq	%r12, -104(%rbp)                ## 8-byte Spill
	movq	(%r12), %rax
	movslq	-52(%rbp), %rcx                 ## 4-byte Folded Reload
	leaq	(%rcx,%rcx,2), %rcx
	movq	%rcx, -152(%rbp)                ## 8-byte Spill
	movl	(%rax,%rcx,4), %eax
	movl	%eax, -92(%rbp)                 ## 4-byte Spill
	testl	%eax, %eax
	jle	LBB0_54
## %bb.42:
	movl	-92(%rbp), %ebx                 ## 4-byte Reload
	xorps	%xmm0, %xmm0
	cvtsi2ss	%ebx, %xmm0
	movss	%xmm0, -144(%rbp)               ## 4-byte Spill
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movl	16(%rax), %r12d
	xorps	%xmm0, %xmm0
	cvtsi2ssl	-48(%rbp), %xmm0        ## 4-byte Folded Reload
	movss	%xmm0, -140(%rbp)               ## 4-byte Spill
	xorl	%r15d, %r15d
	xorl	%r13d, %r13d
	jmp	LBB0_43
	.p2align	4, 0x90
LBB0_53:                                ##   in Loop: Header=BB0_43 Depth=1
	movl	%ebx, %r12d
	addl	%ebx, %r15d
	incl	%r13d
	movl	-136(%rbp), %ebx                ## 4-byte Reload
	subl	%r12d, %ebx
	cmpl	%r15d, -92(%rbp)                ## 4-byte Folded Reload
	jle	LBB0_54
LBB0_43:                                ## =>This Inner Loop Header: Depth=1
	movl	%ebx, %edi
	movl	%r12d, %esi
	callq	_MIN
	movl	%eax, %r14d
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	movq	24(%rsi), %rax
	movl	%r15d, 112(%rax)
	movl	%r14d, 116(%rax)
	movq	_KERN_RUN_2@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx
	movl	$1, %r8d
	movl	%r13d, %r9d
	callq	_run_kernel
	cmpl	$-1, %eax
	je	LBB0_97
## %bb.44:                              ##   in Loop: Header=BB0_43 Depth=1
	movq	-128(%rbp), %rax                ## 8-byte Reload
	cmpl	$0, (%rax)
	je	LBB0_54
## %bb.45:                              ##   in Loop: Header=BB0_43 Depth=1
	movl	%ebx, -136(%rbp)                ## 4-byte Spill
	movl	%r12d, %ebx
	addl	%r15d, %r14d
	xorps	%xmm0, %xmm0
	cvtsi2ss	%r14d, %xmm0
	divss	-144(%rbp), %xmm0               ## 4-byte Folded Reload
	mulss	-140(%rbp), %xmm0               ## 4-byte Folded Reload
	cvttss2si	%xmm0, %eax
	movl	%eax, -120(%rbp)                ## 4-byte Spill
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	movl	84(%r12), %edi
	callq	_hc_timer_get
	movslq	32(%r12), %rax
	movq	40(%r12), %rcx
	movl	-120(%rbp), %edx                ## 4-byte Reload
	movl	%edx, (%rcx,%rax,4)
	movq	48(%r12), %rcx
	movsd	%xmm0, (%rcx,%rax,8)
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	cmpl	$1, 20(%rax)
	jne	LBB0_53
## %bb.46:                              ##   in Loop: Header=BB0_43 Depth=1
	ucomisd	LCPI0_0(%rip), %xmm0
	jbe	LBB0_53
## %bb.47:
	xorps	%xmm0, %xmm0
	cvtsi2sdl	-92(%rbp), %xmm0        ## 4-byte Folded Reload
	cvtsi2sd	%r14d, %xmm1
	divsd	%xmm1, %xmm0
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	mulsd	56(%rax), %xmm0
	movsd	%xmm0, 56(%rax)
	movl	$1, 32(%rax)
	movl	$1, 64(%rax)
	xorl	%ecx, %ecx
	jmp	LBB0_98
LBB0_54:
	movq	_OPTS_TYPE_HOOK23@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	testl	%eax, 8(%rcx)
	movq	-64(%rbp), %r15                 ## 8-byte Reload
	movq	-80(%rbp), %r14                 ## 8-byte Reload
	je	LBB0_66
## %bb.55:
	movq	_KERN_RUN_23@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	movq	%r14, %rdi
	movq	%r15, %rsi
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	_run_kernel
	cmpl	$-1, %eax
	je	LBB0_97
## %bb.56:
	cmpl	$1, 4(%r15)
	jne	LBB0_58
## %bb.57:
	movl	76(%r15), %esi
	movl	12(%r15), %ecx
	movl	72(%r15), %edx
	movq	%r14, %rdi
	callq	_hc_cuMemcpyDtoH
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_58:
	cmpl	$1, 8(%r15)
	jne	LBB0_60
## %bb.59:
	movl	80(%r15), %esi
	movl	12(%r15), %r9d
	movl	68(%r15), %edx
	movq	_CL_TRUE@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movl	76(%r15), %eax
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movl	%eax, (%rsp)
	movl	$0, 8(%rsp)
	movq	%r14, %rdi
	xorl	%r8d, %r8d
	callq	_hc_clEnqueueReadBuffer
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_60:
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	movq	24(%rax), %r12
	movl	%r12d, %edi
	movl	$48, %esi
	callq	_hccalloc
	movq	%rax, %r13
	testl	%r12d, %r12d
	jle	LBB0_61
## %bb.71:
	movl	%r12d, %r14d
	movq	-104(%rbp), %rax                ## 8-byte Reload
	movl	8(%rax), %r8d
	xorl	%ecx, %ecx
	movq	%r13, -88(%rbp)                 ## 8-byte Spill
	movq	-48(%rbp), %rsi                 ## 8-byte Reload
	movl	-52(%rbp), %edi                 ## 4-byte Reload
	movq	-112(%rbp), %rbx                ## 8-byte Reload
	movq	-128(%rbp), %rax                ## 8-byte Reload
LBB0_72:                                ## =>This Inner Loop Header: Depth=1
	movl	%ecx, (%r13)
	movl	%r12d, 4(%r13)
	movq	%rbx, 40(%r13)
	movq	%rax, 32(%r13)
	movq	%r15, 24(%r13)
	movl	%r8d, 16(%r13)
	movl	%edi, 8(%r13)
	movl	%esi, 12(%r13)
	incq	%rcx
	addq	$48, %r13
	cmpq	%rcx, %r14
	jne	LBB0_72
## %bb.73:
	movq	%r12, -120(%rbp)                ## 8-byte Spill
	movl	%r12d, %edi
	movl	$48, %esi
	callq	_calloc
	movq	%rax, %r15
	shlq	$4, %r14
	leaq	(%r14,%r14,2), %r14
	xorl	%ebx, %ebx
	movq	_hook23_thread@GOTPCREL(%rip), %r12
	movq	-88(%rbp), %r13                 ## 8-byte Reload
LBB0_74:                                ## =>This Inner Loop Header: Depth=1
	leaq	(%rbx,%r13), %rsi
	movl	(%r12), %edi
	movups	(%r15,%rbx), %xmm0
	movupd	16(%r15,%rbx), %xmm1
	movups	32(%r15,%rbx), %xmm2
	movups	%xmm2, 32(%rsp)
	movupd	%xmm1, 16(%rsp)
	movups	%xmm0, (%rsp)
	callq	_hc_thread_create
	addq	$48, %rbx
	cmpq	%rbx, %r14
	jne	LBB0_74
## %bb.75:
	movq	-120(%rbp), %r12                ## 8-byte Reload
	jmp	LBB0_62
LBB0_61:
	movl	%r12d, %edi
	movl	$48, %esi
	callq	_calloc
	movq	%rax, %r15
LBB0_62:
	movl	%r12d, %edi
	movq	%r15, %rsi
	callq	_hc_thread_wait
	movq	%r15, %rdi
	callq	_hcfree
	movq	%r13, %rdi
	callq	_hcfree
	movq	-64(%rbp), %r15                 ## 8-byte Reload
	cmpl	$1, 4(%r15)
	movq	-80(%rbp), %r14                 ## 8-byte Reload
	jne	LBB0_64
## %bb.63:
	movl	12(%r15), %ecx
	movl	72(%r15), %esi
	movl	76(%r15), %edx
	movq	%r14, %rdi
	callq	_hc_cuMemcpyHtoD
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_64:
	cmpl	$1, 8(%r15)
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	jne	LBB0_66
## %bb.65:
	movl	80(%r15), %esi
	movl	12(%r15), %r9d
	movl	68(%r15), %edx
	movq	_CL_TRUE@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movl	76(%r15), %eax
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movl	%eax, (%rsp)
	movl	$0, 8(%rsp)
	movq	%r14, %rdi
	xorl	%r8d, %r8d
	callq	_hc_clEnqueueWriteBuffer
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_66:
	movl	8(%rcx), %eax
	movq	_OPTS_TYPE_INIT2@GOTPCREL(%rip), %rcx
	testl	%eax, (%rcx)
	movq	-104(%rbp), %r13                ## 8-byte Reload
	je	LBB0_69
## %bb.67:
	movq	_KERN_RUN_INIT2@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	movq	%r14, %rdi
	movq	%r15, %rsi
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	_run_kernel
	cmpl	$-1, %eax
	je	LBB0_97
## %bb.68:
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	movl	8(%rax), %eax
LBB0_69:
	movq	_OPTS_TYPE_LOOP2@GOTPCREL(%rip), %rcx
	testl	%eax, (%rcx)
	je	LBB0_70
## %bb.76:
	movq	(%r13), %rcx
	movq	-152(%rbp), %rdx                ## 8-byte Reload
	movl	4(%rcx,%rdx,4), %r15d
	testl	%r15d, %r15d
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
	movl	-52(%rbp), %esi                 ## 4-byte Reload
	movq	-112(%rbp), %r8                 ## 8-byte Reload
	jle	LBB0_83
## %bb.77:
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movl	16(%rax), %r14d
	xorl	%r12d, %r12d
	movl	%r15d, %ebx
	xorl	%r13d, %r13d
LBB0_78:                                ## =>This Inner Loop Header: Depth=1
	movl	%ebx, %edi
	movl	%r14d, %esi
	callq	_MIN
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	movq	24(%rsi), %rcx
	movl	%r13d, 112(%rcx)
	movl	%eax, 116(%rcx)
	movq	_KERN_RUN_LOOP2@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx
	movl	$1, %r8d
	movl	%r12d, %r9d
	callq	_run_kernel
	cmpl	$-1, %eax
	je	LBB0_97
## %bb.79:                              ##   in Loop: Header=BB0_78 Depth=1
	movq	-128(%rbp), %rax                ## 8-byte Reload
	cmpl	$0, (%rax)
	je	LBB0_81
## %bb.80:                              ##   in Loop: Header=BB0_78 Depth=1
	addl	%r14d, %r13d
	incl	%r12d
	subl	%r14d, %ebx
	cmpl	%r13d, %r15d
	jg	LBB0_78
LBB0_81:
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	movl	8(%rax), %eax
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
	movl	-52(%rbp), %esi                 ## 4-byte Reload
	movq	-104(%rbp), %r13                ## 8-byte Reload
	jmp	LBB0_82
LBB0_70:
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
	movl	-52(%rbp), %esi                 ## 4-byte Reload
LBB0_82:
	movq	-112(%rbp), %r8                 ## 8-byte Reload
LBB0_83:
	movq	_OPTS_TYPE_DEEP_COMP_KERNEL@GOTPCREL(%rip), %rdx
	testl	%eax, (%rdx)
	je	LBB0_96
## %bb.84:
	movq	(%r13), %rax
	movq	-152(%rbp), %rcx                ## 8-byte Reload
	movl	8(%rax,%rcx,4), %r14d
	testl	%r14d, %r14d
	jle	LBB0_89
## %bb.85:
	leal	-1(%r14), %r15d
	xorl	%ebx, %ebx
	movq	-64(%rbp), %r12                 ## 8-byte Reload
LBB0_86:                                ## =>This Inner Loop Header: Depth=1
	movq	24(%r12), %rax
	movl	%ebx, 112(%rax)
	movl	%r14d, 116(%rax)
	movq	%r13, %rdi
	movl	%ebx, %edx
	callq	*(%r8)
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	movq	%r12, %rsi
	movl	%eax, %edx
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	_run_kernel
	cmpl	$-1, %eax
	je	LBB0_97
## %bb.87:                              ##   in Loop: Header=BB0_86 Depth=1
	movq	-128(%rbp), %rax                ## 8-byte Reload
	cmpl	$0, (%rax)
	movl	-52(%rbp), %esi                 ## 4-byte Reload
	movq	-112(%rbp), %r8                 ## 8-byte Reload
	je	LBB0_89
## %bb.88:                              ##   in Loop: Header=BB0_86 Depth=1
	leal	1(%rbx), %eax
	cmpl	%ebx, %r15d
	movl	%eax, %ebx
	jne	LBB0_86
	jmp	LBB0_89
LBB0_96:
	movq	_KERN_RUN_3@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	_run_kernel
	cmpl	$-1, %eax
	je	LBB0_97
LBB0_89:
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	movl	8(%rax), %eax
	movq	_OPTS_TYPE_HOOK12@GOTPCREL(%rip), %rcx
	testl	%eax, (%rcx)
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	movq	-80(%rbp), %r14                 ## 8-byte Reload
	jne	LBB0_91
## %bb.90:
	movq	_OPTS_TYPE_HOOK23@GOTPCREL(%rip), %rcx
	testl	%eax, (%rcx)
	je	LBB0_95
LBB0_91:
	cmpl	$1, 4(%rbx)
	jne	LBB0_93
## %bb.92:
	movl	12(%rbx), %ecx
	movl	72(%rbx), %edx
	movq	%r14, %rdi
	movq	%rbx, %rsi
	callq	_run_cuda_kernel_bzero
	movl	$-1, %ecx
	cmpl	$-1, %eax
	je	LBB0_98
LBB0_93:
	cmpl	$1, 8(%rbx)
	jne	LBB0_95
## %bb.94:
	movl	12(%rbx), %ecx
	movl	68(%rbx), %edx
	movq	%r14, %rdi
	movq	%rbx, %rsi
	callq	_run_opencl_kernel_bzero
	movl	$-1, %ecx
	cmpl	$-1, %eax
	jne	LBB0_95
	jmp	LBB0_98
LBB0_97:
	movl	$-1, %ecx
LBB0_98:
	movl	%ecx, %eax
	addq	$168, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.comm	_ATTACK_EXEC_INSIDE_KERNEL,8,3  ## @ATTACK_EXEC_INSIDE_KERNEL
	.comm	_ATTACK_MODE_BF,8,3             ## @ATTACK_MODE_BF
	.comm	_OPTS_TYPE_PT_BITSLICE,4,2      ## @OPTS_TYPE_PT_BITSLICE
	.comm	_OPTI_TYPE_OPTIMIZED_KERNEL,4,2 ## @OPTI_TYPE_OPTIMIZED_KERNEL
	.comm	_KERN_RUN_1,4,2                 ## @KERN_RUN_1
	.comm	_KERN_RUN_2,4,2                 ## @KERN_RUN_2
	.comm	_KERN_RUN_3,4,2                 ## @KERN_RUN_3
	.comm	_KERN_RUN_4,4,2                 ## @KERN_RUN_4
	.comm	_OPTS_TYPE_HOOK12,4,2           ## @OPTS_TYPE_HOOK12
	.comm	_KERN_RUN_12,4,2                ## @KERN_RUN_12
	.comm	_CL_TRUE,4,2                    ## @CL_TRUE
	.comm	_hook12_thread,4,2              ## @hook12_thread
	.comm	_OPTS_TYPE_HOOK23,4,2           ## @OPTS_TYPE_HOOK23
	.comm	_KERN_RUN_23,4,2                ## @KERN_RUN_23
	.comm	_hook23_thread,4,2              ## @hook23_thread
	.comm	_OPTS_TYPE_INIT2,4,2            ## @OPTS_TYPE_INIT2
	.comm	_KERN_RUN_INIT2,4,2             ## @KERN_RUN_INIT2
	.comm	_OPTS_TYPE_LOOP2,4,2            ## @OPTS_TYPE_LOOP2
	.comm	_KERN_RUN_LOOP2,4,2             ## @KERN_RUN_LOOP2
	.comm	_OPTS_TYPE_DEEP_COMP_KERNEL,4,2 ## @OPTS_TYPE_DEEP_COMP_KERNEL
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	_choose_kernel                  ; -- Begin function choose_kernel
	.p2align	2
_choose_kernel:                         ; @choose_kernel
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #224
	.cfi_def_cfa_offset 224
	stp	d9, d8, [sp, #112]              ; 16-byte Folded Spill
	stp	x28, x27, [sp, #128]            ; 16-byte Folded Spill
	stp	x26, x25, [sp, #144]            ; 16-byte Folded Spill
	stp	x24, x23, [sp, #160]            ; 16-byte Folded Spill
	stp	x22, x21, [sp, #176]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #192]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #208]            ; 16-byte Folded Spill
	add	x29, sp, #208
	.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
	.cfi_offset b8, -104
	.cfi_offset b9, -112
	mov	x21, x3
	mov	x19, x1
	mov	x20, x0
	ldr	x28, [x0]
	ldr	w8, [x28]
	cmp	w8, #1
	b.ne	LBB0_2
; %bb.1:
	mov	x0, x20
	mov	x1, x19
	mov	x2, x21
	ldp	x29, x30, [sp, #208]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #192]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #176]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #160]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #144]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #128]            ; 16-byte Folded Reload
	ldp	d9, d8, [sp, #112]              ; 16-byte Folded Reload
	add	sp, sp, #224
	b	_process_stdout
LBB0_2:
	ldr	x27, [x20, #32]
	ldr	x8, [x27]
Lloh0:
	adrp	x9, _ATTACK_EXEC_INSIDE_KERNEL@GOTPAGE
Lloh1:
	ldr	x9, [x9, _ATTACK_EXEC_INSIDE_KERNEL@GOTPAGEOFF]
Lloh2:
	ldr	x9, [x9]
	cmp	x8, x9
	b.ne	LBB0_18
; %bb.3:
	mov	x23, x4
	mov	x24, x2
	ldr	x8, [x28, #8]
Lloh3:
	adrp	x9, _ATTACK_MODE_BF@GOTPAGE
Lloh4:
	ldr	x9, [x9, _ATTACK_MODE_BF@GOTPAGEOFF]
Lloh5:
	ldr	x9, [x9]
	cmp	x8, x9
	b.ne	LBB0_15
; %bb.4:
	ldr	w8, [x28, #16]
	cmp	w8, #1
	b.eq	LBB0_15
; %bb.5:
	ldr	w8, [x27, #8]
Lloh6:
	adrp	x9, _OPTS_TYPE_PT_BITSLICE@GOTPAGE
Lloh7:
	ldr	x9, [x9, _OPTS_TYPE_PT_BITSLICE@GOTPAGEOFF]
Lloh8:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_15
; %bb.6:
	ldp	w22, w8, [x19]
	cmp	w8, #1
	b.ne	LBB0_8
; %bb.7:
	ldr	w2, [x19, #112]
	mov	x0, x20
	mov	x1, x19
	mov	x3, x22
	bl	_run_cuda_kernel_bzero
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_8:
	ldr	w8, [x19, #8]
	cmp	w8, #1
	b.ne	LBB0_10
; %bb.9:
	ldr	w2, [x19, #108]
	mov	x0, x20
	mov	x1, x19
	mov	x3, x22
	bl	_run_opencl_kernel_bzero
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_10:
	mov	x0, x20
	mov	x1, x19
	bl	_run_kernel_tm
	cmn	w0, #1
	b.eq	LBB0_40
; %bb.11:
	ldr	w8, [x19, #4]
	cmp	w8, #1
	b.ne	LBB0_13
; %bb.12:
	ldp	w2, w1, [x19, #112]
	mov	x0, x20
	mov	x3, x22
	bl	_hc_cuMemcpyDtoD
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_13:
	ldr	w8, [x19, #8]
	cmp	w8, #1
	b.ne	LBB0_15
; %bb.14:
	ldr	w1, [x19, #80]
	ldp	w3, w2, [x19, #104]
	stp	xzr, xzr, [sp]
	mov	x0, x20
	mov	w4, #0
	mov	w5, #0
	mov	x6, x22
	mov	w7, #0
	bl	_hc_clEnqueueCopyBuffer
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_15:
	ldr	w8, [x27, #12]
Lloh9:
	adrp	x9, _OPTI_TYPE_OPTIMIZED_KERNEL@GOTPAGE
Lloh10:
	ldr	x9, [x9, _OPTI_TYPE_OPTIMIZED_KERNEL@GOTPAGEOFF]
Lloh11:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_34
; %bb.16:
	cmp	w24, #15
	b.gt	LBB0_35
; %bb.17:
Lloh12:
	adrp	x8, _KERN_RUN_1@GOTPAGE
Lloh13:
	ldr	x8, [x8, _KERN_RUN_1@GOTPAGEOFF]
	b	LBB0_38
LBB0_18:
	mov	x22, x5
	ldp	x26, x23, [x20, #16]
	ldr	x8, [x20, #8]
	str	x8, [sp, #56]                   ; 8-byte Folded Spill
	ldr	w8, [x19, #4]
	cmp	w8, #1
	b.ne	LBB0_20
; %bb.19:
	ldp	w2, w1, [x19, #96]
	lsl	w3, w21, #2
	mov	x0, x20
	bl	_hc_cuMemcpyDtoD
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_20:
	ldr	w8, [x19, #8]
	cmp	w8, #1
	b.ne	LBB0_22
; %bb.21:
	ldr	w1, [x19, #80]
	lsl	w6, w21, #2
	ldp	w3, w2, [x19, #88]
	stp	xzr, xzr, [sp]
	mov	x0, x20
	mov	w4, #0
	mov	w5, #0
	mov	w7, #0
	bl	_hc_clEnqueueCopyBuffer
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_22:
	ldr	w8, [x28, #16]
	cmp	w8, #1
	b.eq	LBB0_24
; %bb.23:
	mov	x0, x20
	mov	x1, x19
	mov	x2, x21
	bl	_run_kernel_amp
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_24:
Lloh14:
	adrp	x8, _KERN_RUN_1@GOTPAGE
Lloh15:
	ldr	x8, [x8, _KERN_RUN_1@GOTPAGEOFF]
Lloh16:
	ldr	w2, [x8]
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	mov	w4, #0
	mov	w5, #0
	bl	_run_kernel
	cmn	w0, #1
	b.eq	LBB0_40
; %bb.25:
	ldr	w8, [x27, #8]
Lloh17:
	adrp	x9, _OPTS_TYPE_HOOK12@GOTPAGE
Lloh18:
	ldr	x9, [x9, _OPTS_TYPE_HOOK12@GOTPAGEOFF]
Lloh19:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_54
; %bb.26:
Lloh20:
	adrp	x8, _KERN_RUN_12@GOTPAGE
Lloh21:
	ldr	x8, [x8, _KERN_RUN_12@GOTPAGEOFF]
Lloh22:
	ldr	w2, [x8]
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	mov	w4, #0
	mov	w5, #0
	bl	_run_kernel
	cmn	w0, #1
	b.eq	LBB0_40
; %bb.27:
	ldr	w8, [x19, #4]
	cmp	w8, #1
	b.ne	LBB0_29
; %bb.28:
	ldp	w2, w1, [x19, #72]
	ldr	w3, [x19, #12]
	mov	x0, x20
	bl	_hc_cuMemcpyDtoH
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_29:
	ldr	w8, [x19, #8]
	cmp	w8, #1
	b.ne	LBB0_31
; %bb.30:
	ldr	w2, [x19, #68]
Lloh23:
	adrp	x8, _CL_TRUE@GOTPAGE
Lloh24:
	ldr	x8, [x8, _CL_TRUE@GOTPAGEOFF]
Lloh25:
	ldr	w3, [x8]
	ldr	w5, [x19, #12]
	ldp	w6, w1, [x19, #76]
	stp	xzr, xzr, [sp]
	mov	x0, x20
	mov	w4, #0
	mov	w7, #0
	bl	_hc_clEnqueueReadBuffer
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_31:
	ldr	x25, [x28, #24]
	mov	x0, x25
	mov	w1, #48
	bl	_hccalloc
	mov	x24, x0
	cmp	w25, #0
	stp	x26, x22, [sp, #32]             ; 16-byte Folded Spill
	str	x23, [sp, #16]                  ; 8-byte Folded Spill
	b.le	LBB0_41
; %bb.32:
	str	x27, [sp, #24]                  ; 8-byte Folded Spill
	and	x27, x25, #0xffffffff
	ldr	w8, [x23, #8]
	cmp	x27, #4
	b.hs	LBB0_42
; %bb.33:
	mov	x9, #0
	ldr	x16, [sp, #56]                  ; 8-byte Folded Reload
	b	LBB0_45
LBB0_34:
Lloh26:
	adrp	x8, _KERN_RUN_4@GOTPAGE
Lloh27:
	ldr	x8, [x8, _KERN_RUN_4@GOTPAGEOFF]
	b	LBB0_38
LBB0_35:
	cmp	w24, #31
	b.hi	LBB0_37
; %bb.36:
Lloh28:
	adrp	x8, _KERN_RUN_2@GOTPAGE
Lloh29:
	ldr	x8, [x8, _KERN_RUN_2@GOTPAGEOFF]
	b	LBB0_38
LBB0_37:
Lloh30:
	adrp	x8, _KERN_RUN_3@GOTPAGE
Lloh31:
	ldr	x8, [x8, _KERN_RUN_3@GOTPAGEOFF]
LBB0_38:
	ldr	w2, [x8]
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	mov	w4, #1
	mov	x5, x23
	bl	_run_kernel
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_39:
	mov	w0, #0
LBB0_40:
	ldp	x29, x30, [sp, #208]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #192]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #176]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #160]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #144]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #128]            ; 16-byte Folded Reload
	ldp	d9, d8, [sp, #112]              ; 16-byte Folded Reload
	add	sp, sp, #224
	ret
LBB0_41:
	mov	x0, x25
	mov	w1, #48
	bl	_calloc
	mov	x26, x0
	b	LBB0_50
LBB0_42:
	mov	x11, #0
	and	x10, x27, #0x3
	and	x9, x27, #0xfffffffc
	add	x12, x24, #184
	ldr	x16, [sp, #56]                  ; 8-byte Folded Reload
LBB0_43:                                ; =>This Inner Loop Header: Depth=1
	add	w13, w11, #1
	add	w14, w11, #2
	add	w15, w11, #3
	stp	w11, w25, [x12, #-184]
	stp	w13, w25, [x12, #-136]
	stp	w14, w25, [x12, #-88]
	stp	w15, w25, [x12, #-40]
	stp	x16, x26, [x12, #-152]
	stp	x16, x26, [x12, #-104]
	stp	x16, x26, [x12, #-56]
	stp	x16, x26, [x12, #-8]
	stur	x19, [x12, #-160]
	stur	x19, [x12, #-112]
	stur	x19, [x12, #-64]
	stur	x19, [x12, #-16]
	stp	w21, w8, [x12, #-172]
	stp	w21, w8, [x12, #-124]
	stp	w21, w8, [x12, #-76]
	stp	w21, w8, [x12, #-28]
	stur	w22, [x12, #-176]
	stur	w22, [x12, #-128]
	stur	w22, [x12, #-80]
	add	x11, x11, #4
	stur	w22, [x12, #-32]
	add	x12, x12, #192
	cmp	x9, x11
	b.ne	LBB0_43
; %bb.44:
	cbz	x10, LBB0_47
LBB0_45:
	mov	w10, #48
	madd	x10, x9, x10, x24
	add	x10, x10, #40
LBB0_46:                                ; =>This Inner Loop Header: Depth=1
	stp	w9, w25, [x10, #-40]
	stp	x16, x26, [x10, #-8]
	stur	x19, [x10, #-16]
	stp	w21, w8, [x10, #-28]
	add	x9, x9, #1
	stur	w22, [x10, #-32]
	add	x10, x10, #48
	cmp	x27, x9
	b.ne	LBB0_46
LBB0_47:
	mov	x0, x25
	mov	w1, #48
	bl	_calloc
	mov	x26, x0
	mov	x22, #0
Lloh32:
	adrp	x23, _hook12_thread@GOTPAGE
Lloh33:
	ldr	x23, [x23, _hook12_thread@GOTPAGEOFF]
LBB0_48:                                ; =>This Inner Loop Header: Depth=1
	add	x2, x24, x22
	ldr	w1, [x23]
	add	x8, x26, x22
	ldp	q0, q1, [x8]
	ldr	q2, [x8, #32]
	stp	q1, q2, [sp, #80]
	str	q0, [sp, #64]
	add	x0, sp, #64
	bl	_hc_thread_create
	add	x22, x22, #48
	subs	x27, x27, #1
	b.ne	LBB0_48
; %bb.49:
	ldr	x27, [sp, #24]                  ; 8-byte Folded Reload
LBB0_50:
	mov	x0, x25
	mov	x1, x26
	bl	_hc_thread_wait
	mov	x0, x26
	bl	_hcfree
	mov	x0, x24
	bl	_hcfree
	ldr	w8, [x19, #4]
	cmp	w8, #1
	b.ne	LBB0_52
; %bb.51:
	ldp	w1, w2, [x19, #72]
	ldr	w3, [x19, #12]
	mov	x0, x20
	bl	_hc_cuMemcpyHtoD
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_52:
	ldr	w8, [x19, #8]
	cmp	w8, #1
	ldp	x26, x22, [sp, #32]             ; 16-byte Folded Reload
	ldr	x23, [sp, #16]                  ; 8-byte Folded Reload
	b.ne	LBB0_54
; %bb.53:
	ldr	w2, [x19, #68]
Lloh34:
	adrp	x8, _CL_TRUE@GOTPAGE
Lloh35:
	ldr	x8, [x8, _CL_TRUE@GOTPAGEOFF]
Lloh36:
	ldr	w3, [x8]
	ldr	w5, [x19, #12]
	ldp	w6, w1, [x19, #76]
	stp	xzr, xzr, [sp]
	mov	x0, x20
	mov	w4, #0
	mov	w7, #0
	bl	_hc_clEnqueueWriteBuffer
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_54:
	stp	x27, x26, [sp, #24]             ; 16-byte Folded Spill
	str	x23, [sp, #16]                  ; 8-byte Folded Spill
	ldr	x8, [x23]
	mov	w9, #12
	str	x22, [sp, #40]                  ; 8-byte Folded Spill
	smull	x9, w22, w9
	ldr	w8, [x8, x9]
	str	w8, [sp, #52]                   ; 4-byte Folded Spill
	cmp	w8, #1
	b.lt	LBB0_62
; %bb.55:
	mov	w22, #0
	mov	w24, #0
	ldr	w25, [x19, #16]
	ldr	w26, [sp, #52]                  ; 4-byte Folded Reload
	scvtf	s8, w26
	scvtf	s9, w21
	b	LBB0_57
LBB0_56:                                ;   in Loop: Header=BB0_57 Depth=1
	add	w24, w24, #1
	sub	w26, w26, w25
	add	w22, w22, w25
	ldr	w8, [sp, #52]                   ; 4-byte Folded Reload
	cmp	w8, w22
	b.le	LBB0_62
LBB0_57:                                ; =>This Inner Loop Header: Depth=1
	mov	x0, x26
	mov	x1, x25
	bl	_MIN
	mov	x27, x0
	ldr	x8, [x19, #24]
	stp	w22, w0, [x8, #112]
Lloh37:
	adrp	x8, _KERN_RUN_2@GOTPAGE
Lloh38:
	ldr	x8, [x8, _KERN_RUN_2@GOTPAGEOFF]
Lloh39:
	ldr	w2, [x8]
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	mov	w4, #1
	mov	x5, x24
	bl	_run_kernel
	cmn	w0, #1
	b.eq	LBB0_40
; %bb.58:                               ;   in Loop: Header=BB0_57 Depth=1
	ldr	x8, [sp, #56]                   ; 8-byte Folded Reload
	ldr	w8, [x8]
	cbz	w8, LBB0_62
; %bb.59:                               ;   in Loop: Header=BB0_57 Depth=1
	add	w8, w27, w22
	scvtf	s0, w8
	fdiv	s0, s0, s8
	fmul	s0, s0, s9
	fcvtzs	w23, s0
	ldr	w0, [x19, #84]
	bl	_hc_timer_get
	ldrsw	x8, [x19, #32]
	ldr	x9, [x19, #40]
	str	w23, [x9, x8, lsl #2]
	ldr	x9, [x19, #48]
	str	d0, [x9, x8, lsl #3]
	ldr	w8, [x28, #20]
	cmp	w8, #1
	b.ne	LBB0_56
; %bb.60:                               ;   in Loop: Header=BB0_57 Depth=1
	mov	x8, #70368744177664
	movk	x8, #16559, lsl #48
	fmov	d1, x8
	fcmp	d0, d1
	b.le	LBB0_56
; %bb.61:
	mov	w0, #0
	ldr	w8, [sp, #52]                   ; 4-byte Folded Reload
	scvtf	d0, w8
	add	w8, w27, w22
	scvtf	d1, w8
	fdiv	d0, d0, d1
	ldr	d1, [x19, #56]
	fmul	d0, d0, d1
	str	d0, [x19, #56]
	mov	w8, #1
	str	w8, [x19, #32]
	str	w8, [x19, #64]
	b	LBB0_40
LBB0_62:
	ldr	x27, [sp, #24]                  ; 8-byte Folded Reload
	ldr	w8, [x27, #8]
Lloh40:
	adrp	x9, _OPTS_TYPE_HOOK23@GOTPAGE
Lloh41:
	ldr	x9, [x9, _OPTS_TYPE_HOOK23@GOTPAGEOFF]
Lloh42:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_83
; %bb.63:
Lloh43:
	adrp	x8, _KERN_RUN_23@GOTPAGE
Lloh44:
	ldr	x8, [x8, _KERN_RUN_23@GOTPAGEOFF]
Lloh45:
	ldr	w2, [x8]
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	mov	w4, #0
	mov	w5, #0
	bl	_run_kernel
	cmn	w0, #1
	b.eq	LBB0_40
; %bb.64:
	ldr	w8, [x19, #4]
	cmp	w8, #1
	b.ne	LBB0_66
; %bb.65:
	ldp	w2, w1, [x19, #72]
	ldr	w3, [x19, #12]
	mov	x0, x20
	bl	_hc_cuMemcpyDtoH
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_66:
	ldr	w8, [x19, #8]
	cmp	w8, #1
	b.ne	LBB0_68
; %bb.67:
	ldr	w2, [x19, #68]
Lloh46:
	adrp	x8, _CL_TRUE@GOTPAGE
Lloh47:
	ldr	x8, [x8, _CL_TRUE@GOTPAGEOFF]
Lloh48:
	ldr	w3, [x8]
	ldr	w5, [x19, #12]
	ldp	w6, w1, [x19, #76]
	stp	xzr, xzr, [sp]
	mov	x0, x20
	mov	w4, #0
	mov	w7, #0
	bl	_hc_clEnqueueReadBuffer
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_68:
	ldr	x25, [x28, #24]
	mov	x0, x25
	mov	w1, #48
	bl	_hccalloc
	mov	x24, x0
	cmp	w25, #0
	b.le	LBB0_71
; %bb.69:
	and	x28, x25, #0xffffffff
	ldr	x8, [sp, #16]                   ; 8-byte Folded Reload
	ldr	w8, [x8, #8]
	cmp	x28, #4
	b.hs	LBB0_72
; %bb.70:
	mov	x9, #0
	ldp	x17, x16, [sp, #32]             ; 16-byte Folded Reload
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	b	LBB0_75
LBB0_71:
	mov	x0, x25
	mov	w1, #48
	bl	_calloc
	mov	x26, x0
	b	LBB0_79
LBB0_72:
	mov	x11, #0
	and	x10, x28, #0x3
	and	x9, x28, #0xfffffffc
	add	x12, x24, #184
	ldp	x17, x16, [sp, #32]             ; 16-byte Folded Reload
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
LBB0_73:                                ; =>This Inner Loop Header: Depth=1
	add	w13, w11, #1
	add	w14, w11, #2
	add	w15, w11, #3
	stp	w11, w25, [x12, #-184]
	stp	w13, w25, [x12, #-136]
	stp	w14, w25, [x12, #-88]
	stp	w15, w25, [x12, #-40]
	stp	x0, x17, [x12, #-152]
	stp	x0, x17, [x12, #-104]
	stp	x0, x17, [x12, #-56]
	stp	x0, x17, [x12, #-8]
	stur	x19, [x12, #-160]
	stur	x19, [x12, #-112]
	stur	x19, [x12, #-64]
	stur	x19, [x12, #-16]
	stp	w21, w8, [x12, #-172]
	stp	w21, w8, [x12, #-124]
	stp	w21, w8, [x12, #-76]
	stp	w21, w8, [x12, #-28]
	stur	w16, [x12, #-176]
	stur	w16, [x12, #-128]
	stur	w16, [x12, #-80]
	add	x11, x11, #4
	stur	w16, [x12, #-32]
	add	x12, x12, #192
	cmp	x9, x11
	b.ne	LBB0_73
; %bb.74:
	cbz	x10, LBB0_77
LBB0_75:
	mov	w10, #48
	madd	x10, x9, x10, x24
	add	x10, x10, #40
LBB0_76:                                ; =>This Inner Loop Header: Depth=1
	stp	w9, w25, [x10, #-40]
	stp	x0, x17, [x10, #-8]
	stur	x19, [x10, #-16]
	stp	w21, w8, [x10, #-28]
	add	x9, x9, #1
	stur	w16, [x10, #-32]
	add	x10, x10, #48
	cmp	x28, x9
	b.ne	LBB0_76
LBB0_77:
	mov	x0, x25
	mov	w1, #48
	bl	_calloc
	mov	x26, x0
	mov	x22, #0
Lloh49:
	adrp	x23, _hook23_thread@GOTPAGE
Lloh50:
	ldr	x23, [x23, _hook23_thread@GOTPAGEOFF]
LBB0_78:                                ; =>This Inner Loop Header: Depth=1
	add	x2, x24, x22
	ldr	w1, [x23]
	add	x8, x26, x22
	ldp	q0, q1, [x8]
	ldr	q2, [x8, #32]
	stp	q1, q2, [sp, #80]
	str	q0, [sp, #64]
	add	x0, sp, #64
	bl	_hc_thread_create
	add	x22, x22, #48
	subs	x28, x28, #1
	b.ne	LBB0_78
LBB0_79:
	mov	x0, x25
	mov	x1, x26
	bl	_hc_thread_wait
	mov	x0, x26
	bl	_hcfree
	mov	x0, x24
	bl	_hcfree
	ldr	w8, [x19, #4]
	cmp	w8, #1
	b.ne	LBB0_81
; %bb.80:
	ldp	w1, w2, [x19, #72]
	ldr	w3, [x19, #12]
	mov	x0, x20
	bl	_hc_cuMemcpyHtoD
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_81:
	ldr	w8, [x19, #8]
	cmp	w8, #1
	b.ne	LBB0_83
; %bb.82:
	ldr	w2, [x19, #68]
Lloh51:
	adrp	x8, _CL_TRUE@GOTPAGE
Lloh52:
	ldr	x8, [x8, _CL_TRUE@GOTPAGEOFF]
Lloh53:
	ldr	w3, [x8]
	ldr	w5, [x19, #12]
	ldp	w6, w1, [x19, #76]
	stp	xzr, xzr, [sp]
	mov	x0, x20
	mov	w4, #0
	mov	w7, #0
	bl	_hc_clEnqueueWriteBuffer
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_83:
	ldr	w8, [x27, #8]
Lloh54:
	adrp	x9, _OPTS_TYPE_INIT2@GOTPAGE
Lloh55:
	ldr	x9, [x9, _OPTS_TYPE_INIT2@GOTPAGEOFF]
Lloh56:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_86
; %bb.84:
Lloh57:
	adrp	x8, _KERN_RUN_INIT2@GOTPAGE
Lloh58:
	ldr	x8, [x8, _KERN_RUN_INIT2@GOTPAGEOFF]
Lloh59:
	ldr	w2, [x8]
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	mov	w4, #0
	mov	w5, #0
	bl	_run_kernel
	cmn	w0, #1
	ldp	x26, x24, [sp, #32]             ; 16-byte Folded Reload
	b.eq	LBB0_40
; %bb.85:
	ldr	w8, [x27, #8]
	b	LBB0_87
LBB0_86:
	ldp	x26, x24, [sp, #32]             ; 16-byte Folded Reload
LBB0_87:
	sxtw	x23, w24
Lloh60:
	adrp	x9, _OPTS_TYPE_LOOP2@GOTPAGE
Lloh61:
	ldr	x9, [x9, _OPTS_TYPE_LOOP2@GOTPAGEOFF]
Lloh62:
	ldr	w9, [x9]
	tst	w9, w8
	ldr	x25, [sp, #16]                  ; 8-byte Folded Reload
	b.eq	LBB0_94
; %bb.88:
	ldr	x9, [x25]
	mov	w10, #12
	madd	x9, x23, x10, x9
	ldr	w22, [x9, #4]
	cmp	w22, #1
	b.lt	LBB0_94
; %bb.89:
	mov	w24, #0
	mov	w28, #0
	ldr	w25, [x19, #16]
Lloh63:
	adrp	x27, _KERN_RUN_LOOP2@GOTPAGE
Lloh64:
	ldr	x27, [x27, _KERN_RUN_LOOP2@GOTPAGEOFF]
	mov	x26, x22
LBB0_90:                                ; =>This Inner Loop Header: Depth=1
	mov	x0, x26
	mov	x1, x25
	bl	_MIN
	ldr	x8, [x19, #24]
	stp	w28, w0, [x8, #112]
	ldr	w2, [x27]
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	mov	w4, #1
	mov	x5, x24
	bl	_run_kernel
	cmn	w0, #1
	b.eq	LBB0_40
; %bb.91:                               ;   in Loop: Header=BB0_90 Depth=1
	ldr	x8, [sp, #56]                   ; 8-byte Folded Reload
	ldr	w8, [x8]
	cbz	w8, LBB0_93
; %bb.92:                               ;   in Loop: Header=BB0_90 Depth=1
	add	w24, w24, #1
	sub	w26, w26, w25
	add	w28, w28, w25
	cmp	w22, w28
	b.gt	LBB0_90
LBB0_93:
	ldp	x25, x27, [sp, #16]             ; 16-byte Folded Reload
	ldr	w8, [x27, #8]
	ldp	x26, x24, [sp, #32]             ; 16-byte Folded Reload
LBB0_94:
Lloh65:
	adrp	x9, _OPTS_TYPE_DEEP_COMP_KERNEL@GOTPAGE
Lloh66:
	ldr	x9, [x9, _OPTS_TYPE_DEEP_COMP_KERNEL@GOTPAGEOFF]
Lloh67:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_99
; %bb.95:
	ldr	x8, [x25]
	mov	w9, #12
	madd	x8, x23, x9, x8
	ldr	w22, [x8, #8]
	cmp	w22, #1
	b.lt	LBB0_100
; %bb.96:
	mov	w23, #1
LBB0_97:                                ; =>This Inner Loop Header: Depth=1
	sub	w2, w23, #1
	ldr	x8, [x19, #24]
	stp	w2, w22, [x8, #112]
	ldr	x8, [x26]
	mov	x0, x25
	mov	x1, x24
	blr	x8
	mov	x2, x0
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	mov	w4, #0
	mov	w5, #0
	bl	_run_kernel
	cmn	w0, #1
	b.eq	LBB0_40
; %bb.98:                               ;   in Loop: Header=BB0_97 Depth=1
	ldr	x8, [sp, #56]                   ; 8-byte Folded Reload
	ldr	w8, [x8]
	cmp	w8, #0
	ccmp	w22, w23, #4, ne
	add	w23, w23, #1
	b.ne	LBB0_97
	b	LBB0_100
LBB0_99:
Lloh68:
	adrp	x8, _KERN_RUN_3@GOTPAGE
Lloh69:
	ldr	x8, [x8, _KERN_RUN_3@GOTPAGEOFF]
Lloh70:
	ldr	w2, [x8]
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	mov	w4, #0
	mov	w5, #0
	bl	_run_kernel
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_100:
	ldr	w8, [x27, #8]
Lloh71:
	adrp	x9, _OPTS_TYPE_HOOK12@GOTPAGE
Lloh72:
	ldr	x9, [x9, _OPTS_TYPE_HOOK12@GOTPAGEOFF]
Lloh73:
	ldr	w9, [x9]
	tst	w9, w8
	b.ne	LBB0_102
; %bb.101:
Lloh74:
	adrp	x9, _OPTS_TYPE_HOOK23@GOTPAGE
Lloh75:
	ldr	x9, [x9, _OPTS_TYPE_HOOK23@GOTPAGEOFF]
Lloh76:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_39
LBB0_102:
	ldr	w8, [x19, #4]
	cmp	w8, #1
	b.ne	LBB0_104
; %bb.103:
	ldr	w2, [x19, #72]
	ldr	w3, [x19, #12]
	mov	x0, x20
	mov	x1, x19
	bl	_run_cuda_kernel_bzero
	cmn	w0, #1
	b.eq	LBB0_40
LBB0_104:
	ldr	w8, [x19, #8]
	cmp	w8, #1
	b.ne	LBB0_39
; %bb.105:
	ldr	w2, [x19, #68]
	ldr	w3, [x19, #12]
	mov	x0, x20
	mov	x1, x19
	bl	_run_opencl_kernel_bzero
	cmn	w0, #1
	b.ne	LBB0_39
	b	LBB0_40
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.loh AdrpLdrGotLdr	Lloh3, Lloh4, Lloh5
	.loh AdrpLdrGotLdr	Lloh6, Lloh7, Lloh8
	.loh AdrpLdrGotLdr	Lloh9, Lloh10, Lloh11
	.loh AdrpLdrGot	Lloh12, Lloh13
	.loh AdrpLdrGotLdr	Lloh14, Lloh15, Lloh16
	.loh AdrpLdrGotLdr	Lloh17, Lloh18, Lloh19
	.loh AdrpLdrGotLdr	Lloh20, Lloh21, Lloh22
	.loh AdrpLdrGotLdr	Lloh23, Lloh24, Lloh25
	.loh AdrpLdrGot	Lloh26, Lloh27
	.loh AdrpLdrGot	Lloh28, Lloh29
	.loh AdrpLdrGot	Lloh30, Lloh31
	.loh AdrpLdrGot	Lloh32, Lloh33
	.loh AdrpLdrGotLdr	Lloh34, Lloh35, Lloh36
	.loh AdrpLdrGotLdr	Lloh37, Lloh38, Lloh39
	.loh AdrpLdrGotLdr	Lloh40, Lloh41, Lloh42
	.loh AdrpLdrGotLdr	Lloh43, Lloh44, Lloh45
	.loh AdrpLdrGotLdr	Lloh46, Lloh47, Lloh48
	.loh AdrpLdrGot	Lloh49, Lloh50
	.loh AdrpLdrGotLdr	Lloh51, Lloh52, Lloh53
	.loh AdrpLdrGotLdr	Lloh54, Lloh55, Lloh56
	.loh AdrpLdrGotLdr	Lloh57, Lloh58, Lloh59
	.loh AdrpLdrGotLdr	Lloh60, Lloh61, Lloh62
	.loh AdrpLdrGot	Lloh63, Lloh64
	.loh AdrpLdrGotLdr	Lloh65, Lloh66, Lloh67
	.loh AdrpLdrGotLdr	Lloh68, Lloh69, Lloh70
	.loh AdrpLdrGotLdr	Lloh71, Lloh72, Lloh73
	.loh AdrpLdrGotLdr	Lloh74, Lloh75, Lloh76
	.cfi_endproc
                                        ; -- End function
	.comm	_ATTACK_EXEC_INSIDE_KERNEL,8,3  ; @ATTACK_EXEC_INSIDE_KERNEL
	.comm	_ATTACK_MODE_BF,8,3             ; @ATTACK_MODE_BF
	.comm	_OPTS_TYPE_PT_BITSLICE,4,2      ; @OPTS_TYPE_PT_BITSLICE
	.comm	_OPTI_TYPE_OPTIMIZED_KERNEL,4,2 ; @OPTI_TYPE_OPTIMIZED_KERNEL
	.comm	_KERN_RUN_1,4,2                 ; @KERN_RUN_1
	.comm	_KERN_RUN_2,4,2                 ; @KERN_RUN_2
	.comm	_KERN_RUN_3,4,2                 ; @KERN_RUN_3
	.comm	_KERN_RUN_4,4,2                 ; @KERN_RUN_4
	.comm	_OPTS_TYPE_HOOK12,4,2           ; @OPTS_TYPE_HOOK12
	.comm	_KERN_RUN_12,4,2                ; @KERN_RUN_12
	.comm	_CL_TRUE,4,2                    ; @CL_TRUE
	.comm	_hook12_thread,4,2              ; @hook12_thread
	.comm	_OPTS_TYPE_HOOK23,4,2           ; @OPTS_TYPE_HOOK23
	.comm	_KERN_RUN_23,4,2                ; @KERN_RUN_23
	.comm	_hook23_thread,4,2              ; @hook23_thread
	.comm	_OPTS_TYPE_INIT2,4,2            ; @OPTS_TYPE_INIT2
	.comm	_KERN_RUN_INIT2,4,2             ; @KERN_RUN_INIT2
	.comm	_OPTS_TYPE_LOOP2,4,2            ; @OPTS_TYPE_LOOP2
	.comm	_KERN_RUN_LOOP2,4,2             ; @KERN_RUN_LOOP2
	.comm	_OPTS_TYPE_DEEP_COMP_KERNEL,4,2 ; @OPTS_TYPE_DEEP_COMP_KERNEL
.subsections_via_symbols
