LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xca30d
movq %rsi, %r15
leaq 0x2(%rsi), %r13
addq $0x8, %r15
jmp 0xca325
leaq 0x10(%rsp), %rdi
callq 0xc83da
testl %eax, %eax
js 0xca37c
leaq 0x18(%rsp), %r15
leaq 0x12(%rsp), %r13
movl $0xffffffef, %r14d      # imm = 0xFFFFFFEF
cmpw $0x0, (%r13)
je 0xca37f
movq %rbx, 0x8(%rsp)
xorl %r12d, %r12d
xorl %ebx, %ebx
movq (%r15), %rdi
addq %r12, %rdi
callq 0xca10b
cmpl %ebp, %eax
je 0xca362
incq %rbx
movzwl (%r13), %eax
addq $0x580, %r12            # imm = 0x580
cmpq %rax, %rbx
jb 0xca33d
jmp 0xca37f
addq (%r15), %r12
leaq 0x20(%rsp), %rdx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0xc94ec
xorl %r14d, %r14d
jmp 0xca37f
movl %eax, %r14d
leaq 0xa1faa(%rip), %rdi     # 0x16c330
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_O1/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 0xca469
movl %edx, %ebp
movq %rdi, %r14
movl $0x1fff, %r12d          # imm = 0x1FFF
xorl %eax, %eax
leaq 0x4a638(%rip), %r15     # 0x114a55
xorl %r13d, %r13d
cmpq $0x4, %r12
setb %cl
orb %al, %cl
testb $0x1, %cl
jne 0xca435
cmpb $0x0, (%r14,%r12)
je 0xca456
movzwl %r13w, %edi
addq %rbx, %rdi
movzbl (%r14,%r12), %ecx
movl $0x3, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x56850
addl $0x2, %r13d
movb $0x1, %al
movzwl %r13w, %ecx
subq $0x1, %r12
jb 0xca46b
leal 0x1(%rcx), %edx
cmpl %ebp, %edx
jb 0xca420
jmp 0xca46b
xorl %ecx, %ecx
movb $0x0, (%rbx,%rcx)
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_O1/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:
cmpl $-0x1, 0xa4d8e(%rip)    # 0x16f2b4
jne 0xca577
pushq %rbx
subq $0x20, %rsp
callq 0xcd8f0
testl %eax, %eax
je 0xca55c
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movq %rbx, %rdi
callq 0xcd8f6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xca57e
movl %eax, 0xa4d5a(%rip)     # 0x16f2b4
jmp 0xca572
leaq 0xa1dcd(%rip), %rdi     # 0x16c330
callq 0x566e0
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbx
movl 0xa4d37(%rip), %eax     # 0x16f2b4
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xca650
movl %edi, %eax
leaq 0x4a097(%rip), %rcx     # 0x114680
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
jmp 0xcc254
leaq 0x4a8c0(%rip), %rdi     # 0x114ec2
jmp 0xca64a
leaq 0x4a8e2(%rip), %rdi     # 0x114eed
jmp 0xca64a
movq %rbx, %rdi
popq %rbx
jmp 0xcd8d7
leaq 0x4a86d(%rip), %rdi     # 0x114e8a
jmp 0xca64a
movq %rbx, %rdi
popq %rbx
jmp 0xcc4a5
leaq 0x4a899(%rip), %rdi     # 0x114ec8
jmp 0xca64a
leaq 0x4a8a0(%rip), %rdi     # 0x114ed8
jmp 0xca64a
leaq 0x4a8b4(%rip), %rdi     # 0x114ef5
jmp 0xca64a
leaq 0x4a89a(%rip), %rdi     # 0x114ee4
movq %rbx, %rsi
popq %rbx
jmp 0xca684
leaq 0x4a8c7(%rip), %rdi     # 0x114f1e
xorl %eax, %eax
callq 0xca95e
leaq 0xa1ccb(%rip), %rdi     # 0x16c330
callq 0x566e0
movl $0xfffffff0, 0x30(%rax) # imm = 0xFFFFFFF0
movl $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x56370
movq %rax, %r15
testl %r15d, %r15d
jle 0xca6c9
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 0xca6b1
incl %ebp
jmp 0xca6ce
movl $0x1, %ebp
movslq %ebp, %rdi
shlq $0x3, %rdi
callq 0x57ff0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xca789
movl %ebp, (%rbx)
testl %r15d, %r15d
js 0xca7f3
leaq 0x1(%r14), %rax
movq %rax, (%rsp)
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x10(%rsp)
leal 0x1(%r15), %eax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %ebp, %ebp
cmpq %r12, 0x10(%rsp)
je 0xca729
cmpb $0x2c, (%r14,%r12)
jne 0xca77d
movl %r12d, %eax
subl %r15d, %eax
movslq %eax, %rdi
callq 0x57ff0
movq 0x8(%rbx), %rcx
movslq %ebp, %r13
movq %rax, (%rcx,%r13,8)
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0xca7a7
movslq %r15d, %rsi
addq (%rsp), %rsi
notl %r15d
addl %r12d, %r15d
movslq %r15d, %r15
movq %r15, %rdx
callq 0x552d0
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
movb $0x0, (%rax,%r15)
incl %r13d
movl %r13d, %ebp
movl %r12d, %r15d
incq %r12
cmpq %r12, 0x8(%rsp)
jne 0xca71b
jmp 0xca7f3
movl $0x0, (%rbx)
leaq 0xa1b9a(%rip), %rdi     # 0x16c330
callq 0x566e0
movl $0xfffffffd, 0x30(%rax) # imm = 0xFFFFFFFD
jmp 0xca7f3
leaq 0xa1b82(%rip), %rdi     # 0x16c330
callq 0x566e0
movl $0xfffffffd, 0x30(%rax) # imm = 0xFFFFFFFD
testl %ebp, %ebp
jle 0xca7dc
movl %ebp, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x55790
incq %r15
cmpq %r15, %r14
jne 0xca7c7
movq 0x8(%rbx), %rdi
callq 0x55790
movl $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xca902
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0xca8f2
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x55790
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0xca8da
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55790
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xca95d
movl %esi, %eax
xorl %esi, %esi
movl (%rdi,%rsi,8), %r8d
btl %r8d, %edx
jae 0xca955
movl 0x4(%rdi,%rsi,8), %r8d
movb $0x1, 0x58(%rcx,%r8)
incq %rsi
cmpq %rsi, %rax
jne 0xca940
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xca9ba
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, 0xa48f6(%rip)     # 0x16f2b8
je 0xcaa0d
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 *0xa48ab(%rip)          # 0x16f2b8
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcaa6d
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, 0xaf595(%rip)     # 0x17a008
jl 0xcaabe
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 *0xa47fa(%rip)          # 0x16f2b8
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %rdi
shlq $0x3, %rdi
callq 0x57ff0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xcaf36
testl %ebp, %ebp
jle 0xcaf48
movl %ebp, %r13d
xorl %r15d, %r15d
leaq 0x4a8aa(%rip), %rbp     # 0x115744
movl $0x0, 0x4(%rsp)
movq %r13, 0x8(%rsp)
imulq $0x78, %r15, %rax
leaq (%r14,%rax), %r12
addq $0x34, %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x566b0
testq %rax, %rax
jne 0xcaf28
movq %rbp, %r13
movq %r14, %rbp
movl 0x4(%rsp), %r14d
movq %r14, 0x10(%rsp)
testl %r14d, %r14d
jle 0xcaef2
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r14,8), %rdi
decq %r14
movq %r12, %rsi
callq 0x57bc0
testl %eax, %eax
jne 0xcaed3
jmp 0xcaf1d
movq %r12, %rdi
callq 0x550f0
movq 0x8(%rbx), %rcx
movl 0x4(%rsp), %r14d
movslq %r14d, %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x8(%rbx), %rax
cmpq $0x0, (%rax,%rdx,8)
je 0xcaf65
incl %r14d
movl %r14d, 0x4(%rsp)
movq %rbp, %r14
movq %r13, %rbp
movq 0x8(%rsp), %r13
incq %r15
cmpq %r13, %r15
jne 0xcaea7
jmp 0xcaf50
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0xc81e8
movl $0x0, (%rbx)
jmp 0xcaf56
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0xc81e8
movl $0x0, (%rbx)
testl %r14d, %r14d
movq 0x10(%rsp), %r15
jle 0xcaf97
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x55790
incq %r14
cmpq %r14, %r15
jne 0xcaf82
movq 0x8(%rbx), %rdi
callq 0x55790
movq $0x0, 0x8(%rbx)
jmp 0xcaf56
// File: /workspace/github_c_makefile_star2_O1/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 0xcb041
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 0xcb05b
cmpl $-0x1, %eax
je 0xcb036
xorl %r14d, %r14d
testl %r13d, %r13d
jle 0xcb027
movq %r15, %rbp
movsbl (%rbp), %edi
movslq %r14d, %rsi
addq %rbx, %rsi
callq 0xcb05b
cmpl $-0x1, %eax
je 0xcb027
addl %eax, %r14d
incq %rbp
cmpl %r13d, %r14d
jl 0xcb008
cmpl %r13d, %r14d
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbp
je 0xcb046
incq %r12
incq %r15
cmpq %rbp, %r12
jne 0xcafeb
xorl %r12d, %r12d
jmp 0xcb049
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
testb %bpl, %bpl
je 0xcb0d7
movq %rsi, %r14
movzbl (%rsi), %r15d
movl $0x1, %ebx
cmpb %bpl, %r15b
je 0xcb0dc
cmpl $0x5b, %r15d
je 0xcb0a5
cmpl $0x2e, %r15d
je 0xcb0dc
cmpl $0x23, %r15d
jne 0xcb0d7
callq 0x55570
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0xcb0dc
cmpl $0x5b, %r15d
jne 0xcb0d7
movl $0x1, %ebx
movzbl (%r14,%rbx), %eax
testl %eax, %eax
je 0xcb0d7
cmpl $0x5d, %eax
je 0xcb0bd
incq %rbx
jmp 0xcb0aa
cmpq $0x2, %rbx
jb 0xcb0d7
leaq -0x1(%rbx), %rax
incq %r14
cmpb %bpl, (%r14)
je 0xcb0e9
incq %r14
decq %rax
jne 0xcb0ca
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incl %ebx
jmp 0xcb0dc
// File: /workspace/github_c_makefile_star2_O1/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, 0xaef18(%rip)     # 0x17a00c
jne 0xcb138
pushq %rax
leaq 0xaef12(%rip), %rsi     # 0x17a010
xorl %edi, %edi
callq 0xc9904
testl %eax, %eax
je 0xcb12d
leaq 0xaef00(%rip), %rdi     # 0x17a010
movl $0x21e0, %edx           # imm = 0x21E0
xorl %esi, %esi
callq 0x55f20
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xaeee9(%rip)     # 0x17a010
movl %eax, 0xaef37(%rip)     # 0x17a064
movb $0x1, 0xaeed8(%rip)     # 0x17a00c
addq $0x8, %rsp
leaq 0xaeed1(%rip), %rax     # 0x17a010
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4a5eb(%rip), %r15     # 0x11574c
leaq 0x4a5e8(%rip), %r12     # 0x115750
xorl %r13d, %r13d
btq %r13, %r14
jae 0xcb18c
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0xcaa16
movl %ebx, %edi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0xcaa16
incq %r13
cmpq $0x40, %r13
jne 0xcb16b
leaq 0x476e7(%rip), %rsi     # 0x112883
movl %ebx, %edi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcaa16
// File: /workspace/github_c_makefile_star2_O1/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 0xcb2a6
movzbl 0x16(%rdi), %eax
cmpl $0x4, %edx
jb 0xcb2ab
movl 0x40(%rdi), %ecx
shrl $0x1a, %ecx
incl %ecx
jmp 0xcb2ab
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x0, 0x72(%rsi)
je 0xcb2c3
cmpl $0x2, %ecx
jl 0xcb2db
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 0xcb2da
movb $0x0, 0x72(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4a2d1(%rip), %rdi     # 0x115865
leaq 0x47ef3(%rip), %rsi     # 0x11348e
callq 0x58e70
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xcb636
movq %rax, %r14
leaq 0x10(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdx
callq 0x56f20
testq %rax, %rax
je 0xcb62e
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 0xcb619
movq %r15, %rdi
movl $0x3a, %esi
callq 0x569e0
testq %rax, %rax
je 0xcb619
movq %rax, %rdi
leaq 0x4a271(%rip), %rsi     # 0x11587b
movq %r13, %rdx
xorl %eax, %eax
callq 0x55380
cmpl $0x1, %eax
je 0xcb64a
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x56f20
testq %rax, %rax
jne 0xcb5dd
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 0xcb636
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libcpuid/rdtsc.c
// Function: busy_loop_delay
int busy_loop_delay(int milliseconds)
{
	int cycles = 0, r = 0, first = 1;
	uint64_t a, b, c;
	sys_precise_clock(&a);
	while (1) {
		sys_precise_clock(&c);
		if ((c - a) / 1000 > milliseconds) return r;
		r += busy_loop(cycles);
		if (first) {
			first = 0;
		} else {
			if (c - b < 1000) cycles *= 2;
			if (c - b > 10000) cycles /= 2;
		}
		b = c;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x567e0
movq (%rbx), %r14
movq 0x8(%rbx), %r15
movslq %ebp, %r12
movabsq $0x20c49ba5e353f7cf, %r13 # imm = 0x20C49BA5E353F7CF
movq %rbx, %rdi
xorl %esi, %esi
callq 0x567e0
movq 0x8(%rsp), %rax
subq %r14, %rax
movq 0x10(%rsp), %rcx
subq %r15, %rcx
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
addq %rcx, %rax
shrq $0x3, %rax
mulq %r13
shrq $0x4, %rdx
cmpq %r12, %rdx
jbe 0xcb68b
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcb57c
testl %eax, %eax
jle 0xcbbf3
popq %rcx
retq
movl $0xc8, %edi
movl $0x1, %esi
popq %rax
jmp 0xcb6d0
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libcpuid/recog_intel.c
// Function: cpuid_get_epc
struct cpu_epc_t cpuid_get_epc(int index, const struct cpu_raw_data_t* raw)
{
	uint32_t regs[4];
	struct cpu_epc_t retval = {0, 0};
	if (raw && index < MAX_INTELFN12H_LEVEL - 2) {
		// this was queried already, use the data:
		memcpy(regs, raw->intel_fn12h[2 + index], sizeof(regs));
	} else {
		// query this ourselves:
		regs[0] = 0x12;
		regs[2] = 2 + index;
		regs[1] = regs[3] = 0;
		cpu_exec_cpuid_ext(regs);
	}

	// decode values:
	if ((regs[0] & 0xf) == 0x1) {
		retval.start_addr |= (regs[0] & 0xfffff000); // bits [12, 32) -> bits [12, 32)
		retval.start_addr |= ((uint64_t) (regs[1] & 0x000fffff)) << 32; // bits [0, 20) -> bits [32, 52)
		retval.length     |= (regs[2] & 0xfffff000); // bits [12, 32) -> bits [12, 32)
		retval.length     |= ((uint64_t) (regs[3] & 0x000fffff)) << 32; // bits [0, 20) -> bits [32, 52)
	}
	return retval;
}

// Assembly:
subq $0x18, %rsp
testq %rsi, %rsi
sete %al
cmpl $0x2, %edi
setge %cl
addl $0x2, %edi
orb %al, %cl
jne 0xcc4e8
movslq %edi, %rax
shlq $0x4, %rax
movups 0x4c0(%rsi,%rax), %xmm0
movaps %xmm0, (%rsp)
jmp 0xcc504
movq %rsp, %rax
movq $0x12, (%rax)
movl %edi, 0x8(%rax)
movl $0x0, 0xc(%rax)
movq %rax, %rdi
callq 0xc823e
movl (%rsp), %ecx
movl %ecx, %eax
andl $0xf, %eax
cmpl $0x1, %eax
jne 0xcc540
andl $0xfffff000, %ecx       # imm = 0xFFFFF000
movl $0xfffff, %edx          # imm = 0xFFFFF
movl 0x4(%rsp), %eax
andl %edx, %eax
shlq $0x20, %rax
orq %rcx, %rax
movl 0x8(%rsp), %ecx
andl $0xfffff000, %ecx       # imm = 0xFFFFF000
andl 0xc(%rsp), %edx
shlq $0x20, %rdx
orq %rcx, %rdx
jmp 0xcc544
xorl %edx, %edx
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcdce3
cmpl $0xa, (%rdi)
movslq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
jbe 0xcdce9
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 0xcdce2
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_O1/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 0xcdfd6
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
jg 0xcdfcd
movq 0x70(%rbx), %rdi
callq 0x57290
movq $0x0, 0x70(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xce013
movq %rdi, %rdx
movl $0xf, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
cmpq $0x0, 0x70(%rdx)
je 0xce013
movl $0x1, 0xc(%rax)
movq $0x0, 0x70(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xce04b
movq %rdi, %rax
movl $0xf, %ecx
movq %rsi, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
cmpq $0x0, 0x70(%rax)
je 0xce04b
movl $0x1, 0xc(%rax)
movq $0x0, 0x70(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xce381
xorl %eax, %eax
cmpl $0x2, 0xc(%rdi)
jl 0xce380
testq %rsi, %rsi
je 0xce380
movl (%rdi), %ecx
addl $-0x7, %ecx
cmpl $0x3, %ecx
ja 0xce380
xorl %eax, %eax
cmpl $0x0, 0x8(%rsi)
setne %al
retq
pushq %rax
leaq 0x5b2ad(%rip), %rdi     # 0x129636
leaq 0x5b20e(%rip), %rsi     # 0x12959e
leaq 0x5b2ae(%rip), %rcx     # 0x129645
movl $0x130, %edx            # imm = 0x130
callq 0x55710
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xce3f8
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 0xce417
addq $0x10, %rsp
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0xce3e5
movl (%rsp), %eax
cmpl $0x7, %eax
jne 0xce3f3
cmpl $0x0, 0x4(%rsp)
je 0xce3f3
movl $0x4, (%rsp)
movl (%rsp), %eax
popq %rcx
retq
leaq 0x5b2ab(%rip), %rdi     # 0x1296aa
leaq 0x5b2b4(%rip), %rsi     # 0x1296ba
leaq 0x5b2c0(%rip), %rcx     # 0x1296cd
movl $0x1a5, %edx            # imm = 0x1A5
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rcx, %rcx
je 0xce9d1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %r15
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %r13d
leaq 0x8(%rsp), %rdi
movl $0x209, %esi            # imm = 0x209
callq 0x56a10
testl %eax, %eax
je 0xce9d4
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x60(%rdx)
movaps %xmm0, 0x50(%rdx)
movaps %xmm0, 0x40(%rdx)
movaps %xmm0, 0x30(%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
leaq 0x8(%rsp), %rax
movq %rax, (%rdx)
movl %r13d, 0x8(%rsp)
movq %rbx, 0x18(%rsp)
movl %ebp, 0x20(%rsp)
movq %r15, 0x28(%rsp)
movl $0x1, 0x14(%rsp)
movq %r12, %rdi
movq %r14, %rsi
callq 0xceb3f
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmoveq %rbx, %rax
jmp 0xce9d6
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdx, %rdx
je 0xceb28
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %r12
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movl $0x209, %esi            # imm = 0x209
callq 0x56a10
testl %eax, %eax
je 0xceb2b
movl 0x150(%rsp), %eax
movq 0x148(%rsp), %rcx
movq 0x140(%rsp), %rsi
movl 0x138(%rsp), %edi
movq 0x130(%rsp), %r8
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x60(%rdx)
movaps %xmm0, 0x50(%rdx)
movaps %xmm0, 0x40(%rdx)
movaps %xmm0, 0x30(%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
leaq 0x8(%rsp), %r9
movq %r9, (%rdx)
movl $0xb, 0x8(%rsp)
movq %rbx, 0x18(%rsp)
movl %ebp, 0x38(%rsp)
movq %r13, 0x48(%rsp)
movq %r12, 0x20(%rsp)
movl %edi, 0x3c(%rsp)
movq %r8, 0x50(%rsp)
movq %rsi, 0x28(%rsp)
movl %eax, 0x40(%rsp)
movq %rcx, 0x58(%rsp)
movl $0x1, 0x14(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0xceb3f
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmoveq %rbx, %rax
jmp 0xceb2d
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcee0d
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%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)
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 0xcee0d
testq %r13, %r13
je 0xcede9
movl 0x84(%rsp), %eax
movl %eax, (%r13)
testq %r12, %r12
je 0xcedf9
movl 0x88(%rsp), %eax
movl %eax, (%r12)
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xceb3f
testl %eax, %eax
je 0xcee21
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 0xcee38
leaq 0x80(%rsp), %rdi
callq 0xcdfd7
movq 0x90(%rsp), %rax
jmp 0xcee0f
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %r14
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
movq 0xa8(%rsp), %r15
movq 0xa0(%rsp), %r12
testq %r14, %r14
sete %al
testq %r9, %r9
sete %dil
orb %al, %dil
testq %r12, %r12
sete %al
orb %dil, %al
testq %r15, %r15
sete %dil
orb %al, %dil
je 0xceef9
xorl %eax, %eax
jmp 0xcef33
movq %r9, %rbx
movq %rsp, %r9
movl $0xb, %edi
callq 0xced4b
testq %rax, %rax
je 0xcef33
movq 0x18(%rsp), %rcx
movq %rcx, (%r14)
movq 0x20(%rsp), %rcx
movq %rcx, (%rbx)
movl 0x30(%rsp), %ecx
movl %ecx, (%r12)
movl 0x34(%rsp), %ecx
movl %ecx, (%r15)
cmpl 0x38(%rsp), %ecx
jne 0xcef3f
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5a7c2(%rip), %rdi     # 0x129708
leaq 0x5a76d(%rip), %rsi     # 0x1296ba
leaq 0x5a7d3(%rip), %rcx     # 0x129727
movl $0x2ad, %edx            # imm = 0x2AD
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPGetInfo
int WebPGetInfo(const uint8_t* data, size_t data_size,
                int* width, int* height) {
  WebPBitstreamFeatures features;

  if (GetFeatures(data, data_size, &features) != VP8_STATUS_OK) {
    return 0;
  }

  if (width != NULL) {
    *width  = features.width;
  }
  if (height != NULL) {
    *height = features.height;
  }

  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
testq %rdi, %rdi
je 0xcefc8
movq %rcx, %rbx
movq %rdx, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, -0x10(%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
leaq 0x4(%rsp), %rcx
leaq 0x8(%rsp), %r8
leaq 0xc(%rsp), %r9
movq %rsp, %rdx
pushq %r15
pushq %rax
callq 0xce417
addq $0x10, %rsp
testl %eax, %eax
jne 0xcefcb
testq %r14, %r14
je 0xcefb5
movl (%rsp), %eax
movl %eax, (%r14)
movl $0x1, %r15d
testq %rbx, %rbx
je 0xcefcb
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
jmp 0xcefcb
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPInitDecoderConfigInternal
int WebPInitDecoderConfigInternal(WebPDecoderConfig* config,
                                  int version) {
  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
    return 0;   // version mismatch
  }
  if (config == NULL) {
    return 0;
  }
  memset(config, 0, sizeof(*config));
  DefaultFeatures(&config->input);
  if (!WebPInitDecBuffer(&config->output)) {
    return 0;
  }
  return 1;
}

// Assembly:
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
cmpl $0x200, %esi            # imm = 0x200
setne %cl
testq %rdi, %rdi
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0xcf01b
pushq %rbx
leaq 0x28(%rdi), %rbx
movl $0xf0, %edx
xorl %esi, %esi
callq 0x55f20
movq %rbx, %rdi
movl $0x209, %esi            # imm = 0x209
callq 0x56a10
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPGetFeaturesInternal
VP8StatusCode WebPGetFeaturesInternal(const uint8_t* data, size_t data_size,
                                      WebPBitstreamFeatures* features,
                                      int version) {
  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
    return VP8_STATUS_INVALID_PARAM;   // version mismatch
  }
  if (features == NULL) {
    return VP8_STATUS_INVALID_PARAM;
  }
  return GetFeatures(data, data_size, features);
}

// Assembly:
testq %rdi, %rdi
je 0xcf063
testq %rdx, %rdx
je 0xcf063
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
cmpl $0x200, %ecx            # imm = 0x200
jne 0xcf063
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdx)
movups %xmm0, (%rdx)
xorl %eax, %eax
movq %rax, 0x20(%rdx)
leaq 0x10(%rdx), %r10
leaq 0x4(%rdx), %rcx
leaq 0x8(%rdx), %r8
leaq 0xc(%rdx), %r9
pushq %rax
pushq %r10
callq 0xce417
addq $0x10, %rsp
popq %rcx
retq
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPDecode
VP8StatusCode WebPDecode(const uint8_t* data, size_t data_size,
                         WebPDecoderConfig* config) {
  WebPDecParams params;
  VP8StatusCode status;

  if (config == NULL) {
    return VP8_STATUS_INVALID_PARAM;
  }

  status = GetFeatures(data, data_size, &config->input);
  if (status != VP8_STATUS_OK) {
    if (status == VP8_STATUS_NOT_ENOUGH_DATA) {
      return VP8_STATUS_BITSTREAM_ERROR;  // Not-enough-data treated as error.
    }
    return status;
  }

  WebPResetDecParams(&params);
  params.options = &config->options;
  params.output = &config->output;
  if (WebPAvoidSlowMemory(params.output, &config->input)) {
    // decoding to slow memory: use a temporary in-mem buffer to decode into.
    WebPDecBuffer in_mem_buffer;
    if (!WebPInitDecBuffer(&in_mem_buffer)) {
      return VP8_STATUS_INVALID_PARAM;
    }
    in_mem_buffer.colorspace = config->output.colorspace;
    in_mem_buffer.width = config->input.width;
    in_mem_buffer.height = config->input.height;
    params.output = &in_mem_buffer;
    status = DecodeInto(data, data_size, &params);
    if (status == VP8_STATUS_OK) {  // do the slow-copy
      status = WebPCopyDecBufferPixels(&in_mem_buffer, &config->output);
    }
    WebPFreeDecBuffer(&in_mem_buffer);
  } else {
    status = DecodeInto(data, data_size, &params);
  }

  return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
testq %rdx, %rdx
je 0xcf18f
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0xcf0c9
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
xorl %eax, %eax
movq %rax, 0x20(%r15)
leaq 0x10(%r15), %r10
leaq 0x4(%r15), %rcx
leaq 0x8(%r15), %r8
leaq 0xc(%r15), %r9
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
pushq %rax
pushq %r10
callq 0xce417
addq $0x10, %rsp
jmp 0xcf0ce
movl $0x2, %eax
testl %eax, %eax
je 0xcf0e5
movl $0x3, %ebx
cmpl $0x7, %eax
je 0xcf1a6
jmp 0xcf1a4
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0xa0(%r15), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%r15), %r12
movq %r12, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0xce35b
testl %eax, %eax
je 0xcf196
leaq 0x78(%rsp), %r13
movq %r13, %rdi
movl $0x209, %esi            # imm = 0x209
callq 0x56a10
testl %eax, %eax
je 0xcf18f
movl 0x28(%r15), %eax
movl %eax, 0x78(%rsp)
movl (%r15), %eax
movl %eax, 0x7c(%rsp)
movl 0x4(%r15), %eax
movl %eax, 0x80(%rsp)
movq %rsp, %rdx
movq %r13, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xceb3f
movl %eax, %ebx
testl %eax, %eax
jne 0xcf183
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0xce04c
movl %eax, %ebx
leaq 0x78(%rsp), %rdi
callq 0x57c60
jmp 0xcf1a6
movl $0x2, %ebx
jmp 0xcf1a6
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xceb3f
movl %eax, %ebx
movl %ebx, %eax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq