LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: samplesToBeats
double
samplesToBeats(double samples)
    {
    return samples
           / (double) SampleRate
           / 60.0
           * beatsPerMinute;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
cvtsi2sdl 0xeb2a(%rip), %xmm1 # 0x12400
divsd %xmm1, %xmm0
movsd 0x9a8e(%rip), %xmm1     # 0xd370
divsd %xmm1, %xmm0
mulsd 0xeb92(%rip), %xmm0     # 0x12480
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: setLocation
int
setLocation(int future)
    {
    int old = location;

    location = future;

    if (location > maxLocation)
        {
        while (location >= output->samples)
            growOutput();
        maxLocation = location;
        }

    if (location < 0)
        {
        //printf("attempt to rewind to a negative index, "
        //       "setting index to zero\n");
        location = 0;
        }

    return old;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cvttsd2si 0x1e3d5(%rip), %eax # 0x21cd8
movl %eax, -0x8(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movsd %xmm0, 0x1e3c5(%rip)    # 0x21cd8
movsd 0x1e3bd(%rip), %xmm0    # 0x21cd8
cvtsi2sdl 0x1e3bd(%rip), %xmm1 # 0x21ce0
ucomisd %xmm1, %xmm0
jbe 0x395a
jmp 0x392b
movsd 0x1e3a5(%rip), %xmm0    # 0x21cd8
movq 0x1e396(%rip), %rax     # 0x21cd0
cvtsi2sdl 0xc(%rax), %xmm1
ucomisd %xmm1, %xmm0
jb 0x394c
callq 0x3b60
jmp 0x392b
cvttsd2si 0x1e384(%rip), %eax # 0x21cd8
movl %eax, 0x1e386(%rip)     # 0x21ce0
xorps %xmm0, %xmm0
ucomisd 0x1e373(%rip), %xmm0    # 0x21cd8
jbe 0x3972
xorps %xmm0, %xmm0
movsd %xmm0, 0x1e366(%rip)    # 0x21cd8
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: oneshot
void
oneshot(int *data,int length, int bps)
    {
    int i;
    double  bpsFactor;

    dTrace("entering\n");
    //printf("playing oneshot note at %f\n",location - spaces);

    bpsFactor = pow(2,bitsPerSample) / pow(2,bps);

    if (length <= 0) return;

    while (location + length >= output->samples)
        growOutput();

    /* write out all the data */

    for (i = 0; i < length; ++i)
        {
        output->data[0][(int)location] +=
            data[i] * amplitude * bpsFactor;
        location += 1;
        }

    if (location > maxLocation) maxLocation = location;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cvtsi2sdl 0xe9ee(%rip), %xmm1 # 0x12408
movsd 0x990e(%rip), %xmm0     # 0xd330
callq 0x2080
movsd %xmm0, -0x28(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm1
movsd 0x98f7(%rip), %xmm0     # 0xd330
callq 0x2080
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x3a5a
jmp 0x3b23
jmp 0x3a5c
movsd 0x1e274(%rip), %xmm0    # 0x21cd8
cvtsi2sdl -0xc(%rbp), %xmm1
addsd %xmm1, %xmm0
movq 0x1e25c(%rip), %rax     # 0x21cd0
cvtsi2sdl 0xc(%rax), %xmm1
ucomisd %xmm1, %xmm0
jb 0x3a86
callq 0x3b60
jmp 0x3a5c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3aff
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
mulsd 0xe98e(%rip), %xmm0     # 0x12438
movsd -0x20(%rbp), %xmm2
movq 0x1e21a(%rip), %rax     # 0x21cd0
movq 0x18(%rax), %rax
movq (%rax), %rax
cvttsd2si 0x1e213(%rip), %ecx # 0x21cd8
movslq %ecx, %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movl %edx, (%rax,%rcx,4)
movsd 0x9844(%rip), %xmm0     # 0xd328
addsd 0x1e1ec(%rip), %xmm0    # 0x21cd8
movsd %xmm0, 0x1e1e4(%rip)    # 0x21cd8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3a8d
movsd 0x1e1d1(%rip), %xmm0    # 0x21cd8
cvtsi2sdl 0x1e1d1(%rip), %xmm1 # 0x21ce0
ucomisd %xmm1, %xmm0
jbe 0x3b23
cvttsd2si 0x1e1bb(%rip), %eax # 0x21cd8
movl %eax, 0x1e1bd(%rip)     # 0x21ce0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: growOutput
static void
growOutput()
    {
    int i;
    int samples = output->samples;

    growRRA(output);

    for (i = samples; i < output->samples; ++i)
        output->data[0][i] = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1e161(%rip), %rax     # 0x21cd0
movl 0xc(%rax), %eax
movl %eax, -0x8(%rbp)
movq 0x1e154(%rip), %rdi     # 0x21cd0
callq 0xa5c0
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq 0x1e13f(%rip), %rcx     # 0x21cd0
cmpl 0xc(%rcx), %eax
jge 0x3bba
movq 0x1e133(%rip), %rax     # 0x21cd0
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3b87
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: achord
void
achord(double beats,int inst,int octave,int pitch,int *offsets,int length)
    {
    int i;
    int notes[CHORD_LENGTH];

    for (i = 0; i < length; ++i)
        {
        if (i >= sizeof(notes) / sizeof(int))
            Fatal("achord: too many notes\n");
        notes[i] = octave * 12 + pitch + offsets[i];
        }

    anchord(beats,inst,notes,length);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x830, %rsp            # imm = 0x830
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x41e2
movslq -0x28(%rbp), %rax
cmpq $0x200, %rax            # imm = 0x200
jb 0x41ba
leaq 0x9314(%rip), %rdi      # 0xd4c7
movb $0x0, %al
callq 0x8c70
imull $0xc, -0x10(%rbp), %ecx
addl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rdx
addl (%rax,%rdx,4), %ecx
movslq -0x28(%rbp), %rax
movl %ecx, -0x830(%rbp,%rax,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4198
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %edi
leaq -0x830(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x3e30
addq $0x830, %rsp            # imm = 0x830
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: softer
void
softer(double factor)
    {
    if (factor == 0.0)
        {
        setAmplitude(getAmplitude() * softLoud);
        softLoud = popAmplitudeFactor();
        }
    else
        {
        setAmplitude(getAmplitude() / factor);
        softLoud = factor;
        pushAmplitudeFactor(factor);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x50be
jp 0x50be
callq 0x6220
mulsd 0xd346(%rip), %xmm0     # 0x123f0
callq 0x6de0
callq 0x6e50
movsd %xmm0, 0xd334(%rip)     # 0x123f0
jmp 0x50e4
callq 0x6220
divsd -0x8(%rbp), %xmm0
callq 0x6de0
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0xd316(%rip)     # 0x123f0
movsd -0x8(%rbp), %xmm0
callq 0x6eb0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: resolve
void
resolve(int inst,int soctave,int spitch,double sbeats,
        int eoctave,int epitch,double ebeats)
    {
    draw(inst,
        eoctave,epitch,0.0,
        soctave,spitch,sbeats,
        eoctave,epitch,ebeats,
        (int) 0
        );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
cvtsi2sdl -0x8(%rbp), %xmm1
movl -0xc(%rbp), %ecx
movsd -0x18(%rbp), %xmm2
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %r9d
movsd -0x28(%rbp), %xmm3
xorl %edx, %edx
movl $0x0, (%rsp)
movb $0x4, %al
callq 0x5160
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: nresolve
void
nresolve(int inst,int startNote,double sbeats,int endNote,double ebeats)
    {
    //printf("in nresolve...\n");
    ndraw(inst,
        endNote,0.0,
        startNote,sbeats,
        endNote,ebeats,
        (int) 0
        );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm1, -0x20(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movl -0x14(%rbp), %edi
cvtsi2sdl -0x8(%rbp), %xmm1
movsd -0x10(%rbp), %xmm2
movl -0x14(%rbp), %edx
movsd -0x20(%rbp), %xmm3
xorl %ecx, %ecx
movl %ecx, %esi
movb $0x4, %al
callq 0x5470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: trill
void
trill(double beats,int instrument,int octave,int pitch,int offset,
    double initial,double tlength,int count)
    {
    int i,j;
    int octaves[CHORD_LENGTH];
    int pitches[CHORD_LENGTH];
    double lengths[CHORD_LENGTH];

    octaves[0] = octave;
    pitches[0] = pitch;
    lengths[0] = initial;

    j = 1;
    for (i = 0; j < sizeof(octaves)/sizeof(int) && i < count; ++i)
        {
        octaves[j] = octave;
        pitches[j] = pitch + offset;
        lengths[j] = tlength;
        ++j;
        octaves[j] = octave;
        pitches[j] = pitch;
        lengths[j] = tlength;
        ++j;
        }

    /*
    for (i = 0; i < 2*count+1; ++i)
        printf("[%d,%d,%f]\n",octaves[i],pitches[i],lengths[i]);
    */

    adraw(beats,instrument,2*count+1,octaves,pitches,lengths);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x840(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1040(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x2040(%rbp)
movl $0x1, -0x34(%rbp)
movl $0x0, -0x30(%rbp)
movslq -0x34(%rbp), %rcx
xorl %eax, %eax
cmpq $0x200, %rcx            # imm = 0x200
movb %al, -0x2041(%rbp)
jae 0x5aab
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
setl %al
movb %al, -0x2041(%rbp)
movb -0x2041(%rbp), %al
testb $0x1, %al
jne 0x5ab7
jmp 0x5b36
movl -0x10(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x840(%rbp,%rax,4)
movl -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x1040(%rbp,%rax,4)
movsd -0x28(%rbp), %xmm0
movslq -0x34(%rbp), %rax
movsd %xmm0, -0x2040(%rbp,%rax,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x10(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x840(%rbp,%rax,4)
movl -0x14(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x1040(%rbp,%rax,4)
movsd -0x28(%rbp), %xmm0
movslq -0x34(%rbp), %rax
movsd %xmm0, -0x2040(%rbp,%rax,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5a87
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %edi
movl -0x2c(%rbp), %esi
shll %esi
addl $0x1, %esi
leaq -0x840(%rbp), %rdx
leaq -0x1040(%rbp), %rcx
leaq -0x2040(%rbp), %r8
callq 0x45e0
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: setDrawRamp
double
setDrawRamp(double amount)
    {
    static double old = 0;
    if (amount < 0)
        {
        drawRamp = old;
        }
    else
        {
        old = drawRamp;
        drawRamp = amount;
        }
    return old;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x5c65
movsd 0x1c405(%rip), %xmm0    # 0x22060
movsd %xmm0, 0xc7fd(%rip)     # 0x12460
jmp 0x5c82
movsd 0xc7f3(%rip), %xmm0     # 0x12460
movsd %xmm0, 0x1c3eb(%rip)    # 0x22060
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0xc7de(%rip)     # 0x12460
movsd 0x1c3d6(%rip), %xmm0    # 0x22060
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movl -0x14(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x44(%rbp)
movslq -0x44(%rbp), %rax
shlq $0x2, %rax
movl %eax, %edi
callq 0x8ec0
movq %rax, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x3980
cvttsd2si %xmm0, %eax
movl %eax, -0x4c(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x3980
cvttsd2si %xmm0, %eax
movl %eax, -0x48(%rbp)
movsd 0x755c(%rip), %xmm0     # 0xd328
subsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x4c(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movl $0x0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movl -0x38(%rbp), %ecx
xorl %eax, %eax
cmpl -0x44(%rbp), %ecx
movb %al, -0x69(%rbp)
jge 0x5e11
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x5e1a
jmp 0x5e8e
movq 0x1be9f(%rip), %rax     # 0x21cc0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd -0x58(%rbp), %xmm0
callq *%rax
movl %eax, %edx
movq -0x40(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x38(%rbp), %eax
movl -0x48(%rbp), %ecx
addl -0x4c(%rbp), %ecx
cmpl %ecx, %eax
jl 0x5e58
movsd 0x74d7(%rip), %xmm0     # 0xd328
movsd %xmm0, -0x60(%rbp)
jmp 0x5e71
movl -0x38(%rbp), %eax
cmpl -0x48(%rbp), %eax
jle 0x5e6f
movsd -0x68(%rbp), %xmm0
addsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
jmp 0x5e71
movsd -0x60(%rbp), %xmm0
addsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x5df8
movsd -0x8(%rbp), %xmm0
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
callq 0x31c0
movq -0x40(%rbp), %rdi
callq 0x2030
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
cmpl $0x1, 0xc620(%rip)      # 0x12514
jne 0x5f65
movsd 0xc4e2(%rip), %xmm0     # 0x123e0
ucomisd -0x8(%rbp), %xmm0
jne 0x5f65
jp 0x5f65
cmpl $0x0, 0xc4da(%rip)      # 0x123e8
je 0x5f30
movsd 0x70f0(%rip), %xmm0     # 0xd008
mulsd -0x8(%rbp), %xmm0
movsd 0x7423(%rip), %xmm1     # 0xd348
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5f4e
movsd 0x73f8(%rip), %xmm0     # 0xd330
mulsd -0x8(%rbp), %xmm0
movsd 0x7403(%rip), %xmm1     # 0xd348
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
cmpl $0x0, 0xc493(%rip)      # 0x123e8
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc483(%rip)      # 0x123e8
movsd -0x8(%rbp), %xmm0
callq 0x5f80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x0, 0xc38a(%rip)      # 0x12470
jl 0x60f6
movl 0xc382(%rip), %eax      # 0x12470
cmpl 0x1bf44(%rip), %eax     # 0x22038
jne 0x6104
leaq 0x745d(%rip), %rdi      # 0xd55a
movb $0x0, %al
callq 0x8c70
cmpl $0x1, 0x1bf35(%rip)     # 0x22040
jne 0x613d
movsd 0xc33b(%rip), %xmm0     # 0x12450
movl 0x1bf1d(%rip), %eax     # 0x22038
subl 0xc34f(%rip), %eax      # 0x12470
cvtsi2sd %eax, %xmm2
movsd 0x71fb(%rip), %xmm1     # 0xd328
divsd %xmm2, %xmm1
callq 0x2080
movsd %xmm0, -0x18(%rbp)
jmp 0x616a
movsd 0xc30b(%rip), %xmm0     # 0x12450
movsd 0x71db(%rip), %xmm1     # 0xd328
subsd %xmm1, %xmm0
movl 0x1bee1(%rip), %eax     # 0x22038
subl 0xc313(%rip), %eax      # 0x12470
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x6220
movsd %xmm0, -0x10(%rbp)
movl 0xc2f6(%rip), %eax      # 0x12470
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x1beb2(%rip), %eax     # 0x22038
jge 0x61e5
movsd -0x10(%rbp), %xmm1
movq 0x1bb3c(%rip), %rax     # 0x21cd0
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movl %edx, (%rax,%rcx,4)
cmpl $0x1, 0x1be8a(%rip)     # 0x22040
jne 0x61c9
movsd -0x18(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x61d8
movsd -0x18(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x61da
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x617d
movl $0xffffffff, 0xc281(%rip) # imm = 0xFFFFFFFF
callq 0x6220
mulsd 0xc254(%rip), %xmm0     # 0x12450
movsd %xmm0, 0xc234(%rip)     # 0x12438
movsd 0x711c(%rip), %xmm0     # 0xd328
movsd %xmm0, 0xc23c(%rip)     # 0x12450
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: setInterp
int
setInterp(int mode)
    {
    int old;

    old = interpType;
    interpType = mode;

    switch (mode)
        {
        case 1:
            interp = interp1;
            break;
        case 2:
            interp = interp2;
            break;
        case 3:
            interp = interp3;
            break;
        default:
            interp = interp2;
            interpType = 2;
        }

    return old;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl 0xc09b(%rip), %eax      # 0x12478
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0xc08f(%rip)      # 0x12478
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x640a
jmp 0x63f6
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x641a
jmp 0x6400
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x642a
jmp 0x643a
leaq 0x4f(%rip), %rax        # 0x6460
movq %rax, 0x1b8a8(%rip)     # 0x21cc0
jmp 0x6452
leaq -0x3941(%rip), %rax     # 0x2ae0
movq %rax, 0x1b898(%rip)     # 0x21cc0
jmp 0x6452
leaq 0xcf(%rip), %rax        # 0x6500
movq %rax, 0x1b888(%rip)     # 0x21cc0
jmp 0x6452
leaq -0x3961(%rip), %rax     # 0x2ae0
movq %rax, 0x1b878(%rip)     # 0x21cc0
movl $0x2, 0xc026(%rip)      # 0x12478
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
cvttsd2si -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x64a3
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x64f7
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
movsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
subl (%rcx,%rdx,4), %eax
cvtsi2sd %eax, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
cvttsd2si -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: popAmplitudeFactor
static double
popAmplitudeFactor(void)
    {
    if (AmplitudeFactorTop > 0)
        return AmplitudeFactors[--AmplitudeFactorTop];
    Fatal("too many calls to louder/softer with 0.0 amplitude factor\n");
    return 0.0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x1ba41(%rip)     # 0x228a0
jle 0x6e86
movl 0x1ba39(%rip), %eax     # 0x228a0
addl $-0x1, %eax
movl %eax, 0x1ba30(%rip)     # 0x228a0
movslq %eax, %rcx
leaq 0x1ba36(%rip), %rax     # 0x228b0
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x6e9c
leaq 0x67c4(%rip), %rdi      # 0xd651
movb $0x0, %al
callq 0x8c70
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: setDrawAmpFactor
double
setDrawAmpFactor(double amount)
    {
    static double old = 0;
    if (amount < 0)
        {
        drawAmpFactor = old;
        }
    else
        {
        old = drawAmpFactor;
        drawAmpFactor = amount;
        }
    return old;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x6fb5
movsd 0x1b0bd(%rip), %xmm0    # 0x22068
movsd %xmm0, 0xb4b5(%rip)     # 0x12468
jmp 0x6fd2
movsd 0xb4ab(%rip), %xmm0     # 0x12468
movsd %xmm0, 0x1b0a3(%rip)    # 0x22068
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0xb496(%rip)     # 0x12468
movsd 0x1b08e(%rip), %xmm0    # 0x22068
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x641c(%rip), %rsi      # 0xd578
callq 0x2040
cmpl $0x0, %eax
jne 0x7189
movl $0x1, 0xb3a4(%rip)      # 0x12514
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0xb263(%rip)     # 0x123e0
movl $0x1, 0xb261(%rip)      # 0x123e8
jmp 0x71be
movq -0x8(%rbp), %rdi
leaq 0x63ea(%rip), %rsi      # 0xd57e
callq 0x2040
cmpl $0x0, %eax
jne 0x71aa
movl $0x0, 0xb36c(%rip)      # 0x12514
jmp 0x71bc
movq -0x8(%rbp), %rsi
leaq 0x63cf(%rip), %rdi      # 0xd584
movb $0x0, %al
callq 0x8c70
jmp 0x71be
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7385
movq $0x0, -0x8(%rbp)
jmp 0x73e0
testb $0x1, -0x11(%rbp)
je 0x73be
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jle 0x73be
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x22a0
movq -0x10(%rbp), %rcx
cltd
idivl 0x8(%rcx)
movq -0x20(%rbp), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x73e0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x73d8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x73e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movl $0x1, %edx
callq 0x9190
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movq -0x8(%rbp), %rax
cvtsi2sdl 0xc(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x76ca
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0x767c
movq -0x28(%rbp), %rdi
callq 0xa5c0
movq 0x1a63d(%rip), %rax     # 0x21cc0
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rdi
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %esi
movsd -0x20(%rbp), %xmm0
callq *%rax
movl %eax, %edx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movsd -0x10(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7653
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xa5f0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x77ed
cvttsd2si 0x1a4f6(%rip), %eax # 0x21cd8
movl %eax, 0x1a88c(%rip)     # 0x22074
jmp 0x7877
movsd 0x1a4e3(%rip), %xmm0    # 0x21cd8
cvtsi2sdl 0x1a877(%rip), %xmm1 # 0x22074
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
callq 0x3b30
movsd %xmm0, -0x20(%rbp)
movsd 0x1a4a3(%rip), %xmm0    # 0x21cd8
subsd 0x1a7eb(%rip), %xmm0    # 0x22028
cvtsi2sdl 0x1a807(%rip), %xmm1 # 0x2204c
subsd %xmm1, %xmm0
callq 0x3b30
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x24(%rbp), %ecx
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
addsd 0x1a7e7(%rip), %xmm1    # 0x22050
leaq 0x5d52(%rip), %rdi      # 0xd5c2
movb $0x2, %al
callq 0x20c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: closeComments
void 
closeComments()    
    {
    COMMENT *temp;
    temp = head;

    while(temp)
	{
	head = temp->next;
	free(temp);
	temp = head;
	}
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1a5b9(%rip), %rax     # 0x22088
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7b02
movq -0x8(%rbp), %rax
movq 0x208(%rax), %rax
movq %rax, 0x1a59c(%rip)     # 0x22088
movq -0x8(%rbp), %rdi
callq 0x2030
movq 0x1a58c(%rip), %rax     # 0x22088
movq %rax, -0x8(%rbp)
jmp 0x7ad3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: readComment
int 
readComment()
    {
    static COMMENT *temp ;
    int samples;

    temp = head;

    if(temp)
	{
	samples = temp->location;
	temp = temp->next;
	fprintf(stderr,"samples:: %d \n",samples);
	}
    else
	{
	samples = 0;
	}
	
    return samples;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1a569(%rip), %rax     # 0x22088
movq %rax, 0x1a56a(%rip)     # 0x22090
cmpq $0x0, 0x1a562(%rip)     # 0x22090
je 0x7b70
movq 0x1a559(%rip), %rax     # 0x22090
cvttsd2si (%rax), %eax
movl %eax, -0x4(%rbp)
movq 0x1a54b(%rip), %rax     # 0x22090
movq 0x208(%rax), %rax
movq %rax, 0x1a53d(%rip)     # 0x22090
movq 0xa49e(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x5a8c(%rip), %rsi      # 0xd5f3
movb $0x0, %al
callq 0x2190
jmp 0x7b77
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: sort
static void
sort(int *notes,int size)
    {
    int i,j;
    for (i = 0; i < size - 1; ++i)
        {
        int min = i;
        for (j = i+1; j < size; ++j)
            if (notes[j] < notes[min])
                min = j;
        int temp = notes[i];
        notes[i] = notes[min];
        notes[min] = temp;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x8285
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8245
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x8238
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x823a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8212
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x81f2
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %edi
callq 0x8ec0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x8305
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x82d3
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: readClosestNote
static void
readClosestNote(int inst,int baseNote)
    {
    int i;

    for (i = 0; i < OCTAVES * NOTES; ++i)
        {
        int up = baseNote + i;
        int down = baseNote - i;

        if (up < OCTAVES * NOTES)
            {
            dDebug("looking for note %d\n",up);
            if (originals[inst][up] == 1) return;
            if (readNote(inst,up) != 0) return;
            }

        if (i != 0 && down >= 0)
            {
            dDebug("looking for note %d\n",down);
            if (originals[inst][down] == 1) return;
            if (readNote(inst,down) != 0) return;
            }
        }

    Fatal("No notes found for instrument %d\n"
          "(%s%s)\n",inst,InstrumentDir[inst],InstrumentBase[inst]);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x84, -0xc(%rbp)
jge 0x844b
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x84, -0x10(%rbp)
jge 0x83f9
movslq -0x4(%rbp), %rcx
leaq 0xa178(%rip), %rax      # 0x12540
imulq $0x210, %rcx, %rcx      # imm = 0x210
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x83e1
jmp 0x847a
movl -0x4(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x85e0
cmpq $0x0, %rax
je 0x83f7
jmp 0x847a
jmp 0x83f9
cmpl $0x0, -0xc(%rbp)
je 0x843b
cmpl $0x0, -0x14(%rbp)
jl 0x843b
movslq -0x4(%rbp), %rcx
leaq 0xa130(%rip), %rax      # 0x12540
imulq $0x210, %rcx, %rcx      # imm = 0x210
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x8426
jmp 0x847a
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x85e0
cmpq $0x0, %rax
je 0x8439
jmp 0x847a
jmp 0x843b
jmp 0x843d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8395
movl -0x4(%rbp), %esi
movslq -0x4(%rbp), %rcx
leaq 0x19897(%rip), %rax     # 0x21cf0
movq (%rax,%rcx,8), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x199c8(%rip), %rax     # 0x21e30
movq (%rax,%rcx,8), %rcx
leaq 0x523f(%rip), %rdi      # 0xd6b2
movb $0x0, %al
callq 0x8c70
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: findClosestNote
static int
findClosestNote(int inst, int baseNote)
    {
    int i;

    //printf("findClosestNote: instrument %d, octave: %d, note: %s\n",
        //inst,baseNote / NOTES,NoteNames[baseNote % NOTES]);

    for (i = 0; i < OCTAVES * NOTES; ++i)
        {
        int up = baseNote + i;
        int down = baseNote - i;

        if (up < OCTAVES * NOTES && originals[inst][up] == 1)
            return up;

        if (down >= 0 && originals[inst][down] == 1)
            return down;
        }

    Fatal("INTERNAL ERROR: findClosestNote failed\n");

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x84, -0x10(%rbp)
jge 0x851d
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x84, -0x14(%rbp)
jge 0x84e0
movslq -0x8(%rbp), %rcx
leaq 0xa07c(%rip), %rax      # 0x12540
imulq $0x210, %rcx, %rcx      # imm = 0x210
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x84e0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8532
cmpl $0x0, -0x18(%rbp)
jl 0x850d
movslq -0x8(%rbp), %rcx
leaq 0xa04f(%rip), %rax      # 0x12540
imulq $0x210, %rcx, %rcx      # imm = 0x210
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x850d
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8532
jmp 0x850f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8495
leaq 0x5204(%rip), %rdi      # 0xd728
movb $0x0, %al
callq 0x8c70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: resampleSet
static SAMPLE_SET *
resampleSet(SAMPLE_SET *ss,double factor)
    {
    int i;
    SAMPLE_SET *newss = newSampleSet();
    newss->count = ss->count;
    newss->samples = (RRA **) New(sizeof(RRA*) * ss->count);

    /* transfer over the samples */

    for (i = 0; i < ss->count; ++i)
        newss->samples[i] = resample(ss->samples[i], factor);

    return newss;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
callq 0x8340
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x8ec0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x85ce
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x7610
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x858c
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: ensureFadeIn
static void
ensureFadeIn(RRA *h)
    {
    int i;
    double factor = 0.00001;
    int multiplier = 3;

    /* quickly ramp amplitudes up from zero */
    /* a multiplier of 3 means a 10 sample fade in */

    for (i = 0; i < h->samples && factor < 0; ++i)
        {
        if (h->data[0][i] == 0) return;
        h->data[0][i] = h->data[0][i] * factor;
        factor *= multiplier;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd 0x4870(%rip), %xmm0     # 0xd3b0
movsd %xmm0, -0x18(%rbp)
movl $0x3, -0x1c(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpl 0xc(%rdx), %ecx
movb %al, -0x1d(%rbp)
jge 0x8b72
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
seta %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x8b7b
jmp 0x8bde
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x8b92
jmp 0x8bde
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
mulsd -0x18(%rbp), %xmm0
cvttsd2si %xmm0, %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x1c(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8b53
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: endsWith
static int
endsWith(const char *str, const char *suffix)
{
    if (!str || !suffix)
        return 0;
    size_t lenstr = strlen(str);
    size_t lensuffix = strlen(suffix);
    if (lensuffix >  lenstr)
        return 0;
    return strncmp(str + lenstr - lensuffix, suffix, lensuffix) == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8bfe
cmpq $0x0, -0x18(%rbp)
jne 0x8c07
movl $0x0, -0x4(%rbp)
jmp 0x8c60
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x8c34
movl $0x0, -0x4(%rbp)
jmp 0x8c60
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
xorl %eax, %eax
subq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2050
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x8ec0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movslq -0x4(%rbp), %rax
shlq $0x2, %rax
movl %eax, %edi
callq 0x8ec0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xb704
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x8(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xb6de
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: updateDelay
int
updateDelay(delay *d,int in)
    {
    int old = getDelay(d);
    //printf("setting %d at index %d\n",in,d->index);
    d->store[d->index] = in;
    d->index = (d->index + 1) % d->length;
    return old;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb710
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x4(%rcx)
movq -0x8(%rbp), %rax
movl %edx, (%rax)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/filters.c
// Function: getVarDelay
int
getVarDelay(delay *d,double back)
    {
    //printf("length is %d, back is %f\n",d->length,back);
    int hi = (int) back;
    int lo = hi + 1;
    int vhi = d->store[(d->index + (d->length - hi)) % d->length];
    int vlo = d->store[(d->index + (d->length - lo)) % d->length];
    //printf("lo is %d (value is %d), vhi is %d (value is %d)\n",
    //   lo,vlo,hi,vhi);
    //getchar();
    return (int)(vlo + (lo - back) * (vhi - vlo));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
cvttsd2si -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl -0x14(%rbp), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x4(%rcx)
movq -0x30(%rbp), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl -0x18(%rbp), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x4(%rcx)
movq -0x28(%rbp), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
cvtsi2sdl -0x20(%rbp), %xmm1
cvtsi2sdl -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
cvtsi2sd %eax, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl $0x20, %edi
callq 0x8ec0
movq %rax, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd 0x1f95(%rip), %xmm0     # 0xd808
mulsd -0x8(%rbp), %xmm0
leaq 0x6b81(%rip), %rax      # 0x12400
cvtsi2sdl (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xb901
movsd -0x18(%rbp), %xmm0
callq 0x2140
movaps %xmm0, %xmm1
movsd 0x1a89(%rip), %xmm0     # 0xd330
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1ad2(%rip), %xmm1     # 0xd398
addsd %xmm1, %xmm0
movsd 0x1a86(%rip), %xmm1     # 0xd358
callq 0x2080
subsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x28(%rbp), %rax
movsd 0x1a37(%rip), %xmm0     # 0xd328
addsd 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0xb97f
movsd -0x18(%rbp), %xmm0
callq 0x2140
movaps %xmm0, %xmm1
movsd 0x1a1a(%rip), %xmm0     # 0xd330
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1a59(%rip), %xmm1     # 0xd398
addsd %xmm1, %xmm0
movsd 0x1a0d(%rip), %xmm1     # 0xd358
callq 0x2080
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x28(%rbp), %rax
movsd 0x19b7(%rip), %xmm0     # 0xd328
subsd 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl $0x1, %edi
callq 0xb690
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movl $0x38, %edi
callq 0x8ec0
movq %rax, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movl $0x2, %edi
callq 0xb690
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x2, %edi
callq 0xb690
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)