LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_in_create_default
RtMidiInPtr rtmidi_in_create_default ()
{
    RtMidiWrapper* wrp = new RtMidiWrapper;
    
    try {
        RtMidiIn* rIn = new RtMidiIn ();
        
        wrp->ptr = (void*) rIn;
        wrp->ok  = true;
        wrp->msg = "";
    
    } catch (const RtMidiError & err) {
        wrp->ptr = 0;
        wrp->ok  = false;
        wrp->msg = err.what ();
    }

    return wrp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x20, %edi
callq 0xda40
movq %rax, -0x8(%rbp)
movl $0x10, %edi
callq 0xda40
movq %rax, -0x58(%rbp)
jmp 0x175f6
movb $0x1, -0x42(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xe5a0
movq -0x60(%rbp), %rdx
leaq 0x24a6(%rip), %rsi      # 0x19ab8
leaq -0x40(%rbp), %rdi
callq 0xe4e0
jmp 0x1761d
movq -0x58(%rbp), %rdi
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
movl $0x64, %ecx
callq 0xd710
jmp 0x17633
movb $0x0, -0x42(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd600
leaq -0x41(%rbp), %rdi
callq 0xdba0
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x232c(%rip), %rcx      # 0x1999b
movq %rcx, 0x18(%rax)
jmp 0x17710
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x176ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x176a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd600
leaq -0x41(%rbp), %rdi
callq 0xdba0
testb $0x1, -0x42(%rbp)
jne 0x176ba
jmp 0x176c8
movq -0x58(%rbp), %rdi
movl $0x10, %esi
callq 0xda90
jmp 0x176ca
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1771a
movq -0x18(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xe360
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xe590
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_in_create
RtMidiInPtr rtmidi_in_create (enum RtMidiApi api, const char *clientName, unsigned int queueSizeLimit)
{
    std::string name = clientName;
    RtMidiWrapper* wrp = new RtMidiWrapper;
    
    try {
        RtMidiIn* rIn = new RtMidiIn ((RtMidi::Api) api, name, queueSizeLimit);
        
        wrp->ptr = (void*) rIn;
        wrp->data = 0;
        wrp->ok  = true;
        wrp->msg = "";

    } catch (const RtMidiError & err) {
        wrp->ptr = 0;
        wrp->data = 0;
        wrp->ok  = false;
        wrp->msg = err.what ();
    }

    return wrp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xe5a0
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xe4e0
jmp 0x17779
leaq -0x39(%rbp), %rdi
callq 0xdba0
movl $0x20, %edi
callq 0xda40
movq %rax, -0xa8(%rbp)
jmp 0x17795
movq -0xa8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x10, %edi
callq 0xda40
movq %rax, -0xb0(%rbp)
jmp 0x177b3
movb $0x1, -0x81(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xb4(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd3d0
jmp 0x177d2
movl -0xb4(%rbp), %esi
movq -0xb0(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq -0x80(%rbp), %rdx
callq 0xd710
jmp 0x177ed
movb $0x0, -0x81(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xd600
movq -0xb0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x58(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x58(%rbp), %rax
leaq 0x2169(%rip), %rcx      # 0x1999b
movq %rcx, 0x18(%rax)
jmp 0x17914
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xdba0
jmp 0x17941
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x17938
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x178b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x17897
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xd600
testb $0x1, -0x81(%rbp)
jne 0x178a2
jmp 0x178b3
movq -0xb0(%rbp), %rdi
movl $0x10, %esi
callq 0xda90
jmp 0x178b5
movl -0x4c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x17938
movq -0x48(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x90(%rbp)
movq -0x58(%rbp), %rax
movq $0x0, (%rax)
movq -0x58(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x58(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xe360
jmp 0x17912
jmp 0x17914
movq -0x58(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd600
movq -0xc0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xd600
movq -0x48(%rbp), %rdi
callq 0xe590
nopw (%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_in_free
void rtmidi_in_free (RtMidiInPtr device)
{
    if (device->data)
      delete (CallbackProxyUserData*) device->data;
    delete (RtMidiIn*) device->ptr;
    delete device;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17989
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x17987
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0xda90
jmp 0x17989
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x179a4
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x179c0
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0xda90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_in_set_callback
void rtmidi_in_set_callback (RtMidiInPtr device, RtMidiCCallback callback, void *userData)
{
    device->data = (void*) new CallbackProxyUserData (callback, userData);
    try {
        ((RtMidiIn*) device->ptr)->setCallback (callback_proxy, device->data);
    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
        delete (CallbackProxyUserData*) device->data;
        device->data = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x10, %edi
callq 0xda40
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xd450
jmp 0x17a27
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rdx
leaq 0xab(%rip), %rsi        # 0x17af0
callq 0xdaa0
jmp 0x17a4c
jmp 0x17ae0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0xda90
jmp 0x17ae6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x17ae6
movq -0x20(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x17acf
movq -0x40(%rbp), %rdi
movl $0x10, %esi
callq 0xda90
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
callq 0xe360
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xe590
nop
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_in_cancel_callback
void rtmidi_in_cancel_callback (RtMidiInPtr device)
{
    try {
        ((RtMidiIn*) device->ptr)->cancelCallback ();
        delete (CallbackProxyUserData*) device->data;
        device->data = 0;
    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd1d0
jmp 0x17b6a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x17b8a
movq -0x28(%rbp), %rdi
movl $0x10, %esi
callq 0xda90
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x17bdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x17be5
movq -0x10(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xe360
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xe590
nop
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_in_get_message
double rtmidi_in_get_message (RtMidiInPtr device, 
                              unsigned char **message, 
                              size_t * size)
{
    try {
        // FIXME: use allocator to achieve efficient buffering
        std::vector<unsigned char> *v = new std::vector<unsigned char> ();
        double ret = ((RtMidiIn*) device->ptr)->getMessage (v);
        *size = v->size ();

        if (v->size () > 0) {
            *message = (unsigned char *) 
                        malloc (sizeof (unsigned char *) * (int) v->size ());
            memcpy (*message, v->data (), (int) v->size ());
        }
        delete v;
        return ret;
    } 
    catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
        return -1;
    }
    catch (...) {
        device->ok  = false;
        device->msg = "Unknown error";
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x18, %edi
callq 0xda40
movq %rax, -0x50(%rbp)
jmp 0x17c64
movq -0x50(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0xd330
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xe5d0
movsd %xmm0, -0x58(%rbp)
jmp 0x17c9a
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe2c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0xe2c0
cmpq $0x0, %rax
jbe 0x17da9
movq -0x28(%rbp), %rdi
callq 0xe2c0
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0xdf10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe080
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe2c0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movslq %eax, %rdx
callq 0xd830
jmp 0x17da9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x17d75
movq -0x30(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movsd 0x1d47(%rip), %xmm0     # 0x19ab0
movsd %xmm0, -0x8(%rbp)
callq 0xe360
jmp 0x17dd8
movq -0x30(%rbp), %rdi
callq 0xd3a0
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x1d3b(%rip), %rcx      # 0x19acc
movq %rcx, 0x18(%rax)
movsd 0x1d13(%rip), %xmm0     # 0x19ab0
movsd %xmm0, -0x8(%rbp)
callq 0xe360
jmp 0x17dd8
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x17dce
movq -0x70(%rbp), %rdi
callq 0xd280
movq -0x70(%rbp), %rdi
movl $0x18, %esi
callq 0xda90
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_out_create_default
RtMidiOutPtr rtmidi_out_create_default ()
{
    RtMidiWrapper* wrp = new RtMidiWrapper;

    try {
        RtMidiOut* rOut = new RtMidiOut ();
        
        wrp->ptr = (void*) rOut;
        wrp->ok  = true;
        wrp->msg = "";
    
    } catch (const RtMidiError & err) {
        wrp->ptr = 0;
        wrp->ok  = false;
        wrp->msg = err.what ();
    }

    return wrp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x20, %edi
callq 0xda40
movq %rax, -0x8(%rbp)
movl $0x10, %edi
callq 0xda40
movq %rax, -0x58(%rbp)
jmp 0x17e16
movb $0x1, -0x42(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xe5a0
movq -0x60(%rbp), %rdx
leaq 0x1ca8(%rip), %rsi      # 0x19ada
leaq -0x40(%rbp), %rdi
callq 0xe4e0
jmp 0x17e3d
movq -0x58(%rbp), %rdi
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
callq 0xd8f0
jmp 0x17e4e
movb $0x0, -0x42(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd600
leaq -0x41(%rbp), %rdi
callq 0xdba0
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x1b11(%rip), %rcx      # 0x1999b
movq %rcx, 0x18(%rax)
jmp 0x17f2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x17ee5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x17ec4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd600
leaq -0x41(%rbp), %rdi
callq 0xdba0
testb $0x1, -0x42(%rbp)
jne 0x17ed5
jmp 0x17ee3
movq -0x58(%rbp), %rdi
movl $0x10, %esi
callq 0xda90
jmp 0x17ee5
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x17f35
movq -0x18(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xe360
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xe590
nop
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_out_create
RtMidiOutPtr rtmidi_out_create (enum RtMidiApi api, const char *clientName)
{
    RtMidiWrapper* wrp = new RtMidiWrapper;
    std::string name = clientName;

    try {
        RtMidiOut* rOut = new RtMidiOut ((RtMidi::Api) api, name);
        
        wrp->ptr = (void*) rOut;
        wrp->ok  = true;
        wrp->msg = "";
    
    } catch (const RtMidiError & err) {
        wrp->ptr = 0;
        wrp->ok  = false;
        wrp->msg = err.what ();
    }


    return wrp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0xda40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xe5a0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xe4e0
jmp 0x17f94
leaq -0x39(%rbp), %rdi
callq 0xdba0
movl $0x10, %edi
callq 0xda40
movq %rax, -0xa0(%rbp)
jmp 0x17fb0
movb $0x1, -0x79(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xa4(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd3d0
jmp 0x17fcc
movl -0xa4(%rbp), %esi
movq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0xd8f0
jmp 0x17fe4
movb $0x0, -0x79(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xd600
movq -0xa0(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
leaq 0x1981(%rip), %rcx      # 0x1999b
movq %rcx, 0x18(%rax)
jmp 0x180dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xdba0
jmp 0x18115
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x18089
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1806e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xd600
testb $0x1, -0x79(%rbp)
jne 0x18076
jmp 0x18087
movq -0xa0(%rbp), %rdi
movl $0x10, %esi
callq 0xda90
jmp 0x18089
movl -0x4c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1810c
movq -0x48(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0xe360
jmp 0x180da
jmp 0x180dc
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd600
movq -0xb0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd600
movq -0x48(%rbp), %rdi
callq 0xe590
nop
// File: tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_out_send_message
int rtmidi_out_send_message (RtMidiOutPtr device, const unsigned char *message, int length)
{
    try {
        // FIXME: use allocator to achieve efficient buffering
        std::vector<unsigned char> *v = new std::vector<unsigned char> (length);
        memcpy (v->data (), message, length);
        ((RtMidiOut*) device->ptr)->sendMessage (v);
        delete v;
        return 0;
    }
    catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
        return -1;
    }
    catch (...) {
        device->ok  = false;
        device->msg = "Unknown error";
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x18, %edi
callq 0xda40
movq %rax, -0x48(%rbp)
jmp 0x181b3
movb $0x1, -0x36(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x35(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xda70
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xe310
jmp 0x181df
movb $0x0, -0x36(%rbp)
leaq -0x35(%rbp), %rdi
callq 0xd8a0
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe080
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0xd830
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xe440
jmp 0x1821f
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x18244
movq -0x60(%rbp), %rdi
callq 0xd280
movq -0x60(%rbp), %rdi
movl $0x18, %esi
callq 0xda90
movl $0x0, -0x4(%rbp)
jmp 0x182fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1828b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x35(%rbp), %rdi
callq 0xd8a0
testb $0x1, -0x36(%rbp)
jne 0x1827b
jmp 0x18289
movq -0x48(%rbp), %rdi
movl $0x18, %esi
callq 0xda90
jmp 0x1828b
movl -0x34(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x182cf
movq -0x30(%rbp), %rdi
callq 0xd3a0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
callq 0xe360
jmp 0x182fb
movq -0x30(%rbp), %rdi
callq 0xd3a0
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x17e1(%rip), %rcx      # 0x19acc
movq %rcx, 0x18(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
callq 0xe360
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jp-myk[P]WAVUtil/src/wav_test.cpp
// Function: main
int main(int argc, char *argv[]){
  if(argc<2){
    std::cout << argv[0] << " FILENAME" << std::endl;
    exit(0);
  }
  const char* wavFName=argv[1];
  std::string outFNameStr=wavFName;
  outFNameStr+="_cp.wav";
  WAV wav;
  int res=0;
  res=wav.Read(wavFName);
  wav.Write(outFNameStr.c_str());
  wav.dumpHeader();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x5427
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq 0x3bd3(%rip), %rdi      # 0x8fd0
callq 0x2190
movq %rax, %rdi
leaq 0xf11(%rip), %rsi       # 0x631d
callq 0x2190
movq %rax, %rdi
movq 0x3ba5(%rip), %rsi      # 0x8fc0
callq 0x21c0
xorl %edi, %edi
callq 0x2220
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x2300
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x5560
jmp 0x5467
leaq -0x39(%rbp), %rdi
callq 0x21e0
leaq 0xeb0(%rip), %rsi       # 0x6327
leaq -0x38(%rbp), %rdi
callq 0x2180
jmp 0x5482
leaq -0xa8(%rbp), %rdi
callq 0x4520
jmp 0x5490
movl $0x0, -0xac(%rbp)
movq -0x18(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x2f80
movl %eax, -0xc4(%rbp)
jmp 0x54b2
movl -0xc4(%rbp), %eax
movl %eax, -0xac(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20b0
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x2b20
jmp 0x54d8
leaq -0xa8(%rbp), %rdi
callq 0x3750
jmp 0x54e6
movl $0x0, -0x4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x45e0
leaq -0x38(%rbp), %rdi
callq 0x2100
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x21e0
jmp 0x5554
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x554b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x45e0
leaq -0x38(%rbp), %rdi
callq 0x2100
movq -0x48(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: pranavmodx[P]modlang/test/parser_test.cpp
// Function: main
int main()
{
	TestLetStatement();
	TestReturnStatement();
	TestIdentifierExpression();
	TestIntegerLiteralExpression();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0xc520
callq 0xcaf0
callq 0xce60
callq 0xd2d0
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: pranavmodx[P]modlang/test/parser_test.cpp
// Function: checkParserErrors(Parser&)
void checkParserErrors(Parser &parser)
{
	std::vector<std::string> errors = parser.Errors();

	if (errors.empty())
		return;

	else
	{
		std::cout << "parser has " << errors.size() << " errors" << std::endl;
		for (std::string error : errors)
			std::cout << "parser error : " << error << std::endl;

		exit(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1cfb0
leaq -0x20(%rbp), %rdi
callq 0xdc10
testb $0x1, %al
jne 0xd74b
jmp 0xd75d
leaq -0x20(%rbp), %rdi
callq 0xdd50
addq $0x90, %rsp
popq %rbp
retq
movq 0x2a86c(%rip), %rdi     # 0x37fd0
leaq 0x18935(%rip), %rsi     # 0x260a0
callq 0x5260
movq %rax, -0x70(%rbp)
jmp 0xd776
leaq -0x20(%rbp), %rdi
callq 0xdc50
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x50a0
movq %rax, -0x78(%rbp)
jmp 0xd791
movq -0x78(%rbp), %rdi
leaq 0x18910(%rip), %rsi     # 0x260ac
callq 0x5260
movq %rax, -0x80(%rbp)
jmp 0xd7a7
movq -0x80(%rbp), %rdi
movq 0x2a7f6(%rip), %rsi     # 0x37fa8
callq 0x52a0
jmp 0xd7b9
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xdc70
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xdca0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xdcd0
testb $0x1, %al
jne 0xd7f1
jmp 0xd88e
leaq -0x40(%rbp), %rdi
callq 0xdd10
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x5120
jmp 0xd808
movq 0x2a7c1(%rip), %rdi     # 0x37fd0
leaq 0x1889e(%rip), %rsi     # 0x260b4
callq 0x5260
movq %rax, -0x88(%rbp)
jmp 0xd824
movq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5230
movq %rax, -0x90(%rbp)
jmp 0xd83d
movq -0x90(%rbp), %rdi
movq 0x2a75d(%rip), %rsi     # 0x37fa8
callq 0x52a0
jmp 0xd852
leaq -0x68(%rbp), %rdi
callq 0x54d8
leaq -0x40(%rbp), %rdi
callq 0xdd30
jmp 0xd7db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xd895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x54d8
jmp 0xd895
xorl %edi, %edi
callq 0x5300
leaq -0x20(%rbp), %rdi
callq 0xdd50
movq -0x28(%rbp), %rdi
callq 0x5460
nopw (%rax,%rax)
// File: bradleybossard[P]karplus-strong-in-c/karplus-strong.cpp
// Function: main
int main(int argc, char **argv) {
  // sound format parameters
  const int c_sampleRate = 44100;
  const int c_numSeconds = 9;
  const int c_numChannels = 1;
  const int c_numSamples = c_sampleRate * c_numChannels * c_numSeconds;

  // make space for our samples
  std::vector<float> samples;
  samples.resize(c_numSamples);

  // generate samples
  GenerateSamples(samples, c_sampleRate);

  // convert from float to the final format
  std::vector<int32> samplesInt;
  ConvertFloatSamples(samples, samplesInt);

  // write our samples to a wave file
  WriteWaveFile("out.wav", samplesInt, c_numChannels, c_sampleRate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xac44, -0x14(%rbp)    # imm = 0xAC44
movl $0x9, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x60e64, -0x20(%rbp)   # imm = 0x60E64
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1d50
movq -0x80(%rbp), %rdi
movl $0x60e64, %esi          # imm = 0x60E64
callq 0x1d70
jmp 0x18ab
leaq -0x38(%rbp), %rdi
movl $0xac44, %esi           # imm = 0xAC44
callq 0x12a0
jmp 0x18bb
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1e00
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1e20
jmp 0x18dd
leaq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2030
jmp 0x18ec
leaq 0x3795(%rip), %rdi      # 0x5088
leaq -0x78(%rbp), %rsi
movl $0x1, %edx
movl $0xac44, %ecx           # imm = 0xAC44
callq 0x1f00
jmp 0x1908
leaq -0x78(%rbp), %rdi
callq 0x2120
leaq -0x60(%rbp), %rdi
callq 0x2120
leaq -0x38(%rbp), %rdi
callq 0x2180
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1968
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x195f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2120
leaq -0x60(%rbp), %rdi
callq 0x2120
leaq -0x38(%rbp), %rdi
callq 0x2180
movq -0x40(%rbp), %rdi
callq 0x1110
nopw (%rax,%rax)
// File: bradleybossard[P]karplus-strong-in-c/karplus-strong.cpp
// Function: StringPluck::StringPluck(float, float, float)
StringPluck (float frequency, float sampleRate, float feedback) {
    m_buffer.resize(uint32(float(sampleRate) / frequency));
    for (size_t i = 0, c = m_buffer.size(); i < c; ++i) {
      m_buffer[i] = ((float)rand()) / ((float)RAND_MAX) * 2.0f - 1.0f;  // noise
      //m_buffer[i] = float(i) / float(c); // saw wave
    }
    m_index = 0;
    m_feedback = feedback;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x1d50
movq -0x40(%rbp), %rdi
movss -0x10(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, %eax
movl %eax, %esi
callq 0x1d70
jmp 0x1a41
movq -0x48(%rbp), %rdi
movq $0x0, -0x30(%rbp)
callq 0x19a0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x1ac5
callq 0x1030
movq -0x48(%rbp), %rdi
cvtsi2ss %eax, %xmm0
movss 0x35db(%rip), %xmm1     # 0x5050
divss %xmm1, %xmm0
addss %xmm0, %xmm0
movss 0x35c7(%rip), %xmm1     # 0x504c
addss %xmm1, %xmm0
movss %xmm0, -0x4c(%rbp)
movq -0x30(%rbp), %rsi
callq 0x1b10
movss -0x4c(%rbp), %xmm0
movss %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1a56
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2180
jmp 0x1ae1
movq -0x48(%rbp), %rax
movq $0x0, 0x18(%rax)
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1110
nopw (%rax,%rax)
// File: bradleybossard[P]karplus-strong-in-c/karplus-strong.cpp
// Function: StringPluck::GenerateSample()
float GenerateSample () {
    // get our sample to return
    float ret = m_buffer[m_index];

    // low pass filter (average) some samples
    float value = (m_buffer[m_index] + m_buffer[(m_index + 1) % m_buffer.size()]) * 0.5f * m_feedback;
    m_buffer[m_index] = value;

    // move to the next sample
    m_index = (m_index + 1) % m_buffer.size();

    // return the sample from the buffer
    return ret;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq 0x18(%rdi), %rsi
callq 0x1b10
movq -0x18(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movq 0x18(%rdi), %rsi
callq 0x1b10
movq -0x18(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movq 0x18(%rdi), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
callq 0x19a0
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
callq 0x1b10
movss -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rdi
addss (%rax), %xmm0
movss 0x33da(%rip), %xmm1     # 0x5048
mulss %xmm1, %xmm0
mulss 0x20(%rdi), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movq 0x18(%rdi), %rsi
callq 0x1b10
movss -0x24(%rbp), %xmm0
movq -0x18(%rbp), %rdi
movss %xmm0, (%rax)
movq 0x18(%rdi), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
callq 0x19a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq -0x18(%rbp), %rax
movq %rdx, 0x18(%rax)
movss -0xc(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: bradleybossard[P]karplus-strong-in-c/karplus-strong.cpp
// Function: void ConvertFloatSamples<int>(std::vector<float, std::allocator<float>> const&, std::vector<int, std::allocator<int>>&)
void ConvertFloatSamples (const std::vector<float>& in, std::vector<T>& out) {
  // make our out samples the right size
  out.resize(in.size());

  // convert in format to out format !
  for (size_t i = 0, c = in.size(); i < c; ++i) {
    float v = in[i];
    if (v < 0.0f)
      v *= -float(std::numeric_limits<T>::lowest());
    else
      v *= float(std::numeric_limits<T>::max());
    out[i] = T(v);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19a0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3c50
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1eeb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ce0
movss (%rax), %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x24(%rbp), %xmm0
jbe 0x1ead
callq 0x3d00
cvtsi2ss %eax, %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss -0x24(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
jmp 0x1ec0
callq 0x3d10
cvtsi2ss %eax, %xmm0
mulss -0x24(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
cvttss2si -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d20
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1e62
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: bradleybossard[P]karplus-strong-in-c/karplus-strong.cpp
// Function: bool WriteWaveFile<int>(char const*, std::vector<int, std::allocator<int>>, short, int)
bool WriteWaveFile(const char *fileName, std::vector<T> data, int16 numChannels, int32 sampleRate) {
  int32 dataSize = data.size() * sizeof(T);
  int32 bitsPerSample = sizeof(T) * 8;

  //open the file if we can
  FILE *File = fopen(fileName, "w+b");
  if (!File) {
    return false;
  }

  SMinimalWaveFileHeader waveHeader;

  //fill out the main chunk
  memcpy(waveHeader.m_chunkID, "RIFF", 4);
  waveHeader.m_chunkSize = dataSize + 36;
  memcpy(waveHeader.m_format, "WAVE", 4);

  //fill out sub chunk 1 "fmt "
  memcpy(waveHeader.m_subChunk1ID, "fmt ", 4);
  waveHeader.m_subChunk1Size = 16;
  waveHeader.m_audioFormat = 1;
  waveHeader.m_numChannels = numChannels;
  waveHeader.m_sampleRate = sampleRate;
  waveHeader.m_byteRate = sampleRate * numChannels * bitsPerSample / 8;
  waveHeader.m_blockAlign = numChannels * bitsPerSample / 8;
  waveHeader.m_bitsPerSample = bitsPerSample;

  //fill out sub chunk 2 "data"
  memcpy(waveHeader.m_subChunk2ID, "data", 4);
  waveHeader.m_subChunk2Size = dataSize;

  //write the header
  fwrite(&waveHeader, sizeof(SMinimalWaveFileHeader), 1, File);

  //write the wave data itself
  fwrite(&data[0], dataSize, 1, File);

  //close the file and return success
  fclose(File);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edx, %eax
movq %rsi, -0x68(%rbp)
movq %rdi, %rdx
movq -0x68(%rbp), %rdi
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movl %ecx, -0x20(%rbp)
callq 0x3d40
shlq $0x2, %rax
movl %eax, -0x24(%rbp)
movl $0x20, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3182(%rip), %rsi      # 0x50c4
callq 0x10c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1f5b
movb $0x0, -0x1(%rbp)
jmp 0x2023
movl 0x3167(%rip), %eax      # 0x50c8
movl %eax, -0x5c(%rbp)
movl -0x24(%rbp), %eax
addl $0x24, %eax
movl %eax, -0x58(%rbp)
movl 0x315a(%rip), %eax      # 0x50cd
movl %eax, -0x54(%rbp)
movl 0x3156(%rip), %eax      # 0x50d2
movl %eax, -0x50(%rbp)
movl $0x10, -0x4c(%rbp)
movw $0x1, -0x48(%rbp)
movw -0x1a(%rbp), %ax
movw %ax, -0x46(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x20(%rbp), %eax
movswl -0x1a(%rbp), %ecx
imull %ecx, %eax
imull -0x28(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x40(%rbp)
movswl -0x1a(%rbp), %eax
imull -0x28(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movw %ax, -0x3c(%rbp)
movl -0x28(%rbp), %eax
movw %ax, -0x3a(%rbp)
movl 0x3103(%rip), %eax      # 0x50d7
movl %eax, -0x38(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rcx
leaq -0x5c(%rbp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1120
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3d20
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
movq -0x30(%rbp), %rcx
movl $0x1, %edx
callq 0x1120
movq -0x30(%rbp), %rdi
callq 0x1090
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: patmorin[P]rotate/permtest.cpp
// Function: unsigned long outshuffle_perm2<unsigned long>(unsigned long, unsigned long)
inline I outshuffle_perm2(I i, I n) {
	if (i%2 == 0) {
		return n/2+i/2;
	} else {
		return i/2;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x2333
movq -0x18(%rsp), %rax
shrq %rax
movq -0x10(%rsp), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
jmp 0x2340
movq -0x10(%rsp), %rax
shrq %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: patmorin[P]rotate/permtest.cpp
// Function: unsigned long inshuffle_perm2<unsigned long>(unsigned long, unsigned long)
inline I inshuffle_perm2(I i, I n) {
	if (i < n/2) {
		return 2*i+1;
	} else {
		return 2*i-n;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
shrq %rcx
cmpq %rcx, %rax
jae 0x240f
movq -0x10(%rsp), %rax
shlq %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x2421
movq -0x10(%rsp), %rax
shlq %rax
subq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: mburhanpurkar[P]fast_xorshift_plus/test_rng.cpp
// Function: warm_up_cpu()
void warm_up_cpu()
{
    // A throwaway computation which uses the CPU for ~10^9
    // clock cycles.  The details (usleep, xor) are to prevent the
    // compiler from optimizing it out!
    //
    // Empirically, this makes timing results more stable (without it,
    // the CPU seems to run slow for the first ~10^9 cycles or so.)

    long n = 0;
    for (long i = 0; i < 1000L * 1000L * 1000L; i++)
        n += (i ^ (i-1));
    usleep(n % 2);
}

// Assembly:
subq $0x18, %rsp
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x3b9aca00, 0x8(%rsp)  # imm = 0x3B9ACA00
jge 0x239c
movq 0x8(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
xorq %rcx, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2366
movq 0x10(%rsp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movl %edx, %edi
callq 0x2170
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: mburhanpurkar[P]fast_xorshift_plus/test_rng.cpp
// Function: main
int main()
{
    // Warm up the CPU - needed for timing
    warm_up_cpu();

    // Timing test
    __m256i out;
    time_64_bits(&out, 1000000);

    cout << "--------------------------------------------------" << endl;
  
    // Test to compare the outputs of vec_xorshift_plus and xorshift_plus
    test_xorshift();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x40, %rsp
movl $0x0, 0x2c(%rsp)
callq 0x2350
movq %rsp, %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x2420
movq 0x5be3(%rip), %rdi      # 0x7fd0
leaq 0x2c44(%rip), %rsi      # 0x5038
callq 0x2110
movq %rax, %rdi
movq 0x5bb5(%rip), %rsi      # 0x7fb8
callq 0x2130
movl $0x2710, %edi           # imm = 0x2710
callq 0x25a0
xorl %eax, %eax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: mburhanpurkar[P]fast_xorshift_plus/test_rng.cpp
// Function: time_64_bits(long long vector[4]*, int)
inline void time_64_bits(__m256i *out, int niter)
{
  fast_rng::vec_xorshift_plus x;
    __m256i tmp;
  
    struct timeval tv0 = rng_helpers::get_time();
  
    for (int iter = 0; iter < niter; iter++)
        tmp = _mm256_xor_si256(tmp, x.gen_rand_bits());

    struct timeval tv1 = rng_helpers::get_time();
    double dt = rng_helpers::time_diff(tv0, tv1);
    double noutputs = double(niter) * 256; // generate 256 random bits per iteration
    double ns_per_output = 1.0e9 * dt / noutputs * 64; // actually, get the time for one bit, then mutiply by 64
    
    _mm256_store_si256(out, tmp);
  
    cout << "64 bit test: time for 64 bits = " << ns_per_output << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, 0xd8(%rsp)
movl %esi, 0xd4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2e10
callq 0x3170
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0xd4(%rsp), %eax
jge 0x24c3
vmovdqa 0x60(%rsp), %ymm0
vmovaps %ymm0, (%rsp)
leaq 0x80(%rsp), %rdi
callq 0x3200
vmovaps (%rsp), %ymm1
vmovdqa %ymm1, 0x100(%rsp)
vmovdqa %ymm0, 0xe0(%rsp)
vmovdqa 0x100(%rsp), %ymm0
vpxor 0xe0(%rsp), %ymm0, %ymm0
vmovdqa %ymm0, 0x60(%rsp)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x2462
vzeroupper
callq 0x3170
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x33c0
vmovsd %xmm0, 0x30(%rsp)
vcvtsi2sdl 0xd4(%rsp), %xmm0, %xmm0
vmovsd 0x2b1d(%rip), %xmm1     # 0x5018
vmulsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rsp)
vmovsd 0x2b03(%rip), %xmm0     # 0x5010
vmulsd 0x30(%rsp), %xmm0, %xmm0
vdivsd 0x28(%rsp), %xmm0, %xmm0
vmovsd 0x2ae7(%rip), %xmm1     # 0x5008
vmulsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
movq 0xd8(%rsp), %rax
vmovdqa 0x60(%rsp), %ymm0
movq %rax, 0x148(%rsp)
vmovdqa %ymm0, 0x120(%rsp)
vmovdqa 0x120(%rsp), %ymm0
movq 0x148(%rsp), %rax
vmovdqa %ymm0, (%rax)
movq 0x5a6a(%rip), %rdi      # 0x7fd0
leaq 0x2afe(%rip), %rsi      # 0x506b
vzeroupper
callq 0x2110
movq %rax, %rdi
vmovsd 0x20(%rsp), %xmm0
callq 0x2200
movq %rax, %rdi
movq 0x5a2b(%rip), %rsi      # 0x7fb8
callq 0x2130
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mburhanpurkar[P]fast_xorshift_plus/./fast_rng.hpp
// Function: fast_rng::vec_xorshift_plus::vec_xorshift_plus(long long vector[4], long long vector[4])
vec_xorshift_plus(__m256i _s0, __m256i _s1)
    {
        if (!is_aligned(&s0,32) || !is_aligned(&s1,32))
	    throw std::runtime_error("Fatal: unaligned vec_xorshift_plus!  See discussion in fast_rng.hpp");

	s0 = _s0;
	s1 = _s1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x80, %rsp
movq %rdi, 0x68(%rsp)
vmovdqa %ymm0, 0x40(%rsp)
vmovdqa %ymm1, 0x20(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x20, %esi
vzeroupper
callq 0x3410
testb $0x1, %al
jne 0x359d
jmp 0x35b4
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movl $0x20, %esi
callq 0x3410
testb $0x1, %al
jne 0x3606
movl $0x10, %edi
callq 0x2080
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x1abd(%rip), %rsi      # 0x508c
callq 0x2060
jmp 0x35d6
movq (%rsp), %rdi
movq 0x4a0f(%rip), %rsi      # 0x7ff0
movq 0x49e0(%rip), %rdx      # 0x7fc8
callq 0x21c0
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x20b0
jmp 0x3628
movq 0x8(%rsp), %rax
vmovdqa 0x40(%rsp), %ymm0
vmovdqa %ymm0, (%rax)
vmovdqa 0x20(%rsp), %ymm0
vmovdqa %ymm0, 0x20(%rax)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
movq 0x18(%rsp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mburhanpurkar[P]fast_xorshift_plus/./fast_rng.hpp
// Function: fast_rng::vec_xorshift_plus::gen_arr(float*, int)
inline void gen_arr(float *out, int N)
    {
        if (N % 8 != 0 || N < 0)
    	    throw std::runtime_error("gen_arr(out, N): N must be divisible by 8 and greater than 0!");

    	for (int i=0; i < N; i+=8)
    	  _mm256_storeu_ps(out + i, gen_floats());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x80, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3acf
cmpl $0x0, 0x2c(%rsp)
jge 0x3b24
movl $0x10, %edi
callq 0x2080
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x1771(%rip), %rsi      # 0x525c
callq 0x2060
jmp 0x3af2
movq 0x8(%rsp), %rdi
movq 0x44f2(%rip), %rsi      # 0x7ff0
movq 0x44c3(%rip), %rdx      # 0x7fc8
callq 0x21c0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x20b0
jmp 0x3b88
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x3b80
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rax
movslq 0x18(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
callq 0x3770
movq (%rsp), %rax
movq %rax, 0x68(%rsp)
vmovaps %ymm0, 0x40(%rsp)
vmovaps 0x40(%rsp), %ymm0
movq 0x68(%rsp), %rax
vmovups %ymm0, (%rax)
movl 0x18(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x18(%rsp)
jmp 0x3b2c
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
movq 0x20(%rsp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: uclaopt[P]AsyncQVI/include/util.h
// Function: get_wall_time()
double get_wall_time(){
  struct timeval time;
  if (gettimeofday(&time,NULL)){
    //  Handle error
    return 0;
  }
  return (double)time.tv_sec + (double)time.tv_usec * .000001;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2320
cmpl $0x0, %eax
je 0x3884
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x38a5
cvtsi2sdq -0x18(%rbp), %xmm1
cvtsi2sdq -0x10(%rbp), %xmm0
movsd 0x9770(%rip), %xmm2     # 0xd008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: uclaopt[P]AsyncQVI/include/async.h
// Function: asyncQVI(int, QVI, Params*)
void asyncQVI(int thread_id, QVI qvi, Params* params) {
	
	while(!params->stop){
		qvi.update(iter);
		iter++;
		
		// evaluate policy every check_step iterations  
		if(iter > params->threshold){
			// let one thread check policy quality
			pthread_barrier_wait(&barrier);
			if(thread_id == 0){
				cout<<iter<<' ';
				qvi.test();
				params->threshold += params->check_step;
				if(iter > params->max_outer_iter)
					params->stop = 1;
			}
			pthread_barrier_wait(&barrier);
		}			
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x70(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3aed
jmp 0x3bb1
leaq 0xf714(%rip), %rdi      # 0x13208
callq 0x50c0
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x4e90
leaq 0xf6fd(%rip), %rdi      # 0x13208
xorl %esi, %esi
callq 0x5150
leaq 0xf6ef(%rip), %rdi      # 0x13208
callq 0x50c0
movq -0x10(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jle 0x3bac
leaq 0x10a7e(%rip), %rdi     # 0x145b0
callq 0x2260
cmpl $0x0, -0x4(%rbp)
jne 0x3ba0
leaq 0xf6c4(%rip), %rdi      # 0x13208
callq 0x50c0
movl %eax, %esi
movq 0xf486(%rip), %rdi      # 0x12fd8
callq 0x2380
movq %rax, %rdi
movl $0x20, %esi
callq 0x2270
movq -0x18(%rbp), %rdi
callq 0x5200
movq -0x10(%rbp), %rax
movl 0x6c(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x74(%rax), %ecx
movl %ecx, 0x74(%rax)
leaq 0xf683(%rip), %rdi      # 0x13208
callq 0x50c0
movq -0x10(%rbp), %rcx
cmpl 0x34(%rcx), %eax
jle 0x3b9e
movq -0x10(%rbp), %rax
movl $0x1, 0x70(%rax)
jmp 0x3ba0
leaq 0x10a09(%rip), %rdi     # 0x145b0
callq 0x2260
jmp 0x3ad7
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: uclaopt[P]AsyncQVI/include/async.h
// Function: asyncQL(int, Qlearning, Params*)
void asyncQL(int thread_id, Qlearning ql, Params* params) {
	
	while(!params->stop){
		ql.update(iter);
		iter++;
		
		// evaluate policy every check_step iterations
		if(iter > params->threshold){
			// let one thread check policy quality
			pthread_barrier_wait(&barrier);
			if(thread_id == 0){
				cout<<iter<<' ';
				ql.test();
				params->threshold += params->check_step;
				if(iter > params->max_outer_iter)
					params->stop = 1;
			}
			pthread_barrier_wait(&barrier);
		}	
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x70(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3bed
jmp 0x3cb1
leaq 0xf614(%rip), %rdi      # 0x13208
callq 0x50c0
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x5230
leaq 0xf5fd(%rip), %rdi      # 0x13208
xorl %esi, %esi
callq 0x5150
leaq 0xf5ef(%rip), %rdi      # 0x13208
callq 0x50c0
movq -0x10(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jle 0x3cac
leaq 0x1097e(%rip), %rdi     # 0x145b0
callq 0x2260
cmpl $0x0, -0x4(%rbp)
jne 0x3ca0
leaq 0xf5c4(%rip), %rdi      # 0x13208
callq 0x50c0
movl %eax, %esi
movq 0xf386(%rip), %rdi      # 0x12fd8
callq 0x2380
movq %rax, %rdi
movl $0x20, %esi
callq 0x2270
movq -0x18(%rbp), %rdi
callq 0x5540
movq -0x10(%rbp), %rax
movl 0x6c(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x74(%rax), %ecx
movl %ecx, 0x74(%rax)
leaq 0xf583(%rip), %rdi      # 0x13208
callq 0x50c0
movq -0x10(%rbp), %rcx
cmpl 0x34(%rcx), %eax
jle 0x3c9e
movq -0x10(%rbp), %rax
movl $0x1, 0x70(%rax)
jmp 0x3ca0
leaq 0x10909(%rip), %rdi     # 0x145b0
callq 0x2260
jmp 0x3bd7
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: uclaopt[P]AsyncQVI/include/oracle.h
// Function: Sailing::setValues(Params*)
void setValues(Params* params){
			DIMX = (int)sqrt(params->len_state/DIMWIND);
			DIMY = DIMX;
			GOALX = (int)DIMX/2; // the target place is the center of the grid
			GOALY = GOALX;
			probs = params->probs;
			d = params->d;
			std::random_device rd; 
			local_rng.seed(rd());
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x13c0, %rsp           # imm = 0x13C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x13c0(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl %edi, %eax
addl $0x7, %eax
testl %edi, %edi
cmovsl %eax, %edi
sarl $0x3, %edi
callq 0x6eb0
movq -0x13c0(%rbp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %ecx
movl %ecx, 0x10(%rax)
movl 0xc(%rax), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %edx, %ecx
sarl %ecx
movl %ecx, 0x14(%rax)
movl 0x14(%rax), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x28(%rax)
leaq -0x1398(%rbp), %rdi
movq %rdi, -0x13b8(%rbp)
callq 0x5570
movq -0x13c0(%rbp), %rax
movq -0x13b8(%rbp), %rdi
addq $0x30, %rax
movq %rax, -0x13b0(%rbp)
callq 0x5640
movl %eax, -0x13a8(%rbp)
jmp 0x4d74
movq -0x13b0(%rbp), %rdi
movl -0x13a8(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x6ed0
jmp 0x4d8c
leaq -0x1398(%rbp), %rdi
callq 0x5610
addq $0x13c0, %rsp           # imm = 0x13C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x13a0(%rbp)
movl %eax, -0x13a4(%rbp)
leaq -0x1398(%rbp), %rdi
callq 0x5610
movq -0x13a0(%rbp), %rdi
callq 0x23a0
nopl (%rax,%rax)