LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x20, %rdi
callq 0x5a050
movq -0x20(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x1315f5
callq 0x5ba00
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rsi
callq 0x5dc40
cmpl $0x0, %eax
jne 0x131604
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x59e70
jmp 0x131659
movq -0x20(%rbp), %rdi
movq 0x48(%rdi), %rax
movq %rax, -0x10(%rbp)
movb 0x50(%rdi), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq $0x0, 0x48(%rdi)
addq $0x20, %rdi
callq 0x59e70
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5a140
testb $0x1, -0x11(%rbp)
je 0x131659
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x131657
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x595b0
jmp 0x131659
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
xorl %edi, %edi
callq 0x131660
movl %eax, -0x14(%rbp)
xorl %edi, %edi
callq 0x131660
movl %eax, -0x18(%rbp)
movw $0x0, -0x1a(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x131af7
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
callq 0x131660
movl %eax, -0x4(%rbp)
jmp 0x131bb8
callq 0x131bd0
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x131c00
movzwl -0x1a(%rbp), %edi
callq 0x131c40
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x2a(%rbp)
jne 0x131b31
movzwl -0x1a(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x131b3a
jmp 0x131ba7
movzwl -0x1a(%rbp), %edx
movl $0x2, %edi
leaq 0x757de(%rip), %rsi     # 0x1a7328
movb $0x0, %al
callq 0x135780
movq -0x10(%rbp), %rdi
movzwl -0x1a(%rbp), %eax
addl $0x1, %eax
movzwl %ax, %esi
callq 0x131d00
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0x1a(%rbp), %ecx
imulq $0x580, %rcx, %rcx      # imm = 0x580
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x131760
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x131b96
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movw -0x1a(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1a(%rbp)
jmp 0x131b0f
testb $0x1, -0x29(%rbp)
je 0x131bb2
callq 0x131df0
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: set_cpu_affinity
static bool set_cpu_affinity(logical_cpu_t logical_cpu)
{
	cpu_set_t cpuset;
	CPU_ZERO(&cpuset);
	CPU_SET(logical_cpu, &cpuset);
	return sched_setaffinity(0, sizeof(cpuset), &cpuset) == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x5a200
movzwl -0x2(%rbp), %eax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0x131cba
movq -0x90(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x90(%rbp), %rcx
shrq $0x6, %rcx
orq -0x88(%rbp,%rcx,8), %rax
movq %rax, -0x88(%rbp,%rcx,8)
movq %rax, -0xa0(%rbp)
jmp 0x131cc5
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0x131cc5
movq -0xa0(%rbp), %rax
movq %rax, -0x98(%rbp)
xorl %edi, %edi
movl $0x80, %esi
leaq -0x88(%rbp), %rdx
callq 0x5ba30
cmpl $0x0, %eax
sete %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq $0x0, -0x18(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x0, %eax
jle 0x131d34
movzwl -0xa(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x131d39
jmp 0x131ddc
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edx
movzwl -0xa(%rbp), %ecx
movl $0x3, %edi
leaq 0x75c9e(%rip), %rsi     # 0x1a79ef
movb $0x0, %al
callq 0x135780
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movzwl -0xa(%rbp), %eax
imulq $0x580, %rax, %rsi      # imm = 0x580
callq 0x594e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x131d87
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x131660
jmp 0x131ddc
movq -0x8(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0x131dc4
movq -0x18(%rbp), %rdi
movzwl -0xc(%rbp), %eax
imulq $0x580, %rax, %rax      # imm = 0x580
addq %rax, %rdi
callq 0x1324a0
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x131d93
movw -0xa(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpu_ident_internal
int cpu_ident_internal(struct cpu_raw_data_t* raw, struct cpu_id_t* data, struct internal_id_info_t* internal)
{
	int r;
	struct cpu_raw_data_t myraw;
	if (!raw) {
		if ((r = cpuid_get_raw_data(&myraw)) < 0)
			return cpuid_set_error(r);
		raw = &myraw;
	}
	cpu_id_t_constructor(data);
	memset(internal->cache_mask, 0, sizeof(internal->cache_mask));
	if ((r = cpuid_basic_identify(raw, data)) < 0)
		return cpuid_set_error(r);
	switch (data->vendor) {
		case VENDOR_INTEL:
			r = cpuid_identify_intel(raw, data, internal);
			break;
		case VENDOR_AMD:
		case VENDOR_HYGON:
			r = cpuid_identify_amd(raw, data, internal);
			break;
		case VENDOR_CENTAUR:
			r = cpuid_identify_centaur(raw, data, internal);
			break;
		default:
			break;
	}
	/* Backward compatibility */
	/* - Deprecated since v0.5.0 */
	data->l1_assoc     = data->l1_data_assoc;
	data->l1_cacheline = data->l1_data_cacheline;
	return cpuid_set_error(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x5b0, %rsp            # imm = 0x5B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x13338d
leaq -0x5a4(%rbp), %rdi
callq 0x131760
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x133382
movl -0x24(%rbp), %edi
callq 0x131660
movl %eax, -0x4(%rbp)
jmp 0x133471
leaq -0x5a4(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x133480
movq -0x20(%rbp), %rdi
addq $0x14, %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x5a200
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x133610
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x1333cf
movl -0x24(%rbp), %edi
callq 0x131660
movl %eax, -0x4(%rbp)
jmp 0x133471
movq -0x18(%rbp), %rax
movl 0x54(%rax), %eax
movq %rax, -0x5b0(%rbp)
subq $0xa, %rax
ja 0x13343c
movq -0x5b0(%rbp), %rax
leaq 0x73b8f(%rip), %rcx     # 0x1a6f80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1385c0
movl %eax, -0x24(%rbp)
jmp 0x13343e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x137390
movl %eax, -0x24(%rbp)
jmp 0x13343e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x137f80
movl %eax, -0x24(%rbp)
jmp 0x13343e
jmp 0x13343e
movq -0x18(%rbp), %rax
movl 0x110(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10c(%rax)
movq -0x18(%rbp), %rax
movl 0x128(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x124(%rax)
movl -0x24(%rbp), %edi
callq 0x131660
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x5b0, %rsp            # imm = 0x5B0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpu_id_t_constructor
static void cpu_id_t_constructor(struct cpu_id_t* id)
{
	memset(id, 0, sizeof(struct cpu_id_t));
	id->l1_data_cache = id->l1_instruction_cache = id->l2_cache = id->l3_cache = id->l4_cache = -1;
	id->l1_assoc = id->l1_data_assoc = id->l1_instruction_assoc = id->l2_assoc = id->l3_assoc = id->l4_assoc = -1;
	id->l1_cacheline = id->l1_data_cacheline = id->l1_instruction_cacheline = id->l2_cacheline = id->l3_cacheline = id->l4_cacheline = -1;
	id->l1_data_instances = id->l1_instruction_instances = id->l2_instances = id->l3_instances = id->l4_instances = -1;
	id->sse_size = -1;
	init_affinity_mask(&id->affinity_mask);
	id->purpose = PURPOSE_GENERAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x21e0, %edx           # imm = 0x21E0
callq 0x5a200
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x108(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x104(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x100(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xfc(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xf8(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x120(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x11c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x118(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x114(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x110(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x10c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x138(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x134(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x130(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x12c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x128(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x124(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x14c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x148(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x144(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x140(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x13c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x190(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x136260
movq -0x8(%rbp), %rax
movl $0x0, 0x21d8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: system_id_t_constructor
static void system_id_t_constructor(struct system_id_t* system)
{
	system->num_cpu_types                  = 0;
	system->cpu_types                      = NULL;
	system->l1_data_total_instances        = -1;
	system->l1_instruction_total_instances = -1;
	system->l2_total_instances             = -1;
	system->l3_total_instances             = -1;
	system->l4_total_instances             = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x134d30
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x134102
movl $0xfffffff9, %edi       # imm = 0xFFFFFFF9
callq 0x131660
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13415f
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x134126
jmp 0x13410e
movl -0x34(%rbp), %eax
subl $0x1, %eax
jne 0x134134
jmp 0x134118
movq -0x10(%rbp), %rdi
callq 0x137a40
movl %eax, -0x18(%rbp)
jmp 0x13413b
movq -0x10(%rbp), %rdi
callq 0x139370
movl %eax, -0x18(%rbp)
jmp 0x13413b
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0x134950
movq %rax, %rdx
movl $0x3, %edi
leaq 0x73dff(%rip), %rsi     # 0x1a7f51
movb $0x0, %al
callq 0x135780
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpuid_grow_system_id
static void cpuid_grow_system_id(struct system_id_t* system, uint8_t n)
{
	uint8_t i;
	struct cpu_id_t *tmp = NULL;

	if ((n <= 0) || (n < system->num_cpu_types)) return;
	debugf(3, "Growing system_id_t from %u to %u items\n", system->num_cpu_types, n);
	tmp = realloc(system->cpu_types, sizeof(struct cpu_id_t) * n);
	if (tmp == NULL) { /* Memory allocation failure */
		cpuid_set_error(ERR_NO_MEM);
		return;
	}

	for (i = system->num_cpu_types; i < n; i++)
		cpu_id_t_constructor(&tmp[i]);
	system->num_cpu_types = n;
	system->cpu_types     = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jle 0x134442
movzbl -0x9(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x134447
jmp 0x1344df
movq -0x8(%rbp), %rax
movzbl (%rax), %edx
movzbl -0x9(%rbp), %ecx
movl $0x3, %edi
leaq 0x73b95(%rip), %rsi     # 0x1a7ff3
movb $0x0, %al
callq 0x135780
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movzbl -0x9(%rbp), %eax
imulq $0x21e0, %rax, %rsi     # imm = 0x21E0
callq 0x594e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x134494
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x131660
jmp 0x1344df
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1344ca
movq -0x18(%rbp), %rdi
movzbl -0xa(%rbp), %eax
imulq $0x21e0, %rax, %rax     # imm = 0x21E0
addq %rax, %rdi
callq 0x133480
movb -0xa(%rbp), %al
addb $0x1, %al
movb %al, -0xa(%rbp)
jmp 0x13449d
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpl $0x0, 0x8(%rax,%rcx,8)
je 0x13453b
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl 0x8(%rax,%rcx,8), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x134580
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movzwl 0x4(%rax,%rcx,8), %eax
cmpl $0x0, %eax
jne 0x134557
movq -0x8(%rbp), %rax
movb (%rax), %cl
addb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, 0x8(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movw 0x4(%rax,%rcx,8), %dx
addw $0x1, %dx
movw %dx, 0x4(%rax,%rcx,8)
jmp 0x1345a3
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl 0x8(%rax,%rcx,8), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x73a80(%rip), %rdi     # 0x1a801c
movb $0x0, %al
callq 0x1356a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw $0x0, -0x1e(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x134819
leaq -0x30(%rbp), %rdi
callq 0x131ab0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x134811
movl -0x1c(%rbp), %edi
callq 0x131660
movl %eax, -0x4(%rbp)
jmp 0x13489b
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movw $0x0, -0x1e(%rbp)
movzwl -0x1e(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x13488e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movzwl -0x1e(%rbp), %eax
imulq $0x580, %rax, %rax      # imm = 0x580
addq %rax, %rdi
callq 0x1340c0
cmpl -0x8(%rbp), %eax
jne 0x13487e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movzwl -0x1e(%rbp), %eax
imulq $0x580, %rax, %rax      # imm = 0x580
addq %rax, %rdi
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x133340
xorl %edi, %edi
callq 0x131660
movl %eax, -0x4(%rbp)
jmp 0x13489b
jmp 0x134880
movw -0x1e(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1e(%rbp)
jmp 0x13481f
movl $0xffffffef, %edi       # imm = 0xFFFFFFEF
callq 0x131660
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpu_architecture_str
const char* cpu_architecture_str(cpu_architecture_t architecture)
{
	const struct { cpu_architecture_t architecture; const char* name; }
	matchtable[] = {
		{ ARCHITECTURE_UNKNOWN, "unknown" },
		{ ARCHITECTURE_X86,     "x86"     },
		{ ARCHITECTURE_ARM,     "ARM"     },
	};
	unsigned i, n = COUNT_OF(matchtable);
	if (n != NUM_CPU_ARCHITECTURES + 1) {
		warnf("Warning: incomplete library, architecture matchtable size differs from the actual number of architectures.\n");
	}
	for (i = 0; i < n; i++)
		if (matchtable[i].architecture == architecture)
			return matchtable[i].name;
	return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0xd274a(%rip), %rsi     # 0x207010
movl $0x30, %edx
callq 0x593a0
movl $0x3, -0x48(%rbp)
cmpl $0x3, -0x48(%rbp)
je 0x1348eb
leaq 0x72ac4(%rip), %rdi     # 0x1a73a8
movb $0x0, %al
callq 0x1356a0
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x48(%rbp), %eax
jae 0x134938
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq -0x40(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x13492b
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq -0x40(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x134943
jmp 0x13492d
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1348f2
leaq 0x70f45(%rip), %rax     # 0x1a5884
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpu_purpose_str
const char* cpu_purpose_str(cpu_purpose_t purpose)
{
	const struct { cpu_purpose_t purpose; const char* name; }
	matchtable[] = {
		{ PURPOSE_GENERAL,     "general"     },
		{ PURPOSE_PERFORMANCE, "performance" },
		{ PURPOSE_EFFICIENCY,  "efficiency"  },
	};
	unsigned i, n = COUNT_OF(matchtable);
	if (n != NUM_CPU_PURPOSES) {
		warnf("Warning: incomplete library, purpose matchtable size differs from the actual number of purposes.\n");
	}
	for (i = 0; i < n; i++)
		if (matchtable[i].purpose == purpose)
			return matchtable[i].name;
	return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0xd26da(%rip), %rsi     # 0x207040
movl $0x30, %edx
callq 0x593a0
movl $0x3, -0x48(%rbp)
cmpl $0x3, -0x48(%rbp)
je 0x13498b
leaq 0x72aaf(%rip), %rdi     # 0x1a7433
movb $0x0, %al
callq 0x1356a0
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x48(%rbp), %eax
jae 0x1349d8
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq -0x40(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1349cb
movl -0x44(%rbp), %eax
movl %eax, %ecx
leaq -0x40(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1349e3
jmp 0x1349cd
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x134992
leaq 0x70ea5(%rip), %rax     # 0x1a5884
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movw $0x1fff, -0x16(%rbp)    # imm = 0x1FFF
movw $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movzwl -0x18(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jae 0x134a91
testb $0x1, -0x19(%rbp)
jne 0x134a3f
movzwl -0x16(%rbp), %eax
cmpl $0x4, %eax
jl 0x134a3f
movq -0x8(%rbp), %rax
movzwl -0x16(%rbp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x134a78
movq -0x10(%rbp), %rdi
movzwl -0x18(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movzwl -0x16(%rbp), %ecx
movzbl (%rax,%rcx), %ecx
movl $0x3, %esi
leaq 0x72a33(%rip), %rdx     # 0x1a7495
movb $0x0, %al
callq 0x5ad40
movb $0x1, -0x19(%rbp)
movzwl -0x18(%rbp), %eax
addl $0x2, %eax
movw %ax, -0x18(%rbp)
movzwl -0x16(%rbp), %eax
cmpl $0x0, %eax
jne 0x134a83
jmp 0x134a91
movw -0x16(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x16(%rbp)
jmp 0x134a13
movq -0x10(%rbp), %rax
movzwl -0x18(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpuid_error
const char* cpuid_error(void)
{
	const struct { cpu_error_t error; const char *description; }
	matchtable[] = {
		{ ERR_OK       , "No error"},
		{ ERR_NO_CPUID , "CPUID instruction is not supported"},
		{ ERR_NO_RDTSC , "RDTSC instruction is not supported"},
		{ ERR_NO_MEM   , "Memory allocation failed"},
		{ ERR_OPEN     , "File open operation failed"},
		{ ERR_BADFMT   , "Bad file format"},
		{ ERR_NOT_IMP  , "Not implemented"},
		{ ERR_CPU_UNKN , "Unsupported processor"},
		{ ERR_NO_RDMSR , "RDMSR instruction is not supported"},
		{ ERR_NO_DRIVER, "RDMSR driver error (generic)"},
		{ ERR_NO_PERMS , "No permissions to install RDMSR driver"},
		{ ERR_EXTRACT  , "Cannot extract RDMSR driver (read only media?)"},
		{ ERR_HANDLE   , "Bad handle"},
		{ ERR_INVMSR   , "Invalid MSR"},
		{ ERR_INVCNB   , "Invalid core number"},
		{ ERR_HANDLE_R , "Error on handle read"},
		{ ERR_INVRANGE , "Invalid given range"},
		{ ERR_NOT_FOUND, "Requested type not found"},
	};
	unsigned i;
	for (i = 0; i < COUNT_OF(matchtable); i++)
		if (_libcpuid_errno == matchtable[i].error)
			return matchtable[i].description;
	return "Unknown error";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
leaq -0x130(%rbp), %rdi
leaq 0xd2bc7(%rip), %rsi     # 0x207790
movl $0x120, %edx            # imm = 0x120
callq 0x593a0
movl $0x0, -0x134(%rbp)
movl -0x134(%rbp), %eax
cmpq $0x12, %rax
jae 0x134c4b
leaq 0xd3710(%rip), %rdi     # 0x208300
callq 0x5abb0
leaq 0x30(%rax), %rax
movl (%rax), %eax
movl -0x134(%rbp), %ecx
movl %ecx, %edx
leaq -0x130(%rbp), %rcx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x134c38
movl -0x134(%rbp), %eax
movl %eax, %ecx
leaq -0x130(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x134c56
jmp 0x134c3a
movl -0x134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0x134bdd
leaq 0x52501(%rip), %rax     # 0x187153
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $-0x1, 0xd6f55(%rip)    # 0x20bc34
jne 0x134d17
callq 0x1316e0
cmpl $0x0, %eax
jne 0x134cf7
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x131660
jmp 0x134d15
leaq -0x10(%rbp), %rsi
xorl %edi, %edi
callq 0x1316f0
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x134d30
movl %eax, 0xd6f1f(%rip)     # 0x20bc34
jmp 0x134d17
movl 0xd6f17(%rip), %eax     # 0x20bc34
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: cpuid_vendor_identify
static cpu_vendor_t cpuid_vendor_identify(const uint32_t *raw_vendor, char *vendor_str)
{
	int i;
	cpu_vendor_t vendor = VENDOR_UNKNOWN;
	const struct { cpu_vendor_t vendor; char match[16]; }
	matchtable[NUM_CPU_VENDORS] = {
		/* source: http://www.sandpile.org/ia32/cpuid.htm */
		{ VENDOR_INTEL		, "GenuineIntel" },
		{ VENDOR_AMD		, "AuthenticAMD" },
		{ VENDOR_CYRIX		, "CyrixInstead" },
		{ VENDOR_NEXGEN		, "NexGenDriven" },
		{ VENDOR_TRANSMETA	, "GenuineTMx86" },
		{ VENDOR_UMC		, "UMC UMC UMC " },
		{ VENDOR_CENTAUR	, "CentaurHauls" },
		{ VENDOR_RISE		, "RiseRiseRise" },
		{ VENDOR_SIS		, "SiS SiS SiS " },
		{ VENDOR_NSC		, "Geode by NSC" },
		{ VENDOR_HYGON		, "HygonGenuine" },
	};

	memcpy(vendor_str + 0, &raw_vendor[1], 4);
	memcpy(vendor_str + 4, &raw_vendor[3], 4);
	memcpy(vendor_str + 8, &raw_vendor[2], 4);
	vendor_str[12] = 0;

	/* Determine vendor: */
	for (i = 0; i < NUM_CPU_VENDORS; i++)
		if (!strcmp(vendor_str, matchtable[i].match)) {
			vendor = matchtable[i].vendor;
			break;
		}
	return vendor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
leaq -0x100(%rbp), %rdi
leaq 0x724e8(%rip), %rsi     # 0x1a7240
movl $0xdc, %edx
callq 0x593a0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0xc(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0xb, -0x14(%rbp)
jge 0x134dea
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq -0x100(%rbp), %rsi
imulq $0x14, %rax, %rax
addq %rax, %rsi
addq $0x4, %rsi
callq 0x5c440
cmpl $0x0, %eax
jne 0x134ddd
movslq -0x14(%rbp), %rcx
leaq -0x100(%rbp), %rax
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x134dea
jmp 0x134ddf
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x134d9a
movl -0x18(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xa, %rax
ja 0x134ee2
movq -0x18(%rbp), %rax
leaq 0x72181(%rip), %rcx     # 0x1a6fac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x13a300
jmp 0x134f10
movq -0x10(%rbp), %rdi
callq 0x137a10
jmp 0x134f10
movq -0x10(%rbp), %rsi
leaq 0x72ad1(%rip), %rdi     # 0x1a792c
callq 0x134f20
jmp 0x134f10
movq -0x10(%rbp), %rsi
leaq 0x72af4(%rip), %rdi     # 0x1a7964
callq 0x134f20
jmp 0x134f10
movq -0x10(%rbp), %rsi
leaq 0x72ae5(%rip), %rdi     # 0x1a796a
callq 0x134f20
jmp 0x134f10
movq -0x10(%rbp), %rsi
leaq 0x72ae0(%rip), %rdi     # 0x1a797a
callq 0x134f20
jmp 0x134f10
movq -0x10(%rbp), %rdi
callq 0x1384a0
jmp 0x134f10
movq -0x10(%rbp), %rsi
leaq 0x72acf(%rip), %rdi     # 0x1a7986
callq 0x134f20
jmp 0x134f10
movq -0x10(%rbp), %rsi
leaq 0x72ac6(%rip), %rdi     # 0x1a798f
callq 0x134f20
jmp 0x134f10
movq -0x10(%rbp), %rsi
leaq 0x72abc(%rip), %rdi     # 0x1a7997
callq 0x134f20
jmp 0x134f10
leaq 0x72ad7(%rip), %rdi     # 0x1a79c0
movb $0x0, %al
callq 0x1356a0
movl $0xfffffff0, %edi       # imm = 0xFFFFFFF0
callq 0x131660
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x135267
jmp 0x1352a6
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x135299
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x59930
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13526e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x59930
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/cpuid_main.c
// Function: apic_info_t_constructor
static void apic_info_t_constructor(struct internal_apic_info_t* apic_info, logical_cpu_t logical_cpu)
{
	memset(apic_info, 0, sizeof(struct internal_apic_info_t));
	apic_info->apic_id     = -1;
	apic_info->package_id  = -1;
	apic_info->core_id     = -1;
	apic_info->smt_id      = -1;
	apic_info->logical_cpu = logical_cpu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x5a200
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movw -0xa(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x24(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x135661
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movl (%rcx,%rdx,8), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x135654
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movl 0x4(%rcx,%rdx,8), %ecx
movb $0x1, 0x58(%rax,%rcx)
jmp 0x135656
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x135619
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
testb %al, %al
je 0x1356e7
movaps %xmm0, -0x4b0(%rbp)
movaps %xmm1, -0x4a0(%rbp)
movaps %xmm2, -0x490(%rbp)
movaps %xmm3, -0x480(%rbp)
movaps %xmm4, -0x470(%rbp)
movaps %xmm5, -0x460(%rbp)
movaps %xmm6, -0x450(%rbp)
movaps %xmm7, -0x440(%rbp)
movq %r9, -0x4b8(%rbp)
movq %r8, -0x4c0(%rbp)
movq %rcx, -0x4c8(%rbp)
movq %rdx, -0x4d0(%rbp)
movq %rsi, -0x4d8(%rbp)
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0xd6522(%rip)     # 0x20bc38
jne 0x13571a
jmp 0x135774
leaq -0x430(%rbp), %rax
leaq -0x4e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq -0x430(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x5b9b0
leaq -0x430(%rbp), %rax
movq 0xd64cd(%rip), %rax     # 0x20bc38
leaq -0x410(%rbp), %rdi
callq *%rax
addq $0x4e0, %rsp            # imm = 0x4E0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
testb %al, %al
je 0x1357c7
movaps %xmm0, -0x4b0(%rbp)
movaps %xmm1, -0x4a0(%rbp)
movaps %xmm2, -0x490(%rbp)
movaps %xmm3, -0x480(%rbp)
movaps %xmm4, -0x470(%rbp)
movaps %xmm5, -0x460(%rbp)
movaps %xmm6, -0x450(%rbp)
movaps %xmm7, -0x440(%rbp)
movq %r9, -0x4b8(%rbp)
movq %r8, -0x4c0(%rbp)
movq %rcx, -0x4c8(%rbp)
movq %rdx, -0x4d0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xe1465(%rip), %eax     # 0x216c58
jle 0x1357f7
jmp 0x135851
leaq -0x430(%rbp), %rax
leaq -0x4e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x430(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x5b9b0
leaq -0x430(%rbp), %rax
movq 0xd63f0(%rip), %rax     # 0x20bc38
leaq -0x410(%rbp), %rdi
callq *%rax
addq $0x4e0, %rsp            # imm = 0x4E0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5a790
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5a790
movl %eax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x135fa3
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x18(%rbp), %rsi
movsbl %al, %edi
callq 0x135fc0
cmpl $-0x1, %eax
je 0x135f93
movl $0x0, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x20(%rbp), %ecx
xorl %eax, %eax
cmpl -0x30(%rbp), %ecx
movb %al, -0x31(%rbp)
jge 0x135f61
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rcx
addq %rcx, %rsi
movsbl %al, %edi
callq 0x135fc0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x135f6a
jmp 0x135f7e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x135f25
movl -0x20(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x135f91
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x135faa
jmp 0x135f93
jmp 0x135f95
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x135eef
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x0, %eax
jne 0x135fe7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x136100
movsbl -0x5(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x136002
movl $0x1, -0x4(%rbp)
jmp 0x136100
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x13601a
movl $0x1, -0x4(%rbp)
jmp 0x136100
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x13604f
callq 0x596d0
movq (%rax), %rax
movsbl -0x5(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x13604f
movl $0x1, -0x4(%rbp)
jmp 0x136100
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x1360f9
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x136091
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x13609a
jmp 0x1360a5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x136066
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x1360bc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x136100
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1360f7
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1360ea
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x136100
jmp 0x1360ec
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1360c3
jmp 0x1360f9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0xe0b3d(%rip)     # 0x216c5c
je 0x13612e
leaq 0xe0b38(%rip), %rax     # 0x216c60
movq %rax, -0x8(%rbp)
jmp 0x13617f
xorl %eax, %eax
movl %eax, %edi
leaq 0xe0b27(%rip), %rsi     # 0x216c60
callq 0x133850
cmpl $0x0, %eax
je 0x13616a
leaq 0xe0b16(%rip), %rdi     # 0x216c60
xorl %esi, %esi
movl $0x21e0, %edx           # imm = 0x21E0
callq 0x5a200
movl $0xffffffff, 0xe0b00(%rip) # imm = 0xFFFFFFFF
movl $0xffffffff, 0xe0b4a(%rip) # imm = 0xFFFFFFFF
movl $0x1, 0xe0ae8(%rip)     # 0x216c5c
leaq 0xe0ae5(%rip), %rax     # 0x216c60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0x13623f
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x136232
cmpl $0x0, -0x18(%rbp)
je 0x13620d
movl $0x0, -0x18(%rbp)
jmp 0x13621e
movl -0x4(%rbp), %edi
leaq 0x71fe9(%rip), %rsi     # 0x1a8200
movb $0x0, %al
callq 0x135780
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %edx
leaq 0x71fd9(%rip), %rsi     # 0x1a8204
movb $0x0, %al
callq 0x135780
jmp 0x136234
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1361dd
movl -0x4(%rbp), %edi
leaq 0x6f63a(%rip), %rsi     # 0x1a5883
movb $0x0, %al
callq 0x135780
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libcpuid/libcpuid_util.c
// Function: assign_cache_data
void assign_cache_data(uint8_t on, cache_type_t cache, int size, int assoc, int linesize, struct cpu_id_t* data)
{
	if (!on) return;
	switch (cache) {
		case L1I:
			data->l1_instruction_cache = size;
			data->l1_instruction_assoc = assoc;
			data->l1_instruction_cacheline = linesize;
			break;
		case L1D:
			data->l1_data_cache = size;
			data->l1_data_assoc = assoc;
			data->l1_data_cacheline = linesize;
			break;
		case L2:
			data->l2_cache = size;
			data->l2_assoc = assoc;
			data->l2_cacheline = linesize;
			break;
		case L3:
			data->l3_cache = size;
			data->l3_assoc = assoc;
			data->l3_cacheline = linesize;
			break;
		case L4:
			data->l4_cache = size;
			data->l4_assoc = assoc;
			data->l4_cacheline = linesize;
			break;
		default:
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movq %r9, -0x20(%rbp)
cmpb $0x0, -0x1(%rbp)
jne 0x1363e6
jmp 0x1364dd
movl -0x8(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x1364db
movq -0x28(%rbp), %rax
leaq 0x71d3e(%rip), %rcx     # 0x1a8140
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xfc(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x114(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x12c(%rax)
jmp 0x1364dd
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xf8(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x110(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x128(%rax)
jmp 0x1364dd
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x100(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x118(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x130(%rax)
jmp 0x1364dd
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x104(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x11c(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x134(%rax)
jmp 0x1364dd
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x108(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x120(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x138(%rax)
jmp 0x1364dd
jmp 0x1364dd
popq %rbp
retq
nop