LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/backends/posix/threadposix.cpp
// Function: smooth::Threads::ThreadPOSIX::Stop()
S::Int S::Threads::ThreadPOSIX::Stop()
{
	pthread_mutex_lock(&mutex);

	if (thread == NIL || pthread_equal(pthread_self(), *thread))
	{
		pthread_mutex_unlock(&mutex);

		return Error();
	}

	pthread_t	*thread	  = this->thread;
	Bool		 myThread = this->myThread;

	this->thread = NIL;

	pthread_mutex_unlock(&mutex);

	pthread_cancel(*thread);
	pthread_detach(*thread);

	if (myThread) delete thread;

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x55da0
movq 0x48(%r15), %rbx
testq %rbx, %rbx
je 0xc70e6
callq 0x57370
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x58f70
testl %eax, %eax
je 0xc70fe
movq %r14, %rdi
callq 0x55c20
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb 0x50(%r15), %r12b
movq $0x0, 0x48(%r15)
movq %r14, %rdi
callq 0x55c20
movq (%rbx), %rdi
callq 0x58770
movq (%rbx), %rdi
callq 0x55e60
xorl %ebp, %ebp
cmpb $0x1, %r12b
jne 0xc70f3
movl $0x8, %esi
movq %rbx, %rdi
callq 0x55480
jmp 0xc70f3
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/backends/posix/threadposix.cpp
// Function: smooth::Threads::ThreadPOSIX::Wait()
S::Int S::Threads::ThreadPOSIX::Wait()
{
	pthread_mutex_lock(&mutex);

	if (thread == NIL || pthread_equal(pthread_self(), *thread))
	{
		pthread_mutex_unlock(&mutex);

		return Error();
	}

	pthread_t	*thread	  = this->thread;
	Bool		 myThread = this->myThread;

	this->thread = NIL;

	pthread_mutex_unlock(&mutex);

	pthread_join(*thread, NIL);

	if (myThread) delete thread;

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x55da0
movq 0x48(%r15), %rbx
testq %rbx, %rbx
je 0xc716d
callq 0x57370
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x58f70
testl %eax, %eax
je 0xc7189
movq %r14, %rdi
callq 0x55c20
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb 0x50(%r15), %bpl
movq $0x0, 0x48(%r15)
movq %r14, %rdi
callq 0x55c20
movq (%rbx), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x55f00
cmpb $0x1, %bpl
jne 0xc717b
movl $0x8, %esi
movq %rbx, %rdi
callq 0x55480
jmp 0xc717b
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/threads/backends/posix/threadposix.cpp
// Function: smooth::Threads::ThreadPOSIX::Exit()
S::Void S::Threads::ThreadPOSIX::Exit()
{
	pthread_mutex_lock(&mutex);

	if (thread == NIL || !pthread_equal(pthread_self(), *thread))
	{
		pthread_mutex_unlock(&mutex);

		return;
	}

	pthread_t	*thread	  = this->thread;
	Bool		 myThread = this->myThread;

	this->thread = NIL;

	pthread_mutex_unlock(&mutex);

	pthread_detach(*thread);

	if (myThread) delete thread;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x55da0
movq 0x48(%r15), %rbx
testq %rbx, %rbx
je 0xc722c
callq 0x57370
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x58f70
testl %eax, %eax
je 0xc722c
movb 0x50(%r15), %bpl
movq $0x0, 0x48(%r15)
movq %r14, %rdi
callq 0x55c20
movq (%rbx), %rdi
callq 0x55e60
cmpb $0x1, %bpl
jne 0xc723e
movl $0x8, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x55480
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x55c20
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpuid_get_all_raw_data
int cpuid_get_all_raw_data(struct cpu_raw_data_array_t* data)
{
	int cur_error = cpuid_set_error(ERR_OK);
	int ret_error = cpuid_set_error(ERR_OK);
	logical_cpu_t logical_cpu = 0;
	struct cpu_raw_data_t* raw_ptr = NULL;

	if (data == NULL)
		return cpuid_set_error(ERR_HANDLE);

	bool affinity_saved = save_cpu_affinity();

	cpu_raw_data_array_t_constructor(data, true);
	while (set_cpu_affinity(logical_cpu) || logical_cpu == 0) {
		debugf(2, "Getting raw dump for logical CPU %i\n", logical_cpu);
		cpuid_grow_raw_data_array(data, logical_cpu + 1);
		raw_ptr = &data->raw[logical_cpu];
		cur_error = cpuid_get_raw_data(raw_ptr);
		if (ret_error == ERR_OK)
			ret_error = cur_error;
		logical_cpu++;
	}

	if (affinity_saved)
		restore_cpu_affinity();

	return ret_error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0xa3eaa(%rip), %rdi     # 0x16b330
callq 0x566e0
movl $0x0, 0x30(%rax)
testq %rbx, %rbx
je 0xc759c
leaq 0x38(%rax), %rdx
movl $0x80, %esi
xorl %edi, %edi
movq %rdx, 0x8(%rsp)
callq 0x55fd0
movl %eax, 0x4(%rsp)
movb $0x1, (%rbx)
movw $0x0, 0x2(%rbx)
movq $0x0, 0x8(%rbx)
leaq 0x10(%rsp), %r12
leaq 0x4c725(%rip), %r13     # 0x113bfc
xorl %ebp, %ebp
xorl %r14d, %r14d
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movzwl %r14w, %r15d
cmpl $0x3ff, %r15d           # imm = 0x3FF
ja 0xc752e
movl $0x1, %eax
movl %r15d, %ecx
shlq %cl, %rax
movq %r15, %rcx
shrq $0x6, %rcx
orq %rax, 0x10(%rsp,%rcx,8)
movl $0x80, %esi
xorl %edi, %edi
movq %r12, %rdx
callq 0x57390
testw %r14w, %r14w
je 0xc7547
testl %eax, %eax
jne 0xc7582
movl $0x2, %edi
movq %r13, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0xc9c3a
incl %r14d
movzwl %r14w, %esi
movq %rbx, %rdi
callq 0xc75c2
imulq $0x580, %r15, %rdi      # imm = 0x580
addq 0x8(%rbx), %rdi
callq 0xc72a7
testl %ebp, %ebp
cmovel %eax, %ebp
jmp 0xc74dc
cmpl $0x0, 0x4(%rsp)
jne 0xc75ae
movl $0x80, %esi
xorl %edi, %edi
movq 0x8(%rsp), %rdx
callq 0x57390
jmp 0xc75ae
leaq 0x30(%rax), %rax
movl $0xfffffff4, (%rax)     # imm = 0xFFFFFFF4
movl $0xfffffff4, %ebp       # imm = 0xFFFFFFF4
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpuid_grow_raw_data_array
static void cpuid_grow_raw_data_array(struct cpu_raw_data_array_t* raw_array, logical_cpu_t n)
{
	logical_cpu_t i;
	struct cpu_raw_data_t *tmp = NULL;

	if ((n <= 0) || (n < raw_array->num_raw)) return;
	debugf(3, "Growing cpu_raw_data_array_t from %u to %u items\n", raw_array->num_raw, n);
	tmp = realloc(raw_array->raw, sizeof(struct cpu_raw_data_t) * n);
	if (tmp == NULL) { /* Memory allocation failure */
		cpuid_set_error(ERR_NO_MEM);
		return;
	}

	for (i = raw_array->num_raw; i < n; i++)
		raw_data_t_constructor(&tmp[i]);
	raw_array->num_raw = n;
	raw_array->raw     = tmp;
}

// Assembly:
testl %esi, %esi
je 0xc766f
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movzwl 0x2(%rdi), %edx
cmpw %r14w, %dx
ja 0xc766a
leaq 0x4cb73(%rip), %rsi     # 0x11415d
movl $0x3, %edi
movl %r14d, %ecx
xorl %eax, %eax
callq 0xc9c3a
movq 0x8(%rbx), %rdi
movzwl %r14w, %eax
imulq $0x580, %rax, %rsi      # imm = 0x580
callq 0x553d0
testq %rax, %rax
je 0xc7654
movq %rax, %r15
movzwl 0x2(%rbx), %eax
cmpw %r14w, %ax
jae 0xc7649
imulq $0x580, %rax, %rcx      # imm = 0x580
movq %r15, %rdi
addq %rcx, %rdi
notl %eax
addl %r14d, %eax
movzwl %ax, %eax
imulq $0x580, %rax, %rdx      # imm = 0x580
addq $0x580, %rdx            # imm = 0x580
xorl %esi, %esi
callq 0x55f20
movw %r14w, 0x2(%rbx)
movq %r15, 0x8(%rbx)
jmp 0xc766a
leaq 0xa3cd5(%rip), %rdi     # 0x16b330
callq 0x566e0
movl $0xfffffffd, 0x30(%rax) # imm = 0xFFFFFFFD
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpu_ident_purpose
static cpu_purpose_t cpu_ident_purpose(struct cpu_raw_data_t* raw)
{
	cpu_vendor_t vendor = VENDOR_UNKNOWN;
	cpu_purpose_t purpose = PURPOSE_GENERAL;
	char vendor_str[VENDOR_STR_MAX];

	vendor = cpuid_vendor_identify(raw->basic_cpuid[0], vendor_str);
	if (vendor == VENDOR_UNKNOWN) {
		cpuid_set_error(ERR_CPU_UNKN);
		return purpose;
	}

	switch (vendor) {
		case VENDOR_AMD:
			purpose = cpuid_identify_purpose_amd(raw);
			break;
		case VENDOR_INTEL:
			purpose = cpuid_identify_purpose_intel(raw);
			break;
		default:
			purpose = PURPOSE_GENERAL;
			break;
	}
	debugf(3, "Identified a '%s' CPU core type\n", cpu_purpose_str(purpose));

	return purpose;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rsi
callq 0xc978e
cmpl $0x1, %eax
je 0xc9349
testl %eax, %eax
je 0xc933f
xorl %ebx, %ebx
cmpl $-0x1, %eax
jne 0xc9353
leaq 0xa2004(%rip), %rdi     # 0x16b330
callq 0x566e0
movl $0xfffffff9, 0x30(%rax) # imm = 0xFFFFFFF9
xorl %ebx, %ebx
jmp 0xc938f
movq %rbx, %rdi
callq 0xcca84
jmp 0xc9351
movq %rbx, %rdi
callq 0xcb458
movl %eax, %ebx
movl $0x8, %eax
leaq 0xa0d51(%rip), %rcx     # 0x16a0b0
leaq 0x486c2(%rip), %rdx     # 0x111a28
cmpl %ebx, -0x8(%rax,%rcx)
je 0xc9378
addq $0x10, %rax
cmpq $0x38, %rax
jne 0xc9366
jmp 0xc937c
movq (%rax,%rcx), %rdx
leaq 0x4b33c(%rip), %rsi     # 0x1146bf
movl $0x3, %edi
xorl %eax, %eax
callq 0xc9c3a
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: update_core_instances
static void update_core_instances(struct internal_core_instances_t* cores,
                                   struct internal_apic_info_t* apic_info)
{
	uint32_t core_id_index = 0;

	core_id_index = apic_info->core_id % CORES_HTABLE_SIZE;
	if ((cores->htable[core_id_index].core_id == 0) || (cores->htable[core_id_index].core_id == apic_info->core_id)) {
		if (cores->htable[core_id_index].num_logical_cpu == 0)
			cores->instances++;
		cores->htable[core_id_index].core_id = apic_info->core_id;
		cores->htable[core_id_index].num_logical_cpu++;
	}
	else {
		warnf("update_core_instances: collision at index %u (core ID is %i, not %i)\n",
			core_id_index, cores->htable[core_id_index].core_id, apic_info->core_id);
	}
}

// Assembly:
movl %esi, %ecx
leal 0xff(%rcx), %eax
testl %esi, %esi
cmovnsl %esi, %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
subl %eax, %esi
movl 0x8(%rdi,%rsi,8), %edx
testl %edx, %edx
setne %al
cmpl %ecx, %edx
setne %r8b
testb %r8b, %al
jne 0xc93d7
movzwl 0x4(%rdi,%rsi,8), %eax
testw %ax, %ax
jne 0xc93cb
incb (%rdi)
movl %ecx, 0x8(%rdi,%rsi,8)
incl %eax
movw %ax, 0x4(%rdi,%rsi,8)
retq
leaq 0x4b3ac(%rip), %rdi     # 0x11478a
xorl %eax, %eax
jmp 0xc9b82
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpu_request_core_type
int cpu_request_core_type(cpu_purpose_t purpose, struct cpu_raw_data_array_t* raw_array, struct cpu_id_t* data)
{
	int error;
	logical_cpu_t logical_cpu = 0;
	struct cpu_raw_data_array_t my_raw_array;
	struct internal_id_info_t throwaway;

	if (!raw_array) {
		if ((error = cpuid_get_all_raw_data(&my_raw_array)) < 0)
			return cpuid_set_error(error);
		raw_array = &my_raw_array;
	}

	for (logical_cpu = 0; logical_cpu < raw_array->num_raw; logical_cpu++) {
		if (cpu_ident_purpose(&raw_array->raw[logical_cpu]) == purpose) {
			cpu_ident_internal(&raw_array->raw[logical_cpu], data, &throwaway);
			return cpuid_set_error(ERR_OK);
		}
	}

	return cpuid_set_error(ERR_NOT_FOUND);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl %edi, %ebp
testq %rsi, %rsi
je 0xc950e
movq %rsi, %r15
leaq 0x2(%rsi), %r13
addq $0x8, %r15
jmp 0xc9526
leaq 0x10(%rsp), %rdi
callq 0xc746b
testl %eax, %eax
js 0xc957d
leaq 0x18(%rsp), %r15
leaq 0x12(%rsp), %r13
movl $0xffffffef, %r14d      # imm = 0xFFFFFFEF
cmpw $0x0, (%r13)
je 0xc9580
movq %rbx, 0x8(%rsp)
xorl %r12d, %r12d
xorl %ebx, %ebx
movq (%r15), %rdi
addq %r12, %rdi
callq 0xc9305
cmpl %ebp, %eax
je 0xc9563
incq %rbx
movzwl (%r13), %eax
addq $0x580, %r12            # imm = 0x580
cmpq %rax, %rbx
jb 0xc953e
jmp 0xc9580
addq (%r15), %r12
leaq 0x20(%rsp), %rdx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0xc85c8
xorl %r14d, %r14d
jmp 0xc9580
movl %eax, %r14d
leaq 0xa1da9(%rip), %rdi     # 0x16b330
callq 0x566e0
movl %r14d, 0x30(%rax)
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: affinity_mask_str_r
char* affinity_mask_str_r(cpu_affinity_mask_t* affinity_mask, char* buffer, uint32_t buffer_len)
{
	logical_cpu_t mask_index = __MASK_SETSIZE - 1;
	logical_cpu_t str_index = 0;
	bool do_print = false;

	while (((uint32_t) str_index) + 1 < buffer_len) {
		if (do_print || (mask_index < 4) || (affinity_mask->__bits[mask_index] != 0x00)) {
			snprintf(&buffer[str_index], 3, "%02X", affinity_mask->__bits[mask_index]);
			do_print = true;
			str_index += 2;
		}
		/* mask_index in unsigned, so we cannot decrement it beyond 0 */
		if (mask_index == 0)
			break;
		mask_index--;
	}
	buffer[str_index] = '\0';

	return buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x2, %edx
jb 0xc9676
movl %edx, %ebp
movq %rdi, %r14
movw $0x1fff, %r12w          # imm = 0x1FFF
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpw $0x4, %r12w
setb %cl
orb %r15b, %cl
movzwl %r12w, %eax
movb (%r14,%rax), %al
testb %al, %al
setne %r15b
orb %cl, %r15b
testb $0x1, %r15b
je 0xc9663
movzbl %al, %ecx
movzwl %r13w, %edi
addq %rbx, %rdi
movl $0x3, %esi
leaq 0x4a613(%rip), %rdx     # 0x113c65
xorl %eax, %eax
callq 0x56850
addl $0x2, %r13d
testw %r12w, %r12w
je 0xc9670
decl %r12d
movzwl %r13w, %eax
incl %eax
cmpl %ebp, %eax
jb 0xc961a
movzwl %r13w, %eax
jmp 0xc9678
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpuid_get_vendor
cpu_vendor_t cpuid_get_vendor(void)
{
	static cpu_vendor_t vendor = VENDOR_UNKNOWN;
	uint32_t raw_vendor[4];
	char vendor_str[VENDOR_STR_MAX];

	if(vendor == VENDOR_UNKNOWN) {
		if (!cpuid_present())
			cpuid_set_error(ERR_NO_CPUID);
		else {
			cpu_exec_cpuid(0, raw_vendor);
			vendor = cpuid_vendor_identify(raw_vendor, vendor_str);
		}
	}
	return vendor;
}

// Assembly:
movl 0xa4b82(%rip), %eax     # 0x16e2b4
cmpl $-0x1, %eax
je 0xc9738
retq
pushq %rbx
subq $0x20, %rsp
callq 0xccae0
testl %eax, %eax
je 0xc976c
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movq %rbx, %rdi
callq 0xccae6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc978e
movl %eax, 0xa4b4a(%rip)     # 0x16e2b4
jmp 0xc9788
leaq 0xa1bbd(%rip), %rdi     # 0x16b330
callq 0x566e0
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movl 0xa4b2c(%rip), %eax     # 0x16e2b4
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpuid_get_cpu_list
void cpuid_get_cpu_list(cpu_vendor_t vendor, struct cpu_list_t* list)
{
	switch (vendor) {
		case VENDOR_INTEL:
			cpuid_get_list_intel(list);
			break;
		case VENDOR_AMD:
		case VENDOR_HYGON:
			cpuid_get_list_amd(list);
			break;
		case VENDOR_CYRIX:
			make_list_from_string("Cx486,Cx5x86,6x86,6x86MX,M II,MediaGX,MediaGXi,MediaGXm", list);
			break;
		case VENDOR_NEXGEN:
			make_list_from_string("Nx586", list);
			break;
		case VENDOR_TRANSMETA:
			make_list_from_string("Crusoe,Efficeon", list);
			break;
		case VENDOR_UMC:
			make_list_from_string("UMC x86 CPU", list);
			break;
		case VENDOR_CENTAUR:
			cpuid_get_list_centaur(list);
			break;
		case VENDOR_RISE:
			make_list_from_string("Rise mP6", list);
			break;
		case VENDOR_SIS:
			make_list_from_string("SiS mP6", list);
			break;
		case VENDOR_NSC:
			make_list_from_string("Geode GXm,Geode GXLV,Geode GX1,Geode GX2", list);
			break;
		default:
			warnf("Unknown vendor passed to cpuid_get_cpu_list()\n");
			cpuid_set_error(ERR_INVRANGE);
			list->num_entries = 0;
			list->names = NULL;
			break;
 	}
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpl $0xa, %edi
ja 0xc9860
movl %edi, %eax
leaq 0x4a097(%rip), %rcx     # 0x113890
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
jmp 0xcb444
leaq 0x4a8c0(%rip), %rdi     # 0x1140d2
jmp 0xc985a
leaq 0x4a8e2(%rip), %rdi     # 0x1140fd
jmp 0xc985a
movq %rbx, %rdi
popq %rbx
jmp 0xccac1
leaq 0x4a86d(%rip), %rdi     # 0x11409a
jmp 0xc985a
movq %rbx, %rdi
popq %rbx
jmp 0xcb740
leaq 0x4a899(%rip), %rdi     # 0x1140d8
jmp 0xc985a
leaq 0x4a8a0(%rip), %rdi     # 0x1140e8
jmp 0xc985a
leaq 0x4a8b4(%rip), %rdi     # 0x114105
jmp 0xc985a
leaq 0x4a89a(%rip), %rdi     # 0x1140f4
movq %rbx, %rsi
popq %rbx
jmp 0xc9894
leaq 0x4a8c7(%rip), %rdi     # 0x11412e
xorl %eax, %eax
callq 0xc9b82
leaq 0xa1abb(%rip), %rdi     # 0x16b330
callq 0x566e0
movl $0xfffffff0, 0x30(%rax) # imm = 0xFFFFFFF0
movl $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: make_list_from_string
static void make_list_from_string(const char* csv, struct cpu_list_t* list)
{
	int i, j, n, l, last;
	l = (int) strlen(csv);
	n = 0;
	for (i = 0; i < l; i++) if (csv[i] == ',') n++;
	n++;
	list->names = (char**) malloc(sizeof(char*) * n);
	if (!list->names) { /* Memory allocation failed */
		list->num_entries = 0;
		cpuid_set_error(ERR_NO_MEM);
		return;
	}
	list->num_entries = n;
	last = -1;
	n = 0;
	for (i = 0; i <= l; i++) if (i == l || csv[i] == ',') {
		list->names[n] = (char*) malloc(i - last);
		if (!list->names[n]) { /* Memory allocation failed */
			cpuid_set_error(ERR_NO_MEM);
			for (j = 0; j < n; j++) free(list->names[j]);
			free(list->names);
			list->num_entries = 0;
			list->names = NULL;
			return;
		}
		memcpy(list->names[n], &csv[last + 1], i - last - 1);
		list->names[n][i - last - 1] = '\0';
		n++;
		last = i;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x56370
movq %rax, %r15
testl %r15d, %r15d
jle 0xc98d9
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorl %ebp, %ebp
xorl %edx, %edx
cmpb $0x2c, (%r14,%rcx)
sete %dl
addl %edx, %ebp
incq %rcx
cmpq %rcx, %rax
jne 0xc98c1
incl %ebp
jmp 0xc98de
movl $0x1, %ebp
movslq %ebp, %rdi
shlq $0x3, %rdi
callq 0x57ff0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xc99ad
movq %r14, (%rsp)
movq %rbx, 0x10(%rsp)
movl %ebp, (%rbx)
testl %r15d, %r15d
js 0xc9a1d
movq (%rsp), %rax
incq %rax
movq %rax, 0x8(%rsp)
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x20(%rsp)
leal 0x1(%r15), %eax
movq %rax, 0x18(%rsp)
xorl %r12d, %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movq 0x10(%rsp), %r13
cmpq %r12, 0x20(%rsp)
je 0xc994f
movq (%rsp), %rax
cmpb $0x2c, (%rax,%r12)
jne 0xc99a1
movl %r12d, %eax
subl %ebp, %eax
movslq %eax, %rdi
callq 0x57ff0
movq 0x8(%r13), %rcx
movslq %r14d, %rbx
movq %rax, (%rcx,%rbx,8)
movq 0x8(%r13), %r15
movq (%r15,%rbx,8), %rdi
testq %rdi, %rdi
je 0xc99cb
movslq %ebp, %rsi
addq 0x8(%rsp), %rsi
notl %ebp
addl %r12d, %ebp
movslq %ebp, %r15
movq %r15, %rdx
callq 0x552d0
movq 0x8(%r13), %rax
movq (%rax,%rbx,8), %rax
movb $0x0, (%rax,%r15)
incl %ebx
movl %ebx, %r14d
movl %r12d, %ebp
incq %r12
cmpq %r12, 0x18(%rsp)
jne 0xc993d
jmp 0xc9a1d
movl $0x0, (%rbx)
leaq 0xa1976(%rip), %rdi     # 0x16b330
callq 0x566e0
movl $0xfffffffd, 0x30(%rax) # imm = 0xFFFFFFFD
jmp 0xc9a1d
leaq 0xa195e(%rip), %rdi     # 0x16b330
callq 0x566e0
movl $0xfffffffd, 0x30(%rax) # imm = 0xFFFFFFFD
testl %r14d, %r14d
jle 0xc9a05
movl %r14d, %ebx
xorl %r14d, %r14d
movq 0x8(%r13), %rax
movq (%rax,%r14,8), %rdi
callq 0x55790
incq %r14
cmpq %r14, %rbx
jne 0xc99ec
movq 0x8(%r13), %r15
movq %r15, %rdi
callq 0x55790
movl $0x0, (%r13)
movq $0x0, 0x8(%r13)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpuid_free_cpu_list
void cpuid_free_cpu_list(struct cpu_list_t* list)
{
	int i;
	if (list->num_entries <= 0) return;
	for (i = 0; i < list->num_entries; i++)
		free(list->names[i]);
	free(list->names);
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0xc9b27
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x55790
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0xc9aff
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55790
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/libcpuid_util.c
// Function: match_features
void match_features(const struct feature_map_t* matchtable, int count, uint32_t reg, struct cpu_id_t* data)
{
	int i;
	for (i = 0; i < count; i++)
		if (reg & (1u << matchtable[i].bit))
			data->flags[matchtable[i].feature] = 1;
}

// Assembly:
testl %esi, %esi
jle 0xc9b81
movl %esi, %eax
xorl %esi, %esi
movl (%rdi,%rsi,8), %r8d
btl %r8d, %edx
jae 0xc9b79
movl 0x4(%rdi,%rsi,8), %r8d
movb $0x1, 0x58(%rcx,%r8)
incq %rsi
cmpq %rsi, %rax
jne 0xc9b64
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/libcpuid_util.c
// Function: warnf
void warnf(const char* format, ...)
{
	char buff[1024];
	va_list va;
	if (!_warn_fun) return;
	va_start(va, format);
	vsnprintf(buff, sizeof(buff), format, va);
	va_end(va);
	_warn_fun(buff);
}

// Assembly:
pushq %rbx
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xc9bde
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpq $0x0, 0xa46d2(%rip)     # 0x16e2b8
je 0xc9c31
movq %rdi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x4e0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0xd0(%rsp), %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
movq %r10, %rdx
callq 0x57330
movq %rbx, %rdi
callq *0xa4687(%rip)          # 0x16e2b8
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/libcpuid_util.c
// Function: debugf
void debugf(int verboselevel, const char* format, ...)
{
	char buff[1024];
	va_list va;
	if (verboselevel > _current_verboselevel) return;
	va_start(va, format);
	vsnprintf(buff, sizeof(buff), format, va);
	va_end(va);
	_warn_fun(buff);
}

// Assembly:
pushq %rbx
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xc9c91
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl %edi, 0xaf371(%rip)     # 0x179008
jl 0xc9ce2
movq %rsi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x4e0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
movq %r10, %rdx
callq 0x57330
movq %rbx, %rdi
callq *0xa45d6(%rip)          # 0x16e2b8
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/libcpuid_util.c
// Function: generic_get_cpu_list
void generic_get_cpu_list(const struct match_entry_t* matchtable, int count,
                          struct cpu_list_t* list)
{
	int i, j, n, good;
	n = 0;
	list->names = (char**) malloc(sizeof(char*) * count);
	if (!list->names) { /* Memory allocation failure */
		cpuid_set_error(ERR_NO_MEM);
		list->num_entries = 0;
		return;
	}
	for (i = 0; i < count; i++) {
		if (strstr(matchtable[i].name, "Unknown")) continue;
		good = 1;
		for (j = n - 1; j >= 0; j--)
			if (!strcmp(list->names[j], matchtable[i].name)) {
				good = 0;
				break;
			}
		if (!good) continue;
#if defined(_MSC_VER)
		list->names[n] = _strdup(matchtable[i].name);
#else
		list->names[n] = strdup(matchtable[i].name);
#endif
		if (!list->names[n]) { /* Memory allocation failure */
			cpuid_set_error(ERR_NO_MEM);
			list->num_entries = 0;
			for (j = 0; j < n; j++) {
				free(list->names[j]);
			}
			free(list->names);
			list->names = NULL;
			return;
		}
		n++;
	}
	list->num_entries = n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, 0x8(%rsp)
movslq %esi, %rdi
shlq $0x3, %rdi
callq 0x57ff0
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0xca15f
testl %ebp, %ebp
jle 0xca172
movq %rax, %r15
movl %ebp, %eax
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
xorl %ebx, %ebx
movq 0x8(%rsp), %rbp
movq %r14, 0x10(%rsp)
imulq $0x78, %r12, %rax
leaq (%rax,%rbp), %r13
addq $0x34, %r13
movq %r13, %rdi
leaq 0x4a872(%rip), %rsi     # 0x114954
callq 0x566b0
testq %rax, %rax
jne 0xca14f
movl %ebx, %eax
movq %rax, 0x18(%rsp)
testl %ebx, %ebx
jle 0xca127
movq 0x18(%rsp), %rax
leaq (%r15,%rax,8), %r14
addq $-0x8, %r14
movl %ebx, %ebp
movq (%r14), %rdi
movq %r13, %rsi
callq 0x57bc0
testl %eax, %eax
je 0xca145
addq $-0x8, %r14
decl %ebp
jg 0xca106
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbp
movq %r13, %rdi
callq 0x550f0
movslq %ebx, %rcx
movq %rax, (%r15,%rcx,8)
movq 0x8(%r14), %r15
cmpq $0x0, (%r15,%rcx,8)
je 0xca186
incl %ebx
jmp 0xca14f
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbp
incq %r12
cmpq 0x20(%rsp), %r12
jne 0xca0cc
jmp 0xca174
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0xc724c
movl $0x0, (%r14)
jmp 0xca177
xorl %ebx, %ebx
movl %ebx, (%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0xc724c
movl $0x0, (%r14)
testl %ebx, %ebx
movq 0x18(%rsp), %r15
jle 0xca1b7
xorl %ebx, %ebx
movq 0x8(%r14), %rax
movq (%rax,%rbx,8), %rdi
callq 0x55790
incq %rbx
cmpq %rbx, %r15
jne 0xca1a2
movq 0x8(%r14), %rdi
callq 0x55790
movq $0x0, 0x8(%r14)
jmp 0xca177
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/libcpuid_util.c
// Function: match_pattern
int match_pattern(const char* s, const char* p)
{
	int i, j, dj, k, n, m;
	n = (int) strlen(s);
	m = (int) strlen(p);
	for (i = 0; i < n; i++) {
		if (xmatch_entry(s[i], p) != -1) {
			j = 0;
			k = 0;
			while (j < m && ((dj = xmatch_entry(s[i + k], p + j)) != -1)) {
				k++;
				j += dj;
			}
			if (j == m) return i + 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x56370
movq %rax, %rbp
movq %rbx, %rdi
callq 0x56370
testl %ebp, %ebp
jle 0xca261
movq %rax, %r13
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq %r14, %r15
movq %r14, 0x10(%rsp)
movq %rbp, 0x8(%rsp)
movsbl (%r14,%r12), %edi
movq %rbx, %rsi
callq 0xca27b
cmpl $-0x1, %eax
je 0xca256
xorl %r14d, %r14d
testl %r13d, %r13d
jle 0xca247
movq %r15, %rbp
movsbl (%rbp), %edi
movslq %r14d, %rsi
addq %rbx, %rsi
callq 0xca27b
cmpl $-0x1, %eax
je 0xca247
addl %eax, %r14d
incq %rbp
cmpl %r13d, %r14d
jl 0xca228
cmpl %r13d, %r14d
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbp
je 0xca266
incq %r12
incq %r15
cmpq %rbp, %r12
jne 0xca20b
xorl %r12d, %r12d
jmp 0xca269
incl %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/libcpuid_util.c
// Function: xmatch_entry
static int xmatch_entry(char c, const char* p)
{
	int i, j;
	if (c == 0) return -1;
	if (c == p[0]) return 1;
	if (p[0] == '.') return 1;
	if (p[0] == '#' && isdigit(c)) return 1;
	if (p[0] == '[') {
		j = 1;
		while (p[j] && p[j] != ']') j++;
		if (!p[j]) return -1;
		for (i = 1; i < j; i++)
			if (p[i] == c) return j + 1;
	}
	return -1;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
testb %bl, %bl
je 0xca2ec
movzbl (%rsi), %ecx
movl $0x1, %eax
cmpb %bl, %cl
je 0xca2f1
cmpl $0x23, %ecx
je 0xca2b4
cmpl $0x2e, %ecx
je 0xca2f1
cmpl $0x5b, %ecx
jne 0xca2ec
movl $0x1, %eax
movzbl (%rsi,%rax), %ecx
testl %ecx, %ecx
je 0xca2ec
cmpl $0x5d, %ecx
je 0xca2d3
incq %rax
jmp 0xca2a2
callq 0x55570
movq (%rax), %rax
movsbq %bl, %rcx
movb 0x1(%rax,%rcx,2), %cl
andb $0x8, %cl
xorl %eax, %eax
cmpb $0x1, %cl
sbbl %eax, %eax
orl $0x1, %eax
jmp 0xca2f1
cmpq $0x2, %rax
jb 0xca2ec
leaq -0x1(%rax), %rcx
incq %rsi
cmpb %bl, (%rsi)
je 0xca2f3
incq %rsi
decq %rcx
jne 0xca2e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
incl %eax
jmp 0xca2f1
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/libcpuid_util.c
// Function: get_cached_cpuid
struct cpu_id_t* get_cached_cpuid(void)
{
	static int initialized = 0;
	static struct cpu_id_t id;
	if (initialized) return &id;
	if (cpu_identify(NULL, &id) != ERR_OK) {
		memset(&id, 0, sizeof(id));
		id.architecture = ARCHITECTURE_UNKNOWN;
		id.vendor       = VENDOR_UNKNOWN;
	}
	initialized = 1;
	return &id;
}

// Assembly:
cmpb $0x0, 0xaed0e(%rip)     # 0x17900c
jne 0xca342
pushq %rax
leaq 0xaed08(%rip), %rsi     # 0x179010
xorl %edi, %edi
callq 0xc89ed
testl %eax, %eax
je 0xca337
leaq 0xaecf6(%rip), %rdi     # 0x179010
movl $0x21e0, %edx           # imm = 0x21E0
xorl %esi, %esi
callq 0x55f20
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xaecdf(%rip)     # 0x179010
movl %eax, 0xaed2d(%rip)     # 0x179064
movb $0x1, 0xaecce(%rip)     # 0x17900c
addq $0x8, %rsp
leaq 0xaecc7(%rip), %rax     # 0x179010
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/libcpuid_util.c
// Function: debug_print_lbits
void debug_print_lbits(int debuglevel, uint64_t mask)
{
	int i, first = 0;
	for (i = 0; i < 64; i++) if (mask & (((uint64_t) 1) << i)) {
		if (first) first = 0;
		else debugf(debuglevel, " + ");
		debugf(debuglevel, "LBIT(%d)", i);
	}
	debugf(debuglevel, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x4a5f1(%rip), %r15     # 0x11495c
leaq 0x4a5ee(%rip), %r12     # 0x114960
xorl %r13d, %r13d
btq %r13, %r14
jae 0xca396
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0xc9c3a
movl %ebx, %edi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0xc9c3a
incq %r13
cmpq $0x40, %r13
jne 0xca375
leaq 0x47681(%rip), %rsi     # 0x111a27
movl %ebx, %edi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc9c3a
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/libcpuid_util.c
// Function: decode_number_of_cores_x86
void decode_number_of_cores_x86(struct cpu_raw_data_t* raw, struct cpu_id_t* data)
{
	int logical_cpus = -1, num_cores = -1;

	if (raw->basic_cpuid[0][EAX] >= 1) {
		logical_cpus = (raw->basic_cpuid[1][EBX] >> 16) & 0xff;
		if (raw->basic_cpuid[0][EAX] >= 4) {
			num_cores = 1 + ((raw->basic_cpuid[4][EAX] >> 26) & 0x3f);
		}
	}
	if (data->flags[CPU_FEATURE_HT]) {
		if (num_cores > 1) {
			data->num_cores = num_cores;
			data->num_logical_cpus = logical_cpus;
		} else {
			data->num_cores = 1;
			data->num_logical_cpus = (logical_cpus >= 1 ? logical_cpus : 1);
			if (data->num_logical_cpus == 1)
				data->flags[CPU_FEATURE_HT] = 0;
		}
	} else {
		data->num_cores = data->num_logical_cpus = (logical_cpus >= 1 ? logical_cpus : 1);
	}
}

// Assembly:
movl (%rdi), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %edx, %edx
je 0xca4b0
movzbl 0x16(%rdi), %eax
cmpl $0x4, %edx
jb 0xca4b5
movl 0x40(%rdi), %ecx
shrl $0x1a, %ecx
incl %ecx
jmp 0xca4b5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, 0x72(%rsi)
je 0xca4cd
cmpl $0x2, %ecx
jl 0xca4e5
movl %ecx, 0xec(%rsi)
movl %eax, 0xf0(%rsi)
retq
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movl %ecx, 0xf0(%rsi)
movl %ecx, 0xec(%rsi)
retq
movl $0x1, %ecx
movl %ecx, 0xec(%rsi)
cmpl $0x2, %eax
movl $0x1, %edx
cmovgel %eax, %edx
movl %edx, 0xf0(%rsi)
cmpl %ecx, %eax
jg 0xca4e4
movb $0x0, 0x72(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/rdtsc.c
// Function: cpu_clock_by_os
int cpu_clock_by_os(void)
{
	FILE *f;
	char line[1024], *s;
	int result;

	f = fopen("/proc/cpuinfo", "rt");
	if (!f) return -1;

	while (fgets(line, sizeof(line), f)) {
		if (!strncmp(line, "cpu MHz", 7)) {
			s = strchr(line, ':');
			if (s && 1 == sscanf(s, ":%d.", &result)) {
				fclose(f);
				return result;
			}
		}
	}
	fclose(f);
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
leaq 0x4a2d9(%rip), %rdi     # 0x114a75
leaq 0x47eb0(%rip), %rsi     # 0x112653
callq 0x58e70
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xca83e
movq %rax, %r14
leaq 0x10(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdx
callq 0x56f20
testq %rax, %rax
je 0xca836
movl $0x20757063, %ebp       # imm = 0x20757063
movl $0x7a484d20, %r12d      # imm = 0x7A484D20
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r13
movl 0x10(%rsp), %eax
xorl %ebp, %eax
movl 0x13(%rsp), %ecx
xorl %r12d, %ecx
orl %eax, %ecx
jne 0xca821
movq %r15, %rdi
movl $0x3a, %esi
callq 0x569e0
testq %rax, %rax
je 0xca821
movq %rax, %rdi
leaq 0x4a279(%rip), %rsi     # 0x114a8b
movq %r13, %rdx
xorl %eax, %eax
callq 0x55380
cmpl $0x1, %eax
je 0xca852
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x56f20
testq %rax, %rax
jne 0xca7e5
movq %r14, %rdi
callq 0x564b0
movl %ebx, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x564b0
movl 0xc(%rsp), %ebx
jmp 0xca83e
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libcpuid/rdtsc.c
// Function: cpu_clock
int cpu_clock(void)
{
	int result;
	result = cpu_clock_by_os();
	if (result <= 0)
		result = cpu_clock_measure(200, 1);
	return result;
}

// Assembly:
pushq %rax
callq 0xca784
testl %eax, %eax
jle 0xcadf0
popq %rcx
retq
movl $0xc8, %edi
movl $0x1, %esi
popq %rax
jmp 0xca8d8
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/buffer_dec.c
// Function: WebPFlipBuffer
VP8StatusCode WebPFlipBuffer(WebPDecBuffer* const buffer) {
  if (buffer == NULL) {
    return VP8_STATUS_INVALID_PARAM;
  }
  if (WebPIsRGBMode(buffer->colorspace)) {
    WebPRGBABuffer* const buf = &buffer->u.RGBA;
    buf->rgba += (int64_t)(buffer->height - 1) * buf->stride;
    buf->stride = -buf->stride;
  } else {
    WebPYUVABuffer* const buf = &buffer->u.YUVA;
    const int64_t H = buffer->height;
    buf->y += (H - 1) * buf->y_stride;
    buf->y_stride = -buf->y_stride;
    buf->u += ((H - 1) >> 1) * buf->u_stride;
    buf->u_stride = -buf->u_stride;
    buf->v += ((H - 1) >> 1) * buf->v_stride;
    buf->v_stride = -buf->v_stride;
    if (buf->a != NULL) {
      buf->a += (H - 1) * buf->a_stride;
      buf->a_stride = -buf->a_stride;
    }
  }
  return VP8_STATUS_OK;
}

// Assembly:
testq %rdi, %rdi
je 0xcced3
cmpl $0xa, (%rdi)
movslq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
jbe 0xcced9
decq %rcx
movslq 0x30(%rdi), %rdx
movq %rdx, %rsi
imulq %rcx, %rsi
addq %rsi, %rax
movq %rax, 0x10(%rdi)
negl %edx
movl %edx, 0x30(%rdi)
movq %rcx, %rax
sarq %rax
movslq 0x34(%rdi), %rdx
movq %rdx, %rsi
imulq %rax, %rsi
addq %rsi, 0x18(%rdi)
negl %edx
movl %edx, 0x34(%rdi)
movslq 0x38(%rdi), %rdx
imulq %rdx, %rax
addq %rax, 0x20(%rdi)
negl %edx
movl %edx, 0x38(%rdi)
movq 0x28(%rdi), %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0xcced2
movslq 0x3c(%rdi), %rsi
imulq %rsi, %rcx
addq %rcx, %rdx
movq %rdx, 0x28(%rdi)
negl %esi
movl %esi, 0x3c(%rdi)
retq
movl $0x2, %eax
retq
decq %rcx
movslq 0x18(%rdi), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rdi)
negl %edx
movl %edx, 0x18(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/buffer_dec.c
// Function: WebPFreeDecBuffer
void WebPFreeDecBuffer(WebPDecBuffer* buffer) {
  if (buffer != NULL) {
    if (buffer->is_external_memory <= 0) {
      WebPSafeFree(buffer->private_memory);
    }
    buffer->private_memory = NULL;
  }
}

// Assembly:
testq %rdi, %rdi
je 0xcd18a
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
jg 0xcd181
movq 0x70(%rbx), %rdi
callq 0x57290
movq $0x0, 0x70(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/buffer_dec.c
// Function: WebPCopyDecBuffer
void WebPCopyDecBuffer(const WebPDecBuffer* const src,
                       WebPDecBuffer* const dst) {
  if (src != NULL && dst != NULL) {
    *dst = *src;
    if (src->private_memory != NULL) {
      dst->is_external_memory = 1;   // dst buffer doesn't own the memory.
      dst->private_memory = NULL;
    }
  }
}

// Assembly:
movq %rsi, %rax
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %sil
orb %cl, %sil
jne 0xcd1c7
movq %rdi, %rdx
movl $0xf, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
cmpq $0x0, 0x70(%rdx)
je 0xcd1c7
movl $0x1, 0xc(%rax)
movq $0x0, 0x70(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/buffer_dec.c
// Function: WebPGrabDecBuffer
void WebPGrabDecBuffer(WebPDecBuffer* const src, WebPDecBuffer* const dst) {
  if (src != NULL && dst != NULL) {
    *dst = *src;
    if (src->private_memory != NULL) {
      src->is_external_memory = 1;   // src relinquishes ownership
      src->private_memory = NULL;
    }
  }
}

// Assembly:
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0xcd1ff
movq %rdi, %rax
movl $0xf, %ecx
movq %rsi, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
cmpq $0x0, 0x70(%rax)
je 0xcd1ff
movl $0x1, 0xc(%rax)
movq $0x0, 0x70(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/buffer_dec.c
// Function: WebPAvoidSlowMemory
int WebPAvoidSlowMemory(const WebPDecBuffer* const output,
                        const WebPBitstreamFeatures* const features) {
  assert(output != NULL);
  return (output->is_external_memory >= 2) &&
         WebPIsPremultipliedMode(output->colorspace) &&
         (features != NULL && features->has_alpha);
}

// Assembly:
testq %rdi, %rdi
je 0xcd547
xorl %eax, %eax
cmpl $0x2, 0xc(%rdi)
jl 0xcd546
testq %rsi, %rsi
je 0xcd546
movl (%rdi), %ecx
addl $-0x7, %ecx
cmpl $0x3, %ecx
ja 0xcd546
xorl %eax, %eax
cmpl $0x0, 0x8(%rsi)
setne %al
retq
pushq %rax
leaq 0x5b307(%rip), %rdi     # 0x128856
leaq 0x5b268(%rip), %rsi     # 0x1287be
leaq 0x5b308(%rip), %rcx     # 0x128865
movl $0x130, %edx            # imm = 0x130
callq 0x55710
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPParseHeaders
VP8StatusCode WebPParseHeaders(WebPHeaderStructure* const headers) {
  // status is marked volatile as a workaround for a clang-3.8 (aarch64) bug
  volatile VP8StatusCode status;
  int has_animation = 0;
  assert(headers != NULL);
  // fill out headers, ignore width/height/has_alpha.
  status = ParseHeadersInternal(headers->data, headers->data_size,
                                NULL, NULL, NULL, &has_animation,
                                NULL, headers);
  if (status == VP8_STATUS_OK || status == VP8_STATUS_NOT_ENOUGH_DATA) {
    // The WebPDemux API + libwebp can be used to decode individual
    // uncomposited frames or the WebPAnimDecoder can be used to fully
    // reconstruct them (see webp/demux.h).
    if (has_animation) {
      status = VP8_STATUS_UNSUPPORTED_FEATURE;
    }
  }
  return status;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
testq %rdi, %rdi
je 0xcd5bc
movq %rdi, %rax
movq (%rdi), %rdi
movq 0x8(%rax), %rsi
leaq 0x4(%rsp), %r9
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq $0x0
callq 0xcd5db
addq $0x10, %rsp
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0xcd5a9
movl (%rsp), %eax
cmpl $0x7, %eax
jne 0xcd5b7
cmpl $0x0, 0x4(%rsp)
je 0xcd5b7
movl $0x4, (%rsp)
movl (%rsp), %eax
popq %rcx
retq
leaq 0x5b307(%rip), %rdi     # 0x1288ca
leaq 0x5b310(%rip), %rsi     # 0x1288da
leaq 0x5b31c(%rip), %rcx     # 0x1288ed
movl $0x1a5, %edx            # imm = 0x1A5
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: DecodeIntoRGBABuffer
WEBP_NODISCARD static uint8_t* DecodeIntoRGBABuffer(WEBP_CSP_MODE colorspace,
                                                    const uint8_t* const data,
                                                    size_t data_size,
                                                    uint8_t* const rgba,
                                                    int stride, size_t size) {
  WebPDecParams params;
  WebPDecBuffer buf;
  if (rgba == NULL || !WebPInitDecBuffer(&buf)) {
    return NULL;
  }
  WebPResetDecParams(&params);
  params.output = &buf;
  buf.colorspace    = colorspace;
  buf.u.RGBA.rgba   = rgba;
  buf.u.RGBA.stride = stride;
  buf.u.RGBA.size   = size;
  buf.is_external_memory = 1;
  if (DecodeInto(data, data_size, &params) != VP8_STATUS_OK) {
    return NULL;
  }
  return rgba;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
testq %rcx, %rcx
je 0xcdad7
movq %r9, %r15
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
movl %edi, %r14d
movq %rsp, %rdi
movl $0x209, %esi            # imm = 0x209
callq 0x56a10
testl %eax, %eax
je 0xcdad7
xorps %xmm0, %xmm0
leaq 0x78(%rsp), %rdx
movups %xmm0, 0x58(%rdx)
movups %xmm0, 0x48(%rdx)
movups %xmm0, 0x38(%rdx)
movups %xmm0, 0x28(%rdx)
movups %xmm0, 0x18(%rdx)
movups %xmm0, 0x8(%rdx)
movq %r13, %rsi
xorl %r13d, %r13d
movq %r13, 0x68(%rdx)
movq %rsp, %rax
movq %rax, (%rdx)
movl %r14d, (%rsp)
movq %rbx, 0x10(%rsp)
movl %ebp, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movl $0x1, 0xc(%rsp)
movq %r12, %rdi
callq 0xcdc3f
testl %eax, %eax
cmoveq %rbx, %r13
jmp 0xcdada
xorl %r13d, %r13d
movq %r13, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPDecodeYUVInto
uint8_t* WebPDecodeYUVInto(const uint8_t* data, size_t data_size,
                           uint8_t* luma, size_t luma_size, int luma_stride,
                           uint8_t* u, size_t u_size, int u_stride,
                           uint8_t* v, size_t v_size, int v_stride) {
  WebPDecParams params;
  WebPDecBuffer output;
  if (luma == NULL || !WebPInitDecBuffer(&output)) return NULL;
  WebPResetDecParams(&params);
  params.output = &output;
  output.colorspace      = MODE_YUV;
  output.u.YUVA.y        = luma;
  output.u.YUVA.y_stride = luma_stride;
  output.u.YUVA.y_size   = luma_size;
  output.u.YUVA.u        = u;
  output.u.YUVA.u_stride = u_stride;
  output.u.YUVA.u_size   = u_size;
  output.u.YUVA.v        = v;
  output.u.YUVA.v_stride = v_stride;
  output.u.YUVA.v_size   = v_size;
  output.is_external_memory = 1;
  if (DecodeInto(data, data_size, &params) != VP8_STATUS_OK) {
    return NULL;
  }
  return luma;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
testq %rdx, %rdx
je 0xcdc27
movq %r9, %r12
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdi
movl $0x209, %esi            # imm = 0x209
callq 0x56a10
testl %eax, %eax
je 0xcdc27
movl 0x140(%rsp), %eax
movq 0x138(%rsp), %rcx
movq 0x130(%rsp), %r9
movl 0x128(%rsp), %edi
movq 0x120(%rsp), %r8
xorps %xmm0, %xmm0
leaq 0x78(%rsp), %rdx
movups %xmm0, 0x58(%rdx)
movups %xmm0, 0x48(%rdx)
movups %xmm0, 0x38(%rdx)
movups %xmm0, 0x28(%rdx)
movups %xmm0, 0x18(%rdx)
movups %xmm0, 0x8(%rdx)
movq %r14, %rsi
xorl %r14d, %r14d
movq %r14, 0x68(%rdx)
movq %rsp, %r10
movq %r10, (%rdx)
movl $0xb, (%rsp)
movq %rbx, 0x10(%rsp)
movl %ebp, 0x30(%rsp)
movq %r13, 0x40(%rsp)
movq %r12, 0x18(%rsp)
movl %edi, 0x34(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x20(%rsp)
movl %eax, 0x38(%rsp)
movq %rcx, 0x50(%rsp)
movl $0x1, 0xc(%rsp)
movq %r15, %rdi
callq 0xcdc3f
testl %eax, %eax
cmoveq %rbx, %r14
jmp 0xcdc2a
xorl %r14d, %r14d
movq %r14, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: Decode
WEBP_NODISCARD static uint8_t* Decode(WEBP_CSP_MODE mode,
                                      const uint8_t* const data,
                                      size_t data_size, int* const width,
                                      int* const height,
                                      WebPDecBuffer* const keep_info) {
  WebPDecParams params;
  WebPDecBuffer output;

  if (!WebPInitDecBuffer(&output)) {
    return NULL;
  }
  WebPResetDecParams(&params);
  params.output = &output;
  output.colorspace = mode;

  // Retrieve (and report back) the required dimensions from bitstream.
  if (!WebPGetInfo(data, data_size, &output.width, &output.height)) {
    return NULL;
  }
  if (width != NULL) *width = output.width;
  if (height != NULL) *height = output.height;

  // Decode
  if (DecodeInto(data, data_size, &params) != VP8_STATUS_OK) {
    return NULL;
  }
  if (keep_info != NULL) {    // keep track of the side-info
    WebPCopyDecBuffer(&output, keep_info);
  }
  // return decoded samples (don't clear 'output'!)
  return WebPIsRGBMode(mode) ? output.u.RGBA.rgba : output.u.YUVA.y;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl $0x209, %esi            # imm = 0x209
callq 0x56a10
testl %eax, %eax
je 0xcdf08
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rsp)
movups %xmm0, 0x58(%rsp)
movups %xmm0, 0x48(%rsp)
movups %xmm0, 0x38(%rsp)
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x78(%rsp)
movq %rbx, 0x10(%rsp)
leaq 0x84(%rsp), %rdx
movl %ebp, -0x4(%rdx)
leaq 0x88(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x57760
testl %eax, %eax
je 0xcdf08
testq %r13, %r13
je 0xcdee4
movl 0x84(%rsp), %eax
movl %eax, (%r13)
testq %r12, %r12
je 0xcdef4
movl 0x88(%rsp), %eax
movl %eax, (%r12)
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xcdc3f
testl %eax, %eax
je 0xcdf1c
xorl %eax, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xcdf33
leaq 0x80(%rsp), %rdi
callq 0xcd18b
movq 0x90(%rsp), %rax
jmp 0xcdf0a
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPDecodeYUV
uint8_t* WebPDecodeYUV(const uint8_t* data, size_t data_size,
                       int* width, int* height, uint8_t** u, uint8_t** v,
                       int* stride, int* uv_stride) {
  // data, width and height are checked by Decode().
  if (u == NULL || v == NULL || stride == NULL || uv_stride == NULL) {
    return NULL;
  }

  {
    WebPDecBuffer output;   // only to preserve the side-infos
    uint8_t* const out = Decode(MODE_YUV, data, data_size,
                                width, height, &output);

    if (out != NULL) {
      const WebPYUVABuffer* const buf = &output.u.YUVA;
      *u = buf->u;
      *v = buf->v;
      *stride = buf->y_stride;
      *uv_stride = buf->u_stride;
      assert(buf->u_stride == buf->v_stride);
    }
    return out;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %r8, %r14
movq %r9, %xmm0
movq %r8, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm1
pcmpeqd 0x90(%rsp), %xmm0
movdqa %xmm1, %xmm2
shufps $0xdd, %xmm0, %xmm2     # xmm2 = xmm2[1,3],xmm0[1,3]
shufps $0x88, %xmm0, %xmm1     # xmm1 = xmm1[0,2],xmm0[0,2]
andps %xmm2, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
je 0xcdfe4
xorl %eax, %eax
jmp 0xce037
movq %r9, %rbx
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %r9
movl $0xb, %edi
callq 0xcde42
testq %rax, %rax
je 0xce037
movq 0x98(%rsp), %rcx
movq 0x90(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq %rsi, (%r14)
movq 0x20(%rsp), %rsi
movq %rsi, (%rbx)
movl 0x30(%rsp), %esi
movl %esi, (%rdx)
movl 0x34(%rsp), %edx
movl %edx, (%rcx)
cmpl 0x38(%rsp), %edx
jne 0xce03f
addq $0x78, %rsp
popq %rbx
popq %r14
retq
leaq 0x5a8e2(%rip), %rdi     # 0x128928
leaq 0x5a88d(%rip), %rsi     # 0x1288da
leaq 0x5a8f3(%rip), %rcx     # 0x128947
movl $0x2ad, %edx            # imm = 0x2AD
callq 0x55710