LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/eigen.c
// Function: cdiv
complex cdiv (complex a,complex b)
{
    double ratio, den;
    complex c;

    if (fabs(b.re) <= fabs(b.im)) {
        ratio = b.re / b.im;
        den = b.im * (1 + ratio * ratio);
        c.re = (a.re * ratio + a.im) / den;
        c.im = (a.im * ratio - a.re) / den;
    }
    else {
        ratio = b.im / b.re;
        den = b.re * (1 + ratio * ratio);
        c.re = (a.re + a.im * ratio) / den;
        c.im = (a.im - a.re * ratio) / den;
    }
    return(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd -0x30(%rbp), %xmm1
movaps 0x18e4c(%rip), %xmm0    # 0x3f3a0
pand %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movaps 0x18e3c(%rip), %xmm2    # 0x3f3a0
pand %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x26607
movsd -0x30(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm1
movsd 0x18a84(%rip), %xmm2    # 0x3f020
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x26697
movsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm1
movsd 0x189ef(%rip), %xmm2    # 0x3f020
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/eigen.c
// Function: cexpp
complex cexpp (complex a)
{
   complex c;
   c.re = exp(a.re);
   if (fabs(a.im)==0) c.im = 0;
   else  { c.im = c.re*sin(a.im); c.re*=cos(a.im); }
   return (c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x22b0
movsd %xmm0, -0x10(%rbp)
movsd -0x18(%rbp), %xmm0
movaps 0x18cc3(%rip), %xmm1    # 0x3f3a0
pand %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x266f6
jp 0x266f6
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2672f
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2250
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2160
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/eigen.c
// Function: cmatby
int cmatby (complex a[], complex b[], complex c[], int n,int m,int k)
/* a[n*m], b[m*k], c[n*k]  ......  c = a*b
*/
{
   int i,j,i1;
   complex t;

   FOR (i,n)  FOR(j,k) {
       for (i1=0,t=compl(0,0); i1<m; i1++)
           t = cplus (t, cby(a[i*m+i1],b[i1*k+j]));
       c[i*k+j] = t;
   }
   return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x26943
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x26933
movl $0x0, -0x30(%rbp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x263b0
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x268fe
movq -0x8(%rbp), %rcx
movl -0x28(%rbp), %eax
imull -0x20(%rbp), %eax
addl -0x30(%rbp), %eax
cltq
shlq $0x4, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %edx
imull -0x24(%rbp), %edx
addl -0x2c(%rbp), %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movsd (%rcx), %xmm0
movsd 0x8(%rcx), %xmm1
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm3
callq 0x264c0
movsd %xmm0, -0x70(%rbp)
movsd %xmm1, -0x68(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x70(%rbp), %xmm2
movsd -0x68(%rbp), %xmm3
callq 0x26420
movsd %xmm0, -0x60(%rbp)
movsd %xmm1, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x26861
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x24(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x26829
jmp 0x26935
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x26816
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dapogon[P]cellcoal/src/eigen.c
// Function: cmatout
int cmatout (FILE * fout, complex x[], int n, int m)
{
   int i,j;
   for (i=0,FPN(fout); i<n; i++,FPN(fout))
        FOR(j,m) fprintf(fout, "%7.3f%7.3f  ", x[i*m+j].re, x[i*m+j].im);
   return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x2170
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x26a0a
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x269ec
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull -0x18(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull -0x18(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm1
leaq 0x2065d(%rip), %rsi     # 0x47037
movb $0x2, %al
callq 0x21b0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2698e
jmp 0x269ee
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x2170
jmp 0x2697b
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: fiu_init
int fiu_init(unsigned int flags)
{
	char *static_seed_from_env;

	/* Used to avoid re-initialization, protected by enabled_fails_lock */
	static int initialized = 0;

	rec_count++;
	ef_wlock();
	if (initialized) {
		ef_wunlock();
		rec_count--;
		return 0;
	}

	pthread_key_create(&last_failinfo_key, NULL);

	enabled_fails = wtable_create((void (*)(void *))pf_free);

	if (pthread_atfork(NULL, NULL, atfork_child) != 0) {
		ef_wunlock();
		rec_count--;
		return -1;
	}

	static_seed_from_env = getenv("FIU_PRNG_SEED");
	if (static_seed_from_env != NULL) {
		fiu_set_prng_seed(atoi(static_seed_from_env));
	}

	prng_seed();

	initialized = 1;

	ef_wunlock();
	rec_count--;
	return 0;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
leaq 0x5b88(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x5d72(%rip), %rdi      # 0x81d8
callq 0x20a0
cmpl $0x0, 0x5d5e(%rip)      # 0x81d0
je 0x24a6
jmp 0x2476
leaq 0x5d5b(%rip), %rdi      # 0x81d8
callq 0x2270
leaq 0x5b4e(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
jmp 0x257a
leaq 0x5d63(%rip), %rdi      # 0x8210
xorl %eax, %eax
movl %eax, %esi
callq 0x2170
leaq 0xd3(%rip), %rdi        # 0x2590
callq 0x3c30
movq %rax, %rcx
leaq 0x5cfc(%rip), %rax      # 0x81c8
movq %rcx, (%rax)
xorl %eax, %eax
movl %eax, %esi
leaq 0xe6(%rip), %rdx        # 0x25c0
movq %rsi, %rdi
callq 0x55d0
cmpl $0x0, %eax
je 0x2516
jmp 0x24e9
leaq 0x5ce8(%rip), %rdi      # 0x81d8
callq 0x2270
leaq 0x5adb(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x257a
leaq 0x3afb(%rip), %rdi      # 0x6018
callq 0x2030
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2540
movq 0x8(%rsp), %rdi
callq 0x2310
movl %eax, %edi
callq 0x2150
callq 0x25f0
movl $0x1, 0x5c81(%rip)      # 0x81d0
leaq 0x5c82(%rip), %rdi      # 0x81d8
callq 0x2270
leaq 0x5a75(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: prng_seed
static void prng_seed(void)
{
	struct timeval tv;

	/* If the seed is being handled manually, don't interfere. */
	if (randd_xn_manual) {
		return;
	}

	gettimeofday(&tv, NULL);

	randd_xn = tv.tv_usec;
}

// Assembly:
subq $0x18, %rsp
testb $0x1, 0x5c19(%rip)      # 0x8214
je 0x25ff
jmp 0x2618
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2160
movq 0x10(%rsp), %rax
movl %eax, 0x5ba0(%rip)      # 0x81b8
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: should_stack_fail
static int should_stack_fail(struct pf_info *pf)
{
	// TODO: Find the right offset for pos_in_stack: we should look for
	// fiu_fail(), and start counting from there.
	int nptrs, i;
	void *buffer[100];

	nptrs = get_backtrace(buffer, 100);

	for (i = 0; i < nptrs; i++) {
		if (pc_in_func(pf, buffer[i]) &&
		    (pf->minfo.stack.func_pos_in_stack == -1 ||
		     i == pf->minfo.stack.func_pos_in_stack)) {
			return 1;
		}
	}

	return 0;
}

// Assembly:
subq $0x338, %rsp            # imm = 0x338
movq %rdi, 0x328(%rsp)
movq %rsp, %rdi
movl $0x64, %esi
callq 0x3960
movl %eax, 0x324(%rsp)
movl $0x0, 0x320(%rsp)
movl 0x320(%rsp), %eax
cmpl 0x324(%rsp), %eax
jge 0x2950
movq 0x328(%rsp), %rdi
movslq 0x320(%rsp), %rax
movq (%rsp,%rax,8), %rsi
callq 0x2e80
cmpl $0x0, %eax
je 0x293b
movq 0x328(%rsp), %rax
cmpl $-0x1, 0x60(%rax)
je 0x292e
movl 0x320(%rsp), %eax
movq 0x328(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jne 0x293b
movl $0x1, 0x334(%rsp)
jmp 0x295b
jmp 0x293d
movl 0x320(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x320(%rsp)
jmp 0x28de
movl $0x0, 0x334(%rsp)
movl 0x334(%rsp), %eax
addq $0x338, %rsp            # imm = 0x338
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: fiu_enable
int fiu_enable(const char *name, int failnum, void *failinfo,
               unsigned int flags)
{
	struct pf_info *pf;

	pf = pf_create(name, failnum, failinfo, flags, PF_ALWAYS);
	if (pf == NULL)
		return -1;

	return insert_pf(pf);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl $0x1, %r8d
callq 0x29f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x29ca
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x29d8
movq 0x8(%rsp), %rdi
callq 0x2af0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: pf_create
static struct pf_info *pf_create(const char *name, int failnum, void *failinfo,
                                 unsigned int flags, enum pf_method method)
{
	struct pf_info *pf;

	rec_count++;

	pf = malloc(sizeof(struct pf_info));
	if (pf == NULL)
		goto exit;

	pf->name = strdup(name);
	if (pf->name == NULL) {
		free(pf);
		pf = NULL;
		goto exit;
	}

	pf->namelen = strlen(name);
	pf->failnum = failnum;
	pf->failinfo = failinfo;
	pf->flags = flags;
	pf->method = method;

	/* These two are only use when flags & FIU_ONETIME. */
	pthread_mutex_init(&pf->lock, NULL);
	pf->failed_once = false;

exit:
	rec_count--;
	return pf;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
leaq 0x55c5(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x68, %edi
callq 0x2250
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2a3c
jmp 0x2ac7
movq 0x20(%rsp), %rdi
callq 0x2320
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2a6d
movq (%rsp), %rdi
callq 0x2040
movq $0x0, (%rsp)
jmp 0x2ac7
movq 0x20(%rsp), %rdi
callq 0x2100
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x1c(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0x8(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x4c(%rax)
movq (%rsp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2330
movq (%rsp), %rax
movb $0x0, 0x48(%rax)
leaq 0x5509(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: insert_pf
static int insert_pf(struct pf_info *pf)
{
	bool success;

	rec_count++;

	ef_wlock();
	success = wtable_set(enabled_fails, pf->name, pf);
	ef_wunlock();

	rec_count--;
	return success ? 0 : -1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x54d7(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x56c1(%rip), %rdi      # 0x81d8
callq 0x20a0
leaq 0x56a5(%rip), %rax      # 0x81c8
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x4010
andb $0x1, %al
movb %al, 0xf(%rsp)
leaq 0x5693(%rip), %rdi      # 0x81d8
callq 0x2270
leaq 0x5486(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movb 0xf(%rsp), %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: fiu_enable_random
int fiu_enable_random(const char *name, int failnum, void *failinfo,
                      unsigned int flags, float probability)
{
	struct pf_info *pf;

	pf = pf_create(name, failnum, failinfo, flags, PF_PROB);
	if (pf == NULL)
		return -1;

	pf->minfo.probability = probability;
	return insert_pf(pf);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movss %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl $0x2, %r8d
callq 0x29f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2bd0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x2bee
movss 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0x50(%rax)
movq 0x8(%rsp), %rdi
callq 0x2af0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: fiu_enable_external
int fiu_enable_external(const char *name, int failnum, void *failinfo,
                        unsigned int flags, external_cb_t *external_cb)
{
	struct pf_info *pf;

	pf = pf_create(name, failnum, failinfo, flags, PF_EXTERNAL);
	if (pf == NULL)
		return -1;

	pf->minfo.external_cb = external_cb;
	return insert_pf(pf);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq %r8, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl $0x3, %r8d
callq 0x29f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2c4d
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x2c67
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x50(%rax)
movq (%rsp), %rdi
callq 0x2af0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: fiu_enable_stack
int fiu_enable_stack(const char *name, int failnum, void *failinfo,
                     unsigned int flags, void *func, int func_pos_in_stack)
{
	struct pf_info *pf;

	/* Specifying the stack position is unsupported for now */
	if (func_pos_in_stack != -1)
		return -1;

	if (backtrace_works((void (*)())fiu_enable_stack) == 0)
		return -1;

	// We need either get_func_end() or get_func_start() to work, see
	// pc_in_func() above.
	if (get_func_end(func) == NULL && get_func_start(func) == NULL)
		return -1;

	pf = pf_create(name, failnum, failinfo, flags, PF_STACK);
	if (pf == NULL)
		return -1;

	pf->minfo.stack.func_start = func;
	pf->minfo.stack.func_end = get_func_end(func);
	pf->minfo.stack.func_pos_in_stack = func_pos_in_stack;
	return insert_pf(pf);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movl %r9d, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
je 0x2ca4
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d5e
movq 0x5315(%rip), %rdi      # 0x7fc0
callq 0x3a60
cmpl $0x0, %eax
jne 0x2cc2
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d5e
movq 0x18(%rsp), %rdi
callq 0x39c0
cmpq $0x0, %rax
jne 0x2cec
movq 0x18(%rsp), %rdi
callq 0x3980
cmpq $0x0, %rax
jne 0x2cec
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d5e
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
movl $0x4, %r8d
callq 0x29f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2d20
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d5e
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x18(%rsp), %rdi
callq 0x39c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x60(%rax)
movq 0x8(%rsp), %rdi
callq 0x2af0
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: fiu_enable_stack_by_name
int fiu_enable_stack_by_name(const char *name, int failnum, void *failinfo,
                             unsigned int flags, const char *func_name,
                             int func_pos_in_stack)
{
	void *fp;

	/* We need to check this here instead of relying on the test within
	 * fiu_enable_stack() in case it is inlined; that would fail the check
	 * because fiu_enable_stack() would not be in the stack. */
	if (backtrace_works((void (*)())fiu_enable_stack_by_name) == 0)
		return -1;

	fp = get_func_addr(func_name);
	if (fp == NULL)
		return -1;

	return fiu_enable_stack(name, failnum, failinfo, flags, fp,
	                        func_pos_in_stack);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movl %r9d, 0x14(%rsp)
movq 0x5231(%rip), %rdi      # 0x7fc8
callq 0x3a60
cmpl $0x0, %eax
jne 0x2dab
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x2df1
movq 0x18(%rsp), %rdi
callq 0x3a40
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2dcc
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x2df1
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
movq 0x8(%rsp), %r8
movl 0x14(%rsp), %r9d
callq 0x2360
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: fiu_disable
int fiu_disable(const char *name)
{
	bool success;

	rec_count++;

	/* Just find the point of failure and remove it. */
	ef_wlock();
	success = wtable_del(enabled_fails, name);
	ef_wunlock();

	rec_count--;
	return success ? 0 : -1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x51c7(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x53b1(%rip), %rdi      # 0x81d8
callq 0x20a0
leaq 0x5395(%rip), %rax      # 0x81c8
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x43b0
andb $0x1, %al
movb %al, 0xf(%rsp)
leaq 0x538b(%rip), %rdi      # 0x81d8
callq 0x2270
leaq 0x517e(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movb 0xf(%rsp), %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu.c
// Function: pc_in_func
static int pc_in_func(struct pf_info *pf, void *pc)
{
	/* We don't know if the platform allows us to know func_end,
	 * so we use different methods depending on its availability. */
	if (pf->minfo.stack.func_end) {
		return (pc >= pf->minfo.stack.func_start &&
		        pc <= pf->minfo.stack.func_end);
	} else {
		return pf->minfo.stack.func_start == get_func_start(pc);
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x2ed4
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpq 0x50(%rdx), %rcx
movb %al, 0xf(%rsp)
jb 0x2ec5
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x58(%rcx), %rax
setbe %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x2f01
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x3980
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu-rc.c
// Function: fiu_rc_fifo
int fiu_rc_fifo(const char *basename)
{
	int r;

	r = _fiu_rc_fifo(basename);
	if (r < 0)
		return r;

	npipe_basename = strdup(basename);
	pthread_atfork(NULL, NULL, fifo_atfork_child);

	return r;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x33c0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x3388
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x33b4
movq 0x8(%rsp), %rdi
callq 0x2320
movq %rax, 0x4e7f(%rip)      # 0x8218
xorl %eax, %eax
movl %eax, %esi
leaq 0x21c(%rip), %rdx       # 0x35c0
movq %rsi, %rdi
callq 0x55d0
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu-rc.c
// Function: rc_fifo_thread
static void *rc_fifo_thread(void *unused)
{
	int fdr, fdw, r, errcount;

	/* increment the recursion count so we're not affected by libfiu,
	 * otherwise we could make the remote control useless by enabling all
	 * failure points */
	rec_count++;

	errcount = 0;

reopen:
	if (errcount > 10) {
		fprintf(stderr, "libfiu: Too many errors in remote control "
		                "thread, shutting down\n");
		return NULL;
	}

	fdr = open(npipe_path_in, O_RDONLY);
	if (fdr < 0)
		return NULL;

	fdw = open(npipe_path_out, O_WRONLY);
	if (fdw < 0) {
		close(fdr);
		return NULL;
	}

	for (;;) {
		r = rc_do_command(fdr, fdw);
		if (r < 0 && errno != EPIPE) {
			perror("libfiu: Error reading from remote control");
			errcount++;
			close(fdr);
			close(fdw);
			goto reopen;
		} else if (r == 0 || (r < 0 && errno == EPIPE)) {
			/* one of the ends of the pipe was closed */
			close(fdr);
			close(fdw);
			goto reopen;
		}
	}

	/* we never get here */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
leaq 0x49f7(%rip), %rdi      # 0x7fd8
callq 0x21f0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x0, 0x8(%rsp)
cmpl $0xa, 0x8(%rsp)
jle 0x3625
movq 0x49ea(%rip), %rax      # 0x7ff0
movq (%rax), %rdi
leaq 0x2b2f(%rip), %rsi      # 0x613f
movb $0x0, %al
callq 0x2210
movq $0x0, 0x20(%rsp)
jmp 0x370b
movq 0x4bf4(%rip), %rdi      # 0x8220
xorl %esi, %esi
movb $0x0, %al
callq 0x22b0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x364e
movq $0x0, 0x20(%rsp)
jmp 0x370b
movq 0x4bd3(%rip), %rdi      # 0x8228
movl $0x1, %esi
movb $0x0, %al
callq 0x22b0
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jge 0x3683
movl 0x14(%rsp), %edi
callq 0x21a0
movq $0x0, 0x20(%rsp)
jmp 0x370b
jmp 0x3685
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0x3740
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x36d5
callq 0x2060
cmpl $0x20, (%rax)
je 0x36d5
leaq 0x2ad2(%rip), %rdi      # 0x6180
callq 0x22d0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movl 0x14(%rsp), %edi
callq 0x21a0
movl 0x10(%rsp), %edi
callq 0x21a0
jmp 0x35f8
cmpl $0x0, 0xc(%rsp)
je 0x36ed
cmpl $0x0, 0xc(%rsp)
jge 0x3704
callq 0x2060
cmpl $0x20, (%rax)
jne 0x3704
movl 0x14(%rsp), %edi
callq 0x21a0
movl 0x10(%rsp), %edi
callq 0x21a0
jmp 0x35f8
jmp 0x3706
jmp 0x3685
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu-rc.c
// Function: rc_do_command
static int rc_do_command(int fdr, int fdw)
{
	int len, r, reply_len;
	char buf[MAX_LINE], reply[MAX_LINE];
	char *error = NULL;

	len = read_line(fdr, buf);
	if (len <= 0)
		return len;

	r = fiu_rc_string(buf, &error);
	if (r < 0)
		fprintf(stderr, "libfiu: rc parsing error: %s\n", error);

	reply_len = snprintf(reply, MAX_LINE, "%d\n", r);
	r = write(fdw, reply, reply_len);
	if (r <= 0)
		return r;

	return len;
}

// Assembly:
subq $0x428, %rsp            # imm = 0x428
movl %edi, 0x420(%rsp)
movl %esi, 0x41c(%rsp)
movq $0x0, 0x8(%rsp)
movl 0x420(%rsp), %edi
leaq 0x210(%rsp), %rsi
callq 0x3860
movl %eax, 0x418(%rsp)
cmpl $0x0, 0x418(%rsp)
jg 0x3796
movl 0x418(%rsp), %eax
movl %eax, 0x424(%rsp)
jmp 0x3844
leaq 0x210(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2280
movl %eax, 0x414(%rsp)
cmpl $0x0, 0x414(%rsp)
jge 0x37d6
movq 0x4830(%rip), %rax      # 0x7ff0
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x29db(%rip), %rsi      # 0x61aa
movb $0x0, %al
callq 0x2210
leaq 0x10(%rsp), %rdi
movl 0x414(%rsp), %ecx
movl $0x200, %esi            # imm = 0x200
leaq 0x29da(%rip), %rdx      # 0x61c8
movb $0x0, %al
callq 0x2140
movl %eax, 0x410(%rsp)
movl 0x41c(%rsp), %edi
leaq 0x10(%rsp), %rsi
movslq 0x410(%rsp), %rdx
callq 0x20e0
movl %eax, 0x414(%rsp)
cmpl $0x0, 0x414(%rsp)
jg 0x3836
movl 0x414(%rsp), %eax
movl %eax, 0x424(%rsp)
jmp 0x3844
movl 0x418(%rsp), %eax
movl %eax, 0x424(%rsp)
movl 0x424(%rsp), %eax
addq $0x428, %rsp            # imm = 0x428
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/fiu-rc.c
// Function: read_line
static int read_line(int fd, char *buf)
{
	int r;
	char c;
	unsigned int len;

	c = '\0';
	len = 0;
	memset(buf, 0, MAX_LINE);

	do {
		r = read(fd, &c, 1);
		if (r < 0)
			return -1;
		if (r == 0)
			break;

		len += r;

		*buf = c;
		buf++;

	} while (c != '\n' && c != '\0' && len < MAX_LINE);

	if (len > 0 && c == '\n') {
		*(buf - 1) = '\0';
		len--;
	}

	return len;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb $0x0, 0x13(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x2180
movl 0x20(%rsp), %edi
leaq 0x13(%rsp), %rsi
movl $0x1, %edx
callq 0x21e0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x38b6
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x394c
cmpl $0x0, 0x14(%rsp)
jne 0x38bf
jmp 0x391f
movl 0x14(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movb 0x13(%rsp), %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movsbl 0x13(%rsp), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, 0xb(%rsp)
je 0x3913
movsbl 0x13(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xb(%rsp)
je 0x3913
cmpl $0x200, 0xc(%rsp)       # imm = 0x200
setb %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x388b
cmpl $0x0, 0xc(%rsp)
jbe 0x3944
movsbl 0x13(%rsp), %eax
cmpl $0xa, %eax
jne 0x3944
movq 0x18(%rsp), %rax
movb $0x0, -0x1(%rax)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/backtrace.c
// Function: get_func_start
void *get_func_start(void *pc)
{
	int r;
	Dl_info info;

	r = dladdr(pc, &info);
	if (r == 0)
		return NULL;

	return info.dli_saddr;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x2120
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x39ac
movq $0x0, 0x30(%rsp)
jmp 0x39b6
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/backtrace.c
// Function: get_func_end
void *get_func_end(void *func)
{
	int r;
	Dl_info dl_info;
	ElfW(Sym) * elf_info;

	r = dladdr1(func, &dl_info, (void **)&elf_info, RTLD_DL_SYMENT);
	if (r == 0)
		return NULL;
	if (elf_info == NULL)
		return NULL;
	if (dl_info.dli_saddr == NULL)
		return NULL;

	return ((unsigned char *)func) + elf_info->st_size;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movl $0x1, %ecx
callq 0x22c0
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
jne 0x39f8
movq $0x0, 0x40(%rsp)
jmp 0x3a31
cmpq $0x0, 0x8(%rsp)
jne 0x3a0b
movq $0x0, 0x40(%rsp)
jmp 0x3a31
cmpq $0x0, 0x28(%rsp)
jne 0x3a1e
movq $0x0, 0x40(%rsp)
jmp 0x3a31
movq 0x38(%rsp), %rax
movq 0x8(%rsp), %rcx
addq 0x10(%rcx), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/backtrace.c
// Function: backtrace_works
int backtrace_works(void (*caller)())
{
	/* We remember the result so we don't have to compute it over an over
	 * again, we know it doesn't change. */
	static int works = -1;

	void *start = NULL;
	void *end = NULL;
	void *bt_buffer[100];
	void *pc;
	int nptrs, i;

	/* Return the result if we know it. */
	if (works >= 0)
		return works;

	nptrs = get_backtrace(bt_buffer, 100);
	if (nptrs <= 0) {
		works = 0;
		return works;
	}

	/* We will detect if it works by looking for the caller in the
	 * backtrace. */
	start = get_func_start(fp_to_voidp(caller));
	end = get_func_end(fp_to_voidp(caller));

	if (start == NULL && end == NULL) {
		works = 0;
		return works;
	}

	for (i = 0; i < nptrs; i++) {
		pc = bt_buffer[i];

		/* On some platforms, we have everything except
		 * get_func_end(), and that's ok. */
		if (end) {
			if (pc >= start && pc <= end) {
				works = 1;
				return works;
			}
		} else {
			if (get_func_start(pc) == start) {
				works = 1;
				return works;
			}
		}
	}

	works = 0;
	return works;
}

// Assembly:
subq $0x358, %rsp            # imm = 0x358
movq %rdi, 0x348(%rsp)
movq $0x0, 0x340(%rsp)
movq $0x0, 0x338(%rsp)
cmpl $0x0, 0x472e(%rip)      # 0x81bc
jl 0x3aa2
movl 0x4726(%rip), %eax      # 0x81bc
movl %eax, 0x354(%rsp)
jmp 0x3c00
leaq 0x10(%rsp), %rdi
movl $0x64, %esi
callq 0x3960
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jg 0x3ad8
movl $0x0, 0x46f6(%rip)      # 0x81bc
movl 0x46f0(%rip), %eax      # 0x81bc
movl %eax, 0x354(%rsp)
jmp 0x3c00
movq 0x348(%rsp), %rdi
callq 0x3c10
movq %rax, %rdi
callq 0x3980
movq %rax, 0x340(%rsp)
movq 0x348(%rsp), %rdi
callq 0x3c10
movq %rax, %rdi
callq 0x39c0
movq %rax, 0x338(%rsp)
cmpq $0x0, 0x340(%rsp)
jne 0x3b44
cmpq $0x0, 0x338(%rsp)
jne 0x3b44
movl $0x0, 0x468a(%rip)      # 0x81bc
movl 0x4684(%rip), %eax      # 0x81bc
movl %eax, 0x354(%rsp)
jmp 0x3c00
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x3be9
movslq (%rsp), %rax
movq 0x10(%rsp,%rax,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x338(%rsp)
je 0x3baa
movq 0x8(%rsp), %rax
cmpq 0x340(%rsp), %rax
jb 0x3ba8
movq 0x8(%rsp), %rax
cmpq 0x338(%rsp), %rax
ja 0x3ba8
movl $0x1, 0x4623(%rip)      # 0x81bc
movl 0x461d(%rip), %eax      # 0x81bc
movl %eax, 0x354(%rsp)
jmp 0x3c00
jmp 0x3bd9
movq 0x8(%rsp), %rdi
callq 0x3980
cmpq 0x340(%rsp), %rax
jne 0x3bd7
movl $0x1, 0x45f4(%rip)      # 0x81bc
movl 0x45ee(%rip), %eax      # 0x81bc
movl %eax, 0x354(%rsp)
jmp 0x3c00
jmp 0x3bd9
jmp 0x3bdb
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x3b4b
movl $0x0, 0x45c9(%rip)      # 0x81bc
movl 0x45c3(%rip), %eax      # 0x81bc
movl %eax, 0x354(%rsp)
movl 0x354(%rsp), %eax
addq $0x358, %rsp            # imm = 0x358
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/wtable.c
// Function: wtable_create
struct wtable *wtable_create(void (*destructor)(void *))
{
	struct wtable *t = malloc(sizeof(struct wtable));
	if (t == NULL)
		return NULL;

	t->wildcards = NULL;
	t->wcache = NULL;

	t->finals = hash_create(destructor);
	if (t->finals == NULL)
		goto error;

	t->wildcards = malloc(sizeof(struct wentry) * MIN_SIZE);
	if (t->wildcards == NULL)
		goto error;

	memset(t->wildcards, 0, sizeof(struct wentry) * MIN_SIZE);

	t->wcache = cache_create();
	if (t->wcache == NULL)
		goto error;

	t->ws_size = MIN_SIZE;
	t->ws_used_count = 0;
	t->destructor = destructor;

	return t;

error:
	if (t->finals)
		hash_free(t->finals);
	if (t->wcache)
		cache_free(t->wcache);
	free(t->wildcards);
	free(t);
	return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x30, %edi
callq 0x2250
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x3c5c
movq $0x0, 0x10(%rsp)
jmp 0x3d69
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x8(%rsp), %rdi
callq 0x46f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x3c97
jmp 0x3d1c
movl $0x140, %edi            # imm = 0x140
callq 0x2250
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3cb9
jmp 0x3d1c
movq (%rsp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movl $0x140, %edx            # imm = 0x140
callq 0x2180
movb $0x0, %al
callq 0x4fe0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x3cec
jmp 0x3d1c
movq (%rsp), %rax
movq $0xa, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x3d69
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x3d32
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x47d0
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3d4a
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x5060
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq (%rsp), %rdi
callq 0x2040
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/wtable.c
// Function: wtable_free
void wtable_free(struct wtable *t)
{
	int i;
	struct wentry *entry;

	hash_free(t->finals);
	cache_free(t->wcache);

	for (i = 0; i < t->ws_size; i++) {
		entry = t->wildcards + i;
		if (entry->in_use) {
			t->destructor(entry->value);
			free(entry->key);
		}
	}

	free(t->wildcards);
	free(t);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x47d0
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x5060
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3e0d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x3dfe
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rsp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x2040
jmp 0x3e00
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3dac
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq 0x10(%rsp), %rdi
callq 0x2040
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/wtable.c
// Function: wtable_get
void *wtable_get(struct wtable *t, const char *key)
{
	void *value;
	struct wentry *entry;

	/* Do an exact lookup first. */
	value = hash_get(t->finals, key);
	if (value)
		return value;

	/* Then see if we can find it in the wcache */
	if (cache_get(t->wcache, key, &value))
		return value;

	/* And then walk the wildcards array. */
	entry = wildcards_find_entry(t, key, false, NULL);
	if (entry) {
		cache_set(t->wcache, key, entry->value);
		return entry->value;
	}

	/* Cache the negative result as well. */
	cache_set(t->wcache, key, NULL);

	return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x4860
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3e6c
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x3f00
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x53a0
testb $0x1, %al
jne 0x3e8a
jmp 0x3e96
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x3f00
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3f10
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x3ee0
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x5450
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x3f00
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5450
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/wtable.c
// Function: wildcards_find_entry
static struct wentry *wildcards_find_entry(struct wtable *t, const char *key,
                                           bool exact,
                                           struct wentry **first_free)
{
	size_t key_len;
	size_t pos;
	struct wentry *entry;
	bool found_free = false;

	key_len = strlen(key);

	for (pos = 0; pos < t->ws_size; pos++) {
		entry = t->wildcards + pos;
		if (!entry->in_use) {
			if (!found_free && first_free) {
				*first_free = entry;
				found_free = true;
			}
			continue;

		} else if (ws_matches_s(entry->key, entry->key_len, key,
		                        key_len, exact)) {
			/* The key matches. */
			return entry;
		}
	}

	/* No match. */
	return NULL;
}

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %rcx, 0x20(%rsp)
movb $0x0, 0x7(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2100
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3ff7
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
jne 0x3fa4
testb $0x1, 0x7(%rsp)
jne 0x3fa2
cmpq $0x0, 0x20(%rsp)
je 0x3fa2
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x7(%rsp)
jmp 0x3fe4
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x45a0
testb $0x1, %al
jne 0x3fd4
jmp 0x3fe0
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x4000
jmp 0x3fe2
jmp 0x3fe4
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3f48
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/wtable.c
// Function: wtable_set
bool wtable_set(struct wtable *t, const char *key, void *value)
{
	if (is_wildcard(key, strlen(key))) {
		if ((t->ws_size - t->ws_used_count) <= 1) {
			/* If we only have one entry left, grow by 30%, plus
			 * one to make sure we always increase even if the
			 * percentage isn't enough. */
			if (!resize_table(t, t->ws_size * 1.3 + 1))
				return false;
		}

		/* Invalidate the cache. We could be smart and walk it,
		 * removing only the negative hits, but it's also more
		 * expensive */
		cache_invalidate(t->wcache);

		return wildcards_set(t, strdup(key), value);
	} else {
		return hash_set(t->finals, key, value);
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2100
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x4150
testb $0x1, %al
jne 0x404d
jmp 0x411d
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
subq 0x18(%rcx), %rax
cmpq $0x1, %rax
ja 0x40e1
movq 0x28(%rsp), %rdi
movq 0x10(%rdi), %xmm0
movaps 0x215a(%rip), %xmm1     # 0x61d0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x215e(%rip), %xmm1     # 0x61e0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x2157(%rip), %xmm1     # 0x61f0
mulsd %xmm1, %xmm0
movsd 0x2153(%rip), %xmm1     # 0x61f8
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
movsd 0x2140(%rip), %xmm1     # 0x6200
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rsi
callq 0x4180
testb $0x1, %al
jne 0x40df
movb $0x0, 0x37(%rsp)
jmp 0x413a
jmp 0x40e1
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x5090
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2320
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x42b0
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x413a
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x4aa0
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/wtable.c
// Function: resize_table
static bool resize_table(struct wtable *t, size_t new_size)
{
	size_t i;
	struct wentry *old_wildcards, *e;
	size_t old_size;

	if (new_size < MIN_SIZE) {
		/* Do not resize below the minimum size. */
		return true;
	}

	old_wildcards = t->wildcards;
	old_size = t->ws_size;

	t->wildcards = malloc(sizeof(struct wentry) * new_size);
	if (t->wildcards == NULL)
		return false;

	memset(t->wildcards, 0, sizeof(struct wentry) * new_size);
	t->ws_size = new_size;
	t->ws_used_count = 0;

	/* Insert the old entries into the new table. */
	for (i = 0; i < old_size; i++) {
		e = old_wildcards + i;
		if (e->in_use) {
			wildcards_set(t, e->key, e->value);
		}
	}

	free(old_wildcards);

	/* Keep the cache the same size as our table, which works reasonably
	 * well in practise */
	cache_resize(t->wcache, new_size);

	return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0xa, 0x20(%rsp)
jae 0x41a0
movb $0x1, 0x37(%rsp)
jmp 0x42a3
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
shlq $0x5, %rdi
callq 0x2250
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x41eb
movb $0x0, 0x37(%rsp)
jmp 0x42a3
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rdx
shlq $0x5, %rdx
xorl %esi, %esi
callq 0x2180
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq (%rsp), %rax
jae 0x4281
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x426f
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x42b0
jmp 0x4271
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4228
movq 0x10(%rsp), %rdi
callq 0x2040
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x5150
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libfiu/libfiu/wtable.c
// Function: wildcards_set
static bool wildcards_set(struct wtable *t, char *key, void *value)
{
	struct wentry *entry, *first_free;

	first_free = NULL;
	entry = wildcards_find_entry(t, key, true, &first_free);

	if (entry) {
		/* Found a match, override the value. */
		free(entry->key);
		entry->key = key;
		t->destructor(entry->value);
		entry->value = value;
		return true;
	} else if (first_free) {
		/* We are inserting a new entry. */
		first_free->key = key;
		first_free->key_len = strlen(key);
		first_free->value = value;
		first_free->in_use = true;
		t->ws_used_count++;
		return true;
	}

	/* This should never happen, as we should always have space by the
	 * time this function is called. */
	return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
leaq 0x8(%rsp), %rcx
callq 0x3f10
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4335
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x2040
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movb $0x1, 0x37(%rsp)
jmp 0x4396
cmpq $0x0, 0x8(%rsp)
je 0x438f
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
callq 0x2100
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movb $0x1, 0x37(%rsp)
jmp 0x4396
jmp 0x4391
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)