LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: dbend
void
dbend(double beats,int *data,int length,double start,
    double startLength,double bendLength,int bps)
    {
    int i;
    int* bentNote;
    int maxSamples,startSamples,bendSamples;
    double t;
    double adjust,delta;
    
    maxSamples = 4 * length;

    bentNote = (int *) New(sizeof(int) * maxSamples);

    /* resample */

    bendSamples = beatsToSamples(bendLength);
    startSamples = beatsToSamples(startLength);
    delta = (1.0 - start) / bendSamples;

    i = 0;
    t = 0;
    adjust = start;
    while (i < maxSamples && i < length)
        {
        bentNote[i] = interp(data,length,t);

        if (i >= startSamples + bendSamples)
            adjust = 1.0;
        else if (i > startSamples)
            adjust += delta;

        /* update the new time */

        t += adjust;
        ++i;
        }

    dplay(beats,bentNote,i,bps);

    free(bentNote);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0x1c(%rsp)
movaps %xmm3, 0x20(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %r15
movsd %xmm0, 0x38(%rsp)
movl %esi, %edi
shll $0x4, %edi
callq 0x652d
movq %rax, %r14
movsd 0x4711(%rip), %xmm0     # 0x9278
movapd 0x20(%rsp), %xmm3
mulsd %xmm0, %xmm3
movsd 0x9937(%rip), %xmm1     # 0xe4b0
divsd %xmm1, %xmm3
cvtsi2sdl 0x98ab(%rip), %xmm2 # 0xe430
mulsd %xmm2, %xmm3
cvttsd2si %xmm3, %eax
movsd 0x10(%rsp), %xmm4
mulsd %xmm0, %xmm4
divsd %xmm1, %xmm4
mulsd %xmm2, %xmm4
cvttsd2si %xmm4, %ecx
movsd 0x46b5(%rip), %xmm1     # 0x9260
subsd 0x8(%rsp), %xmm1
cvttpd2dq %xmm3, %xmm0
cvtdq2pd %xmm0, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rsp)
addl %ecx, %eax
movslq %eax, %r13
movslq %ecx, %rax
movq %rax, 0x20(%rsp)
xorl %ebx, %ebx
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
xorpd %xmm0, %xmm0
cmpq %rbx, %r12
je 0x4c3d
movq %r15, %rdi
movl %ebp, %esi
movsd %xmm0, 0x10(%rsp)
callq *0x190f8(%rip)          # 0x1dcf0
movl %eax, (%r14,%rbx,4)
movsd 0x465c(%rip), %xmm1     # 0x9260
cmpq %r13, %rbx
jge 0x4c28
cmpq 0x20(%rsp), %rbx
jle 0x4c22
movsd 0x8(%rsp), %xmm0
addsd 0x40(%rsp), %xmm0
movapd %xmm0, %xmm1
jmp 0x4c28
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
incq %rbx
movsd %xmm1, 0x8(%rsp)
jmp 0x4be2
movsd 0x38(%rsp), %xmm0
movq %r14, %rdi
movl %r12d, %esi
movl 0x1c(%rsp), %edx
callq 0x2e63
movq %r14, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: rest
void
rest(double beats)
    {
    if (style == SWING && swingBeat == beats)
        {
        if (swingDown) beats = beats * 4 / 3;
        else beats = beats *2 / 3;
        swingDown = !swingDown;
        }

    forwards(beats);
    }

// Assembly:
cmpl $0x1, 0x98d0(%rip)      # 0xe544
jne 0x4cb5
movsd 0x978e(%rip), %xmm1     # 0xe410
ucomisd %xmm0, %xmm1
jne 0x4cb0
jp 0x4cb0
xorl %eax, %eax
cmpl $0x0, 0x9785(%rip)      # 0xe418
sete %al
leaq 0x4663(%rip), %rcx      # 0x9300
mulsd (%rcx,%rax,8), %xmm0
divsd 0x45d6(%rip), %xmm0     # 0x9280
movl %eax, 0x9768(%rip)      # 0xe418
jmp 0x4cb5
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: endCrescendo
void
endCrescendo()
    {
    int i = 0;
    double amp,delta;

    if (crescendoStart < 0 || crescendoStart == sustainedLocation)
        Fatal ("Rewound before crescendo");

    if (crescendoMode == EXPONENTIAL)
        delta = pow(crescendoFactor,1.0 / (sustainedLocation - crescendoStart));
    else
        delta = (crescendoFactor - 1.0) / (sustainedLocation - crescendoStart);

    amp = getAmplitude();

    for (i = crescendoStart; i < sustainedLocation; ++i)
        {
        output->data[0][i] *= amp;
        if (crescendoMode == EXPONENTIAL)
            amp *= delta;
        else
            amp += delta;
        }

    crescendoStart = -1;
    amplitude = getAmplitude() * crescendoFactor;
    crescendoFactor = 1;
    }

// Assembly:
pushq %rax
movl 0x96e6(%rip), %eax      # 0xe4a0
testl %eax, %eax
js 0x4dc6
cmpl 0x192a4(%rip), %eax     # 0x1e068
jne 0x4dd4
leaq 0x46f3(%rip), %rdi      # 0x94c0
xorl %eax, %eax
callq 0x6378
cmpl $0x1, 0x19295(%rip)     # 0x1e070
movsd 0x969d(%rip), %xmm0     # 0xe480
jne 0x4e1e
movl 0x1927d(%rip), %eax     # 0x1e068
subl 0x96af(%rip), %eax      # 0xe4a0
cvtsi2sd %eax, %xmm2
movsd 0x4463(%rip), %xmm1     # 0x9260
divsd %xmm2, %xmm1
callq 0x20b0
movl 0x9694(%rip), %edx      # 0xe4a0
movl 0x19256(%rip), %esi     # 0x1e068
cmpl $0x1, 0x19257(%rip)     # 0x1e070
sete %al
jmp 0x4e40
addsd 0x448a(%rip), %xmm0     # 0x92b0
movl 0x1923c(%rip), %esi     # 0x1e068
movl 0x966e(%rip), %edx      # 0xe4a0
movl %esi, %eax
subl %edx, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
xorl %eax, %eax
movsd 0x9620(%rip), %xmm1     # 0xe468
movq 0x18eb1(%rip), %rcx     # 0x1dd00
movslq %edx, %rdx
movslq %esi, %rsi
movapd %xmm1, %xmm2
cmpq %rsi, %rdx
jge 0x4e8a
movq 0x18(%rcx), %rdi
movq (%rdi), %rdi
cvtsi2sdl (%rdi,%rdx,4), %xmm3
mulsd %xmm2, %xmm3
cvttsd2si %xmm3, %r8d
movl %r8d, (%rdi,%rdx,4)
testb %al, %al
jne 0x4e81
addsd %xmm0, %xmm2
jmp 0x4e85
mulsd %xmm0, %xmm2
incq %rdx
jmp 0x4e59
orl $-0x1, 0x960f(%rip)     # 0xe4a0
mulsd 0x95e7(%rip), %xmm1     # 0xe480
movsd %xmm1, 0x95c7(%rip)     # 0xe468
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x95ce(%rip)      # 0xe480
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: interp1
int
interp1(int *data,int length,double t)
    {
    int lo = (int) t;
    int hi = lo + 1;
    double fraction;
    double result;

    if (lo >= length-1) return data[length-1];

    fraction = t - lo;

    result = data[lo] + fraction * (data[hi] - data[lo]);

    return (int) result;
    }

// Assembly:
cvttsd2si %xmm0, %eax
decl %esi
cmpl %eax, %esi
jle 0x5011
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
cltq
movl (%rdi,%rax,4), %ecx
cvtsi2sd %ecx, %xmm1
movl 0x4(%rdi,%rax,4), %eax
subl %ecx, %eax
cvtsi2sd %eax, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
retq
movslq %esi, %rax
movl (%rdi,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: interp3
int
interp3(int *data,int length,double t)
    {
    int x;
    double mu,mu2;
    int y0,y1,y2,y3;
    int a0,a1,a2,a3;

    if (t >= length) return data[length - 1];

    x = (int) t;
    mu = t - x;
    mu2 = mu * mu;

    y1 = data[x];
    if (x == 0)
        {
        y2 = data[x + 1];
        y3 = data[x + 2];
        y0 = y1 + y1 - y2;
        }
    else if (x == length - 2)
        {
        y0 = data[x - 1];
        y2 = data[x + 1];
        y3 = y2 + y2 - y1;
        }
    else if (x == length - 1)
        {
        y0 = data[x - 1];
        y2 = y1 + y1 - y0;
        y3 = y2 + y2 - y1;
        }
    else
        {
        y0 = data[x - 1];
        y2 = data[x + 1];
        y3 = data[x + 2];
        }
        
    a0 = y3 - y2 - y0 + y1;
    a1 = y0 - y1 - a0;
    a2 = y2 - y0;
    a3 = y1;

    return (int) (a0*mu*mu2+a1*mu2+a2*mu+a3);
    }

// Assembly:
cvtsi2sd %esi, %xmm1
ucomisd %xmm1, %xmm0
jae 0x5059
cvttsd2si %xmm0, %ecx
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
subsd %xmm1, %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movslq %ecx, %r8
movl (%rdi,%r8,4), %eax
testl %r8d, %r8d
je 0x5061
leal -0x2(%rsi), %edx
cmpl %ecx, %edx
jne 0x506e
movl -0x4(%rdi,%r8,4), %edx
movl 0x4(%rdi,%r8,4), %ecx
jmp 0x507e
movslq %esi, %rax
movl -0x4(%rdi,%rax,4), %eax
retq
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %esi
leal (%rax,%rax), %edx
subl %ecx, %edx
jmp 0x508f
decl %esi
movl -0x4(%rdi,%r8,4), %edx
cmpl %ecx, %esi
jne 0x5085
leal (%rax,%rax), %ecx
subl %edx, %ecx
leal (%rcx,%rcx), %esi
subl %eax, %esi
jmp 0x508f
movl 0x4(%rdi,%r8,4), %ecx
movl 0x8(%rdi,%r8,4), %esi
addl %eax, %esi
subl %ecx, %esi
subl %edx, %esi
subl %edx, %ecx
cvtsi2sd %esi, %xmm2
subl %eax, %edx
subl %esi, %edx
mulsd %xmm0, %xmm2
cvtsi2sd %edx, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm1, %xmm2
cvtsi2sd %ecx, %xmm1
addsd %xmm3, %xmm2
mulsd %xmm0, %xmm1
cvtsi2sd %eax, %xmm0
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: setStyle
void
setStyle(char *mode,double info)
    {
    if (strcasecmp(mode,"SWING") == 0)
        {
        style = SWING;
        swingBeat = info;
        swingDown = 1;
        }
    else if (strcasecmp(mode,"PLAIN") == 0)
        style = PLAIN;
    else
        Fatal("Style %s not understood\n",mode);
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x3e5f(%rip), %rsi      # 0x94de
callq 0x2050
testl %eax, %eax
je 0x56b1
leaq 0x3e55(%rip), %rsi      # 0x94e4
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x56d0
leaq 0x3e48(%rip), %rdi      # 0x94ea
movq %rbx, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x6378
pushq $0x1
popq %rax
movl %eax, 0x8e8a(%rip)      # 0xe544
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8d48(%rip)     # 0xe410
movl %eax, 0x8d4a(%rip)      # 0xe418
jmp 0x56d7
andl $0x0, 0x8e6d(%rip)      # 0xe544
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: getSample
static RRA *
getSample(SAMPLE_SET *ss,bool random)
{
    if (!ss) return 0;
    
    // Get random sample if requested and if multiple available
    if (random && ss->count > 1) return ss->samples[rand()%(ss->count)];
    
    // Otherwise, if samples exist, use the first
    if (ss->count > 0) return ss->samples[0];

    // No samples found
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x57a9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x2, %eax
setge %cl
andb %sil, %cl
cmpb $0x1, %cl
jne 0x57ac
movq (%rbx), %r14
callq 0x22f0
cltd
idivl 0x8(%rbx)
movslq %edx, %rax
leaq (%r14,%rax,8), %rax
jmp 0x57b3
xorl %eax, %eax
retq
testl %eax, %eax
jle 0x57be
movq (%rbx), %rax
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x57b6
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: resample
RRA *
resample(RRA *note,double factor)
    {
    int i;
    double t;
    RRA *h;

    //printf("in resample...\n");

    h = newRRA(note->sampleRate,note->bitsPerSample,1,note->samples);

    dDebug("dresample: samples in original note is %d\n",length);
    dDebug("dresample: factor is %f\n",factor);
    //printf("samples in original note is %d\n",note->samples);
    //printf("factor is %f\n",factor);

    i = 0;
    t = 0;
    while (t < note->samples)
        {
        if (i >= h->samples)
            {
            //printf("%d samples\n",h->samples);
            //printf("t is %f\n",t);
            growRRA(h);
            }

        h->data[0][i] = interp(note->data[0],note->samples,t);
        t += factor;
        ++i;
        }

    /* remove the excess capacity in the rra object */

    shrinkRRA(h,i);

    dDebug("leaving\n");

    return h;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl 0x4(%rdi), %edi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %ecx
pushq $0x1
popq %rdx
callq 0x6670
movq %rax, %r14
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movl 0xc(%rbx), %esi
cvtsi2sd %esi, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x58b3
movslq 0xc(%r14), %rax
cmpq %rax, %r15
movsd %xmm0, (%rsp)
jl 0x588b
movq %r14, %rdi
callq 0x73a1
movsd (%rsp), %xmm0
movl 0xc(%rbx), %esi
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq *0x18458(%rip)          # 0x1dcf0
movsd (%rsp), %xmm0
movq 0x18(%r14), %rcx
movq (%rcx), %rcx
movl %eax, (%rcx,%r15,4)
addsd 0x8(%rsp), %xmm0
incq %r15
jmp 0x5860
movq %r14, %rdi
movl %r15d, %esi
callq 0x73ab
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: measure
void
measure(const char *file,const char *function,const int line)
    {
    static int last = 0;

    if (file == 0)
        {
        last = location;
        //printf("location is %d\n",last);
        //printf("last is %f\n",samplesToBeats(last));
        //getchar();
        }
    else
        {
        int span = location - last;
        //printf("span is %d\n",span);
        printf("!%s: %s: %4d: %f measures (%f total)\n",
                file,function,line,samplesToMeasures(span),
                samplesToMeasures(location - spaces - measuredLocation)
		    + previousMeasures);
        }
    }

// Assembly:
movsd 0x183b5(%rip), %xmm1    # 0x1dd08
testq %rdi, %rdi
je 0x59e6
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cvtsi2sdl 0x1872f(%rip), %xmm0 # 0x1e0a4
movsd %xmm1, 0x8(%rsp)
subsd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
callq 0x34ce
movsd 0x8(%rsp), %xmm1
subsd 0x186be(%rip), %xmm1    # 0x1e058
movsd %xmm0, 0x8(%rsp)
cvtsi2sdl 0x186d4(%rip), %xmm0 # 0x1e07c
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x34ce
movapd %xmm0, %xmm1
addsd 0x186bf(%rip), %xmm1    # 0x1e080
leaq 0x3b60(%rip), %rdi      # 0x9528
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
movsd 0x8(%rsp), %xmm0
movb $0x2, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20f0
cvttsd2si %xmm1, %eax
movl %eax, 0x186b4(%rip)     # 0x1e0a4
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: addComment
void
addComment(char *drumComment)
    {
    COMMENT *temp, *temp1;
    int commentSamples = getLocation();
    commentBuffer = (COMMENT *)New(sizeof(COMMENT));

    if(tail == NULL)
        {
        head = commentBuffer;
        tail = commentBuffer;
        commentBuffer->location = commentSamples;
        strcpy(commentBuffer->comment,drumComment);
        return;
        }

    if(commentSamples > tail->location) 
	{
	tail->next = commentBuffer;
	commentBuffer->location = commentSamples;
	strcpy(commentBuffer->comment,drumComment);
	//fprintf(stderr,"%s at %d \n",commentBuffer->comment, commentBuffer->location);
	commentBuffer->next = NULL;
	tail = commentBuffer;
	}
    else /* insert in between */
	{
	/* check from head to current
	 * tail, the most suitable
	 * location to place the comment */

	temp1 = (COMMENT *)New(sizeof(COMMENT));
	temp1->location = 0;

	temp = head;
	while(temp != tail)
	    {
	    if(temp->location > commentSamples)
		{
		temp1->next = temp->next;		
		temp->next = commentBuffer;
		commentBuffer->location = commentSamples;
		strcpy(commentBuffer->comment,drumComment);
		fprintf(stderr,"%s at %f \n",commentBuffer->comment, commentBuffer->location);
		commentBuffer->next = temp1->next;
		break;
		}
	    temp = temp->next;	    
	    }
	}
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvttsd2si 0x182d1(%rip), %ebp # 0x1dd08
movl $0x210, %edi            # imm = 0x210
callq 0x652d
movq %rax, %r14
movq %rax, 0x1865d(%rip)     # 0x1e0a8
movq 0x1865e(%rip), %rax     # 0x1e0b0
testq %rax, %rax
je 0x5a96
cvtsi2sd %ebp, %xmm0
ucomisd (%rax), %xmm0
jbe 0x5ac6
movq %r14, 0x208(%rax)
movsd %xmm0, (%r14)
movq %r14, %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x2080
andq $0x0, 0x208(%r14)
movq %r14, 0x18625(%rip)     # 0x1e0b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x1861b(%rip)     # 0x1e0b8
movq %r14, 0x1860c(%rip)     # 0x1e0b0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%r14)
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2080
movl $0x210, %edi            # imm = 0x210
movsd %xmm0, (%rsp)
callq 0x652d
movsd (%rsp), %xmm1
movq %rax, %r14
andq $0x0, (%rax)
leaq 0x185d0(%rip), %rax     # 0x1e0b8
movq 0x185c1(%rip), %rcx     # 0x1e0b0
movq (%rax), %rax
cmpq %rcx, %rax
je 0x5a8b
movsd (%rax), %xmm0
addq $0x208, %rax            # imm = 0x208
ucomisd %xmm1, %xmm0
jbe 0x5aef
movq (%rax), %rcx
movq %rcx, 0x208(%r14)
movq 0x18590(%rip), %r15     # 0x1e0a8
movq %r15, (%rax)
movsd %xmm1, (%r15)
addq $0x8, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2080
movq 0x84c2(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x3a0e(%rip), %rsi      # 0x954e
movq %r15, %rdx
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x21d0
movq 0x208(%r14), %rax
movq 0x1854b(%rip), %rcx     # 0x1e0a8
movq %rax, 0x208(%rcx)
jmp 0x5a8b
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: addSampleToSampleSet
static SAMPLE_SET *
addSampleToSampleSet(RRA *h, SAMPLE_SET *ss)
    {
    int i;
    RRA **oldSamples = ss->samples;
    ss->samples = (RRA **) New(sizeof(RRA *) * (ss->count+1));
    for (i=0;i<ss->count;++i)
        {
        ss->samples[i] = oldSamples[i];
        }
    ss->samples[ss->count] = h;
    ++(ss->count);
    return ss;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movl 0x8(%rsi), %eax
leal 0x8(,%rax,8), %edi
callq 0x652d
movq %rax, (%rbx)
movslq 0x8(%rbx), %rax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x5fce
movq (%r15,%rcx,8), %rsi
movq (%rbx), %rdi
movq %rsi, (%rdi,%rcx,8)
incq %rcx
jmp 0x5fb9
movq (%rbx), %rcx
movq %r14, (%rcx,%rax,8)
incl %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/songlib.c
// Function: newSampleSet
SAMPLE_SET *
newSampleSet()
    {
    SAMPLE_SET *ss = (SAMPLE_SET *) New(sizeof(SAMPLE_SET));
    ss->samples = 0;
    ss->count = 0;
    return ss;
    }

// Assembly:
pushq %rax
pushq $0x10
popq %rdi
callq 0x652d
andq $0x0, (%rax)
andl $0x0, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/filters.c
// Function: newDelay
delay *
newDelay(int delta)
    {
    int i;
    delay *d = New(sizeof(delay));
    d->index = 0;
    d->length = delta;
    d->store = New(sizeof(int) * delta);
    for (i = 0; i < delta; ++i) d->store[i] = 0;
    return d;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x10
popq %rdi
callq 0x652d
movq %rax, %r14
andl $0x0, (%rax)
movl %ebx, 0x4(%rax)
leal (,%rbx,4), %edi
callq 0x652d
movq %rax, 0x8(%r14)
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x7d24
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x7d16
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/filters.c
// Function: newFOF
fof *
newFOF(double freq,int style)
    {
    double theta,gamma;
    fof *f;
    
    f = New(sizeof(fof));

    f->freq = freq;
    theta = 2 * M_PI * freq / SampleRate;
    if (style == LOWPASS)
        {
        gamma = 2 - cos(theta);
        f->b1 = pow(gamma * gamma - 1,0.5) - gamma;
        f->a0 = 1 + f->b1;
        }
    else
        {
        gamma = 2 + cos(theta);
        f->b1 = gamma - pow(gamma * gamma - 1,0.5);
        f->a0 = 1 - f->b1;
        }
    f->sdelay = newDelay(1);
    return f;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movsd %xmm0, (%rsp)
pushq $0x20
popq %rdi
callq 0x652d
movq %rax, %rbx
movsd (%rsp), %xmm1
movsd %xmm1, (%rax)
mulsd 0x19a5(%rip), %xmm1     # 0x9788
leaq 0x6646(%rip), %rax      # 0xe430
cvtsi2sdl (%rax), %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x2170
testl %ebp, %ebp
je 0x7e3c
addsd 0x14d1(%rip), %xmm0     # 0x92d8
movsd %xmm0, (%rsp)
mulsd %xmm0, %xmm0
addsd 0x1498(%rip), %xmm0     # 0x92b0
movsd 0x1448(%rip), %xmm1     # 0x9268
callq 0x20b0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x142a(%rip), %xmm0     # 0x9260
subsd %xmm1, %xmm0
jmp 0x7e7f
movsd 0x1494(%rip), %xmm1     # 0x92d8
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd 0x1453(%rip), %xmm0     # 0x92b0
movsd 0x1403(%rip), %xmm1     # 0x9268
callq 0x20b0
movapd %xmm0, %xmm1
subsd (%rsp), %xmm1
movsd 0x13e5(%rip), %xmm0     # 0x9260
addsd %xmm1, %xmm0
movsd %xmm1, 0x10(%rbx)
movsd %xmm0, 0x8(%rbx)
pushq $0x1
popq %rdi
callq 0x7ce8
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/lib/filters.c
// Function: newBiquad
biquad *
newBiquad(double a0,double a1,double a2,double b1,double b2)
    {
    biquad *f = New(sizeof(biquad));
    f->a0 = a0;
    f->a1 = a1;
    f->a2 = a2;
    f->b1 = b1;
    f->b2 = b2;
    f->ldelay = newDelay(2);
    f->rdelay = newDelay(2);
    return f;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
pushq $0x38
popq %rdi
callq 0x652d
movq %rax, %rbx
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
pushq $0x2
popq %rbp
movl %ebp, %edi
callq 0x7ce8
movq %rax, 0x28(%rbx)
movl %ebp, %edi
callq 0x7ce8
movq %rax, 0x30(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cvtsi2sd %esi, %xmm0
movsd 0x8(%rdi), %xmm1
movsd %xmm1, 0x10(%rsp)
movq 0x28(%rdi), %r14
mulsd (%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x12bc(%rip), %xmm0     # 0x9260
movq %r14, %rdi
callq 0x7d68
cvtsi2sd %eax, %xmm0
mulsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x1303(%rip), %xmm0     # 0x92d8
movq %r14, %rdi
callq 0x7d68
cvtsi2sd %eax, %xmm0
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %r14
movq %r14, %rdi
movsd 0x1253(%rip), %xmm0     # 0x9260
callq 0x7d68
cvtsi2sd %eax, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movsd 0x1296(%rip), %xmm0     # 0x92d8
callq 0x7d68
cvtsi2sd %eax, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x7f75
movl %eax, %ebp
movq 0x28(%r14), %rdi
movl %ebx, %esi
callq 0x7d42
movq 0x30(%r14), %rdi
movl %ebp, %esi
callq 0x7d42
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movsd %xmm6, 0x38(%rsp)
movsd %xmm5, 0x30(%rsp)
movsd %xmm4, 0x28(%rsp)
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
pushq $0x18
popq %rdi
callq 0x652d
movq %rax, %rbx
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movsd 0x20(%rsp), %xmm3
movsd 0x28(%rsp), %xmm4
callq 0x7eef
movq %rax, 0x10(%rbx)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %edi, %ebx
pushq $0x28
popq %rdi
callq 0x652d
movq %rax, %r14
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm4
maxsd %xmm4, %xmm1
movsd 0x10af(%rip), %xmm2     # 0x9260
movapd %xmm2, %xmm3
cmpltsd %xmm4, %xmm3
movapd %xmm3, %xmm4
andnpd %xmm1, %xmm4
andpd %xmm2, %xmm3
orpd %xmm4, %xmm3
movlpd %xmm3, 0x10(%rax)
movsd 0x10(%rsp), %xmm3
maxsd %xmm3, %xmm0
movapd %xmm2, %xmm1
cmpltsd %xmm3, %xmm1
movapd %xmm3, %xmm4
movapd %xmm1, %xmm3
andnpd %xmm0, %xmm3
andpd %xmm2, %xmm1
orpd %xmm3, %xmm1
movlpd %xmm1, (%rax)
subsd %xmm4, %xmm2
movsd %xmm2, 0x8(%rax)
movl %ebx, 0x18(%rax)
movl %ebx, %edi
callq 0x7ce8
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x821c
movl %eax, %ebp
movq %r14, %rdi
movl %ebx, %esi
callq 0x8257
movq 0x20(%r14), %rdi
movl %eax, %esi
callq 0x7d42
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movsd %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq 0x652d
andq $0x0, 0x8(%rax)
movsd (%rsp), %xmm1
movsd %xmm1, (%rax)
leaq 0x6160(%rip), %rcx      # 0xe430
cvtsi2sdl (%rcx), %xmm0
divsd %xmm1, %xmm0
movsd 0x14a8(%rip), %xmm1     # 0x9788
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movsd %xmm2, 0x10(%rsp)
movl %edi, %r14d
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
pushq $0x30
popq %rdi
callq 0x652d
movq %rax, %r15
movsd 0xf17(%rip), %xmm0      # 0x9260
movsd (%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movsd %xmm1, 0x18(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movl %r14d, %edi
callq 0x7ce8
movq %rax, (%r15)
movsd 0x10(%rsp), %xmm0
callq 0x82ad
movq %rax, 0x8(%r15)
movl %ebp, 0x28(%r15)
movl %ebx, 0x2c(%r15)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x8397
movl %eax, %ebp
movq %r14, %rdi
callq 0x83d3
movl %eax, %r15d
movq 0x8(%r14), %r12
movsd 0x8(%r12), %xmm0
callq 0x2280
movsd 0x10(%r12), %xmm0
addsd 0x8(%r12), %xmm0
movsd %xmm0, 0x8(%r12)
cvtsi2sd %ebx, %xmm0
cvtsi2sd %r15d, %xmm1
mulsd 0x20(%r14), %xmm1
movq (%r14), %rdi
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
callq 0x7d42
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %edi, %ebx
pushq $0x18
popq %rdi
callq 0x652d
movq %rax, %r14
movl %ebx, %edi
callq 0x7ce8
movq %rax, 0x10(%r14)
movsd (%rsp), %xmm0
movsd %xmm0, (%r14)
movl %ebx, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %edi, %ebx
pushq $0x30
popq %rdi
callq 0x652d
movq %rax, %r14
leal 0x1(%rbx), %edi
callq 0x7ce8
movq %rax, 0x10(%r14)
movl %ebx, %edi
callq 0x7ce8
movq %rax, 0x18(%r14)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%r14)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%r14)
movl %ebx, 0x8(%r14)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r14
cvtsi2sdl 0x8(%rdi), %xmm0
movq %r14, %rdi
callq 0x7d68
cvtsi2sd %eax, %xmm1
movsd 0x28(%rbx), %xmm2
movsd %xmm2, 0x8(%rsp)
movl (%r14), %eax
incl %eax
cltd
idivl 0x4(%r14)
movq 0x8(%r14), %rax
movslq %edx, %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movq 0x18(%rbx), %r14
movsd 0xca5(%rip), %xmm0      # 0x9260
movq %r14, %rdi
callq 0x7d68
cvtsi2sd %eax, %xmm0
mulsd 0x8(%rsp), %xmm0
movl (%r14), %eax
incl %eax
cltd
idivl 0x4(%r14)
addsd 0x10(%rsp), %xmm0
movq 0x8(%r14), %rax
movslq %edx, %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
mulsd 0x20(%rbx), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x8561
movl %eax, %ebp
movq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x7d42
movq 0x18(%r14), %rdi
movl %ebp, %esi
callq 0x7d42
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %edi, %ebx
pushq $0x28
popq %rdi
callq 0x652d
movq %rax, %r14
movl %ebx, %edi
callq 0x7ce8
movq %rax, 0x10(%r14)
movl %ebx, %edi
callq 0x7ce8
movq %rax, 0x18(%r14)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%r14)
movl %ebx, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x8671
movl %eax, %ebp
movq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x7d42
movq 0x18(%r14), %rdi
movl %ebp, %esi
callq 0x7d42
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movl 0x51f0(%rip), %edx      # 0x7860
leaq 0x91f9(%rip), %rcx      # 0xb870
cmpl %edx, %eax
jae 0x2695
leal (%rax,%rdx), %esi
shrl %esi
cmpl %edi, (%rcx,%rsi,4)
leal 0x1(%rsi), %r8d
cmovbel %edx, %esi
cmoval %eax, %r8d
movl %esi, %edx
movl %r8d, %eax
jmp 0x2677
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x40(%rsp), %rax
movl 0x51b3(%rip), %r12d     # 0x7860
movq 0x10(%rax), %rbx
movq 0x18(%rax), %r14
movq %r12, %r13
shlq $0x4, %r13
xorl %r15d, %r15d
leaq 0x51aa(%rip), %rbp      # 0x7870
cmpq %r15, %r13
je 0x26eb
cmpq %r14, 0x8(%r15,%rbp)
jne 0x26e5
movq (%r15,%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2070
testl %eax, %eax
je 0x2721
addq $0x10, %r15
jmp 0x26c6
leaq 0x40(%rsp), %rdx
movl (%rdx), %eax
leaq 0x9177(%rip), %rcx      # 0xb870
movl %eax, (%rcx,%r12,4)
leal 0x1(%r12), %eax
movl %eax, 0x5158(%rip)      # 0x7860
movups 0x10(%rdx), %xmm0
movups %xmm0, (%r13,%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x48d0(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1ab1(%rip), %rsi      # 0x41e3
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2060
leaq 0x18fe(%rip), %rdi      # 0x4041
leaq 0x1ab0(%rip), %rsi      # 0x41fa
leaq 0x1abe(%rip), %rcx      # 0x420f
pushq $0x45
popq %rdx
callq 0x2030
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %esi, %ebx
callq 0x2668
movl 0x50f9(%rip), %ecx      # 0x7860
movl %eax, %eax
leaq 0x9100(%rip), %rdx      # 0xb870
leaq (%rdx,%rax,4), %rdx
cmpq %rcx, %rax
jae 0x2784
addl %ebx, (%rdx)
incq %rax
addq $0x4, %rdx
jmp 0x2774
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x4050
movq %rax, %rbx
movl (%rax), %r15d
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x48f0
testl %eax, %eax
jne 0x72a5
movl %r15d, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x92d2c(%rip), %rax     # 0x99fd8
movq (%rax), %rdi
leaq 0x6c8fe(%rip), %rsi     # 0x73bb4
movq %r14, %rdx
xorl %eax, %eax
callq 0x4720
callq 0x7467
movl %eax, %ebp
jmp 0x7295
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x743f
cmpb $0x2d, (%rdi)
jne 0x740a
cmpb $0x0, 0x1(%rdi)
je 0x7443
subq $0x28, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq 0x48(%rsi), %rcx
movq %rcx, (%rax)
movq 0x58(%rsi), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x4320
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
js 0x7446
addq $0x28, %rsp
retq
pushq $-0x1
popq %rax
retq
xorl %eax, %eax
retq
movq 0x92b8b(%rip), %rax     # 0x99fd8
movq (%rax), %rcx
leaq 0x6c79c(%rip), %rdi     # 0x73bf3
pushq $0x2b
popq %rsi
pushq $0x1
popq %rdx
callq 0x49e0
pushq $-0x1
popq %rax
jmp 0x743a
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x3, %edi
jl 0x1323
je 0x12f5
cmpl $0x4, %edi
jne 0x1323
movq 0x8(%rbx), %rsi
leaq 0x1d49(%rip), %rdi      # 0x3004
callq 0x10c0
testl %eax, %eax
jne 0x1323
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r14
callq 0x161c
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1679
testq %rax, %rax
je 0x13d7
movq %rax, %rdi
callq 0x1a0b
jmp 0x13e3
movq 0x8(%rbx), %r14
leaq 0x1d09(%rip), %rdi      # 0x3009
movq %r14, %rsi
callq 0x10c0
testl %eax, %eax
je 0x1377
leaq 0x1cfb(%rip), %rdi      # 0x300e
movq %r14, %rsi
callq 0x10c0
testl %eax, %eax
je 0x13c1
leaq 0x1d79(%rip), %rdi      # 0x30a3
callq 0x1040
movq (%rbx), %rsi
leaq 0x1cda(%rip), %rdi      # 0x3013
xorl %eax, %eax
callq 0x1090
movq (%rbx), %rsi
leaq 0x1cfc(%rip), %rdi      # 0x3046
xorl %eax, %eax
callq 0x1090
movq (%rbx), %rsi
leaq 0x1d1e(%rip), %rdi      # 0x3079
xorl %eax, %eax
callq 0x1090
leaq 0x1d41(%rip), %rdi      # 0x30aa
callq 0x1040
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10(%rbx), %rdi
callq 0x161c
movq %rax, %rbx
movq %rax, %rdi
callq 0x16c7
movq %rax, %r14
movq %rax, %rdi
callq 0x16eb
pushq $0x1d
popq %r15
testq %rax, %rax
je 0x13b7
movq %rax, %rdi
callq 0x1a0b
subq $0x1, %r15
jb 0x13b7
movq %r14, %rdi
callq 0x173f
jmp 0x139a
movq %r14, %rdi
callq 0x16e6
jmp 0x13e3
movq 0x10(%rbx), %rdi
callq 0x161c
movq %rax, %rbx
movq %rax, %rdi
callq 0x17fe
jmp 0x13e3
leaq 0x1cfe(%rip), %rdi      # 0x30dc
callq 0x1040
movq %rbx, %rdi
callq 0x15d3
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x1371
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
xorl %ebx, %ebx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x10f0
testl %eax, %eax
je 0x143c
cmpl $0x3, %eax
jne 0x149a
pushq $0x8
popq %rdi
callq 0x1130
movq %rax, %rbx
testq %rax, %rax
jne 0x1496
jmp 0x148e
movq (%r14), %r12
leaq 0x8(,%r12,8), %rdi
callq 0x1130
testq %rax, %rax
je 0x148e
movq %rax, %rbx
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
cmpq %r12, %rbp
jae 0x1492
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1080
testw $0xa000, 0x20(%rsp)     # imm = 0xA000
je 0x1486
movq %r12, (%rbx,%r13,8)
incq %r13
incq %rbp
movq (%r14), %r12
jmp 0x145e
xorl %ebx, %ebx
jmp 0x149a
leaq (%rbx,%r13,8), %rax
andq $0x0, (%rax)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbp
movq %rsi, (%rdi)
leaq 0x10(%rsp), %rdi
callq 0x13fc
testq %rax, %rax
je 0x15aa
movq %rax, %r12
movq %rax, %rdi
callq 0x14af
testq %rax, %rax
je 0x155f
movq %rax, %r15
imulq $0x28, %rax, %rdi
callq 0x1130
movq %rax, 0x10(%rbp)
testq %rax, %rax
je 0x1575
andq $0x0, 0x8(%rbp)
xorl %r14d, %r14d
xorl %eax, %eax
movq %r12, 0x8(%rsp)
cmpq %rax, %r15
je 0x1584
movq %rax, %rbx
movq (%r12,%rax,8), %r12
movq 0x10(%rbp), %rdi
addq %r14, %rdi
movq %r12, %rsi
callq 0x1a48
testq %rax, %rax
je 0x1593
movq %rax, %r13
movq %r12, %rdi
callq 0x1180
movq %rax, (%r13)
incq 0x8(%rbp)
movq %rbx, %rax
incq %rax
addq $0x28, %r14
movq 0x8(%rsp), %r12
jmp 0x151b
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x15be
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbp)
jmp 0x15ac
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x15be
jmp 0x15aa
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x15be
jmp 0x15ac
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x15be
movq %rbp, %rdi
callq 0x15d3
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %r14
cmpq 0x8(%rbx), %r12
jae 0x1609
leaq (%r14,%r15), %rdi
callq 0x1b18
movq (%r14,%r15), %rdi
callq 0x1030
incq %r12
addq $0x28, %r15
jmp 0x15e4
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x1130
testq %rax, %rax
je 0x164b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x14c0
testq %rax, %rax
jne 0x164d
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
imulq $0x28, %r12, %rdi
addq $-0x28, %rdi
incq %r12
xorl %r15d, %r15d
decq %r12
je 0x16ba
leaq -0x28(%rdi), %r13
addq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x1b38
movq %r13, %rdi
testq %rax, %rax
je 0x169a
movq %rax, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
cmpq 0x8(%rax), %r12
jae 0x172c
movq 0x10(%rax), %rdi
addq %r15, %rdi
andq $0x0, -0x8(%r14)
xorl %esi, %esi
callq 0x1bb8
movq %rax, (%r14)
incq %r12
addq $0x28, %r15
addq $0x10, %r14
jmp 0x1700
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x173f