LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: getBiquad
int
getBiquad(biquad *f,int in)
    {
    double result;
    //printf("getting %d from ldelay\n",getVarDelay(f->ldelay,1));
    //printf("getting %d from ldelay\n",getVarDelay(f->ldelay,2));
    //printf("getting %d from rdelay\n",getVarDelay(f->rdelay,1));
    //printf("getting %d from rdelay\n",getVarDelay(f->rdelay,2));
    //result = f->a0 * in;
    //printf("result is %f\n",result);
    //printf("%f\n",f->a1 * getVarDelay(f->ldelay,1));
    //result += f->a1 * getVarDelay(f->ldelay,1);
    //printf("result is %f\n",result);
    //printf("%f\n",f->a2 * getVarDelay(f->ldelay,2));
    //result += f->a2 * getVarDelay(f->ldelay,2);
    //printf("result is %f\n",result);
    //printf("-%f\n",f->b1 * getVarDelay(f->rdelay,1));
    //result -= f->b1 * getVarDelay(f->rdelay,1);
    //printf("result is %f\n",result);
    //printf("-%f\n",f->b2 * getVarDelay(f->rdelay,2));
    //result -= f->b2 * getVarDelay(f->rdelay,2);
    //printf("result is %f\n",result);
    result = f->a0 * in
         + f->a1 * getVarDelay(f->ldelay,1)
         + f->a2 * getVarDelay(f->ldelay,2)
         - f->b1 * getVarDelay(f->rdelay,1)
         - f->b2 * getVarDelay(f->rdelay,2)
         ;
    //printf("result is %f\n",result);
    return (int) result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movsd 0x17c4(%rip), %xmm0     # 0xd328
callq 0xb790
movsd -0x60(%rbp), %xmm1
movsd -0x58(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
cvtsi2sd %eax, %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movsd 0x1785(%rip), %xmm0     # 0xd330
callq 0xb790
movsd -0x48(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
cvtsi2sd %eax, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movsd 0x173f(%rip), %xmm0     # 0xd328
callq 0xb790
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
cvtsi2sd %eax, %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movsd 0x16f2(%rip), %xmm0     # 0xd330
callq 0xb790
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
cvtsi2sd %eax, %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
cvttsd2si -0x18(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: updateBiquad
int
updateBiquad(biquad *f,int in)
    {
    int out = getBiquad(f,in);
    //printf("in is %d\n",in);
    //printf("out is %d\n",out);
    //printf("pushing %d to ldelay\n",in);
    updateDelay(f->ldelay,in);
    //printf("pushing %d to rdelay\n",out);
    updateDelay(f->rdelay,out);
    //getchar();
    return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbb20
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xb740
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0xb740
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: newModBiquad
modbiquad *
newModBiquad(double a0,double a1,double a2,double b1,double b2,double wet,double dry)
    {
    modbiquad *f = New(sizeof(modbiquad));

    f->bq = newBiquad(a0,a1,a2,b1,b2);
    f->wet = wet;
    f->dry = dry;
    return f;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm5, -0x30(%rbp)
movsd %xmm6, -0x38(%rbp)
movl $0x18, %edi
callq 0x8ec0
movq %rax, -0x40(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm3
movsd -0x28(%rbp), %xmm4
callq 0xba70
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movq -0x40(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: newDDL
ddl *
newDDL(int length,double wet,double fb)
    {
    ddl *d = New(sizeof(ddl));
    d->fb = fb > 1? 1 : (fb < 0? 0: fb);
    d->wet = wet > 1? 1 : (wet < 0? 0: wet);
    d->dry = 1 - wet;
    d->length = length;
    d->sdelay = newDelay(length);
    return d;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl $0x28, %edi
callq 0x8ec0
movq %rax, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x14d8(%rip), %xmm1     # 0xd328
ucomisd %xmm1, %xmm0
jbe 0xbe65
movsd 0x14ca(%rip), %xmm0     # 0xd328
movsd %xmm0, -0x28(%rbp)
jmp 0xbe8d
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0xbe79
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xbe83
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
movsd 0x1480(%rip), %xmm1     # 0xd328
ucomisd %xmm1, %xmm0
jbe 0xbebd
movsd 0x1472(%rip), %xmm0     # 0xd328
movsd %xmm0, -0x38(%rbp)
jmp 0xbee5
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0xbed1
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0xbedb
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd 0x142e(%rip), %xmm0     # 0xd328
subsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x4(%rbp), %edi
callq 0xb690
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: updateDDL
int
updateDDL(ddl *d,int in)
    {
    int out = getDDL(d,in);
    int s = getDDLPartial(d,in);
    updateDelay(d->sdelay,s);
    return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbf30
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbfa0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xb740
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: newLFO
lfo *
newLFO(double freq)
    {
    lfo *o = New(sizeof(lfo));
    o->start = 0;
    o->freq = freq;
    o->step = 2 * M_PI / (SampleRate / freq);
    return o;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movl $0x18, %edi
callq 0x8ec0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
leaq 0x6375(%rip), %rax      # 0x12400
cvtsi2sdl (%rax), %xmm1
divsd -0x8(%rbp), %xmm1
movsd 0x176c(%rip), %xmm0     # 0xd808
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: newMDE
mde *
newMDE(double wet,double fb,int dsamples,double freq,int lo,int hi)
    {
    mde *m = New(sizeof(mde));
    m->dry = 1 - wet;
    m->wet = wet;
    m->fb = fb;
    m->sdelay = newDelay(dsamples);
    m->osc = newLFO(freq);
    m->lo = lo;
    m->hi = hi;
    return m;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movsd %xmm2, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl $0x30, %edi
callq 0x8ec0
movq %rax, -0x30(%rbp)
movsd 0x11d2(%rip), %xmm0     # 0xd328
subsd -0x8(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x8(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movl -0x14(%rbp), %edi
callq 0xb690
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movsd -0x20(%rbp), %xmm0
callq 0xc050
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: updateMDE
int
updateMDE(mde *m,int in)
    {
    int out = getMDE(m,in);
    int recirc = getMDEDelay(m);
    
    updateLFO(m->osc);
    updateDelay(m->sdelay,in + m->fb * recirc);

    return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xc1d0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc240
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc0e0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
cvtsi2sdl -0xc(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
callq 0xb740
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: newCombF
combf *
newCombF(int samplesDelayed,double fb)
    {
    combf *c = New(sizeof(combf));
    c->sdelay = newDelay(samplesDelayed);
    c->fb = fb;
    c->length = samplesDelayed;
    return c;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x18, %edi
callq 0x8ec0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
callq 0xb690
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: newLPC
lpc *
newLPC(int samplesDelayed,double gc,double glp)
    {
    lpc *f = New(sizeof(lpc));
    f->idelay = newDelay(samplesDelayed+1);
    f->odelay = newDelay(samplesDelayed);
    f->gc = gc;
    f->glp = glp;
    f->length = samplesDelayed;
    return f;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl $0x30, %edi
callq 0x8ec0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0xb690
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %edi
callq 0xb690
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: getLPC
int 
getLPC(lpc *f,int in)
    {
    return getVarDelay(f->idelay,f->length)
        - f->glp * getDelay(f->idelay)
        + f->glp * getVarDelay(f->odelay,1)
        + f->gc  * getDelay(f->odelay)
        ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
callq 0xb790
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xb710
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
cvtsi2sd %eax, %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movsd 0xe1f(%rip), %xmm0      # 0xd328
callq 0xb790
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
cvtsi2sd %eax, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb710
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
cvtsi2sd %eax, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: updateLPC
int
updateLPC(lpc *f,int in)
    {
    int out = getLPC(f,in);
    updateDelay(f->idelay,in);
    updateDelay(f->odelay,out);
    return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xc470
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xb740
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0xb740
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: newDAP
dap *
newDAP(int samplesDelayed,double g)
    {
    dap *f = New(sizeof(dap));
    f->xdelay = newDelay(samplesDelayed);
    f->ydelay = newDelay(samplesDelayed);
    f->g = g;
    f->length = samplesDelayed;
    return f;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x28, %edi
callq 0x8ec0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
callq 0xb690
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %edi
callq 0xb690
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: updateDAP
int
updateDAP(dap *f,int in)
    {
    int out = getDAP(f,in);
    updateDelay(f->xdelay,in);
    updateDelay(f->ydelay,out);
    return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xc630
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xb740
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0xb740
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/labelQueue.h
// Function: firstLabelAfter
static uint32_t firstLabelAfter(uint32_t pc) {
    // inclusive
    uint32_t begin = 0; 
    // exclusive
    uint32_t end = labelCount;
    while (begin < end) {
        uint32_t mid = (begin + end) / 2;
        if (labelLocations[mid] <= pc) {
            begin = mid + 1;
        } else {
            end = mid;
        }
    }
    return begin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl 0x512c(%rip), %eax      # 0x7860
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x2771
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x911a(%rip), %rax      # 0xb870
movl (%rax,%rcx,4), %eax
cmpl -0x4(%rbp), %eax
ja 0x2769
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x276f
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x2737
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/labelQueue.h
// Function: registerLabel
static void registerLabel(jump_t jump) {
    for (uint32_t i = 0; i < labelCount; i++) {
        if (labels[i].length != jump.label.length) {
            continue;
        }
        if (memcmp(labels[i].start, jump.label.start, jump.label.length)) {
            continue;
        }
        fprintf(stderr, "Duplicate label at %s\n", jump.label.start);
        assert(0); // duplicate label
    }
    labelLocations[labelCount] = jump.programCounter;
    dataSizes[labelCount] = jump.dataSize;
    labels[labelCount++] = jump.label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x50c0(%rip), %eax      # 0x7860
jae 0x2844
movq -0x10(%rbp), %rcx
movl -0x4(%rbp), %eax
movl %eax, %edx
leaq 0x50ba(%rip), %rax      # 0x7870
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x8(%rax), %rax
cmpq 0x18(%rcx), %rax
je 0x27c9
jmp 0x2836
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
movl %ecx, %edx
leaq 0x5097(%rip), %rcx      # 0x7870
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdi
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x2060
cmpl $0x0, %eax
je 0x27f7
jmp 0x2836
movq -0x10(%rbp), %rax
movq 0x47f6(%rip), %rcx      # 0x6ff8
movq (%rcx), %rdi
movq 0x10(%rax), %rdx
leaq 0x19ea(%rip), %rsi      # 0x41fa
movb $0x0, %al
callq 0x2070
leaq 0x1823(%rip), %rdi      # 0x4041
leaq 0x19ec(%rip), %rsi      # 0x4211
movl $0x45, %edx
leaq 0x19f5(%rip), %rcx      # 0x4226
callq 0x2030
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2797
movq -0x10(%rbp), %rcx
movl (%rcx), %esi
movl 0x5010(%rip), %eax      # 0x7860
movl %eax, %edx
leaq 0x9017(%rip), %rax      # 0xb870
movl %esi, (%rax,%rdx,4)
movw 0x4(%rcx), %si
movl 0x4ffa(%rip), %eax      # 0x7860
movl %eax, %edx
leaq 0xa011(%rip), %rax      # 0xc880
movw %si, (%rax,%rdx,2)
movl 0x4fe7(%rip), %eax      # 0x7860
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x4fdc(%rip)      # 0x7860
movl %eax, %eax
movl %eax, %edx
leaq 0x4fe1(%rip), %rax      # 0x7870
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x10(%rcx), %rdx
movq %rdx, (%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/include/labelQueue.h
// Function: incrementLabelLocations
static void incrementLabelLocations(uint32_t after, uint32_t by) {
    for (uint32_t i = firstLabelAfter(after); i < labelCount; i++) {
        int before = labelLocations[i] < 256;
        labelLocations[i] += by;
        int after = labelLocations[i] >= 256;
        if (before && after) {
            // TODO shift label positions 
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x2720
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x4f8e(%rip), %eax      # 0x7860
jae 0x2947
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x8f90(%rip), %rax      # 0xb870
cmpl $0x100, (%rax,%rcx,4)   # imm = 0x100
setb %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x8f6f(%rip), %rax      # 0xb870
addl (%rax,%rcx,4), %edx
leaq 0x8f65(%rip), %rax      # 0xb870
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x8f56(%rip), %rax      # 0xb870
cmpl $0x100, (%rax,%rcx,4)   # imm = 0x100
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x293a
cmpl $0x0, -0x14(%rbp)
je 0x293a
jmp 0x293a
jmp 0x293c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x28c9
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzip.c
// Function: confirm_overwrite
static int confirm_overwrite(const char *fn)
{
    int save_errno = errno;
    int ret = 0;

    if (isatty(STDIN_FILENO)) {
        fprintf(stderr, "[bgzip] %s already exists; do you wish to overwrite (y or n)? ", fn);
        if (ask_yn()) ret = 1;
    }

    errno = save_errno;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4050
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
xorl %edi, %edi
callq 0x48d0
cmpl $0x0, %eax
je 0x78d8
movq 0xff720(%rip), %rax     # 0x106fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xe147a(%rip), %rsi     # 0xe8d38
movb $0x0, %al
callq 0x46f0
callq 0x7cb0
cmpl $0x0, %eax
je 0x78d6
movl $0x1, -0x10(%rbp)
jmp 0x78d8
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x4050
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzip.c
// Function: error
static void HTS_FORMAT(HTS_PRINTF_FMT, 1, 2) error(const char *format, ...)
{
    va_list ap;
    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x7935
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xff649(%rip), %rax     # 0x106fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x4680
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzip.c
// Function: getfilespec
static int getfilespec(const char *path, struct stat *status)
{
    if (!path || !status) {     //invalid
        return -1;
    }
    if (!strcmp(path, "-")) {   //cant get / set for stdin/out, return success
        return 0;
    }
    if (stat(path, status) < 0) {
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7a7e
cmpq $0x0, -0x18(%rbp)
jne 0x7a87
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7ac7
movq -0x10(%rbp), %rdi
leaq 0xe4b66(%rip), %rsi     # 0xec5f8
callq 0x46b0
cmpl $0x0, %eax
jne 0x7aa5
movl $0x0, -0x4(%rbp)
jmp 0x7ac7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4420
cmpl $0x0, %eax
jge 0x7ac0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7ac7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzip.c
// Function: setfilespec
static int setfilespec(const char *path, const struct stat *status)
{
    if (!path || !status) {     //invalid
        return -1;
    }
    if (!strcmp(path, "-")) {   //cant get / set for stdin/out, return success
        return 0;
    }

#ifdef _WIN32
    struct _utimbuf tval;
    //time upto sec - access & modification time
    tval.actime = status->st_atime;
    tval.modtime = status->st_mtime;
    if (_utime(path, &tval) < 0) {
        fprintf(stderr, "[bgzip] Failed to set file specifications.\n");
        return -1;
    }
#else
    struct timeval tval[2];
    memset(&tval[0], 0, sizeof(tval));
    //time upto sec - access time
    tval[0].tv_sec = status->st_atime;
    //time upto sec - modification time
    tval[1].tv_sec = status->st_mtime;
    if (utimes(path, &tval[0]) < 0) {
        fprintf(stderr, "[bgzip] Failed to set file specifications.\n");
        return -1;
    }
#endif //_WIN32
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7aee
cmpq $0x0, -0x18(%rbp)
jne 0x7afa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7b7a
movq -0x10(%rbp), %rdi
leaq 0xe4af3(%rip), %rsi     # 0xec5f8
callq 0x46b0
cmpl $0x0, %eax
jne 0x7b18
movl $0x0, -0x4(%rbp)
jmp 0x7b7a
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x4250
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4310
cmpl $0x0, %eax
jge 0x7b73
movq 0xff477(%rip), %rax     # 0x106fd0
movq (%rax), %rdi
leaq 0xe1214(%rip), %rsi     # 0xe8d77
movb $0x0, %al
callq 0x46f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7b7a
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/samtools[P]htslib/bgzip.c
// Function: check_name_and_extension
static int check_name_and_extension(char *name, int *forced) {
    size_t pos;
    char *ext;

    for (pos = strlen(name); pos > 0; --pos)
        if (name[pos] == '.' || name[pos] == '/') break;

    if (pos == 0 || name[pos] != '.') {
        fprintf(stderr, "[bgzip] can't find an extension in %s -- please rename\n", name);
        return 1;
    }

    name[pos] = '\0';
    ext = &name[pos+1];

    if (!(known_extension(ext) || confirm_filename(forced, name, ext))) {
        fprintf(stderr, "[bgzip] unknown extension .%s -- declining to decompress to %s\n", ext, name);
        return 2;                            //explicit N, continue and return 2
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x7be8
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x7bd6
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x7bd8
jmp 0x7be8
jmp 0x7bda
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7bad
cmpq $0x0, -0x20(%rbp)
je 0x7c00
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x7c25
movq 0xff3c9(%rip), %rax     # 0x106fd0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xe118e(%rip), %rsi     # 0xe8da3
movb $0x0, %al
callq 0x46f0
movl $0x1, -0x4(%rbp)
jmp 0x7c98
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7d30
cmpl $0x0, %eax
jne 0x7c91
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7d90
cmpl $0x0, %eax
jne 0x7c91
movq 0xff361(%rip), %rax     # 0x106fd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xe115a(%rip), %rsi     # 0xe8ddb
movb $0x0, %al
callq 0x46f0
movl $0x2, -0x4(%rbp)
jmp 0x7c98
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzip.c
// Function: ask_yn
static int ask_yn(void)
{
    char line[1024];
    if (fgets(line, sizeof line, stdin) == NULL)
        return 0;
    return line[0] == 'Y' || line[0] == 'y';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
leaq -0x410(%rbp), %rdi
movq 0xff2ff(%rip), %rax     # 0x106fc8
movq (%rax), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x47f0
cmpq $0x0, %rax
jne 0x7ce5
movl $0x0, -0x4(%rbp)
jmp 0x7d1a
movsbl -0x410(%rbp), %ecx
movb $0x1, %al
cmpl $0x59, %ecx
movb %al, -0x411(%rbp)
je 0x7d0c
movsbl -0x410(%rbp), %eax
cmpl $0x79, %eax
sete %al
movb %al, -0x411(%rbp)
movb -0x411(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzip.c
// Function: known_extension
static int known_extension(const char *ext)
{
    static const char *known[] = {
        "gz", "bgz", "bgzf",
        NULL
    };

    const char **p;
    for (p = known; *p; p++)
        if (strcasecmp(ext, *p) == 0) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xff7cd(%rip), %rax     # 0x107510
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7d7f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x7d6f
movl $0x1, -0x4(%rbp)
jmp 0x7d86
jmp 0x7d71
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x7d47
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bgzip.c
// Function: confirm_filename
static int confirm_filename(int *is_forced, const char *name, const char *ext)
{
    if (*is_forced) {
        (*is_forced)--;
        return 1;
    }

    if (!isatty(STDIN_FILENO))
        return 0;

    fprintf(stderr, "[bgzip] .%s is not a known extension; do you wish to decompress to %s (y or n)? ", ext, name);
    return ask_yn();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7dc1
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x7dfe
xorl %edi, %edi
callq 0x48d0
cmpl $0x0, %eax
jne 0x7dd6
movl $0x0, -0x4(%rbp)
jmp 0x7dfe
movq 0xff1f3(%rip), %rax     # 0x106fd0
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0xe1030(%rip), %rsi     # 0xe8e1f
movb $0x0, %al
callq 0x46f0
callq 0x7cb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm_dir.c
// Function: main
int main(int argc, char **argv)
{
	if (argc > 2){

		if (argc == 4 && strcmp("find", argv[1]) == 0)
			return find_in_dir(argv[2], argv[3]);

		if (argc == 3 && strcmp("dump", argv[1]) == 0)
			return dump_dir(argv[2]);

		if (argc == 3 && strcmp("list", argv[1]) == 0)
			return list_dir(argv[2]);
	}

	printf("Usage:\n");
	printf("\t%s list [directory] - list files in the database\n", argv[0]);
	printf("\t%s find [directory] [key] - find in the database\n", argv[0]);
	printf("\t%s dump [directory] - dump the database\n", argv[0]);
	printf("\t\tDo not forget about quotes around the directory\n");

	return 1;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x2, 0x10(%rsp)
jle 0x1360
cmpl $0x4, 0x10(%rsp)
jne 0x12f1
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x2d3d(%rip), %rdi      # 0x4004
callq 0x10b0
cmpl $0x0, %eax
jne 0x12f1
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x13d0
movl %eax, 0x14(%rsp)
jmp 0x13c6
cmpl $0x3, 0x10(%rsp)
jne 0x1329
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x2d01(%rip), %rdi      # 0x4009
callq 0x10b0
cmpl $0x0, %eax
jne 0x1329
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1430
movl %eax, 0x14(%rsp)
jmp 0x13c6
cmpl $0x3, 0x10(%rsp)
jne 0x135e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x2cce(%rip), %rdi      # 0x400e
callq 0x10b0
cmpl $0x0, %eax
jne 0x135e
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x14e0
movl %eax, 0x14(%rsp)
jmp 0x13c6
jmp 0x1360
leaq 0x2cac(%rip), %rdi      # 0x4013
movb $0x0, %al
callq 0x1080
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x2c9e(%rip), %rdi      # 0x401b
movb $0x0, %al
callq 0x1080
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x2cbb(%rip), %rdi      # 0x404e
movb $0x0, %al
callq 0x1080
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x2cd8(%rip), %rdi      # 0x4081
movb $0x0, %al
callq 0x1080
leaq 0x2cf4(%rip), %rdi      # 0x40ab
movb $0x0, %al
callq 0x1080
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm_dir.c
// Function: find_in_dir
static int find_in_dir(const char *path, const char *keytofind)
{
	hm_dir_t *dir = hm_dir_opena(path);

	const hm_pair_t *pair = hm_dir_get(dir, keytofind);

	_print_pair(pair);

	hm_dir_close(dir);
	free(dir);

	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1ab0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1b60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1520
movq 0x10(%rsp), %rdi
callq 0x1a40
movq 0x10(%rsp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm_dir.c
// Function: dump_dir
static int dump_dir(const char *path)
{
	const uint64_t count = 30;

	hm_dir_t *dir = hm_dir_opena(path);

	hm_dir_it_t *it = hm_dir_it_open(dir);

	const hm_pair_t *pair;
	uint64_t i = 0;
	for(pair = hm_dir_it_first(it); pair; pair = hm_dir_it_next(it)){
		_print_pair(pair);

		++i;

		if (i >= count)
			break;
	}

	hm_dir_it_close(it);

	hm_dir_close(dir);
	free(dir);

	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq $0x1e, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1ab0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1c00
movq %rax, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1c70
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x14b5
movq 0x10(%rsp), %rdi
callq 0x1520
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
cmpq $0x1e, 0x8(%rsp)
jb 0x14a2
jmp 0x14b5
jmp 0x14a4
movq 0x18(%rsp), %rdi
callq 0x1d20
movq %rax, 0x10(%rsp)
jmp 0x1478
movq 0x18(%rsp), %rdi
callq 0x1c60
movq 0x20(%rsp), %rdi
callq 0x1a40
movq 0x20(%rsp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm_dir.c
// Function: list_dir
static int list_dir(const char *path)
{
	hm_dir_t *dir = hm_dir_opena(path);

	hm_dir_printf(dir);

	hm_dir_close(dir);
	free(dir);

	return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1ab0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1ec0
movq 0x8(%rsp), %rdi
callq 0x1a40
movq 0x8(%rsp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm_dir.c
// Function: print_pair
static void _print_pair(const hm_pair_t *pair)
{
	const int only = 1;

	if (pair && only){
		hm_pair_printf(pair);
	}else if (pair){
		printf("Pair is %s\n", hm_pair_valid(pair, NULL) ? "valid" : "invalid" );
		printf("Pair checksum is %s\n", hm_pair_checksumvalid(pair) ? "valid" : "invalid" );
		printf("---begin---\n");
		hm_pair_printf(pair);
		printf("----end----\n");
	}else{
		printf("Not Found\n");
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1548
movq 0x10(%rsp), %rdi
callq 0x2360
jmp 0x15ee
cmpq $0x0, 0x10(%rsp)
je 0x15de
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2290
movl %eax, %ecx
leaq 0x2b7f(%rip), %rsi      # 0x40ea
leaq 0x2b7a(%rip), %rax      # 0x40ec
cmpl $0x0, %ecx
cmovneq %rax, %rsi
leaq 0x2b5e(%rip), %rdi      # 0x40de
movb $0x0, %al
callq 0x1080
movq 0x10(%rsp), %rdi
callq 0x22e0
movl %eax, %ecx
leaq 0x2b50(%rip), %rsi      # 0x40ea
leaq 0x2b4b(%rip), %rax      # 0x40ec
cmpl $0x0, %ecx
cmovneq %rax, %rsi
leaq 0x2b43(%rip), %rdi      # 0x40f2
movb $0x0, %al
callq 0x1080
leaq 0x2b4a(%rip), %rdi      # 0x4107
movb $0x0, %al
callq 0x1080
movq 0x10(%rsp), %rdi
callq 0x2360
leaq 0x2b3f(%rip), %rdi      # 0x4114
movb $0x0, %al
callq 0x1080
jmp 0x15ec
leaq 0x2b3c(%rip), %rdi      # 0x4121
movb $0x0, %al
callq 0x1080
jmp 0x15ee
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/hm_glob.c
// Function: hm_glob_open
const char **hm_glob_open(glob_t *globresults, const char *path)
{
	int result = glob(path, 0, NULL, globresults);

	if (result == GLOB_NOMATCH)
		return _hm_glob_emptyresult();

	if (result)
		return NULL;

	// size is at least 1
	size_t size = globresults->gl_pathc;

	const char **files = malloc( (size + 1) * sizeof(char *));
	if (files == NULL)
		return NULL;

	// check if there is something else than file / symlink in the directory
	size_t j = 0;
	size_t i;
	for (i = 0; i < globresults->gl_pathc; ++i){
		const char *filename = globresults->gl_pathv[i];

		if (_hm_glob_check_file( filename ))
			files[j++] = filename;
	}

	files[j] = NULL;

	return files;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rcx
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10e0
movl %eax, 0x2c(%rsp)
cmpl $0x3, 0x2c(%rsp)
jne 0x163d
callq 0x17f0
movq %rax, 0x40(%rsp)
jmp 0x171d
cmpl $0x0, 0x2c(%rsp)
je 0x1652
movq $0x0, 0x40(%rsp)
jmp 0x171d
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq 0x1120
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x168c
movq $0x0, 0x40(%rsp)
jmp 0x171d
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x1701
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x1730
cmpl $0x0, %eax
je 0x16ef
movq (%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x10(%rsp)
movq %rdx, (%rax,%rcx,8)
jmp 0x16f1
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x169e
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/hm_glob.c
// Function: hm_glob_check_file
static int _hm_glob_check_file(const char *filename)
{
	struct stat s;
	stat(filename, & s);

	if (s.st_mode & S_IFREG)	// file
		return 1;

	if (s.st_mode & S_IFLNK)	// symlink
		return 1;

	return 0;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1070
movl 0x20(%rsp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x176c
movl $0x1, 0xa4(%rsp)
jmp 0x1792
movl 0x20(%rsp), %eax
andl $0xa000, %eax           # imm = 0xA000
cmpl $0x0, %eax
je 0x1787
movl $0x1, 0xa4(%rsp)
jmp 0x1792
movl $0x0, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/hm_glob.c
// Function: hm_glob_size
size_t hm_glob_size(const char **files)
{
	size_t count = 0;
	while(*files){
		++files;
		++count;
	}

	return count;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x17e7
movq -0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x17be
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/hm_glob.c
// Function: hm_glob_emptyresult
static const char **_hm_glob_emptyresult()
{
	const char **m = malloc(sizeof(char *));

	if (m){
		m[0] = NULL;
		return m;
	}

	return NULL;
}

// Assembly:
subq $0x18, %rsp
movl $0x8, %edi
callq 0x1120
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1823
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x182c
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/hm_dir.c
// Function: hm_dir_open
hm_dir_t *hm_dir_open(hm_dir_t *dir, const char *path)
{
	dir->path = path;

	glob_t globresults;

	const char **files = hm_glob_open(& globresults, dir->path);

	if (files == NULL)
		return NULL;

	size_t count = hm_glob_size(files);

	if (count == 0){
		hm_glob_close(& globresults, files);

		dir->count = 0;
		dir->files = NULL;

		// success
		return dir;
	}

	// dir->count is at least 1

	dir->files = malloc(count * sizeof(hm_disktable_t));
	if (dir->files == NULL){
		hm_glob_close(& globresults, files);

		return NULL;
	}

	dir->count = 0;

	size_t i;
	for(i = 0; i < count; ++i){
		const char *filename = files[i];
		// open the file
		hm_disktable_t *file = hm_disktable_open( & dir->files[i], filename);

		if (file == NULL){
			// this is really problematic...
			// some files are open, some are not.
			// close / free everything

			hm_glob_close(& globresults, files);

			// dir->count is not increased,
			// so no reason for this not to work...
			hm_dir_close(dir);

			return NULL;
		}

		// I don't like this,
		// because file->filename is "private property",
		// but it seems to be best way.
		// if fail, will produce NULL, so no checks need
		file->filename = strdup(filename);

		++(dir->count);
	}

	hm_glob_close(& globresults, files);

	return dir;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x70(%rsp), %rcx
movq 0x78(%rsp), %rax
movq %rcx, (%rax)
movq 0x78(%rsp), %rax
movq (%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1600
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x188e
movq $0x0, 0x80(%rsp)
jmp 0x19fe
movq 0x20(%rsp), %rdi
callq 0x17b0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x18e0
movq 0x20(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1a10
movq 0x78(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x78(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x78(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x19fe
imulq $0x28, 0x18(%rsp), %rdi
callq 0x1120
movq %rax, %rcx
movq 0x78(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x78(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1923
movq 0x20(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1a10
movq $0x0, 0x80(%rsp)
jmp 0x19fe
movq 0x78(%rsp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x19e2
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rax
movq 0x10(%rax), %rdi
imulq $0x28, 0x10(%rsp), %rax
addq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x2420
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x19aa
movq 0x20(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1a10
movq 0x78(%rsp), %rdi
callq 0x1a40
movq $0x0, 0x80(%rsp)
jmp 0x19fe
movq 0x8(%rsp), %rdi
callq 0x1170
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1939
movq 0x20(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1a10
movq 0x78(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/hm_dir.c
// Function: hm_dir_close
void hm_dir_close(hm_dir_t *dir)
{
	size_t i;
	for(i = 0; i < dir->count; ++i){
		hm_disktable_t *file = & dir->files[i];

		hm_disktable_close(file);

		// cast because file->filename is declared const
		free( (void *) file->filename );
	}

	free(dir->files);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1a9d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
imulq $0x28, 0x8(%rsp), %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x25e0
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1a52
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/hm_dir.c
// Function: hm_dir_opena
hm_dir_t *hm_dir_opena(const char *path)
{
	hm_dir_t *dir = malloc(sizeof(hm_dir_t));

	if (dir == NULL)
		return NULL;

	if (hm_dir_open(dir, path))
		return dir;

	free(dir);

	return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x18, %edi
callq 0x1120
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1ad9
movq $0x0, 0x10(%rsp)
jmp 0x1b0a
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1840
cmpq $0x0, %rax
je 0x1af8
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1b0a
movq (%rsp), %rdi
callq 0x1030
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/hm_dir.c
// Function: hm_dir_get
const void *hm_dir_get(const hm_dir_t *dir, const char *key)
{
	size_t i;
	for(i = dir->count; i > 0; --i){
		hm_disktable_t *file = & dir->files[i - 1];

		const void *data = hm_disktable_get(file, key);

		if (data)
			return data;

		++file;
	}

	return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0x1be8
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2620
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1bca
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1bf1
movq 0x10(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1b7c
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/hm_dir.c
// Function: hm_dir_it_open
hm_dir_it_t *hm_dir_it_open(const hm_dir_t *dir)
{
	hm_dir_it_t *it = malloc(sizeof(hm_dir_it_t) + dir->count * sizeof(hm_dir_it_pair_t) );

	if (it == NULL)
		return NULL;

	it->dir = dir;
	//memset(it->p, 0, psize);

	return it;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
shlq $0x4, %rdi
addq $0x8, %rdi
callq 0x1120
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1c35
movq $0x0, 0x10(%rsp)
jmp 0x1c4a
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/hm_dir.c
// Function: hm_dir_it_first
const hm_pair_t *hm_dir_it_first(hm_dir_it_t *it)
{
	size_t i;
	for(i = 0; i < it->dir->count; ++i){
		const hm_disktable_t *file = & it->dir->files[i];

		it->p[i].pos  = 0;
		it->p[i].pair = hm_disktable_getat(file, 0);
	}

	return hm_dir_it_next(it);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1d06
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
imulq $0x28, 0x8(%rsp), %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2680
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq 0x8(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1c82
movq 0x10(%rsp), %rdi
callq 0x1d20
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)