LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/vfp_alloc.c
// Function: prv_alloc_vfp_copy_instr
static void prv_alloc_vfp_copy_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_vfp_copy_instr_t *instr,
				     subtilis_error_t *err)
{
	int dist_src;
	size_t vreg_src;

	subtilis_arm_reg_ud_t *ud = user_data;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FCPYS:
	case SUBTILIS_VFP_INSTR_FNEGS:
	case SUBTILIS_VFP_INSTR_FABSS:
		subtilis_error_set_assertion_failed(err);
		return;
	default:
		break;
	}

	vreg_src = instr->src;
	(void)subtilis_arm_reg_alloc_ensure(ud, op, ud->int_regs, ud->real_regs,
					    &instr->src, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	dist_src = subtilis_arm_reg_alloc_calculate_dist(
	    ud, vreg_src, op, &ud->real_regs->dist_walker, ud->real_regs);
	if (dist_src == -1)
		ud->real_regs->phys_to_virt[instr->src] = INT_MAX;

	subtilis_arm_reg_alloc_alloc_fp_dest(ud, op, &instr->dest, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/* Need to check for useless moves */

	if ((type != SUBTILIS_VFP_INSTR_FCPYD) || (instr->src != instr->dest))
		ud->real_regs->next[instr->src] = dist_src;

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %rbx
leal -0x4a(%r15), %eax
cmpl $0x4, %eax
ja 0x6c0dc
movl $0x15, %ecx
btl %eax, %ecx
jae 0x6c0dc
leaq 0xafbe(%rip), %rdx      # 0x7707a
movq %r12, %rdi
movl $0xf, %esi
movl $0xa3, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x135b4
leaq 0x10(%r14), %r8
movq 0x10(%r14), %rbp
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %r8, (%rsp)
movq %r12, %r9
callq 0x51fe8
cmpl $0x0, (%r12)
jne 0x6c179
movq 0x10(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x51d8c
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x6c13c
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
movq (%rcx), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
addq $0x8, %r14
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x52297
cmpl $0x0, (%r12)
jne 0x6c179
movq (%rsp), %rax
movq (%rax), %rax
cmpl $0x4b, %r15d
jne 0x6c16a
cmpq (%r14), %rax
je 0x6c175
movq 0x10(%rbx), %rcx
movq 0x10(%rcx), %rcx
movl %ebp, (%rcx,%rax,4)
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/vfp_alloc.c
// Function: prv_alloc_vfp_tran_instr
static void prv_alloc_vfp_tran_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_vfp_tran_instr_t *instr,
				     subtilis_error_t *err)
{
	size_t vreg_src;
	int dist_src;
	subtilis_arm_reg_ud_t *ud = user_data;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FTOSIS:
	case SUBTILIS_VFP_INSTR_FTOUIS:
	case SUBTILIS_VFP_INSTR_FTOUIZS:
	case SUBTILIS_VFP_INSTR_FTOSIZS:
	case SUBTILIS_VFP_INSTR_FSITOS:
	case SUBTILIS_VFP_INSTR_FUITOS:
		subtilis_error_set_assertion_failed(err);
		break;
	default:
		break;
	}

	if (!instr->use_dregs) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	vreg_src = instr->src;
	(void)subtilis_arm_reg_alloc_ensure(ud, op, ud->int_regs, ud->real_regs,
					    &instr->src, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	dist_src = subtilis_arm_reg_alloc_calculate_dist(
	    ud, vreg_src, op, &ud->real_regs->dist_walker, ud->real_regs);
	if (dist_src == -1)
		ud->real_regs->phys_to_virt[instr->src] = INT_MAX;

	subtilis_arm_reg_alloc_alloc_fp_dest(ud, op, &instr->dest, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	ud->real_regs->next[instr->src] = dist_src;

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
addl $-0x52, %edx
cmpl $0xa, %edx
ja 0x6c1f2
movl $0x4ab, %eax            # imm = 0x4AB
btl %edx, %eax
jae 0x6c1f2
leaq 0xae9a(%rip), %rdx      # 0x7707a
movq %r14, %rdi
movl $0xf, %esi
movl $0xdd, %ecx
callq 0x135b4
cmpb $0x0, 0x4(%r15)
je 0x6c295
leaq 0x10(%r15), %r13
movq 0x10(%r15), %rbp
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %r8
movq %r14, %r9
callq 0x51fe8
cmpl $0x0, (%r14)
jne 0x6c286
movq 0x10(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x51d8c
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x6c258
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
movq (%r13), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
addq $0x8, %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x52297
cmpl $0x0, (%r14)
jne 0x6c286
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq (%r13), %rcx
movl %ebp, (%rax,%rcx,4)
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xadde(%rip), %rdx      # 0x7707a
movq %r14, %rdi
movl $0xf, %esi
movl $0xe4, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x135b4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/vfp_alloc.c
// Function: prv_alloc_vfp_tran_dbl_instr
static void prv_alloc_vfp_tran_dbl_instr(void *user_data, subtilis_arm_op_t *op,
					 subtilis_arm_instr_type_t type,
					 subtilis_vfp_tran_dbl_instr_t *instr,
					 subtilis_error_t *err)
{
	size_t vreg_src;
	int dist_src;
	subtilis_arm_reg_ud_t *ud = user_data;

	if (type != SUBTILIS_VFP_INSTR_FMRRD) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	vreg_src = instr->src1;
	(void)subtilis_arm_reg_alloc_ensure(ud, op, ud->int_regs, ud->real_regs,
					    &instr->src1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	dist_src = subtilis_arm_reg_alloc_calculate_dist(
	    ud, vreg_src, op, &ud->real_regs->dist_walker, ud->real_regs);
	if (dist_src == -1)
		ud->real_regs->phys_to_virt[instr->src1] = INT_MAX;

	subtilis_arm_reg_alloc_alloc_dest(ud, op, &instr->dest1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_reg_alloc_alloc_dest(ud, op, &instr->dest2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	ud->real_regs->next[instr->src1] = dist_src;

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
cmpl $0x7e, %edx
jne 0x6c385
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x18(%rcx), %r15
movq 0x18(%rcx), %rbp
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x51fe8
cmpl $0x0, (%r14)
jne 0x6c376
movq 0x10(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x51d8c
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x6c330
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
movq (%r15), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
leaq 0x8(%r12), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x521f0
cmpl $0x0, (%r14)
jne 0x6c376
addq $0x10, %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x521f0
cmpl $0x0, (%r14)
jne 0x6c376
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq (%r15), %rcx
movl %ebp, (%rax,%rcx,4)
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xacee(%rip), %rdx      # 0x7707a
movq %r14, %rdi
movl $0xf, %esi
movl $0x105, %ecx            # imm = 0x105
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x135b4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/vfp_alloc.c
// Function: prv_alloc_vfp_sqrt_instr
static void prv_alloc_vfp_sqrt_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_vfp_sqrt_instr_t *instr,
				     subtilis_error_t *err)
{
	size_t vreg_op1;
	int dist_op1;
	subtilis_arm_reg_ud_t *ud = user_data;

	if (type == SUBTILIS_VFP_INSTR_FSQRTS) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	vreg_op1 = instr->op1;
	(void)subtilis_arm_reg_alloc_ensure(ud, op, ud->int_regs, ud->real_regs,
					    &instr->op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	dist_op1 = subtilis_arm_reg_alloc_calculate_dist(
	    ud, vreg_op1, op, &ud->real_regs->dist_walker, ud->real_regs);
	if (dist_op1 == -1)
		ud->real_regs->phys_to_virt[instr->op1] = INT_MAX;

	subtilis_arm_reg_alloc_alloc_fp_dest(ud, op, &instr->dest, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	ud->real_regs->next[instr->op1] = dist_op1;

	ud->instr_count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
cmpl $0x7a, %edx
jne 0x6c8fc
leaq 0xa79e(%rip), %rdx      # 0x7707a
movq %r14, %rdi
movl $0xf, %esi
movl $0x1ed, %ecx            # imm = 0x1ED
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x135b4
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rcx), %r15
movq 0x10(%rcx), %rbp
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x51fe8
cmpl $0x0, (%r14)
jne 0x6c986
movq 0x10(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x51d8c
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x6c959
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rax
movq (%r15), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
addq $0x8, %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x52297
cmpl $0x0, (%r14)
jne 0x6c986
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq (%r15), %rcx
movl %ebp, (%rax,%rcx,4)
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/vfp_alloc.c
// Function: prv_alloc_vfp_sysreg_instr
static void prv_alloc_vfp_sysreg_instr(void *user_data, subtilis_arm_op_t *op,
				       subtilis_arm_instr_type_t type,
				       subtilis_vfp_sysreg_instr_t *instr,
				       subtilis_error_t *err)
{
	size_t vreg_op1;
	int dist_op1;
	bool fixed_op1 = true;
	subtilis_arm_reg_ud_t *ud = user_data;

	if (type == SUBTILIS_VFP_INSTR_FMRX) {
		subtilis_arm_reg_alloc_alloc_dest(ud, op, &instr->arm_reg, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	} else {
		vreg_op1 = instr->arm_reg;
		fixed_op1 = subtilis_arm_reg_alloc_ensure(
		    ud, op, ud->int_regs, ud->int_regs, &instr->arm_reg, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (!fixed_op1) {
			dist_op1 = subtilis_arm_reg_alloc_calculate_dist(
			    ud, vreg_op1, op, &ud->int_regs->dist_walker,
			    ud->int_regs);
			if (dist_op1 == -1)
				ud->int_regs->phys_to_virt[instr->arm_reg] =
				    INT_MAX;
		}
	}

	ud->instr_count++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %r14
cmpl $0x7c, %edx
jne 0x6c9cd
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x521f0
cmpl $0x0, (%r12)
jne 0x6ca28
jmp 0x6ca24
movq (%r14), %r13
movq 0x8(%rbx), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %rcx, %rdx
movq %r14, %r8
movq %r12, %r9
callq 0x51fe8
cmpl $0x0, (%r12)
jne 0x6ca28
testb %al, %al
jne 0x6ca24
movq 0x8(%rbx), %r8
leaq 0x90(%r8), %rcx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x51d8c
cmpl $-0x1, %eax
jne 0x6ca24
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq (%r14), %rcx
movq $0x7fffffff, (%rax,%rcx,8) # imm = 0x7FFFFFFF
incq 0x20(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_stran_instr
static void prv_dist_vfp_stran_instr(void *user_data, subtilis_arm_op_t *op,
				     subtilis_arm_instr_type_t type,
				     subtilis_vfp_stran_instr_t *instr,
				     subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (type == SUBTILIS_VFP_INSTR_FSTS ||
	    type == SUBTILIS_VFP_INSTR_FLDS) {
		subtilis_error_set_assertion_failed(err);
	}

	/*
	 * The function calling code can generate LDFNV and STFNV when
	 * preserving fpa registers.  These instructions should be
	 * ignored for the purposes of register allocation.
	 */

	if (instr->ccode != SUBTILIS_ARM_CCODE_NV) {
		if (type == SUBTILIS_VFP_INSTR_FSTD) {
			if (instr->dest == ud->reg_num) {
				subtilis_error_set_walker_failed(err);
				return;
			}
		} else {
			if (instr->dest == ud->reg_num) {
				ud->last_used = -1;
				subtilis_error_set_walker_failed(err);
				return;
			}
		}
	}

	ud->last_used++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, %r14
movl %edx, %eax
andl $-0x2, %eax
cmpl $0x46, %eax
jne 0x6cd52
leaq 0xa351(%rip), %rdx      # 0x77091
movq %rbx, %rdi
movl $0xf, %esi
movl $0xed, %ecx
callq 0x135b4
cmpl $0xf, (%r15)
jne 0x6cd67
incl 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rax
movq (%r14), %rcx
cmpl $0x48, %ebp
jne 0x6cd8e
cmpq %rcx, %rax
jne 0x6cd58
leaq 0xa312(%rip), %rdx      # 0x77091
movq %rbx, %rdi
movl $0x1f, %esi
movl $0xf9, %ecx
jmp 0x6cdaf
cmpq %rcx, %rax
jne 0x6cd58
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
leaq 0xa2ef(%rip), %rdx      # 0x77091
movq %rbx, %rdi
movl $0x1f, %esi
movl $0xff, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x135b4
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_copy_instr
static void prv_dist_vfp_copy_instr(void *user_data, subtilis_arm_op_t *op,
				    subtilis_arm_instr_type_t type,
				    subtilis_vfp_copy_instr_t *instr,
				    subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FCPYS:
	case SUBTILIS_VFP_INSTR_FNEGS:
	case SUBTILIS_VFP_INSTR_FABSS:
		subtilis_error_set_assertion_failed(err);
		return;
	default:
		break;
	}

	if (instr->src == ud->reg_num) {
		subtilis_error_set_walker_failed(err);
		return;
	}

	if (instr->dest == ud->reg_num) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// Assembly:
addl $-0x4a, %edx
cmpl $0x4, %edx
ja 0x6cde9
movl $0x15, %eax
btl %edx, %eax
jae 0x6cde9
leaq 0xa2ba(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0xf, %esi
movl $0x113, %ecx            # imm = 0x113
jmp 0x135b4
movq (%rdi), %rax
cmpq %rax, 0x10(%rcx)
jne 0x6ce0b
leaq 0xa298(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0x1f, %esi
movl $0x11a, %ecx            # imm = 0x11A
jmp 0x135b4
cmpq %rax, 0x8(%rcx)
jne 0x6ce31
movl $0xffffffff, 0x8(%rdi)  # imm = 0xFFFFFFFF
leaq 0xa272(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0x1f, %esi
movl $0x120, %ecx            # imm = 0x120
jmp 0x135b4
incl 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_cptran_instr
static void prv_dist_vfp_cptran_instr(void *user_data, subtilis_arm_op_t *op,
				      subtilis_arm_instr_type_t type,
				      subtilis_vfp_cptran_instr_t *instr,
				      subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (!instr->use_dregs) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if (type != SUBTILIS_VFP_INSTR_FMSR) {
		if (instr->src == ud->reg_num) {
			subtilis_error_set_walker_failed(err);
			return;
		}
	} else {
		if (instr->dest == ud->reg_num) {
			ud->last_used = -1;
			subtilis_error_set_walker_failed(err);
			return;
		}
	}

	ud->last_used++;
}

// Assembly:
cmpb $0x0, 0x4(%rcx)
je 0x6cf70
movq (%rdi), %rax
cmpl $0x5d, %edx
jne 0x6cf89
cmpq %rax, 0x8(%rcx)
jne 0x6cfa8
movl $0xffffffff, 0x8(%rdi)  # imm = 0xFFFFFFFF
leaq 0xa133(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0x1f, %esi
movl $0x186, %ecx            # imm = 0x186
jmp 0x135b4
leaq 0xa11a(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0xf, %esi
movl $0x17a, %ecx            # imm = 0x17A
jmp 0x135b4
cmpq %rax, 0x10(%rcx)
jne 0x6cfa8
leaq 0xa0fb(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0x1f, %esi
movl $0x180, %ecx            # imm = 0x180
jmp 0x135b4
incl 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_dist_vfp_cmp_instr
static void prv_dist_vfp_cmp_instr(void *user_data, subtilis_arm_op_t *op,
				   subtilis_arm_instr_type_t type,
				   subtilis_vfp_cmp_instr_t *instr,
				   subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	switch (type) {
	case SUBTILIS_VFP_INSTR_FCMPS:
	case SUBTILIS_VFP_INSTR_FCMPES:
	case SUBTILIS_VFP_INSTR_FCMPZS:
	case SUBTILIS_VFP_INSTR_FCMPEZS:
		subtilis_error_set_assertion_failed(err);
		return;
	default:
		break;
	}

	if (type == SUBTILIS_VFP_INSTR_FCMPED ||
	    type == SUBTILIS_VFP_INSTR_FCMPD) {
		if (instr->op2 == ud->reg_num) {
			subtilis_error_set_walker_failed(err);
			return;
		}
	}

	if (instr->op1 == ud->reg_num) {
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// Assembly:
addl $-0x71, %edx
cmpl $0x6, %edx
ja 0x6d0c5
movl $0x55, %eax
btl %edx, %eax
jae 0x6d099
leaq 0xa00a(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0xf, %esi
movl $0x1d1, %ecx            # imm = 0x1D1
jmp 0x135b4
movl $0xa, %eax
btl %edx, %eax
jae 0x6d0c5
movq (%rdi), %rax
cmpq %rax, 0x10(%rcx)
jne 0x6d0c8
leaq 0x9fde(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0x1f, %esi
movl $0x1da, %ecx            # imm = 0x1DA
jmp 0x135b4
movq (%rdi), %rax
cmpq %rax, 0x8(%rcx)
jne 0x6d0e7
leaq 0x9fbc(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0x1f, %esi
movl $0x1e0, %ecx            # imm = 0x1E0
jmp 0x135b4
incl 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/arch/arm32/arm_vfp_dist.c
// Function: prv_used_vfp_cptran_instr
static void prv_used_vfp_cptran_instr(void *user_data, subtilis_arm_op_t *op,
				      subtilis_arm_instr_type_t type,
				      subtilis_vfp_cptran_instr_t *instr,
				      subtilis_error_t *err)
{
	subtilis_dist_data_t *ud = user_data;

	if (!instr->use_dregs) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	if ((type == SUBTILIS_VFP_INSTR_FMSR) && (instr->dest == ud->reg_num)) {
		ud->last_used = -1;
		subtilis_error_set_walker_failed(err);
		return;
	}

	ud->last_used++;
}

// Assembly:
cmpb $0x0, 0x4(%rcx)
je 0x6d4bd
cmpl $0x5d, %edx
jne 0x6d4d6
movq 0x8(%rcx), %rax
cmpq (%rdi), %rax
jne 0x6d4d6
movl $0xffffffff, 0x8(%rdi)  # imm = 0xFFFFFFFF
leaq 0x9be6(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0x1f, %esi
movl $0x2ba, %ecx            # imm = 0x2BA
jmp 0x135b4
leaq 0x9bcd(%rip), %rdx      # 0x77091
movq %r8, %rdi
movl $0xf, %esi
movl $0x2b4, %ecx            # imm = 0x2B4
jmp 0x135b4
incl 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/backends/ptd/ptd.c
// Function: subtilis_ptd_syscall
void subtilis_ptd_syscall(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_error_t *err)
{
	size_t flags_reg;
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;
	subtilis_ir_sys_call_t *sys_call = &s->ops[start]->op.sys_call;
	subtilis_arm_section_t *arm_s = user_data;

	subtilis_riscos_arm_syscall(s, start, user_data, subtilis_ptd_swi_list,
				    subtilis_ptd_known_swis, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	if (sys_call->flags_reg != SIZE_MAX) {
		if (sys_call->flags_local)
			flags_reg =
			    subtilis_arm_ir_to_arm_reg(sys_call->flags_reg);
		else
			flags_reg =
			    subtilis_arm_ir_to_arm_reg(arm_s->reg_counter++);

		subtilis_arm_add_flags(
		    arm_s, SUBTILIS_ARM_INSTR_MRS, SUBTILIS_ARM_CCODE_AL,
		    SUBTILIS_ARM_FLAGS_CPSR, 0, flags_reg, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		instr = subtilis_arm_section_add_instr(
		    arm_s, SUBTILIS_ARM_INSTR_MOV, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		datai = &instr->operands.data;
		datai->ccode = SUBTILIS_ARM_CCODE_AL;
		datai->status = false;
		datai->dest = flags_reg;
		datai->op2.type = SUBTILIS_ARM_OP2_SHIFTED;
		datai->op2.op.shift.reg = flags_reg;
		datai->op2.op.shift.shift_reg = false;
		datai->op2.op.shift.shift.integer = 28;
		datai->op2.op.shift.type = SUBTILIS_ARM_SHIFT_LSR;

		if (!sys_call->flags_local)
			subtilis_arm_add_stran_imm(
			    arm_s, SUBTILIS_ARM_INSTR_STR,
			    SUBTILIS_ARM_CCODE_AL, flags_reg,
			    subtilis_arm_ir_to_arm_reg(sys_call->flags_reg), 0,
			    false, err);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
leaq 0x9f3c(%rip), %rax      # 0x77500
movq (%rax), %r8
leaq 0x364e2(%rip), %rcx     # 0xa3ab0
movq %rbx, %r9
callq 0x70274
cmpl $0x0, (%rbx)
je 0x6d5e7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r12), %rdi
cmpq $-0x1, %rdi
je 0x6d5db
cmpb $0x0, 0x20(%r12)
jne 0x6d604
movq (%r14), %rdi
leaq 0x1(%rdi), %rax
movq %rax, (%r14)
callq 0x4dfca
movq %rax, %r15
subq $0x8, %rsp
movq %r14, %rdi
movl $0x1d, %esi
movl $0xe, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rax, %r9
pushq %rbx
callq 0x4fcd4
addq $0x10, %rsp
cmpl $0x0, (%rbx)
jne 0x6d5db
movq %r14, %rdi
movl $0xd, %esi
movq %rbx, %rdx
callq 0x4e6f2
cmpl $0x0, (%rbx)
jne 0x6d5db
movl $0xe, 0x8(%rax)
xorl %ecx, %ecx
movb %cl, 0xc(%rax)
movq %r15, 0x10(%rax)
movl $0x2, %edx
movl %edx, 0x20(%rax)
movq %r15, 0x28(%rax)
movb %cl, 0x40(%rax)
movl $0x1c, 0x38(%rax)
movl %edx, 0x30(%rax)
cmpb %cl, 0x20(%r12)
jne 0x6d5db
movq 0x18(%r12), %rdi
callq 0x4dfca
movq %r14, %rdi
movl $0x13, %esi
movl $0xe, %edx
movq %r15, %rcx
movq %rax, %r8
xorl %r9d, %r9d
pushq %rbx
pushq $0x0
callq 0x4f526
addq $0x18, %rsp
jmp 0x6d5df
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/backends/ptd/ptd.c
// Function: subtilis_ptd_signx8to32
void subtilis_ptd_signx8to32(subtilis_ir_section_t *s, size_t start,
			     void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t src;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *signx = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(signx->operands[0].reg);
	src = subtilis_arm_ir_to_arm_reg(signx->operands[1].reg);

	subtilis_arm_add_signx(arm_s, SUBTILIS_ARM_INSTR_SXTB,
			       SUBTILIS_ARM_CCODE_AL, dest, src,
			       SUBTILIS_ARM_SIGNX_ROR_NONE, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %r12
movq 0x10(%r12), %rdi
callq 0x4dfca
movq %rax, %r15
movq 0x18(%r12), %rdi
callq 0x4dfca
movq %rbx, (%rsp)
movq %r14, %rdi
movl $0xa9, %esi
movl $0xe, %edx
movq %r15, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x4fe71
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/backends/ptd/ptd.c
// Function: subtilis_ptd_sys_trans
size_t subtilis_ptd_sys_trans(const char *call_name)
{
	size_t *found;
	size_t error_bit = 0;

	if (call_name[0] == 'X') {
		call_name++;
		error_bit = 0x20000;
	}

	found = bsearch(call_name, &subtilis_ptd_swi_index[0],
			subtilis_ptd_known_swis, sizeof(*found),
			prv_sys_string_lookup);

	if (!found)
		return SIZE_MAX;

	return subtilis_ptd_swi_list[*found].num | error_bit;
}

// Assembly:
pushq %rbx
movb (%rdi), %bl
xorl %eax, %eax
cmpb $0x58, %bl
sete %al
addq %rax, %rdi
leaq 0x9c27(%rip), %rax      # 0x77500
movq (%rax), %rdx
leaq 0x9c2d(%rip), %rsi      # 0x77510
leaq 0x39(%rip), %r8         # 0x6d923
movl $0x8, %ecx
callq 0x112a0
testq %rax, %rax
je 0x6d91a
xorl %ecx, %ecx
cmpb $0x58, %bl
sete %cl
shll $0x11, %ecx
movq (%rax), %rax
leaq (%rax,%rax,2), %rax
leaq 0x3619e(%rip), %rdx     # 0xa3ab0
movl (%rdx,%rax,8), %eax
orq %rcx, %rax
jmp 0x6d921
movq $-0x1, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/backends/ptd/ptd.c
// Function: prv_cursor_on_off
static void prv_cursor_on_off(subtilis_ir_section_t *s, void *user_data,
			      uint32_t swtch, subtilis_error_t *err)
{
	size_t i;
	subtilis_arm_section_t *arm_s = user_data;
	uint32_t ar[] = {23, 1, 0, 0, 0, 0, 0, 0, 0, 0};

	ar[2] = swtch;

	for (i = 0; i < sizeof(ar) / sizeof(ar[0]); i++) {
		/* read_mask = 0 */
		/* write_mask = 0 */
		subtilis_arm_add_swi(arm_s, SUBTILIS_ARM_CCODE_AL,
				     256 + ar[i] + 0x20000, 0, 0, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	subtilis_riscos_handle_graphics_error(arm_s, s, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movabsq $0x100000017, %rax      # imm = 0x100000017
movq %rax, (%rsp)
movl %edx, 0x8(%rsp)
xorl %r12d, %r12d
movl $0x20100, %ebp          # imm = 0x20100
movl (%rsp,%r12,4), %edx
addl %ebp, %edx
movq %r15, %rdi
movl $0xe, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x4f473
cmpl $0x0, (%rbx)
jne 0x6d9f4
incq %r12
cmpq $0xa, %r12
jne 0x6d9b1
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6e56d
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/liuhaotian[P]xmppsh/libstrophe/examples/active.c
// Function: handle_reply
int handle_reply(xmpp_conn_t * const conn,
		 xmpp_stanza_t * const stanza,
		 void * const userdata)
{
    xmpp_stanza_t *query, *item;
    char *type;

    type = xmpp_stanza_get_type(stanza);
    if (strcmp(type, "error") == 0)
	fprintf(stderr, "ERROR: query failed\n");
    else {
	query = xmpp_stanza_get_child_by_name(stanza, "query");
	printf("Active Sessions:\n");
	for (item = xmpp_stanza_get_children(query); item; 
	     item = xmpp_stanza_get_next(item))
	    printf("\t %s\n", xmpp_stanza_get_attribute(item, "jid"));
	printf("END OF LIST\n");
    }

    /* disconnect */
    xmpp_disconnect(conn);

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb3f9
leaq 0xa4c7(%rip), %rsi      # 0xcab0
movq %rax, %rdi
callq 0x2270
testl %eax, %eax
je 0x267f
leaq 0x9a19(%rip), %rsi      # 0xc019
movq %r14, %rdi
callq 0xb417
movq %rax, %r14
leaq 0x9ab0(%rip), %rdi      # 0xc0c2
callq 0x22e0
movq %r14, %rdi
callq 0xb4b6
testq %rax, %rax
je 0x265d
movq %rax, %r14
leaq 0x99f7(%rip), %r15      # 0xc025
leaq 0x99ea(%rip), %r12      # 0xc01f
movq %r14, %rdi
movq %r15, %rsi
callq 0xb5b0
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2030
movq %r14, %rdi
callq 0xb4bb
movq %rax, %r14
testq %rax, %rax
jne 0x2635
leaq 0x9a6f(%rip), %rdi      # 0xc0d3
callq 0x22e0
movq %rbx, %rdi
callq 0x4721
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2380
jmp 0x2669
// File: /workspace/github_c_makefile_star2_O3/liuhaotian[P]xmppsh/libstrophe/examples/active.c
// Function: main
int main(int argc, char **argv)
{
    xmpp_ctx_t *ctx;
    xmpp_conn_t *conn;

    if (argc != 3) {
	fprintf(stderr, "Usage: active <jid> <pass>\n\n");
	return 1;
    }

    /* initialize lib */
    xmpp_initialize();

    /* create a context */
    ctx = xmpp_ctx_new(NULL, NULL);

    /* create a connection */
    conn = xmpp_conn_new(ctx);

    /* setup authentication information */
    xmpp_conn_set_jid(conn, argv[1]);
    xmpp_conn_set_pass(conn, argv[2]);

    /* initiate connection */
    xmpp_connect_client(conn, NULL, 0, conn_handler, ctx);

    /* start the event loop */
    xmpp_run(ctx);

    /* release our connection and context */
    xmpp_conn_release(conn);
    xmpp_ctx_free(ctx);

    /* shutdown lib */
    xmpp_shutdown();

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x3, %edi
jne 0x2733
movq %rsi, %r15
callq 0x4a24
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x4de5
movq %rax, %r14
movq %rax, %rdi
callq 0x3dfc
movq %rax, %r12
movq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x4439
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x4475
leaq -0x73(%rip), %rcx       # 0x2686
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %r8
callq 0x44b4
movq %r14, %rdi
callq 0x542e
movq %r12, %rdi
callq 0x4208
movq %r14, %rdi
callq 0x4e4e
callq 0x4a30
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x24b6
movl $0x1, %ebx
jmp 0x2725
nop
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/mem-rw.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	setbuf(stdout, NULL);
	stress_parse_args(argc, argv, &args);
	allocate_and_use(args.n);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10b0
movq 0x2505(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1090
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x14f9
movl (%r14), %edi
callq 0x172e
// File: /workspace/github_c_makefile_star2_O3/ender672[P]liboil/benchmark.c
// Function: resize
clock_t resize(struct bench_image image, int out_width, int out_height)
{
	int i;
	enum oil_colorspace cs;
	struct oil_scale os;
	unsigned char *inbuf, *outbuf;
	size_t in_row_stride;
	clock_t t;

	cs = image.cs;
	in_row_stride = image.width * OIL_CMP(cs);

	inbuf = image.buffer;
	outbuf = malloc(out_width * OIL_CMP(cs));

	t = clock();
	oil_scale_init(&os, image.height, out_height, image.width, out_width, cs);
	for(i=0; i<out_height; i++) {
		while (oil_scale_slots(&os)) {
			oil_scale_in(&os, inbuf);
			inbuf += in_row_stride;
		}
		oil_scale_out(&os, outbuf);
	}
	t = clock() - t;
	free(outbuf);
	oil_scale_free(&os);
	return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movl %edi, %ebp
movl 0xb0(%rsp), %r13d
movl 0xa8(%rsp), %r14d
movzbl %r13b, %eax
movq 0xa0(%rsp), %r12
movl %eax, 0x4(%rsp)
movl %eax, %edi
imull %ebp, %edi
callq 0x1150
movq %rax, %r15
callq 0x10b0
movq %rax, 0x8(%rsp)
movl 0xac(%rsp), %esi
leaq 0x10(%rsp), %rdi
movl %ebx, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movl %r13d, %r9d
callq 0x16a8
testl %ebx, %ebx
jle 0x360d
imull 0x4(%rsp), %r14d
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x1ccd
movq %rbp, %rdi
testl %eax, %eax
je 0x35fd
movq %r12, %rsi
callq 0x1cff
addq %r14, %r12
jmp 0x35e1
movq %r15, %rsi
callq 0x2980
incl %r13d
cmpl %ebx, %r13d
jne 0x35e1
callq 0x10b0
movq %rax, %rbx
subq 0x8(%rsp), %rbx
movq %r15, %rdi
callq 0x1040
leaq 0x10(%rsp), %rdi
callq 0x195f
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ender672[P]liboil/benchmark.c
// Function: do_bench
void do_bench(struct bench_image image, double ratio, int iterations)
{
	int i, out_width, out_height;
	clock_t t_min, t_tmp;

	out_width = round(image.width * ratio);
	out_height = 500000; /* reasonable maximum height */

	oil_fix_ratio(image.width, image.height, &out_width, &out_height);

	t_min = 0;
	for (i=0; i<iterations; i++) {
		t_tmp = resize(image, out_width, out_height);
		if (!t_min || t_tmp < t_min) {
			t_min = t_tmp;
		}
	}

	printf("    to %4dx%4d %6.2fms\n", out_width, out_height, time_to_ms(t_min));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movl 0x58(%rsp), %ebp
movl 0x5c(%rsp), %r14d
cvtsi2sd %ebp, %xmm1
mulsd %xmm1, %xmm0
callq 0x1060
cvttsd2si %xmm0, %eax
leaq 0x24(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x20(%rsp), %rcx
movl $0x7a120, (%rcx)        # imm = 0x7A120
movl %ebp, %edi
movl %r14d, %esi
callq 0x336f
testl %ebx, %ebx
jle 0x36ce
leaq 0x50(%rsp), %r14
xorl %r15d, %r15d
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movupd (%r14), %xmm0
movupd %xmm0, (%rsp)
callq 0x356a
cmpq %r15, %rax
movq %r15, %rcx
cmovlq %rax, %rcx
testq %r15, %r15
movq %rcx, %r15
cmoveq %rax, %r15
decl %ebx
jne 0x368c
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
jmp 0x36d2
xorpd %xmm0, %xmm0
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
divsd 0xac6(%rip), %xmm0      # 0x41a8
leaq 0xb0f(%rip), %rdi       # 0x41f8
movb $0x1, %al
callq 0x10e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ender672[P]liboil/benchmark.c
// Function: do_bench_sizes
void do_bench_sizes(char *name, char *path, enum oil_colorspace cs, int iterations)
{
	struct bench_image image;

	image = png(path, cs);

	printf("%dx%d %s\n", image.width, image.height, name);

	do_bench(image, 0.01, iterations);
	do_bench(image, 0.125, iterations);
	do_bench(image, 0.8, iterations);
	do_bench(image, 2.14, iterations);

	free(image.buffer);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movq %rdi, %r15
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x37c0
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
leaq 0xaeb(%rip), %rdi       # 0x4210
movq %r15, %rcx
xorl %eax, %eax
callq 0x10e0
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movsd 0xa68(%rip), %xmm0      # 0x41b0
movl %ebx, %edi
callq 0x363e
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movsd 0xa50(%rip), %xmm0      # 0x41b8
movl %ebx, %edi
callq 0x363e
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movsd 0xa38(%rip), %xmm0      # 0x41c0
movl %ebx, %edi
callq 0x363e
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movsd 0xa20(%rip), %xmm0      # 0x41c8
movl %ebx, %edi
callq 0x363e
movq (%r14), %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbi_write_tga
int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
   int has_alpha = (comp == 2 || comp == 4);
   int colorbytes = has_alpha ? comp-1 : comp;
   int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3
   return outfile(filename, -1,-1, x, y, comp, 0, (void *) data, has_alpha, 0,
                  "111 221 2222 11", 0,0,format, 0,0,0, 0,0,x,y, (colorbytes+has_alpha)*8, has_alpha*8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r10
movl %ecx, %r9d
movl %esi, %ecx
leal -0x2(%r9), %eax
xorl %esi, %esi
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
sete %sil
movl %r9d, %eax
subl %esi, %eax
xorl %r11d, %r11d
cmpl $0x2, %eax
setl %r11b
orl $0x2, %r11d
leal (,%r9,8), %r15d
leal (,%rsi,8), %r12d
subq $0x8, %rsp
xorl %ebx, %ebx
leaq 0xd9ef(%rip), %r14      # 0x1220f
movl %edx, %r8d
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %rdx
pushq %rcx
pushq %rbx
pushq %rbx
pushq %rbx
pushq %rbx
pushq %rbx
pushq %r11
pushq %rbx
pushq %rbx
pushq %r14
pushq %rbx
pushq %rsi
pushq %r10
pushq %rbx
callq 0x443d
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__write_run_data(_IO_FILE*, int, unsigned char)
void stbiw__write_run_data(FILE *f, int length, unsigned char databyte)
{
   unsigned char lengthbyte = (unsigned char) (length+128);
   STBIW_ASSERT(length+128 <= 255);
   fwrite(&lengthbyte, 1, 1, f);
   fwrite(&databyte, 1, 1, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x80, %esi
jge 0x492c
movl %edx, %r14d
movq %rdi, %rbx
movsbl %sil, %edi
xorl $-0x80, %edi
movq %rbx, %rsi
callq 0x22e0
movsbl %r14b, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x22e0
leaq 0xd8ec(%rip), %rdi      # 0x1221f
leaq 0xd8f7(%rip), %rsi      # 0x12231
leaq 0xd904(%rip), %rcx      # 0x12245
movl $0x109, %edx            # imm = 0x109
callq 0x2180
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__write_dump_data(_IO_FILE*, int, unsigned char*)
void stbiw__write_dump_data(FILE *f, int length, unsigned char *data)
{
   unsigned char lengthbyte = (unsigned char )(length & 0xff);
   STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
   fwrite(&lengthbyte, 1, 1, f);
   fwrite(data, length, 1, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x81, %esi
jge 0x498f
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movsbl %r15b, %edi
movq %rbx, %rsi
callq 0x22e0
movslq %r15d, %rsi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2410
leaq 0xd8e6(%rip), %rdi      # 0x1227c
leaq 0xd894(%rip), %rsi      # 0x12231
leaq 0xd8e6(%rip), %rcx      # 0x1228a
movl $0x111, %edx            # imm = 0x111
callq 0x2180
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbi_write_hdr
int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
{
   int i;
   FILE *f;
   if (y <= 0 || x <= 0 || data == NULL) return 0;
   f = fopen(filename, "wb");
   if (f) {
      /* Each component is stored separately. Allocate scratch space for full output scanline. */
      unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
      fprintf(f, "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"      );
      fprintf(f, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n"                 , y, x);
      for(i=0; i < y; i++)
         stbiw__write_hdr_scanline(f, x, comp, scratch, data + comp*i*x);
      STBIW_FREE(scratch);
      fclose(f);
   }
   return f != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movl %edx, %r14d
testl %edx, %edx
setle %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %r8, %r8
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x4ea1
movq %r8, %rbx
movl %esi, %r13d
leaq 0xd4d8(%rip), %rsi      # 0x122c4
callq 0x22a0
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x4e97
leal (,%r13,4), %edi
callq 0x22f0
movq %rax, -0x40(%rbp)
leaq 0xd4b1(%rip), %rdi      # 0x122c7
movl $0x41, %esi
movl $0x1, %edx
movq -0x30(%rbp), %r12
movq %r12, %rcx
callq 0x2410
leaq 0xd4d6(%rip), %rsi      # 0x12309
movl %r14d, %edx
movl %r14d, -0x34(%rbp)
xorl %r14d, %r14d
movq %r12, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x2300
movq %rbx, -0x48(%rbp)
movl %r15d, %ebx
imull %r13d, %ebx
movq %r13, %r12
movl %r15d, %r13d
movl -0x34(%rbp), %r15d
movslq %r14d, %r14
movq -0x48(%rbp), %rax
leaq (%rax,%r14,4), %r8
movq -0x30(%rbp), %rdi
movl %r12d, %esi
movl %r13d, %edx
movq -0x40(%rbp), %rcx
callq 0x49ae
addl %ebx, %r14d
decq %r15
jne 0x4e5f
movq -0x40(%rbp), %rdi
callq 0x22b0
movq -0x30(%rbp), %rdi
callq 0x2210
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__sbgrowf(void**, int, int)
static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
{
   int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
   void *p = STBIW_REALLOC(*arr ? stbiw__sbraw(*arr) : 0, itemsize * m + sizeof(int)*2);
   STBIW_ASSERT(p);
   if (p) {
      if (!*arr) ((int *) p)[1] = 0;
      *arr = (void *) ((int *) p + 2);
      stbiw__sbm(*arr) = m;
   }
   return *arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x5679
movl -0x8(%rax), %ecx
leal 0x1(,%rcx,2), %r14d
jmp 0x567f
movl $0x2, %r14d
leaq -0x8(%rax), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
imull %r14d, %esi
movslq %esi, %rsi
addq $0x8, %rsi
callq 0x23b0
testq %rax, %rax
je 0x56be
cmpq $0x0, (%rbx)
jne 0x56ac
movl $0x0, 0x4(%rax)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, (%rbx)
movl %r14d, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xdfb7(%rip), %rdi      # 0x1367c
leaq 0xcb65(%rip), %rsi      # 0x12231
leaq 0xcfb7(%rip), %rcx      # 0x1268a
movl $0x196, %edx            # imm = 0x196
callq 0x2180
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__zlib_flushf(unsigned char*, unsigned int*, int*)
static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
{
   while (*bitcount >= 8) {
      stbiw__sbpush(data, (unsigned char) *bitbuffer);
      *bitbuffer >>= 8;
      *bitcount -= 8;
   }
   return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
movq %rdi, -0x20(%rbp)
cmpl $0x8, (%rdx)
jl 0x5745
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x20(%rbp), %r15
testq %rax, %rax
je 0x570d
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jl 0x5724
movq %r15, %rdi
movl $0x1, %esi
callq 0x565a
movq -0x20(%rbp), %rax
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movb (%r14), %sil
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
movb %sil, (%rax,%rcx)
shrl $0x8, (%r14)
movl (%rbx), %ecx
leal -0x8(%rcx), %edx
movl %edx, (%rbx)
cmpl $0xf, %ecx
jg 0x56fd
movq -0x20(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbiw__crc32(unsigned char*, int)
unsigned int stbiw__crc32(unsigned char *buffer, int len)
{
   static unsigned int crc_table[256];
   unsigned int crc = ~0u;
   int i,j;
   if (crc_table[1] == 0)
      for(i=0; i < 256; i++)
         for (crc_table[i]=i, j=0; j < 8; ++j)
            crc_table[i] = (crc_table[i] >> 1) ^ (crc_table[i] & 1 ? 0xedb88320 : 0);
   for (i=0; i < len; ++i)
      crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
   return ~crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x13b09(%rip)     # 0x19264
leaq 0x13afe(%rip), %rcx     # 0x19260
jne 0x5798
xorl %eax, %eax
movl $0x8, %edx
movl %eax, %r8d
movl %r8d, %r9d
shrl %r9d
andl $0x1, %r8d
negl %r8d
andl $0xedb88320, %r8d       # imm = 0xEDB88320
xorl %r9d, %r8d
decl %edx
jne 0x576e
movl %r8d, (%rcx,%rax,4)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x5766
testl %esi, %esi
jle 0x57c4
movl %esi, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
movzbl %al, %r8d
shrl $0x8, %eax
movzbl (%rdi,%rsi), %r9d
xorl %r9d, %r8d
xorl (%rcx,%r8,4), %eax
incq %rsi
cmpq %rsi, %rdx
jne 0x57a5
notl %eax
jmp 0x57c6
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./stb_image_write.h
// Function: stbi_write_png
int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
   FILE *f;
   int len;
   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (!png) return 0;
   f = fopen(filename, "wb");
   if (!f) { STBIW_FREE(png); return 0; }
   fwrite(png, 1, len, f);
   fclose(f);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r9d, %r10d
movl %ecx, %eax
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %r14
leaq -0x14(%rbp), %r9
movq %r8, %rdi
movl %r10d, %esi
movl %eax, %r8d
callq 0x57c8
testq %rax, %rax
je 0x5da8
movq %rax, %rbx
leaq 0xc550(%rip), %rsi      # 0x122c4
movq %r14, %rdi
callq 0x22a0
testq %rax, %rax
je 0x5dad
movq %rax, %r14
movslq -0x14(%rbp), %rdx
movl $0x1, %esi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x2410
movq %r14, %rdi
callq 0x2210
movl $0x1, %r14d
jmp 0x5db0
xorl %r14d, %r14d
jmp 0x5db8
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x22b0
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./main.h
// Function: strlwr(char*)
char * strlwr(char * string) {
    int length = strlen(string);
    for (int i = 0; i < length; ++i)
    {
        string[i] = tolower(string[i]);
    }
    return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2120
movq %rax, %r14
testl %r14d, %r14d
jle 0x5dfe
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0x2310
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x5de8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./main.h
// Function: strupr(char*)
char * strupr(char * string) {
    int length = strlen(string);
    for (int i = 0; i < length; ++i)
    {
        string[i] = toupper(string[i]);
    }
    return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2120
movq %rax, %r14
testl %r14d, %r14d
jle 0x5e46
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0x23f0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x5e30
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/./stable.h
// Function: StringTable::Get(char const*)
const char * Get(const char *str)
  {
    CharPtrSet::iterator found;
    found = mStrings.find( str );
    if ( found != mStrings.end() ) return (*found);
    int l = strlen(str);
    char *mem = new char[l+1];
    strcpy(mem,str);
    mStrings.insert( mem );
    return mem;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x6aae
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x6a6c
movq 0x20(%rax), %rax
jmp 0x6aa2
movq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x2120
incl %eax
movslq %eax, %rdi
callq 0x2040
leaq -0x28(%rbp), %r15
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6b12
movq (%r15), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/vlenhart[P]q3bsp/arglist.cpp
// Function: TranslateEscapedChar(int)
int TranslateEscapedChar( int ch )
{
  switch( ch )
  {
  case 't':
    ch = '\t';
    break;
  case 'n':
    ch = '\n';
    break;
  case 'f':
    ch = '\f';
    break;
  }
  return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x66, %edi
je 0x6e1b
movl %edi, %eax
cmpl $0x6e, %edi
je 0x6e14
cmpl $0x74, %eax
jne 0x6e20
movl $0x9, %eax
jmp 0x6e20
movl $0xa, %eax
jmp 0x6e20
movl $0xc, %eax
popq %rbp
retq