LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_insert_stran_spill_imm
void subtilis_vfp_insert_stran_spill_imm(subtilis_arm_section_t *s,
					 subtilis_arm_op_t *current,
					 subtilis_arm_instr_type_t itype,
					 subtilis_arm_ccode_type_t ccode,
					 subtilis_arm_reg_t dest,
					 subtilis_arm_reg_t base,
					 subtilis_arm_reg_t spill_reg,
					 int32_t offset, subtilis_error_t *err)
/* clang-format on */
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_stran_instr_t *stran;
	subtilis_arm_data_instr_t *datai;

	(void)subtilis_arm_insert_data_imm_ldr(s, current, ccode, spill_reg,
					       offset, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr = subtilis_arm_section_insert_instr(s, current,
						  SUBTILIS_ARM_INSTR_ADD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	datai = &instr->operands.data;
	datai->ccode = ccode;
	datai->status = false;
	datai->dest = spill_reg;
	datai->op1 = spill_reg;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = base;

	instr = subtilis_arm_section_insert_instr(s, current, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.vfp_stran;
	stran->ccode = ccode;
	stran->dest = dest;
	stran->base = spill_reg;
	stran->offset = 0;
	stran->pre_indexed = false;
	stran->write_back = false;
	stran->subtract = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movq 0x10(%rbp), %rcx
movl 0x18(%rbp), %r8d
movq 0x20(%rbp), %r9
callq 0x71060
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x88163
jmp 0x88247
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x20(%rbp), %rcx
movl $0x4, %edx
callq 0x70bc0
movq %rax, -0x30(%rbp)
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8818b
jmp 0x88247
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x18(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x4(%rax)
movq 0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq 0x20(%rbp), %rcx
callq 0x70bc0
movq %rax, -0x30(%rbp)
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x881fa
jmp 0x88247
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x19(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x1a(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x1b(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_insert_stran_imm
void subtilis_vfp_insert_stran_imm(subtilis_arm_section_t *s,
				   subtilis_arm_op_t *current,
				   subtilis_arm_instr_type_t itype,
				   subtilis_arm_ccode_type_t ccode,
				   subtilis_arm_reg_t dest,
				   subtilis_arm_reg_t base, int32_t offset,
				   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_stran_instr_t *stran;
	bool subtract = false;

	if (offset < 0) {
		offset = -offset;
		subtract = true;
	}

	if (offset > 1023) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	instr = subtilis_arm_section_insert_instr(s, current, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	stran = &instr->operands.vfp_stran;
	stran->ccode = ccode;
	stran->dest = dest;
	stran->base = base;
	stran->offset = (uint8_t)((uint32_t)offset / 4);
	stran->pre_indexed = true;
	stran->write_back = false;
	stran->subtract = subtract;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movb $0x0, -0x39(%rbp)
cmpl $0x0, 0x10(%rbp)
jge 0x8828b
xorl %eax, %eax
subl 0x10(%rbp), %eax
movl %eax, 0x10(%rbp)
movb $0x1, -0x39(%rbp)
cmpl $0x3ff, 0x10(%rbp)      # imm = 0x3FF
jle 0x882b0
movq 0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x255fd(%rip), %rdx     # 0xad8a1
movl $0xb1, %ecx
callq 0x158e0
jmp 0x8832c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq 0x18(%rbp), %rcx
callq 0x70bc0
movq %rax, -0x30(%rbp)
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x882d3
jmp 0x8832c
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movl 0x10(%rbp), %eax
shrl $0x2, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x19(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x1a(%rax)
movb -0x39(%rbp), %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x1b(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_tran
void subtilis_vfp_add_tran(subtilis_arm_section_t *s,
			   subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode, bool use_dregs,
			   subtilis_arm_reg_t dest, subtilis_arm_reg_t src,
			   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_tran_instr_t *tran;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	tran = &instr->operands.vfp_tran;
	tran->ccode = ccode;
	tran->use_dregs = use_dregs;
	tran->dest = dest;
	tran->src = src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq 0x10(%rbp), %rcx
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x10(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x88384
jmp 0x883be
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movb -0x11(%rbp), %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_cmpz
void subtilis_vfp_add_cmpz(subtilis_arm_section_t *s,
			   subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_arm_reg_t op1, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_cmp_instr_t *cmp;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	cmp = &instr->operands.vfp_cmp;
	cmp->ccode = ccode;
	cmp->op1 = op1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x70b50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x88589
jmp 0x885aa
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_sysreg
void subtilis_vfp_add_sysreg(subtilis_arm_section_t *s,
			     subtilis_arm_instr_type_t itype,
			     subtilis_arm_ccode_type_t ccode,
			     subtilis_vfp_sysreg_t sysreg,
			     subtilis_arm_reg_t reg, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_sysreg_instr_t *sysregi;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	sysregi = &instr->operands.vfp_sysreg;
	sysregi->ccode = ccode;
	sysregi->sysreg = sysreg;
	sysregi->arm_reg = reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8865c
jmp 0x88687
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/vfp.c
// Function: subtilis_vfp_add_tran_dbl
void subtilis_vfp_add_tran_dbl(subtilis_arm_section_t *s,
			       subtilis_arm_instr_type_t itype,
			       subtilis_arm_ccode_type_t ccode,
			       subtilis_arm_reg_t dest1,
			       subtilis_arm_reg_t dest2,
			       subtilis_arm_reg_t src1, subtilis_arm_reg_t src2,
			       subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_vfp_tran_dbl_instr_t *tran;

	instr = subtilis_arm_section_add_instr(s, itype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	tran = &instr->operands.vfp_tran_dbl;
	tran->ccode = ccode;
	tran->dest1 = dest1;
	tran->dest2 = dest2;
	tran->src1 = src1;
	tran->src2 = src2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x18(%rbp), %rdx
callq 0x70b50
movq %rax, -0x30(%rbp)
movq 0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x886d5
jmp 0x8871a
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_reset
void subtilis_bitset_reset(subtilis_bitset_t *bs)
{
	size_t i;

	bs->max_value = -1;

	for (i = 0; i < bs->allocated; i++)
		bs->bits[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x88809
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x887db
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_set
void subtilis_bitset_set(subtilis_bitset_t *bs, size_t bit,
			 subtilis_error_t *err)
{
	size_t cell;
	size_t offset;

	if (bit > INT_MAX) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	prv_ensure(bs, bit, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	cell = bit / (sizeof(unsigned int) * 8);
	offset = bit - (cell * (sizeof(unsigned int) * 8));
	bs->bits[cell] |= 1 << offset;
	if ((int)bit > bs->max_value)
		bs->max_value = (int)bit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x7fffffff, -0x10(%rbp) # imm = 0x7FFFFFFF
jbe 0x8884a
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x25074(%rip), %rdx     # 0xad8b2
movl $0x42, %ecx
callq 0x158e0
jmp 0x888bd
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x888d0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x88866
jmp 0x888bd
movq -0x10(%rbp), %rax
shrq $0x5, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x5, %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x888bd
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: prv_ensure
static void prv_ensure(subtilis_bitset_t *bs, size_t bit, subtilis_error_t *err)
{
	unsigned int *new_bits;
	size_t needed = (bit / (sizeof(unsigned int) * 8)) + 1;

	if (needed <= bs->allocated)
		return;

	new_bits = realloc(bs->bits, needed * sizeof(unsigned int));
	if (!new_bits) {
		subtilis_error_set_oom(err);
		return;
	}
	bs->bits = new_bits;
	memset(&bs->bits[bs->allocated], 0,
	       sizeof(unsigned int) * (needed - bs->allocated));
	bs->allocated = needed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq $0x5, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x88904
jmp 0x88983
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
shlq $0x2, %rsi
callq 0x121e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8893f
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x24f7f(%rip), %rdx     # 0xad8b2
movl $0x32, %ecx
callq 0x158e0
jmp 0x88983
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
subq 0x10(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x12110
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_isset
bool subtilis_bitset_isset(subtilis_bitset_t *bs, size_t bit)
{
	size_t cell;
	size_t offset;

	if (!bs->bits || bit > INT_MAX || ((int)bit) > bs->max_value)
		return false;

	cell = bit / (sizeof(unsigned int) * 8);
	offset = bit - (cell * (sizeof(unsigned int) * 8));
	return (bs->bits[cell] & (1 << offset)) != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x889bd
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
ja 0x889bd
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x889c3
movb $0x0, -0x1(%rbp)
jmp 0x88a0a
movq -0x18(%rbp), %rax
shrq $0x5, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x5, %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x28(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_clear
void subtilis_bitset_clear(subtilis_bitset_t *bs, size_t bit)
{
	size_t cell;
	size_t offset;

	if (bit > bs->max_value)
		return;

	cell = bit / (sizeof(unsigned int) * 8);
	offset = bit - (cell * (sizeof(unsigned int) * 8));
	bs->bits[cell] &= ~((unsigned int)(1 << offset));
	if (bit == (size_t)bs->max_value)
		prv_set_max(bs, cell);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
jbe 0x88a43
jmp 0x88aa1
movq -0x10(%rbp), %rax
shrq $0x5, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movl $0x1, %edx
shll %cl, %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
andl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
jne 0x88aa1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x88ab0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: prv_set_max
static void prv_set_max(subtilis_bitset_t *bs, size_t block)
{
	size_t i;
	size_t byte;
	unsigned int mask;

	do {
		if (bs->bits[block] != 0)
			break;
		if (block == 0) {
			bs->max_value = -1;
			return;
		}
		block--;
	} while (true);

	byte = sizeof(unsigned int);
	while (byte > 0) {
		byte--;
		mask = 0xff << (byte * 8);
		if (mask & bs->bits[block])
			break;
	}

	i = 8;
	while (i > 0) {
		i--;
		mask = 1 << (i + (byte * 8));
		if (mask & bs->bits[block])
			break;
	}
	bs->max_value = (block * sizeof(unsigned int) * 8) + (byte * 8) + i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x88acf
jmp 0x88afa
cmpq $0x0, -0x10(%rbp)
jne 0x88ae6
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
jmp 0x88bb7
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x88abc
jmp 0x88afa
movq $0x4, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x88b43
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shlq $0x3, %rax
movl %eax, %ecx
movl $0xff, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
andl (%rcx,%rdx,4), %eax
cmpl $0x0, %eax
je 0x88b41
jmp 0x88b43
jmp 0x88b02
movq $0x8, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x88b93
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
andl (%rcx,%rdx,4), %eax
cmpl $0x0, %eax
je 0x88b91
jmp 0x88b93
jmp 0x88b4b
movq -0x10(%rbp), %rax
shlq $0x2, %rax
shlq $0x3, %rax
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_and
void subtilis_bitset_and(subtilis_bitset_t *bs, subtilis_bitset_t *bs1)
{
	size_t i;
	size_t limit;

	if (bs->max_value < 0)
		return;

	if (bs1->max_value < bs->max_value)
		bs->max_value = bs1->max_value;

	if (bs->max_value >= 0 && bs1->max_value >= 0)
		limit = (bs->max_value / (sizeof(unsigned int) * 8)) + 1;
	else
		limit = 0;

	for (i = 0; i < limit; i++)
		bs->bits[i] &= bs1->bits[i];

	for (i = limit; i < bs->allocated; i++)
		bs->bits[i] = 0;

	if (limit > 0)
		prv_set_max(bs, limit - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x88bdf
jmp 0x88cbc
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x88bfd
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jl 0x88c27
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jl 0x88c27
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
shrq $0x5, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x88c2f
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x88c6e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
andl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x88c37
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x88ca4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x88c76
cmpq $0x0, -0x20(%rbp)
jbe 0x88cbc
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq $0x1, %rsi
callq 0x88ab0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_or
void subtilis_bitset_or(subtilis_bitset_t *bs, subtilis_bitset_t *bs1,
			subtilis_error_t *err)
{
	size_t i;
	size_t limit;

	if (bs1->max_value < 0)
		return;

	prv_ensure(bs, bs1->max_value, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	limit = (bs1->max_value / (sizeof(unsigned int) * 8)) + 1;
	for (i = 0; i < limit; i++)
		bs->bits[i] |= bs1->bits[i];

	if (bs->max_value < bs1->max_value)
		bs->max_value = bs1->max_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x88cf3
jmp 0x88d84
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x888d0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x88d13
jmp 0x88d84
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rax
shrq $0x5, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x88d66
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x88d2f
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x88d84
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_not
void subtilis_bitset_not(subtilis_bitset_t *bs)
{
	size_t limit;
	size_t bits_left;
	size_t i;

	if (bs->max_value < 0)
		return;

	limit = (bs->max_value / (sizeof(unsigned int) * 8));
	for (i = 0; i < limit; i++)
		bs->bits[i] = ~bs->bits[i];

	bits_left = bs->max_value - (limit * sizeof(unsigned int) * 8);
	bs->bits[i] = ~bs->bits[i] & ((1u << bits_left) - 1);
	prv_set_max(bs, limit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x88dab
jmp 0x88e53
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
shrq $0x5, %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x88dfa
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x88dc3
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x2, %rcx
shlq $0x3, %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
xorl $-0x1, %edx
movq -0x18(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
andl %eax, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x88ab0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_sub
void subtilis_bitset_sub(subtilis_bitset_t *bs, subtilis_bitset_t *bs1)
{
	size_t i;
	int min_max_value;
	size_t limit;

	min_max_value =
	    bs->max_value <= bs1->max_value ? bs->max_value : bs1->max_value;

	if (min_max_value < 0)
		return;

	limit = (min_max_value / (sizeof(unsigned int) * 8));

	for (i = 0; i < limit; i++)
		bs->bits[i] &= ~bs1->bits[i];
	bs->bits[i] &= ~bs1->bits[i];
	if (bs->max_value <= bs1->max_value)
		prv_set_max(bs, limit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jg 0x88e8c
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x88e96
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x88ea7
jmp 0x88f34
movslq -0x1c(%rbp), %rax
shrq $0x5, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x88ef5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
andl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x88ebb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
andl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jg 0x88f34
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x88ab0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_dump
void subtilis_bitset_dump(subtilis_bitset_t *bs)
{
	size_t i;

	if (bs->max_value >= 0) {
		for (i = 0; i <= bs->max_value; i++) {
			if (subtilis_bitset_isset(bs, i))
				printf("%zu ", i);
		}
	}
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jl 0x88fa6
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
ja 0x88fa4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x88990
testb $0x1, %al
jne 0x88f82
jmp 0x88f94
movq -0x10(%rbp), %rsi
leaq 0x24935(%rip), %rdi     # 0xad8c2
movb $0x0, %al
callq 0x120f0
jmp 0x88f96
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x88f5e
jmp 0x88fa6
leaq 0x21ec6(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_claim
void subtilis_bitset_claim(subtilis_bitset_t *dst, subtilis_bitset_t *src)
{
	subtilis_bitset_free(dst);
	dst->bits = src->bits;
	dst->max_value = src->max_value;
	dst->allocated = src->allocated;
	subtilis_bitset_init(src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x89020
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x88790
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_count
size_t subtilis_bitset_count(subtilis_bitset_t *bs)
{
	size_t i;
	size_t count = 0;

	if (bs->max_value >= 0) {
		for (i = 0; i <= bs->max_value; i++) {
			if (subtilis_bitset_isset(bs, i))
				++count;
		}
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jl 0x890a8
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
ja 0x890a6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x88990
testb $0x1, %al
jne 0x8908a
jmp 0x89096
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x89098
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x89066
jmp 0x890a8
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/bitset.c
// Function: subtilis_bitset_values
size_t *subtilis_bitset_values(subtilis_bitset_t *bs, size_t *count,
			       subtilis_error_t *err)
{
	size_t i;
	size_t j;
	size_t *vals = NULL;
	size_t cnt = subtilis_bitset_count(bs);

	if (cnt > 0) {
		vals = malloc(cnt * sizeof(size_t));
		if (!vals) {
			subtilis_error_set_oom(err);
			return NULL;
		}

		j = 0;
		for (i = 0; i <= bs->max_value; i++) {
			if (subtilis_bitset_isset(bs, i))
				vals[j++] = i;
		}
	}

	*count = cnt;

	return vals;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x89040
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jbe 0x89191
movq -0x40(%rbp), %rdi
shlq $0x3, %rdi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x89130
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x24796(%rip), %rdx     # 0xad8b2
movl $0x117, %ecx            # imm = 0x117
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x891a4
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
ja 0x8918f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x88990
testb $0x1, %al
jne 0x89164
jmp 0x8917f
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x89181
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x89140
jmp 0x89191
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_sub_section.c
// Function: subtilis_arm_subsections_init
void subtilis_arm_subsections_init(subtilis_arm_subsections_t *sss)
{
	sss->sub_sections = NULL;
	sss->count = 0;
	sss->max_count = 0;
	sss->ss_link_map = NULL;
	sss->link_count = 0;
	sss->max_links = 0;
	subtilis_bitset_init(&sss->int_save);
	subtilis_bitset_init(&sss->real_save);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x88790
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x88790
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_sub_section.c
// Function: prv_add_new_sub_section
static size_t prv_add_new_sub_section(subtilis_arm_subsections_t *sss,
				      subtilis_arm_section_t *arm_s,
				      size_t start, subtilis_error_t *err)
{
	subtilis_arm_ss_t *ss;
	size_t new_max;
	subtilis_arm_ss_t *new_ss;
	size_t ptr;

	if (sss->count == sss->max_count) {
		new_max = sss->max_count + SUBTILIS_CONFIG_SSS_GRAN;
		new_ss = realloc(sss->sub_sections,
				 new_max * sizeof(*sss->sub_sections));
		if (!new_ss) {
			subtilis_error_set_oom(err);
			return SIZE_MAX;
		}
		sss->sub_sections = new_ss;
		sss->max_count = new_max;
	}

	ptr = sss->count;
	ss = &sss->sub_sections[sss->count++];
	memset(ss, 0, sizeof(*ss));

	subtilis_bitset_init(&ss->int_inputs);
	subtilis_bitset_init(&ss->real_inputs);
	ss->start = start;
	ss->end = 0;
	ss->num_links = 0;

	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x895c7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
imulq $0x130, -0x38(%rbp), %rsi # imm = 0x130
callq 0x121e0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x895b0
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x2432e(%rip), %rdx     # 0xad8c7
movl $0x31, %ecx
callq 0x158e0
movq $-0x1, -0x8(%rbp)
jmp 0x89654
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
imulq $0x130, %rcx, %rcx      # imm = 0x130
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x130, %edx            # imm = 0x130
callq 0x12110
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x88790
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x88790
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x128(%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_sub_section.c
// Function: prv_sss_link_map_insert
static void prv_sss_link_map_insert(subtilis_arm_subsections_t *sss,
				    size_t ss_ptr, size_t label,
				    subtilis_error_t *err)
{
	size_t new_max;
	size_t i;
	size_t *new_link_map;

	if (label >= sss->max_links) {
		new_max = label + SUBTILIS_CONFIG_SSS_GRAN;
		new_link_map =
		    realloc(sss->ss_link_map, new_max * sizeof(size_t));
		if (!new_link_map) {
			subtilis_error_set_oom(err);
			return;
		}
		for (i = sss->max_links; i < new_max; i++)
			new_link_map[i] = SIZE_MAX;
		sss->ss_link_map = new_link_map;
		sss->max_links = new_max;
	}
	sss->ss_link_map[label] = ss_ptr;
	if (label >= sss->link_count)
		sss->link_count = label + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x8988e
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rsi
shlq $0x3, %rsi
callq 0x121e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x89842
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x24091(%rip), %rdx     # 0xad8c7
movl $0x52, %ecx
callq 0x158e0
jmp 0x898c0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x89876
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq $-0x1, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8984e
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x898c0
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_sub_section.c
// Function: prv_add_args
static void prv_add_args(subtilis_arm_ss_t *ss, subtilis_arm_section_t *arm_s,
			 subtilis_error_t *err)
{
	size_t i;
	size_t j;
	subtilis_arm_ss_link_t *link;

	for (j = 0; j < ss->num_links; j++) {
		link = &ss->links[j];
		for (i = 0; i < arm_s->stype->int_regs; i++) {
			subtilis_bitset_set(&link->int_outputs,
					    SUBTILIS_ARM_INT_VIRT_REG_START + i,
					    err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
		for (i = 0; i < arm_s->stype->fp_regs; i++) {
			subtilis_bitset_set(&link->real_outputs,
					    arm_s->fp_if->max_regs + i, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x128(%rcx), %rax
jae 0x89bb9
movq -0x8(%rbp), %rax
addq $0x48, %rax
imulq $0x70, -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xa0(%rcx), %rcx
cmpq 0x158(%rcx), %rax
jae 0x89b48
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rdx
callq 0x88810
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x89b38
jmp 0x89bb9
jmp 0x89b3a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x89afd
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xa0(%rcx), %rcx
cmpq 0x160(%rcx), %rax
jae 0x89ba6
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq (%rax), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x88810
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x89b96
jmp 0x89bb9
jmp 0x89b98
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x89b50
jmp 0x89ba8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x89acc
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_sub_section.c
// Function: prv_compute_must_save
static void prv_compute_must_save(subtilis_arm_subsections_t *sss,
				  subtilis_error_t *err)
{
	size_t i;
	size_t j;
	subtilis_arm_ss_t *ss;

	for (i = 0; i < sss->count; i++) {
		ss = &sss->sub_sections[i];
		for (j = 0; j < ss->num_links; j++) {
			prv_link_must_save(sss, ss, j, err);
			if (err->type != SUBTILIS_ERROR_OK)
				return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x89c55
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x130, -0x18(%rbp), %rcx # imm = 0x130
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x128(%rcx), %rax
jae 0x89c45
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x8a470
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x89c35
jmp 0x89c55
jmp 0x89c37
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x89c04
jmp 0x89c47
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x89bd8
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_sub_section.c
// Function: subtilis_arm_subsections_free
void subtilis_arm_subsections_free(subtilis_arm_subsections_t *sss)
{
	size_t i;

	subtilis_bitset_free(&sss->int_save);
	subtilis_bitset_free(&sss->real_save);

	free(sss->ss_link_map);
	if (!sss->sub_sections)
		return;

	for (i = 0; i < sss->count; i++)
		prv_free_sub_section(&sss->sub_sections[i]);
	free(sss->sub_sections);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x89020
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x89020
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x89c9f
jmp 0x89ce6
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x89cda
movq -0x8(%rbp), %rax
movq (%rax), %rdi
imulq $0x130, -0x10(%rbp), %rax # imm = 0x130
addq %rax, %rdi
callq 0x89cf0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x89ca7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_sub_section.c
// Function: prv_free_sub_section
static void prv_free_sub_section(subtilis_arm_ss_t *ss)
{
	size_t i;

	for (i = 0; i < ss->num_links; i++) {
		subtilis_bitset_free(&ss->links[i].int_outputs);
		subtilis_bitset_free(&ss->links[i].real_outputs);
		subtilis_bitset_free(&ss->links[i].int_save);
		subtilis_bitset_free(&ss->links[i].real_save);
	}
	subtilis_bitset_free(&ss->int_inputs);
	subtilis_bitset_free(&ss->real_inputs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x128(%rcx), %rax
jae 0x89d83
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
imulq $0x70, -0x10(%rbp), %rax
addq %rax, %rdi
callq 0x89020
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
imulq $0x70, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x18, %rdi
callq 0x89020
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
imulq $0x70, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x30, %rdi
callq 0x89020
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
imulq $0x70, -0x10(%rbp), %rax
addq %rax, %rdi
addq $0x48, %rdi
callq 0x89020
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x89d04
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x89020
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x89020
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_sub_section.c
// Function: subtilis_arm_subsections_must_save
void subtilis_arm_subsections_must_save(subtilis_arm_subsections_t *sss,
					subtilis_arm_ss_t *ss, size_t link,
					subtilis_bitset_t *int_save,
					subtilis_bitset_t *real_save,
					subtilis_error_t *err)
{
	subtilis_bitset_t visited;
	subtilis_arm_ss_link_t *start;
	subtilis_arm_ss_t *next;

	if (link >= ss->num_links) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	subtilis_bitset_init(&visited);

	start = &ss->links[link];
	if (start->link >= sss->link_count) {
		subtilis_error_set_assertion_failed(err);
		goto cleanup;
	}

	subtilis_bitset_set(&visited, start->link, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	next = &sss->sub_sections[sss->ss_link_map[start->link]];
	prv_visit_subsection(sss, next, start, int_save, real_save, &visited,
			     err);

cleanup:

	subtilis_bitset_free(&visited);

	subtilis_bitset_free(&sss->int_save);
	subtilis_bitset_free(&sss->real_save);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x128(%rcx), %rax
jb 0x89e00
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x23ad6(%rip), %rdx     # 0xad8c7
movl $0x1ee, %ecx            # imm = 0x1EE
callq 0x158e0
jmp 0x89ed9
leaq -0x48(%rbp), %rdi
callq 0x88790
movq -0x10(%rbp), %rax
addq $0x48, %rax
imulq $0x70, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x89e4b
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x23a88(%rip), %rdx     # 0xad8c7
movl $0x1f6, %ecx            # imm = 0x1F6
callq 0x158e0
jmp 0x89eb6
movq -0x50(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x30(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x88810
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x89e6b
jmp 0x89eb6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq -0x50(%rbp), %rdx
movq 0x60(%rdx), %rdx
imulq $0x130, (%rcx,%rdx,8), %rcx # imm = 0x130
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %rax
leaq -0x48(%rbp), %r9
movq %rax, (%rsp)
callq 0x89ee0
leaq -0x48(%rbp), %rdi
callq 0x89020
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x89020
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x89020
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_peephole.c
// Function: prv_remove_op
static size_t prv_remove_op(subtilis_arm_section_t *arm_s, size_t ptr,
			    subtilis_arm_op_t *op)
{
	size_t next;
	size_t prev;

	if (arm_s->first_op == arm_s->last_op) {
		arm_s->first_op = SIZE_MAX;
		arm_s->last_op = SIZE_MAX;
		return SIZE_MAX;
	}

	if (arm_s->first_op == ptr) {
		arm_s->first_op = op->next;
		return op->next;
	}

	if (arm_s->last_op == ptr) {
		arm_s->last_op = op->prev;
		return SIZE_MAX;
	}

	next = op->next;
	prev = op->prev;
	arm_s->op_pool->ops[prev].next = next;
	arm_s->op_pool->ops[next].prev = prev;
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x8a847
movq -0x10(%rbp), %rax
movq $-0x1, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x28(%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x8a8f1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x8a873
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8a8f1
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x8a89b
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x8a8f1
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
imulq $0x68, -0x30(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x58(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
imulq $0x68, -0x28(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_mem.c
// Function: subtilis_arm_mem_memseti32
void subtilis_arm_mem_memseti32(subtilis_ir_section_t *s,
				subtilis_arm_section_t *arm_s,
				subtilis_error_t *err)
{
	const size_t base_reg = 0;
	const size_t size_reg = 1;
	const size_t end_reg = 11;
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_ADD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &instr->operands.data;
	datai->status = false;
	datai->ccode = SUBTILIS_ARM_CCODE_AL;
	datai->dest = end_reg;
	datai->op1 = base_reg;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = size_reg;

	prv_memseti32_core(s, arm_s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, 15, 14,
				 err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq $0xb, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x4, %esi
callq 0x70b50
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8a950
jmp 0x8a9e2
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x40(%rbp), %rax
movl $0xe, (%rax)
movq -0x40(%rbp), %rax
movq $0xb, 0x8(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x40(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x40(%rbp), %rax
movq $0x1, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8a9f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8a9b9
jmp 0x8a9e2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movl $0xf, %r8d
movl $0xe, %r9d
movq %rax, (%rsp)
callq 0x71fa0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)