LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: portInfo(_snd_seq*, _snd_seq_port_info*, unsigned int, int)
unsigned int portInfo( snd_seq_t *seq, snd_seq_port_info_t *pinfo, unsigned int type, int portNumber )
{
  snd_seq_client_info_t *cinfo;
  int client;
  int count = 0;
  snd_seq_client_info_alloca( &cinfo );

  snd_seq_client_info_set_client( cinfo, -1 );
  while ( snd_seq_query_next_client( seq, cinfo ) >= 0 ) {
    client = snd_seq_client_info_get_client( cinfo );
    if ( client == 0 ) continue;
    // Reset query info
    snd_seq_port_info_set_client( pinfo, client );
    snd_seq_port_info_set_port( pinfo, -1 );
    while ( snd_seq_query_next_port( seq, pinfo ) >= 0 ) {
      unsigned int atyp = snd_seq_port_info_get_type( pinfo );
      if ( ( ( atyp & SND_SEQ_PORT_TYPE_MIDI_GENERIC ) == 0 ) &&
           ( ( atyp & SND_SEQ_PORT_TYPE_SYNTH ) == 0 ) &&
           ( ( atyp & SND_SEQ_PORT_TYPE_APPLICATION ) == 0 ) ) continue;
	    
      unsigned int caps = snd_seq_port_info_get_capability( pinfo );
      if ( ( caps & type ) != type ) continue;
      if ( count == portNumber ) return 1;
      ++count;
    }
  }

  // If a negative portNumber was used, return the port count.
  if ( portNumber < 0 ) return count;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
callq 0x7970
movq %rsp, %r13
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
callq 0x7970
movq $0x0, -0x30(%rbp)
movq %r13, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x71f0
pushq $-0x1
popq %rsi
movq %r13, %rdi
callq 0x74b0
movq %r12, %rdi
movq %r13, %rsi
callq 0x7ad0
testl %eax, %eax
js 0x89cf
movq %r13, %rdi
callq 0x7270
testl %eax, %eax
je 0x895e
movq %r15, %rdi
movl %eax, %esi
callq 0x76c0
movq %r15, %rdi
pushq $-0x1
popq %rsi
callq 0x72c0
movq %r12, %rdi
movq %r15, %rsi
callq 0x7410
testl %eax, %eax
js 0x895e
movq %r15, %rdi
callq 0x7a30
testl $0x100402, %eax         # imm = 0x100402
je 0x898e
movq %r15, %rdi
callq 0x72e0
notl %eax
testl %eax, %r14d
jne 0x898e
movq -0x30(%rbp), %rcx
leal 0x1(%rcx), %eax
cmpl %ebx, %ecx
movq %rax, -0x30(%rbp)
jne 0x898e
pushq $0x1
popq %rax
jmp 0x89d7
sarl $0x1f, %ebx
andl -0x30(%rbp), %ebx
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiInAlsa::closePort()
void MidiInAlsa :: closePort( void )
{
  AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);

  if ( connected_ ) {
    if ( data->subscription ) {
      snd_seq_unsubscribe_port( data->seq, data->subscription );
      snd_seq_port_subscribe_free( data->subscription );
      data->subscription = 0;
    }
    // Stop the input queue
#ifndef AVOID_TIMESTAMPING
    snd_seq_stop_queue( data->seq, data->queue_id, NULL );
    snd_seq_drain_output( data->seq );
#endif
    connected_ = false;
  }

  // Stop thread to avoid triggering the callback, while the port is intended to be closed
  if ( inputData_.doInput ) {
    inputData_.doInput = false;
    int res = write( data->trigger_fds[1], &inputData_.doInput, sizeof(inputData_.doInput) );
    (void) res;
    if ( !pthread_equal(data->thread, data->dummy_thread_id) )
      pthread_join( data->thread, NULL );
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
cmpb $0x1, 0x10(%rdi)
jne 0x979c
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x977c
movq (%r14), %rdi
callq 0x79e0
movq 0x10(%r14), %rdi
callq 0x77e0
andq $0x0, 0x10(%r14)
movq (%r14), %rdi
movl 0x48(%r14), %esi
pushq $0x20
popq %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x7500
movq (%r14), %rdi
callq 0x7a20
movb $0x0, 0x10(%rbx)
cmpb $0x1, 0x89(%rbx)
jne 0x97d2
addq $0x89, %rbx
movb $0x0, (%rbx)
movl 0x50(%r14), %edi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x70f0
movq 0x30(%r14), %rbx
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x79d0
testl %eax, %eax
je 0x97da
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x73e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiOutAlsa::~MidiOutAlsa()
MidiOutAlsa :: ~MidiOutAlsa()
{
  // Close a connection if it exists.
  closePort();

  // Cleanup.
  AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
  if ( data->vport >= 0 ) snd_seq_delete_port( data->seq, data->vport );
  if ( data->coder ) snd_midi_event_free( data->coder );
  if ( data->buffer ) free( data->buffer );
  snd_seq_close( data->seq );
  delete data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x775a(%rip), %rax      # 0x10f98
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x7390
movq 0x8(%rbx), %r14
movl 0xc(%r14), %esi
testl %esi, %esi
js 0x985e
movq (%r14), %rdi
callq 0x75c0
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x986c
callq 0x7a00
movq 0x28(%r14), %rdi
callq 0x75a0
movq (%r14), %rdi
callq 0x7760
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x7490
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7370
movq %rax, %rdi
callq 0xa2d3
nop
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiOutAlsa::closePort()
void MidiOutAlsa :: closePort( void )
{
  if ( connected_ ) {
    AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
    snd_seq_unsubscribe_port( data->seq, data->subscription );
    snd_seq_port_subscribe_free( data->subscription );
    connected_ = false;
  }
}

// Assembly:
cmpb $0x1, 0x10(%rdi)
jne 0xa00b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq (%r14), %rdi
movq 0x10(%r14), %rsi
callq 0x79e0
movq 0x10(%r14), %rdi
callq 0x77e0
movb $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiOutAlsa::openVirtualPort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void MidiOutAlsa :: openVirtualPort( std::string portName )
{
  AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
  if ( data->vport < 0 ) {
    data->vport = snd_seq_create_simple_port( data->seq, portName.c_str(),
                                              SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ,
                                              SND_SEQ_PORT_TYPE_MIDI_GENERIC|SND_SEQ_PORT_TYPE_APPLICATION );

    if ( data->vport < 0 ) {
      errorString_ = "MidiOutAlsa::openVirtualPort: ALSA error creating virtual port.";
      error( RtMidiError::DRIVER_ERROR, errorString_ );
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x8(%rdi), %r14
cmpl $0x0, 0xc(%r14)
jns 0xa075
movq %rdi, %rbx
movq (%r14), %rdi
movq (%rsi), %rsi
pushq $0x21
popq %rdx
movl $0x100002, %ecx         # imm = 0x100002
callq 0x7800
movl %eax, 0xc(%r14)
testl %eax, %eax
jns 0xa075
leaq 0x18(%rbx), %r14
leaq 0x26c6(%rip), %rsi      # 0xc70f
movq %r14, %rdi
callq 0x7af0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7720
pushq $0x8
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7240
movq %rsp, %rdi
callq 0x7180
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7180
movq %rbx, %rdi
callq 0x7a10
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_get_compiled_api
int rtmidi_get_compiled_api (enum RtMidiApi **apis) // return length for NULL argument.
{
	if (!apis || !(*apis)) {
		std::vector<RtMidi::Api> *v = new std::vector<RtMidi::Api> ();
		try {
			RtMidi::getCompiledApi (*v);
			int size = v->size ();
			delete v;
			return size;
		} catch (...) {
			return -1;
		}
	} else {
		try {
			std::vector<RtMidi::Api> *v = new std::vector<RtMidi::Api> ();
			RtMidi::getCompiledApi (*v);
			for (unsigned int i = 0; i < v->size (); i++)
				(*apis) [i] = (RtMidiApi) v->at (i);
			delete v;
			return 0;
		} catch (...) {
			return -1;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xaed4
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0xaed4
pushq $0x18
popq %rdi
callq 0x7480
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, %rdi
callq 0x7070
xorl %eax, %eax
movl %eax, %r15d
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x2, %rax
cmpq %r15, %rax
jbe 0xaf16
movq %r14, %rdi
movq %r15, %rsi
callq 0x7b40
movl (%rax), %eax
movq (%rbx), %rcx
movl %eax, (%rcx,%r15,4)
leal 0x1(%r15), %eax
jmp 0xaea7
pushq $0x18
popq %r14
movq %r14, %rdi
callq 0x7480
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, %rdi
callq 0x7070
movq 0x8(%r15), %rbx
subq (%r15), %rbx
shrq $0x2, %rbx
movq %r15, %rdi
callq 0x7770
movq %r15, %rdi
movq %r14, %rsi
callq 0x7490
jmp 0xaf2b
movq %r14, %rdi
callq 0x7770
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x7490
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
jmp 0xaf35
movq %rax, %rdi
callq 0x7150
callq 0x78d0
pushq $-0x1
popq %rbx
jmp 0xaf2b
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_open_port
void rtmidi_open_port (RtMidiPtr device, unsigned int portNumber, const char *portName)
{
    std::string name = portName;
    try {
        ((RtMidi*) device->ptr)->openPort (portNumber, name);
    
    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x7990
movq (%rbx), %r14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7720
movq (%r14), %rax
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq *(%rax)
leaq 0x8(%rsp), %rdi
callq 0x7180
leaq 0x28(%rsp), %rdi
callq 0x7180
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7180
jmp 0xb047
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0xb070
movq %r14, %rdi
callq 0x7150
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x78d0
jmp 0xb01a
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x7180
jmp 0xb07f
movq %rax, %r14
movq %r14, %rdi
callq 0x7a10
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_open_virtual_port
void rtmidi_open_virtual_port (RtMidiPtr device, const char *portName)
{
    std::string name = portName;
    try {
        ((RtMidi*) device->ptr)->openVirtualPort (name);
    
    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7990
movq (%rbx), %r14
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7720
movq (%r14), %rax
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x7180
leaq 0x30(%rsp), %rdi
callq 0x7180
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7180
jmp 0xb0f8
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0xb121
movq %r14, %rdi
callq 0x7150
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x78d0
jmp 0xb0cc
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x7180
jmp 0xb130
movq %rax, %r14
movq %r14, %rdi
callq 0x7a10
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_close_port
void rtmidi_close_port (RtMidiPtr device)
{
    try { 
        ((RtMidi*) device->ptr)->closePort ();

    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x7150
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
popq %rbx
jmp 0x78d0
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_get_port_count
unsigned int rtmidi_get_port_count (RtMidiPtr device)
{
    try {
        return ((RtMidi*) device->ptr)->getPortCount ();

    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
        return -1;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x7150
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x78d0
pushq $-0x1
popq %rax
jmp 0xb173
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/rtmidi_c.cpp
// Function: rtmidi_get_port_name
const char* rtmidi_get_port_name (RtMidiPtr device, unsigned int portNumber)
{
    try {
        std::string name = ((RtMidi*) device->ptr)->getPortName (portNumber);
        return strdup (name.c_str ());
    
    } catch (const RtMidiError & err) {
        device->ok  = false;
        device->msg = err.what ();
        return "";
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %edx
movq %rdi, %rbx
movq (%rdi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
leaq 0x8(%rsp), %r14
movq (%r14), %rdi
callq 0x7a90
movq %rax, %rbx
movq %r14, %rdi
callq 0x7180
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xb201
callq 0x7150
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x78d0
leaq 0x17a4(%rip), %rbx      # 0xc9a3
jmp 0xb1ca
callq 0x7a10
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $0x20
popq %rdi
callq 0x7480
movq %rax, %rbx
pushq $0x10
popq %rdi
callq 0x7480
movq %rax, %r14
leaq 0x1892(%rip), %rsi      # 0xcac0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7990
leaq 0x8(%rsp), %rdx
pushq $0x64
popq %rcx
movq %r14, %rdi
xorl %esi, %esi
callq 0x72d0
leaq 0x8(%rsp), %rdi
callq 0x7180
movq %r14, (%rbx)
movb $0x1, 0x10(%rbx)
leaq 0x173c(%rip), %rax      # 0xc9a3
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x7180
jmp 0xb292
movq %rdx, %r12
movq %rax, %r15
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x7490
jmp 0xb2a5
movq %rdx, %r12
movq %rax, %r15
movq %r15, %rdi
cmpl $0x1, %r12d
jne 0xb2cf
callq 0x7150
andq $0x0, (%rbx)
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x78d0
jmp 0xb26b
callq 0x7a10
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movl %edi, %r14d
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7990
pushq $0x20
popq %rdi
callq 0x7480
movq %rax, %rbx
pushq $0x10
popq %rdi
callq 0x7480
movq %rax, %r15
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7720
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %ecx
callq 0x72d0
leaq 0x10(%rsp), %rdi
callq 0x7180
movq %r15, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
leaq 0x165b(%rip), %rax      # 0xc9a3
movq %rax, 0x18(%rbx)
leaq 0x30(%rsp), %rdi
callq 0x7180
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7180
jmp 0xb37e
movq %rdx, %r12
movq %rax, %r14
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x7490
jmp 0xb391
movq %rdx, %r12
movq %rax, %r14
cmpl $0x1, %r12d
jne 0xb3c2
movq %r14, %rdi
callq 0x7150
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x78d0
jmp 0xb34c
jmp 0xb3bf
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x7180
jmp 0xb3d1
movq %rax, %r14
movq %r14, %rdi
callq 0x7a10
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xb3ee
pushq $0x10
popq %rsi
callq 0x7490
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb3fc
movq (%rdi), %rax
callq *0x40(%rax)
pushq $0x20
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x7490
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7480
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
leaq 0x42(%rip), %rsi        # 0xb47d
movq %rax, %rdx
callq 0x74a0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x7150
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rdi
pushq $0x10
popq %rsi
callq 0x7490
andq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
jmp 0x78d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x70b0
movq 0x8(%rbx), %rdi
pushq $0x10
popq %rsi
callq 0x7490
andq $0x0, 0x8(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x7150
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
popq %rbx
jmp 0x78d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x7480
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x7a40
movsd %xmm0, (%rsp)
movq (%r14), %rbx
movq 0x8(%r14), %rax
subq %rbx, %rax
movq %rax, (%r12)
je 0xb53f
movslq %eax, %r12
leaq (,%r12,8), %rdi
callq 0x76a0
movq %rax, (%r15)
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7350
movq %r14, %rdi
callq 0x7850
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x7490
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb565
movq %rdx, %r14
movq %rax, %rdi
callq 0x7150
movb $0x0, 0x10(%rbx)
cmpl $0x2, %r14d
jne 0xb585
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
jmp 0xb58c
leaq 0x1548(%rip), %rax      # 0xcad4
movq %rax, 0x18(%rbx)
callq 0x78d0
movsd 0x151b(%rip), %xmm0     # 0xcab8
movsd %xmm0, (%rsp)
jmp 0xb552
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $0x20
popq %rdi
callq 0x7480
movq %rax, %rbx
pushq $0x10
popq %rdi
callq 0x7480
movq %rax, %r14
leaq 0x1516(%rip), %rsi      # 0xcae2
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7990
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x73d0
leaq 0x8(%rsp), %rdi
callq 0x7180
movq %r14, (%rbx)
movb $0x1, 0x10(%rbx)
leaq 0x13a1(%rip), %rax      # 0xc9a3
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x7180
jmp 0xb62d
movq %rdx, %r12
movq %rax, %r15
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x7490
jmp 0xb640
movq %rdx, %r12
movq %rax, %r15
movq %r15, %rdi
cmpl $0x1, %r12d
jne 0xb66a
callq 0x7150
andq $0x0, (%rbx)
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x78d0
jmp 0xb606
callq 0x7a10
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movl %edi, %ebp
pushq $0x20
popq %rdi
callq 0x7480
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x7990
pushq $0x10
popq %rdi
callq 0x7480
movq %rax, %r15
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7720
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x73d0
leaq 0x10(%rsp), %rdi
callq 0x7180
movq %r15, (%rbx)
movb $0x1, 0x10(%rbx)
leaq 0x12c5(%rip), %rax      # 0xc9a3
movq %rax, 0x18(%rbx)
leaq 0x30(%rsp), %rdi
callq 0x7180
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7180
jmp 0xb714
movq %rdx, %r12
movq %rax, %r14
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x7490
jmp 0xb727
movq %rdx, %r12
movq %rax, %r14
cmpl $0x1, %r12d
jne 0xb754
movq %r14, %rdi
callq 0x7150
andq $0x0, (%rbx)
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x78d0
jmp 0xb6e2
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x7180
jmp 0xb763
movq %rax, %r14
movq %r14, %rdi
callq 0x7a10
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x7480
movq %rax, %r14
movslq %ebp, %r12
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x78a0
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7350
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x48(%rax)
movq %r14, %rdi
callq 0x7850
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x7490
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r12
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x7490
jmp 0xb81c
movq %rdx, %r15
movq %rax, %r12
movq %r12, %rdi
callq 0x7150
movb $0x0, 0x10(%rbx)
cmpl $0x2, %r15d
jne 0xb839
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
jmp 0xb840
leaq 0x1294(%rip), %rax      # 0xcad4
movq %rax, 0x18(%rbx)
callq 0x78d0
pushq $-0x1
popq %rax
jmp 0xb7f6
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x78, %rsp
cmpl $0x1, %edi
jle 0x36a9
movq 0x8(%rsi), %rbx
movq %rsp, %r14
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36fa
leaq 0xcbd(%rip), %rsi       # 0x4313
movq %r14, %rdi
callq 0x2260
leaq 0x20(%rsp), %rdi
callq 0x3284
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x2852
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x269e
leaq 0x20(%rsp), %rdi
callq 0x2b30
leaq 0x20(%rsp), %rdi
callq 0x32c6
movq %rsp, %rdi
callq 0x20b0
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq (%rsi), %rsi
movq 0x391d(%rip), %rdi      # 0x6fd0
callq 0x2130
leaq 0xc4a(%rip), %rsi       # 0x4309
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x2170
jmp 0x36d8
movq %rax, %rbx
jmp 0x36ea
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x32c6
movq %rsp, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/test/parser_test.cpp
// Function: main
int main()
{
	TestLetStatement();
	TestReturnStatement();
	TestIdentifierExpression();
	TestIntegerLiteralExpression();
}

// Assembly:
pushq %rax
callq 0x68b5
callq 0x6b44
callq 0x6d33
callq 0x6f8a
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/test/parser_test.cpp
// Function: TestReturnStatement()
void TestReturnStatement()
{
	std::string input =
		"return 5;"
		"return 10;"
		"return 838383;";

	Lexer lexer;
	lexer.New(input);

	Parser parser;
	parser.New(lexer);

	Program *program = parser.ParseProgram();

	checkParserErrors(parser);

	if (program == nullptr)
		std::cout << "ParseProgram() returned null" << std::endl;

	if (program->statements.size() != 3)
		std::cout << "program->statements does not contain 3 statements, got " << program->statements.size() << std::endl;

	Statement *stmt;
	for (int i = 0; i < program->statements.size(); i++)
	{
		stmt = program->statements[i];

		if (((ReturnStatement *)stmt)->tokenLiteral() != "return")
			std::cout << "stmt->tokenLiteral() not 'return'"
					  << ", got " << stmt->tokenLiteral() << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
leaq 0xa64a(%rip), %rsi      # 0x111a6
leaq 0x58(%rsp), %rbx
leaq 0x78(%rsp), %rdx
movq %rbx, %rdi
callq 0x7470
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x83a6
leaq 0x78(%rsp), %rdi
callq 0xb630
leaq 0x78(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb9cc
leaq 0x78(%rsp), %rdi
callq 0xd1ee
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x71d4
testq %rbx, %rbx
jne 0x6bdc
movq 0x13408(%rip), %rdi     # 0x19fd0
leaq 0xa52a(%rip), %rsi      # 0x110f9
callq 0x41b0
movq %rax, %rdi
callq 0x40e0
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
cmpq $0x18, %rax
je 0x6c19
movq 0x133df(%rip), %rdi     # 0x19fd0
leaq 0xa51e(%rip), %rsi      # 0x11116
callq 0x41b0
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x4130
movq %rax, %rdi
callq 0x40e0
xorl %ebp, %ebp
leaq 0x38(%rsp), %r14
leaq 0xa5a1(%rip), %r15      # 0x111c8
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
jbe 0x6cba
movq (%rax,%rbp,8), %r12
movq (%r12), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7557
movl %eax, %r13d
movq %r14, %rdi
callq 0x4368
testb %r13b, %r13b
je 0x6cb2
movq 0x13363(%rip), %rdi     # 0x19fd0
leaq 0xa55b(%rip), %rsi      # 0x111cf
callq 0x41b0
movq %rax, %rdi
leaq 0xa5a7(%rip), %rsi      # 0x1122a
callq 0x41b0
movq %rax, %r13
movq (%r12), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *(%rax)
movq %r13, %rdi
movq %r14, %rsi
callq 0x41a0
movq %rax, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4368
incq %rbp
jmp 0x6c27
leaq 0x78(%rsp), %rdi
callq 0x7508
leaq 0x8(%rsp), %rdi
callq 0x4368
leaq 0x58(%rsp), %rdi
callq 0x4368
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6cf9
jmp 0x6cee
movq %rax, %rbx
jmp 0x6d17
jmp 0x6cf9
jmp 0x6cf9
jmp 0x6cf9
movq %rax, %rbx
jmp 0x6d0d
jmp 0x6d00
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4368
leaq 0x78(%rsp), %rdi
callq 0x7508
leaq 0x8(%rsp), %rdi
callq 0x4368
leaq 0x58(%rsp), %rdi
callq 0x4368
movq %rbx, %rdi
callq 0x4320
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xd94e
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x7212
leaq 0x8(%rsp), %rdi
callq 0x74ac
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x12db7(%rip), %rdi     # 0x19fd0
leaq 0x9e80(%rip), %rsi      # 0x110a0
callq 0x41b0
movq 0x10(%rsp), %rsi
subq 0x8(%rsp), %rsi
sarq $0x5, %rsi
movq %rax, %rdi
callq 0x4130
leaq 0x9e6a(%rip), %rsi      # 0x110ac
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
callq 0x40e0
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %r13
leaq 0x20(%rsp), %r14
movq 0x12d68(%rip), %r15     # 0x19fd0
leaq 0x9e45(%rip), %r12      # 0x110b4
cmpq %r13, %rbx
je 0x72ab
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4260
movq %r15, %rdi
movq %r12, %rsi
callq 0x41b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x41a0
movq %rax, %rdi
callq 0x40e0
movq %r14, %rdi
callq 0x4368
addq $0x20, %rbx
jmp 0x726f
xorl %edi, %edi
callq 0x4200
jmp 0x72c3
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4368
jmp 0x72c6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x74ac
movq %rbx, %rdi
callq 0x4320
// File: /workspace/github_cpp_makefile_star2_O2/pranavmodx[P]modlang/test/parser_test.cpp
// Function: testLetStatement(LetStatement*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool testLetStatement(LetStatement *stmt, std::string expectedName)
{
	if (stmt->tokenLiteral() != "let")
	{
		std::cout << "stmt->tokenLiteral() not 'let'"
				  << ", got " << stmt->tokenLiteral() << std::endl;
		return false;
	}

	if (stmt->name.value != expectedName)
	{
		std::cout << "stmt->name.value not " << expectedName << ", got " << stmt->name.value << std::endl;
		return false;
	}

	if (stmt->name.tokenLiteral() != expectedName)
	{
		std::cout << "stmt->name.tokenLiteral() not " << expectedName << ", got " << stmt->name.tokenLiteral() << std::endl;
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *(%rax)
leaq 0x9e4f(%rip), %rsi      # 0x1114e
movq %r15, %rdi
callq 0x7557
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x4368
testb %bpl, %bpl
je 0x736c
movq 0x12cb1(%rip), %rdi     # 0x19fd0
leaq 0x9e2c(%rip), %rsi      # 0x11152
callq 0x41b0
leaq 0x9ef8(%rip), %rsi      # 0x1122a
movq %rax, %rdi
callq 0x41b0
movq %rax, %r14
movq (%rbx), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41a0
movq %rax, %rdi
callq 0x40e0
leaq 0x8(%rsp), %rdi
callq 0x4368
jmp 0x73c2
leaq 0x90(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7561
testb %al, %al
je 0x73cf
movq 0x12c47(%rip), %rdi     # 0x19fd0
leaq 0x9de1(%rip), %rsi      # 0x11171
callq 0x41b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x41a0
leaq 0x9e83(%rip), %rsi      # 0x1122a
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x41a0
movq %rax, %rdi
callq 0x40e0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x70, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4260
movq %r15, %rdi
movq %r14, %rsi
callq 0x7561
movl %eax, %ebp
movq %r15, %rdi
callq 0x4368
movb $0x1, %al
testb %bpl, %bpl
je 0x73c4
movq 0x12bca(%rip), %rdi     # 0x19fd0
leaq 0x9d7a(%rip), %rsi      # 0x11187
callq 0x41b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x41a0
leaq 0x9e06(%rip), %rsi      # 0x1122a
movq %rax, %rdi
callq 0x41b0
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4260
movq %r14, %rdi
movq %r15, %rsi
callq 0x41a0
movq %rax, %rdi
callq 0x40e0
jmp 0x7360
jmp 0x745b
jmp 0x745b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4368
movq %rbx, %rdi
callq 0x4320
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
xorl %eax, %eax
xorl %edx, %edx
subq $0x1, %rcx
jb 0x2338
blsmskq %rdx, %rsi
incq %rdx
addq %rsi, %rax
jmp 0x2325
pushq $0x2
popq %rcx
cqto
idivq %rcx
movq %rdx, %rdi
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x231c
movl $0xf4240, %esi          # imm = 0xF4240
movq %rsp, %rdi
callq 0x2392
movq 0x2c63(%rip), %rdi      # 0x4fd0
leaq 0xcc8(%rip), %rsi       # 0x303c
callq 0x2130
movq %rax, %rdi
callq 0x20a0
movl $0x2710, %edi           # imm = 0x2710
callq 0x2486
xorl %eax, %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xa0, %rsp
leaq 0x40(%rsp), %r13
movq %rdi, 0x18(%rsp)
movl %esi, %r14d
movq %r13, %rdi
callq 0x2820
callq 0x2903
movq %rax, %r12
movl %r14d, %eax
sarl $0x1f, %eax
movq %rdx, %r15
andnl %r14d, %eax, %ebx
subl $0x1, %ebx
jb 0x23f4
movq %r13, %rdi
callq 0x2970
vmovapd 0x20(%rsp), %ymm1
vxorpd %ymm1, %ymm0, %ymm1
vmovapd %ymm1, 0x20(%rsp)
jmp 0x23d5
vzeroupper
callq 0x2903
subq %r12, %rax
subq %r15, %rdx
movq 0x2bc7(%rip), %rdi      # 0x4fd0
leaq 0xc5f(%rip), %rsi       # 0x306f
vcvtsi2sd %rax, %xmm2, %xmm0
movq 0x18(%rsp), %rax
vcvtsi2sd %rdx, %xmm2, %xmm1
vfmadd132sd 0xbe0(%rip), %xmm0, %xmm1 # xmm1 = (xmm1 * mem) + xmm0
vcvtsi2sd %r14d, %xmm2, %xmm2
vmulsd 0xbdb(%rip), %xmm2, %xmm0 # 0x3010
vmulsd 0xbdb(%rip), %xmm1, %xmm1 # 0x3018
vdivsd %xmm0, %xmm1, %xmm0
vmovaps 0x20(%rsp), %ymm1
vmulsd 0xbd1(%rip), %xmm0, %xmm0 # 0x3020
vmovaps %ymm1, (%rax)
vmovsd %xmm0, 0x10(%rsp)
vzeroupper
callq 0x2130
vmovsd 0x10(%rsp), %xmm0
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20a0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl $0x80000007, %edx       # imm = 0x80000007
jne 0x2ba2
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
xorl %r12d, %r12d
cmpq %r15, %r12
jae 0x2b93
movq %r14, %rdi
callq 0x2a82
vmovups %ymm0, (%rbx,%r12,4)
addq $0x8, %r12
jmp 0x2b7a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
vzeroupper
retq
pushq $0x10
popq %rdi
callq 0x20b0
movq %rax, %rbx
leaq 0x668(%rip), %rsi       # 0x321c
movq %rax, %rdi
callq 0x2060
movq 0x242d(%rip), %rsi      # 0x4ff0
movq 0x23fe(%rip), %rdx      # 0x4fc8
movq %rbx, %rdi
callq 0x21c0
movq %rbx, %rdi
movq %rax, %r14
callq 0x20d0
movq %r14, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/uclaopt[P]AsyncQVI/include/oracle.h
// Function: test_sailing(Sailing&, std::vector<int, std::allocator<int>>*, Params*)
void test_sailing(Sailing& s, std::vector<int>* pi, Params* params){
	
	double start_time = get_wall_time();
	s.setValues(params);
	// total discounted reward
	double total_reward = 0.;
	// how many times has the goal state been reached.
	int flag = 0;
	int isflag = 0;
	// run text_max_episode episodes
	for (int episode = 0; episode < params->test_max_episode; episode++){
		// start from an arbitrary state
		int i = uniformInt(0,params->len_state-1);
		int j = 0;
		double r = 0;
		isflag = 0;
		for (int step = 0; step < params->test_max_step; step++){
			s.SO(i,(*pi)[i],j,r);
			total_reward += pow(params->gamma,step)*r;
			if(r == 1 && !isflag){
				flag += 1;
				isflag = 1;
			}
			i = j;
		}
	}
	params->test_time += get_wall_time() - start_time;
	// average total reward
	total_reward /= params->test_max_episode;
	cout<<get_wall_time()-params->test_time-params->time<<' '<<total_reward<<' '<<flag<<endl;
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2b55
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x3608
xorl %ebx, %ebx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %eax, %eax
cmpl 0x20(%r14), %eax
jge 0x2c8d
movl %eax, 0x14(%rsp)
movl (%r14), %esi
decl %esi
xorl %ebp, %ebp
xorl %edi, %edi
callq 0x2aec
andl $0x0, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
xorl %r13d, %r13d
cmpl 0x24(%r14), %r13d
jge 0x2c82
movslq %eax, %rsi
movq (%r15), %rax
movl (%rax,%rsi,4), %edx
movq %r12, %rdi
leaq 0x10(%rsp), %rcx
leaq 0x18(%rsp), %r8
callq 0x36a0
movsd 0x18(%r14), %xmm0
cvtsi2sd %r13d, %xmm1
callq 0x2310
movsd 0x18(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
ucomisd 0x33bb(%rip), %xmm1     # 0x6018
setnp %al
sete %cl
andb %al, %cl
testl %ebp, %ebp
sete %al
andb %cl, %al
movzbl %al, %eax
addl %eax, %ebx
testb %al, %al
pushq $0x1
popq %rax
cmovnel %eax, %ebp
movl 0x10(%rsp), %eax
incl %r13d
jmp 0x2c0a
movl 0x14(%rsp), %eax
incl %eax
jmp 0x2be0
callq 0x2b55
subsd 0x20(%rsp), %xmm0
addsd 0x80(%r14), %xmm0
movsd %xmm0, 0x80(%r14)
cvtsi2sdl 0x20(%r14), %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x2b55
subsd 0x80(%r14), %xmm0
subsd 0x78(%r14), %xmm0
movq 0x62fd(%rip), %rdi      # 0x8fd8
callq 0x2290
pushq $0x20
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x21f0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2290
movq %rax, %rdi
movl %ebp, %esi
callq 0x21f0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2300
movq %rax, %rdi
callq 0x20a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x40(%rsp), %r14
leaq 0x7816(%rip), %r15      # 0xa558
movq 0x628f(%rip), %r12      # 0x8fd8
pushq $0x20
popq %r13
cmpl $0x0, 0x70(%rbx)
jne 0x2dc2
movl 0x6457(%rip), %esi      # 0x91b0
movq %r14, %rdi
callq 0x36ee
lock
incl 0x6448(%rip)            # 0x91b0
movl 0x6442(%rip), %eax      # 0x91b0
cmpl 0x74(%rbx), %eax
jle 0x2d4d
movq %r15, %rdi
callq 0x21e0
testl %ebp, %ebp
jne 0x2db8
movl 0x642b(%rip), %esi      # 0x91b0
movq %r12, %rdi
callq 0x2300
movq %rax, %rdi
movl %r13d, %esi
callq 0x21f0
movq %r14, %rdi
callq 0x385a
movl 0x6c(%rbx), %eax
addl %eax, 0x74(%rbx)
movl 0x6404(%rip), %eax      # 0x91b0
cmpl 0x34(%rbx), %eax
jle 0x2db8
movl $0x1, 0x70(%rbx)
movq %r15, %rdi
callq 0x21e0
jmp 0x2d4d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x40(%rsp), %r14
leaq 0x776b(%rip), %r15      # 0xa558
movq 0x61e4(%rip), %r12      # 0x8fd8
pushq $0x20
popq %r13
cmpl $0x0, 0x70(%rbx)
jne 0x2e6d
movl 0x63ac(%rip), %esi      # 0x91b0
movq %r14, %rdi
callq 0x3874
lock
incl 0x639d(%rip)            # 0x91b0
movl 0x6397(%rip), %eax      # 0x91b0
cmpl 0x74(%rbx), %eax
jle 0x2df8
movq %r15, %rdi
callq 0x21e0
testl %ebp, %ebp
jne 0x2e63
movl 0x6380(%rip), %esi      # 0x91b0
movq %r12, %rdi
callq 0x2300
movq %rax, %rdi
movl %r13d, %esi
callq 0x21f0
movq %r14, %rdi
callq 0x39ae
movl 0x6c(%rbx), %eax
addl %eax, 0x74(%rbx)
movl 0x6359(%rip), %eax      # 0x91b0
cmpl 0x34(%rbx), %eax
jle 0x2e63
movl $0x1, 0x70(%rbx)
movq %r15, %rdi
callq 0x21e0
jmp 0x2df8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1388, %rsp           # imm = 0x1388
movq %rsi, %r14
movl (%rsi), %eax
pushq $0x8
popq %rcx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3634
sqrtsd %xmm0, %xmm0
jmp 0x3639
callq 0x2120
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%rbx)
movl %eax, 0x10(%rbx)
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, 0x14(%rbx)
movl %eax, 0x18(%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x39c8
movq %r14, %rdi
callq 0x2210
addq $0x30, %rbx
movl %eax, %esi
movq %rbx, %rdi
callq 0x460e
movq %rsp, %rdi
callq 0x3a1e
addq $0x1388, %rsp           # imm = 0x1388
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3a1e
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/uclaopt[P]AsyncQVI/include/oracle.h
// Function: Sailing::SO(int, int, int&, double&)
void SO(int i, int a, int& j, double& r){
			indexToState(i);
			apply(a);
			r = reward(a);
			windTransition();
			j = stateToIndex();
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %r15
callq 0x4646
movq %r15, %rdi
movl %ebp, %esi
callq 0x4672
movq %r15, %rdi
movl %ebp, %esi
callq 0x47b8
movsd %xmm0, (%rbx)
movq %r15, %rdi
callq 0x47f6
movq %r15, %rdi
callq 0x485a
movl %eax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop