LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/WojciechMula[P]utf16utf8/benchmarks/benchmark_from_utf16.cpp
// Function: main
int main() {
    // todo: Daniel finds the endless stream of numbers too much
    // Because some schemes use branching, you need to have a sizeable input if you
    // want fair results, given that we repeat the tests many times (we need to account
    // for branch predictors learning the branches).
    std::vector<size_t> input_size{16384};
    for (const size_t size: input_size) {
        Benchmark bench(size);
        bench.run_from_utf16();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x13b8, %rsp           # imm = 0x13B8
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
movq %r14, %rdi
movq $0x4000, (%rsi)         # imm = 0x4000
callq 0x48f8
movq (%r14), %rbx
movq 0x8(%r14), %r12
cmpq %r12, %rbx
je 0x4899
leaq 0x30(%rsp), %r14
leaq 0x28(%rsp), %r15
movq (%rbx), %rax
movq %rax, 0x28(%rsp)
movq %r14, %rdi
callq 0x4d22
movq %r15, %rdi
callq 0x4940
movq %r14, %rdi
callq 0x21a0
addq $0x8, %rbx
cmpq %r12, %rbx
jne 0x486b
movq 0x10(%rsp), %rbx
testq %rbx, %rbx
je 0x48ae
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
subq %rbx, %rsi
callq 0x21d0
xorl %eax, %eax
addq $0x13b8, %rsp           # imm = 0x13B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x48cf
movq %rax, %rbx
movq %r14, %rdi
callq 0x21a0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x48e6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
jmp 0x48f0
movq %rax, %rdi
callq 0x4e31
// File: /workspace/github_cpp_makefile_star2_O3/WojciechMula[P]utf16utf8/dependencies/utf8_v2_3_4/source/utf8/checked.h
// Function: std::back_insert_iterator<std::vector<unsigned char, std::allocator<unsigned char>>> utf8::utf16to8<__gnu_cxx::__normal_iterator<unsigned short const*, std::vector<unsigned short, std::allocator<unsigned short>>>, std::back_insert_iterator<std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned short const*, std::vector<unsigned short, std::allocator<unsigned short>>>, __gnu_cxx::__normal_iterator<unsigned short const*, std::vector<unsigned short, std::allocator<unsigned short>>>, std::back_insert_iterator<std::vector<unsigned char, std::allocator<unsigned char>>>)
octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
    {
        while (start != end) {
            uint32_t cp = utf8::internal::mask16(*start++);
            // Take care of surrogate pairs first
            if (utf8::internal::is_lead_surrogate(cp)) {
                if (start != end) {
                    uint32_t trail_surrogate = utf8::internal::mask16(*start++);
                    if (utf8::internal::is_trail_surrogate(trail_surrogate))
                        cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
                    else
                        throw invalid_utf16(static_cast<uint16_t>(trail_surrogate));
                }
                else
                    throw invalid_utf16(static_cast<uint16_t>(cp));

            }
            // Lone trail surrogate
            else if (utf8::internal::is_trail_surrogate(cp))
                throw invalid_utf16(static_cast<uint16_t>(cp));

            result = utf8::append(cp, result);
        }
        return result;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rax
cmpq %rsi, %rdi
je 0x6b13
movq %rsi, %rbx
movzwl (%rdi), %ebp
leaq 0x2(%rdi), %r14
movzwl %bp, %ecx
movl %ecx, %edx
andl $0xfc00, %edx           # imm = 0xFC00
cmpl $0xd800, %edx           # imm = 0xD800
je 0x6ad4
cmpl $0xdc00, %edx           # imm = 0xDC00
jne 0x6b01
jmp 0x6b18
cmpq %rbx, %r14
je 0x6b18
movzwl (%r14), %ebp
movzwl %bp, %edx
movl %edx, %esi
andl $0xfc00, %esi           # imm = 0xFC00
cmpl $0xdc00, %esi           # imm = 0xDC00
jne 0x6b18
shll $0xa, %ecx
addq $0x4, %rdi
leal -0x35fdc00(%rcx,%rdx), %ecx
movq %rdi, %r14
movl %ecx, %edi
movq %rax, %rsi
callq 0x6b46
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x6ab0
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq 0x84af(%rip), %rdx      # 0xefd8
leaq 0x8220(%rip), %rcx      # 0xed50
leaq 0x81f1(%rip), %rsi      # 0xed28
movq %rax, %rdi
movq %rcx, (%rax)
movw %bp, 0x8(%rax)
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/tokuhirom[P]nanouri/t/02_escape.cc
// Function: main
int main() {
    std::string src;

    src = "hello\x01\x02";
    is(nanouri::escape_uri(src), std::string("hello%01%02"), "escape");

    src = "hi\xff";
    is(nanouri::escape_uri(src), std::string("hi%ff"), "escape");

    done_testing();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x139f(%rip), %rcx      # 0x4058
leaq 0x40(%rsp), %rdi
movl $0x7, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2180
leaq 0x80(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x243c
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1371(%rip), %rsi      # 0x4060
leaq 0x1375(%rip), %rdx      # 0x406b
leaq 0x20(%rsp), %rdi
callq 0x2f68
leaq 0x1365(%rip), %rdx      # 0x406c
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x27a6
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d30
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2120
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d51
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x2120
leaq 0x40(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x1312(%rip), %rcx      # 0x4073
movl $0x3, %r8d
xorl %esi, %esi
callq 0x2180
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x243c
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x12ea(%rip), %rsi      # 0x4077
leaq 0x12e8(%rip), %rdx      # 0x407c
movq %rsp, %rdi
callq 0x2f68
leaq 0x12c9(%rip), %rdx      # 0x406c
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x27a6
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2dc6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2120
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2de1
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x2120
movl 0x3325(%rip), %esi      # 0x610c
leaq 0x122f(%rip), %rdi      # 0x401d
xorl %eax, %eax
callq 0x2040
xorl %edi, %edi
callq 0x2150
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2e1a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2120
jmp 0x2e1a
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e74
movq 0x70(%rsp), %rsi
jmp 0x2e67
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e4e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2120
jmp 0x2e4e
movq %rax, %rbx
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e74
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x2120
jmp 0x2e74
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x2e8b
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2120
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiInAlsa::~MidiInAlsa()
MidiInAlsa :: ~MidiInAlsa()
{
  // Close a connection if it exists.
  closePort();

  // Shutdown the input thread.
  AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
  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 );
  }

  // Cleanup.
  close ( data->trigger_fds[0] );
  close ( data->trigger_fds[1] );
  if ( data->vport >= 0 ) snd_seq_delete_port( data->seq, data->vport );
#ifndef AVOID_TIMESTAMPING
  snd_seq_free_queue( data->seq, data->queue_id );
#endif
  snd_seq_close( data->seq );
  delete data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x85e3(%rip), %rax      # 0x10fa8
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x7730
movq 0x8(%rbx), %r14
cmpb $0x1, 0x89(%rbx)
jne 0x8a14
leaq 0x89(%rbx), %rsi
movb $0x0, (%rsi)
movl 0x50(%r14), %edi
movl $0x1, %edx
callq 0x70d0
movq 0x30(%r14), %r15
movq 0x38(%r14), %rsi
movq %r15, %rdi
callq 0x7870
testl %eax, %eax
jne 0x8a14
movq %r15, %rdi
xorl %esi, %esi
callq 0x7380
movl 0x4c(%r14), %edi
callq 0x7990
movl 0x50(%r14), %edi
callq 0x7990
movl 0xc(%r14), %esi
testl %esi, %esi
js 0x8a36
movq (%r14), %rdi
callq 0x7520
movq (%r14), %rdi
movl 0x48(%r14), %esi
callq 0x7210
movq (%r14), %rdi
callq 0x7670
movl $0x58, %esi
movq %r14, %rdi
callq 0x7420
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x75c0
movq %rax, %rdi
callq 0xade3
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, %r12
callq 0x7810
movq %rsp, %r13
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
callq 0x7810
xorl %r14d, %r14d
movq %r13, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x71d0
movq %r13, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7430
movq %r12, %rdi
movq %r13, %rsi
callq 0x7950
testl %eax, %eax
js 0x8d33
movq %r13, %rdi
callq 0x7220
testl %eax, %eax
je 0x8cca
movq %r15, %rdi
movl %eax, %esi
callq 0x7600
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7270
movq %r12, %rdi
movq %r15, %rsi
callq 0x73a0
testl %eax, %eax
js 0x8cca
movq %r15, %rdi
callq 0x78d0
testl $0x100402, %eax         # imm = 0x100402
je 0x8cfc
movq %r15, %rdi
callq 0x7290
notl %eax
testl %eax, -0x2c(%rbp)
jne 0x8cfc
cmpl %ebx, %r14d
je 0x8d4a
incl %r14d
jmp 0x8cfc
sarl $0x1f, %ebx
andl %r14d, %ebx
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebx
jmp 0x8d39
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9eb3
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x9e91
movq (%r14), %rdi
callq 0x7880
movq 0x10(%r14), %rdi
callq 0x76c0
movq $0x0, 0x10(%r14)
movq (%r14), %rdi
movl 0x48(%r14), %esi
movl $0x20, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x7470
movq (%r14), %rdi
callq 0x78c0
movb $0x0, 0x10(%rbx)
cmpb $0x1, 0x89(%rbx)
jne 0x9eeb
addq $0x89, %rbx
movb $0x0, (%rbx)
movl 0x50(%r14), %edi
movl $0x1, %edx
movq %rbx, %rsi
callq 0x70d0
movq 0x30(%r14), %rbx
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x7870
testl %eax, %eax
je 0x9ef3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7380
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7026(%rip), %rax      # 0x10f90
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x7330
movq 0x8(%rbx), %r14
movl 0xc(%r14), %esi
testl %esi, %esi
js 0x9f8a
movq (%r14), %rdi
callq 0x7520
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x9f98
callq 0x78a0
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x9fa6
callq 0x7500
movq (%r14), %rdi
callq 0x7670
movl $0x58, %esi
movq %r14, %rdi
callq 0x7420
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7310
movq %rax, %rdi
callq 0xade3
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaa3b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq (%r14), %rdi
movq 0x10(%r14), %rsi
callq 0x7880
movq 0x10(%r14), %rdi
callq 0x76c0
movb $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaad5
movq %rdi, %rbx
movq (%r14), %rdi
movq (%rsi), %rsi
movl $0x21, %edx
movl $0x100002, %ecx         # imm = 0x100002
callq 0x76e0
movl %eax, 0xc(%r14)
testl %eax, %eax
jns 0xaad5
leaq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rdx
leaq 0x2c7c(%rip), %rcx      # 0xd6ff
movl $0x3f, %r8d
xorl %esi, %esi
callq 0x7710
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x7130
movq %rbx, %rdi
movl $0x8, %esi
movq %r14, %rdx
callq 0x7200
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xaad5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7420
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xaaf8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7420
movq %rbx, %rdi
callq 0x78b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb982
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0xb982
movl $0x18, %edi
callq 0x7410
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, %rdi
callq 0x7070
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
je 0xb9d3
sarq $0x2, %rax
movq (%r14), %rcx
xorl %edx, %edx
movl (%rdi,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
movl %edx, %esi
cmpq %rsi, %rax
ja 0xb970
jmp 0xb9d8
movl $0x18, %edi
callq 0x7410
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, %rdi
callq 0x7070
movq (%r14), %rdi
movq 0x8(%r14), %rbx
subq %rdi, %rbx
shrq $0x2, %rbx
testq %rdi, %rdi
je 0xb9c4
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x7420
movl $0x18, %esi
movq %r14, %rdi
callq 0x7420
jmp 0xb9f3
testq %rdi, %rdi
je 0xb9e4
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x7420
movl $0x18, %esi
movq %rbx, %rdi
callq 0x7420
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x7140
callq 0x77a0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xb9f3
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x7830
movq (%rbx), %r14
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x7130
movq (%r14), %rax
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq *(%rax)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0xbb56
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7420
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb71
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7420
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0xbba3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xbba3
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0xbbcc
movq %r14, %rdi
callq 0x7140
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x77a0
jmp 0xbb56
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbbec
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xbbec
movq %rax, %r14
movq %r14, %rdi
callq 0x78b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7830
movq (%rbx), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x7130
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x8(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xbc5a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbc75
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7420
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xbca6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xbca6
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0xbccf
movq %r14, %rdi
callq 0x7140
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x77a0
jmp 0xbc5a
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbcef
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xbcef
movq %rax, %r14
movq %r14, %rdi
callq 0x78b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %edx
movq %rdi, %rbx
movq (%rdi), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %r14
movq %r14, %rdi
callq 0x7910
movq %rax, %rbx
cmpq %r15, %r14
je 0xbd7b
movq 0x10(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x7420
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
cmpl $0x1, %edx
jne 0xbda3
movl %edx, %esi
movq %rbx, %rdx
callq 0x7a11
leaq 0x1bf2(%rip), %rbx      # 0xd993
jmp 0xbd7b
callq 0x78b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl $0x20, %edi
callq 0x7410
movq %rax, %rbx
movl $0x10, %edi
callq 0x7410
movq %rax, %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1cd1(%rip), %rsi      # 0xdab0
leaq 0x1cdd(%rip), %rdx      # 0xdac3
movq %rsp, %rdi
callq 0x7100
movq %rsp, %rdx
movq %r14, %rdi
xorl %esi, %esi
movl $0x64, %ecx
callq 0x7280
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xbe16
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7420
movq %r14, (%rbx)
movb $0x1, 0x10(%rbx)
leaq 0x1b6f(%rip), %rax      # 0xd993
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xbe5d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xbe5d
movq %rdx, %r12
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x7420
jmp 0xbe72
movq %rdx, %r12
movq %rax, %r15
movq %r15, %rdi
cmpl $0x1, %r12d
jne 0xbe9f
callq 0x7140
movq $0x0, (%rbx)
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x77a0
jmp 0xbe28
callq 0x78b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movl %edi, %r15d
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7830
movl $0x20, %edi
callq 0x7410
movq %rax, %rbx
movl $0x10, %edi
callq 0x7410
movq %rax, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x7130
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %ecx
callq 0x7280
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xbf29
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
movq %r14, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
leaq 0x1a54(%rip), %rax      # 0xd993
movq %rax, 0x18(%rbx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbf5e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7420
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xbf95
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xbf95
movq %rdx, %r12
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x7420
jmp 0xbfaa
movq %rdx, %r12
movq %rax, %r15
cmpl $0x1, %r12d
jne 0xbfde
movq %r15, %rdi
callq 0x7140
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x77a0
jmp 0xbf43
jmp 0xbfdb
movq %rax, %r15
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbffe
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xbffe
movq %rax, %r15
movq %r15, %rdi
callq 0x78b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc01d
movl $0x10, %esi
callq 0x7420
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc02b
movq (%rdi), %rax
callq *0x40(%rax)
movl $0x20, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x7420
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x10, %edi
callq 0x7410
movq %r15, (%rax)
movq %r14, 0x8(%rax)
leaq 0x8(%rbx), %r14
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movq 0x8(%rcx), %rdi
leaq 0x20(%rip), %rsi        # 0xc0a6
movq %rax, %rdx
callq 0x7080
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl %edx, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x7a32
jmp 0xc08e
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq 0x8(%rax), %rdi
callq 0x7890
movq 0x8(%rbx), %rdi
movl $0x10, %esi
callq 0x7420
movq $0x0, 0x8(%rbx)
popq %rbx
retq
movq %rax, %rdi
movl %edx, %esi
movq %rbx, %rdx
callq 0x7a6e
jmp 0xc0d8
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x18, %edi
callq 0x7410
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x7320
movsd %xmm0, (%rsp)
movq (%r14), %rbx
movq 0x8(%r14), %rax
subq %rbx, %rax
movq %rax, (%r12)
je 0xc16a
movslq %eax, %r12
leaq (,%r12,8), %rdi
callq 0x75e0
movq %rax, (%r15)
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x72f0
testq %rbx, %rbx
je 0xc17e
movq 0x10(%r14), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x7420
movl $0x18, %esi
movq %r14, %rdi
callq 0x7420
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xc19e
movq %rdx, %r14
movq %rax, %rdi
callq 0x7140
movb $0x0, 0x10(%rbx)
cmpl $0x2, %r14d
jne 0xc1be
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
jmp 0xc1c5
leaq 0x18ff(%rip), %rax      # 0xdac4
movq %rax, 0x18(%rbx)
callq 0x77a0
movsd 0x18d2(%rip), %xmm0     # 0xdaa8
movsd %xmm0, (%rsp)
jmp 0xc18b
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl $0x20, %edi
callq 0x7410
movq %rax, %rbx
movl $0x10, %edi
callq 0x7410
movq %rax, %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x18be(%rip), %rsi      # 0xdad2
leaq 0x18cb(%rip), %rdx      # 0xdae6
movq %rsp, %rdi
callq 0x7100
movq %rsp, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x7370
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xc246
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7420
movq %r14, (%rbx)
movb $0x1, 0x10(%rbx)
leaq 0x173f(%rip), %rax      # 0xd993
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xc28d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xc28d
movq %rdx, %r12
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x7420
jmp 0xc2a2
movq %rdx, %r12
movq %rax, %r15
movq %r15, %rdi
cmpl $0x1, %r12d
jne 0xc2cf
callq 0x7140
movq $0x0, (%rbx)
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x77a0
jmp 0xc258
callq 0x78b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movl %edi, %ebp
movl $0x20, %edi
callq 0x7410
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x7830
movl $0x10, %edi
callq 0x7410
movq %rax, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x7130
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x7370
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xc359
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
movq %r14, (%rbx)
movb $0x1, 0x10(%rbx)
leaq 0x162c(%rip), %rax      # 0xd993
movq %rax, 0x18(%rbx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc386
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7420
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xc3bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xc3bd
movq %rdx, %r12
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x7420
jmp 0xc3d2
movq %rdx, %r12
movq %rax, %r15
cmpl $0x1, %r12d
jne 0xc405
movq %r15, %rdi
callq 0x7140
movq $0x0, (%rbx)
movb $0x0, 0x10(%rbx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x18(%rbx)
callq 0x77a0
jmp 0xc36b
movq %rax, %r15
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc425
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7420
jmp 0xc425
movq %rax, %r15
movq %r15, %rdi
callq 0x78b0
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x18, %edi
callq 0x7410
movq %rax, %r14
movslq %ebp, %r12
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x7770
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x72f0
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x48(%rax)
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc4cb
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x7420
movl $0x18, %esi
movq %r14, %rdi
callq 0x7420
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r12
movl $0x18, %esi
movq %r14, %rdi
callq 0x7420
jmp 0xc502
movq %rdx, %r15
movq %rax, %r12
movq %r12, %rdi
callq 0x7140
movb $0x0, 0x10(%rbx)
cmpl $0x2, %r15d
jne 0xc51f
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
jmp 0xc526
leaq 0x159e(%rip), %rax      # 0xdac4
movq %rax, 0x18(%rbx)
callq 0x77a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xc4da
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3b80
movq 0x8(%rsi), %rbx
movq %rsp, %r14
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3bec
leaq 0x82d(%rip), %rsi       # 0x4313
movq %r14, %rdi
callq 0x22b0
xorl %eax, %eax
leaq 0x20(%rsp), %rdi
movl %eax, 0x4(%rdi)
movabsq $0x2000100000010, %rcx  # imm = 0x2000100000010
movq %rcx, 0x10(%rdi)
movabsq $0x7d000000ac44, %rcx   # imm = 0x7D000000AC44
movq %rcx, 0x18(%rdi)
movl $0x100002, 0x20(%rdi)   # imm = 0x100002
movl %eax, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
movq %rbx, %rsi
callq 0x2ab0
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2808
leaq 0x20(%rsp), %rdi
callq 0x2e10
leaq 0x20(%rsp), %rdi
callq 0x275e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b76
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq (%rsi), %rsi
movq 0x2446(%rip), %rdi      # 0x5fd0
callq 0x2170
leaq 0x773(%rip), %rsi       # 0x4309
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21c0
jmp 0x3be4
movq %rax, %rbx
jmp 0x3bc1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x275e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bdc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2280
movq %rax, %rdi
callq 0x37bf
// File: /workspace/github_cpp_makefile_star2_O3/pranavmodx[P]modlang/test/parser_test.cpp
// Function: main
int main()
{
	TestLetStatement();
	TestReturnStatement();
	TestIdentifierExpression();
	TestIntegerLiteralExpression();
}

// Assembly:
pushq %rax
callq 0x7615
callq 0x79df
callq 0x7cfb
callq 0x80c4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x135e6
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x84bc
movq %rsp, %rdi
callq 0x8898
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x15b15(%rip), %rdi     # 0x1dfd8
leaq 0xdb8c(%rip), %rsi      # 0x16056
movl $0xb, %edx
callq 0x4210
movq 0x8(%rsp), %rsi
subq (%rsp), %rsi
sarq $0x5, %rsi
movq 0x15af0(%rip), %rdi     # 0x1dfd8
callq 0x4130
movq %rax, %rbx
leaq 0xdb6b(%rip), %rsi      # 0x16062
movl $0x7, %edx
movq %rax, %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x40e0
movq (%rsp), %r12
movq 0x8(%rsp), %rbp
cmpq %rbp, %r12
jne 0x8521
xorl %edi, %edi
callq 0x4230
leaq 0x28(%rsp), %r13
leaq 0x18(%rsp), %rbx
movq 0x15aa6(%rip), %r14     # 0x1dfd8
leaq 0xdb31(%rip), %r15      # 0x1606a
movq %r13, 0x18(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x8bda
movl $0xf, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x4210
movq %rax, %rdi
callq 0x40e0
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x8593
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x41d0
addq $0x20, %r12
cmpq %rbp, %r12
jne 0x8539
jmp 0x851a
jmp 0x85bf
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x85c2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x41d0
jmp 0x85c2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8898
movq %rbx, %rdi
callq 0x4330
// File: /workspace/github_cpp_makefile_star2_O3/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:
vpmovsxbq 0x1df2(%rip), %zmm1 # 0x4148
vpbroadcastq 0x1de0(%rip), %zmm3 # 0x4140
vpxor %xmm0, %xmm0, %xmm0
movl $0x3b9aca00, %eax       # imm = 0x3B9ACA00
vpternlogd $0xff, %zmm2, %zmm2, %zmm2
vpaddq %zmm2, %zmm1, %zmm4
addq $-0x8, %rax
vpxorq %zmm1, %zmm4, %zmm4
vpaddq %zmm3, %zmm1, %zmm1
vpaddq %zmm0, %zmm4, %zmm0
jne 0x2370
vextracti64x4 $0x1, %zmm0, %ymm1
vpaddq %zmm1, %zmm0, %zmm0
vextracti128 $0x1, %ymm0, %xmm1
vpaddq %xmm1, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpaddq %xmm1, %xmm0, %xmm0
vmovq %xmm0, %rdi
movq %rdi, %rax
shrq $0x3f, %rax
addl %edi, %eax
andl $-0x2, %eax
subl %eax, %edi
vzeroupper
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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:
vpmovsxbq 0x1d75(%rip), %zmm1 # 0x4148
vpbroadcastq 0x1d63(%rip), %zmm3 # 0x4140
vpxor %xmm0, %xmm0, %xmm0
movl $0x3b9aca00, %eax       # imm = 0x3B9ACA00
vpternlogd $0xff, %zmm2, %zmm2, %zmm2
vpaddq %zmm2, %zmm1, %zmm4
addq $-0x8, %rax
vpxorq %zmm1, %zmm4, %zmm4
vpaddq %zmm3, %zmm1, %zmm1
vpaddq %zmm0, %zmm4, %zmm0
jne 0x23ed
pushq %rbp
movq %rsp, %rbp
pushq %rbx
andq $-0x20, %rsp
subq $0x40, %rsp
vextracti64x4 $0x1, %zmm0, %ymm1
vpaddq %zmm1, %zmm0, %zmm0
vextracti128 $0x1, %ymm0, %xmm1
vpaddq %xmm1, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpaddq %xmm1, %xmm0, %xmm0
vmovq %xmm0, %rdi
movq %rdi, %rax
shrq $0x3f, %rax
addl %edi, %eax
andl $-0x2, %eax
subl %eax, %edi
vzeroupper
callq 0x2170
movl $0xf4240, %esi          # imm = 0xF4240
movq %rsp, %rdi
callq 0x24b5
movq 0x3b69(%rip), %rbx      # 0x5fd0
leaq 0x1d1e(%rip), %rsi      # 0x418c
movl $0x32, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20b0
movl $0x2710, %edi           # imm = 0x2710
callq 0x267f
xorl %eax, %eax
leaq -0x8(%rbp), %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movl %esi, %r14d
callq 0x2e60
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x21a0
testl %eax, %eax
js 0x261a
testl %r14d, %r14d
jle 0x2545
vmovdqa 0x20(%rsp), %ymm1
vmovdqa 0x40(%rsp), %ymm0
movl %r14d, %eax
vpsllq $0x17, %ymm1, %ymm2
decl %eax
vpxor %ymm1, %ymm2, %ymm2
vmovdqa %ymm0, %ymm1
vpsrlq $0x1a, %ymm1, %ymm3
vpsrlq $0x11, %ymm2, %ymm0
vpxor %ymm0, %ymm3, %ymm0
vpternlogq $0x96, %ymm1, %ymm2, %ymm0
vpaddq %ymm1, %ymm0, %ymm2
vpxor %ymm4, %ymm2, %ymm4
jne 0x2503
vmovdqa %ymm0, 0x40(%rsp)
vmovdqa %ymm4, 0x60(%rsp)
vmovdqa %ymm1, 0x20(%rsp)
jmp 0x2545
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movq (%rdi), %r12
movq 0x8(%rdi), %r15
vzeroupper
callq 0x21a0
testl %eax, %eax
js 0x2638
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
leaq 0x1c4b(%rip), %rsi      # 0x41bf
movl $0x20, %edx
subq %r12, %rax
subq %r15, %rcx
vcvtsi2sd %rax, %xmm5, %xmm0
vcvtsi2sd %rcx, %xmm5, %xmm1
vfmadd132sd 0x1bbe(%rip), %xmm0, %xmm1 # xmm1 = (xmm1 * mem) + xmm0
vcvtsi2sd %r14d, %xmm5, %xmm2
vmulsd 0x1bb9(%rip), %xmm2, %xmm0 # 0x4158
vmulsd 0x1bb9(%rip), %xmm1, %xmm1 # 0x4160
vdivsd %xmm0, %xmm1, %xmm0
vmovaps 0x60(%rsp), %ymm1
vmulsd 0x1baf(%rip), %xmm0, %xmm0 # 0x4168
vmovaps %ymm1, (%rbx)
movq 0x3a0c(%rip), %rbx      # 0x5fd0
movq %rbx, %rdi
vmovsd %xmm0, 0x8(%rsp)
vzeroupper
callq 0x2150
vmovsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x2190
movq %rax, %rbx
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20b0
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2090
movq %rax, %rbx
leaq 0x1be4(%rip), %rsi      # 0x4212
movq %rax, %rdi
callq 0x2070
jmp 0x2654
movl $0x10, %edi
callq 0x2090
movq %rax, %rbx
leaq 0x1bc6(%rip), %rsi      # 0x4212
movq %rax, %rdi
callq 0x2070
movq 0x3995(%rip), %rsi      # 0x5ff0
movq 0x3966(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x21d0
jmp 0x266c
movq %rbx, %rdi
movq %rax, %r14
callq 0x20d0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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
leal 0x7(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x3, %ecx
cvtsi2sd %ecx, %xmm0
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3bcf
sqrtsd %xmm0, %xmm0
jmp 0x3bd4
callq 0x2150
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%rbx)
movl %eax, 0x10(%rbx)
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, 0x14(%rbx)
movl %ecx, 0x18(%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x4042
movq %r14, %rdi
callq 0x2250
movl %eax, %ecx
movq %rcx, 0x30(%rbx)
movl $0x7, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0x6, %ecx
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq $0x276, %rax            # imm = 0x276
jne 0x3c14
movq $0x270, 0x13b0(%rbx) # imm = 0x270
movq %rsp, %rdi
callq 0x21c0
addq $0x1388, %rsp           # imm = 0x1388
popq %rbx
popq %r14
retq
jmp 0x3c6a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2360
movq %rax, %rdi
callq 0x545c
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movl 0x10(%rdi), %ecx
movl 0xc(%rdi), %edi
imull %ecx, %edi
movl %esi, %eax
cltd
idivl %edi
movl %eax, 0x8(%r14)
imull %eax, %edi
movl %edx, %eax
cltd
idivl %ecx
movl %eax, (%r14)
imull %ecx, %eax
addl %edi, %eax
subl %eax, %esi
movl %esi, 0x4(%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x5226
movq %r14, %rdi
movl %ebp, %esi
callq 0x53d0
movsd %xmm0, (%r15)
movq %r14, %rdi
callq 0x5410
movl 0xc(%r14), %eax
imull 0x8(%r14), %eax
addl (%r14), %eax
imull 0x10(%r14), %eax
addl 0x4(%r14), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop