LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/pixel-pusher-client.cc
// Function: PixelPusherClient::SendPacket(int)
bool PixelPusherClient::SendPacket(int packet_index) {
    if (socket_ < 0) return false;
    const size_t block_size = rows_per_packet_ * row_size_;
    const size_t start = packet_index * block_size;
    const size_t end = height_ * row_size_;
    if (start >= end) return false;

    if (block_dirty_[packet_index]) {
        // Each packet has a sequence number in the beginning, but our pixel
        // buffer if contiguous.
        // So we stuff it in front atomically with writev().
        iovec parts[2];
        parts[0].iov_base = &sequence_number_;
        parts[0].iov_len = sizeof(sequence_number_);
        parts[1].iov_base = pixel_buffer_ + start;
        parts[1].iov_len = std::min(end - start, block_size);
        writev(socket_, parts, 2);

        sequence_number_++;
    }

    return (packet_index + 1) * block_size < end;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl 0x10(%rdi), %edi
testl %edi, %edi
js 0x3c6d
movl %esi, %ebx
movslq 0x20(%r14), %r15
movq 0x18(%r14), %rcx
imulq %rcx, %r15
movslq %esi, %rdx
movq %r15, %rax
imulq %rdx, %rax
movslq 0xc(%r14), %r12
imulq %rcx, %r12
movq %r12, %rcx
subq %rax, %rcx
jbe 0x3c6d
movq 0x30(%r14), %rsi
cmpb $0x1, (%rsi,%rdx)
jne 0x3c5c
leaq 0x40(%r14), %rdx
movq %rsp, %rsi
movq %rdx, (%rsi)
movq $0x4, 0x8(%rsi)
addq 0x38(%r14), %rax
movq %rax, 0x10(%rsi)
cmpq %rcx, %r15
cmovbq %r15, %rcx
movq %rcx, 0x18(%rsi)
movl $0x2, %edx
callq 0x20f0
incl 0x40(%r14)
incl %ebx
movslq %ebx, %rax
imulq %rax, %r15
cmpq %r12, %r15
setb %al
jmp 0x3c6f
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/pixel-pusher-client.cc
// Function: CreateLuminanceCIE1931LookupTable()
static ColorLookup *CreateLuminanceCIE1931LookupTable() {
  ColorLookup *for_brightness = new ColorLookup[100];
  for (int c = 0; c < 256; ++c)
    for (int b = 0; b < 100; ++b)
      for_brightness[b].color[c] = luminance_cie1931(c, b + 1);

  return for_brightness;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0xc800, %edi           # imm = 0xC800
callq 0x2040
movq %rax, %rbx
xorl %r14d, %r14d
movss 0x1723(%rip), %xmm1     # 0x53fc
movss 0x171f(%rip), %xmm2     # 0x5400
movsd 0x1737(%rip), %xmm3     # 0x5420
movq %rax, %r15
movzbl %r14b, %eax
xorps %xmm4, %xmm4
cvtsi2ss %eax, %xmm4
movq $-0xc800, %r12          # imm = 0xFFFF3800
movb $0x1, %bpl
movss %xmm4, 0xc(%rsp)
movsbl %bpl, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss %xmm4, %xmm0
divss %xmm1, %xmm0
ucomiss %xmm0, %xmm2
jae 0x3d60
addss 0x16dd(%rip), %xmm0     # 0x5404
cvtss2sd %xmm0, %xmm0
divsd 0x16dd(%rip), %xmm0     # 0x5410
movsd 0x16dd(%rip), %xmm1     # 0x5418
callq 0x2300
movss 0xc(%rsp), %xmm4
movsd 0x16d2(%rip), %xmm3     # 0x5420
movss 0x16aa(%rip), %xmm2     # 0x5400
movss 0x169e(%rip), %xmm1     # 0x53fc
jmp 0x3d6c
cvtss2sd %xmm0, %xmm0
divsd 0x169c(%rip), %xmm0     # 0x5408
mulsd %xmm3, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, 0xc800(%r15,%r12)
incb %bpl
addq $0x200, %r12            # imm = 0x200
jne 0x3d07
incq %r14
addq $0x2, %r15
cmpq $0x100, %r14            # imm = 0x100
jne 0x3cec
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/bjk-pixel-pusher.cc
// Function: BJKPixelPusher::BJKPixelPusher(int, int)
BJKPixelPusher::BJKPixelPusher(int max_udp_packet_size, int brightness) {
    for (int i = 0; i < kPixelPusherCount; ++i) {
        clients_.push_back(
            new PixelPusherClient(kStripLen, kStripsPerPP,
                                  kPixelPusherHost[i], kPixelPusherPort,
                                  max_udp_packet_size, brightness));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl %esi, %r15d
leaq 0x3f92(%rip), %rax      # 0x7d68
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x18(%rdi)
xorl %r12d, %r12d
leaq 0x1709(%rip), %r13      # 0x5504
movl $0x48, %edi
callq 0x21d0
movq %rax, %rbx
movslq (%r12,%r13), %rcx
addq %r13, %rcx
movl %ebp, (%rsp)
movq %rax, %rdi
movl $0xf0, %esi
movl $0x8, %edx
leaq 0x17a9(%rip), %r8       # 0x55cf
movl %r15d, %r9d
callq 0x385c
movq %rbx, 0x10(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x40b4
addq $0x4, %r12
cmpq $0xc, %r12
jne 0x3dfb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x48, %esi
movq %rbx, %rdi
callq 0x21e0
jmp 0x3e6e
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3e87
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
subq %rdi, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/bjk-pixel-pusher.cc
// Function: BJKPixelPusher::SetPixel(int, int, Color const&)
void BJKPixelPusher::SetPixel(int x, int y, const Color &col) {
    if (x < 0 || x >= width() || y < 0 || y >= height()) return;

    // BJK, here you need to do the mapping. This is just roughtly from
    // what I assume things are, but I might be off.

    const int columns_per_pp = kStripsPerPP * kZigZagCount;
    const int pp_index = x / columns_per_pp;
    assert(pp_index >= 0 && pp_index < (int)clients_.size());
    x %= columns_per_pp;

    int strip = x / kZigZagCount;
    int strip_offset = x % kZigZagCount * height();
    int strip_pos = ((x + strip) % 2 == 0) ? y : height() - 1 - y; // Zigzag
    clients_[pp_index]->SetPixel(strip_offset + strip_pos, strip, col);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
js 0x4013
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
testl %ebp, %ebp
js 0x4013
cmpl %r15d, %eax
jle 0x4013
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
cmpl %ebp, %eax
jle 0x4013
movq %rbx, 0x10(%rsp)
movl %r15d, %eax
movl $0xcccccccd, %ebx       # imm = 0xCCCCCCCD
imulq %rax, %rbx
shrq $0x25, %rbx
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
shrq $0x3, %rax
cmpl %eax, %ebx
jge 0x4022
leal (,%rbx,8), %eax
leal (%rax,%rax,4), %eax
subl %eax, %r15d
movzbl %r15b, %eax
imull $0xcd, %eax, %r12d
shrl $0xa, %r12d
leal (%r12,%r12,4), %ecx
subb %cl, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl %eax, %r13d
imull 0xc(%rsp), %r13d
addl %r12d, %r15d
testb $0x1, %r15b
je 0x3fe5
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
notl %ebp
addl %eax, %ebp
addl %r13d, %ebp
movq 0x8(%r14), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl %ebp, %esi
movl %r12d, %edx
movq 0x10(%rsp), %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14f8(%rip), %rdi      # 0x5521
leaq 0x1522(%rip), %rsi      # 0x5552
leaq 0x152f(%rip), %rcx      # 0x5566
movl $0x44, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/bjk-pixel-pusher.cc
// Function: BJKPixelPusher::Send()
void BJKPixelPusher::Send() {
    bool need_more_packets = true;
    for (int packet = 0; need_more_packets; ++packet) {
        need_more_packets = false;
        for (size_t i = 0; i < clients_.size(); ++i) {
            need_more_packets |= clients_[i]->SendPacket(packet);
        }
        usleep(3000);  // PixelPushers need some time to digest
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x40a0
xorl %r15d, %r15d
xorl %r14d, %r14d
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
callq 0x3be2
orb %al, %r14b
incq %r15
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x405e
movl $0xbb8, %edi            # imm = 0xBB8
callq 0x2280
incl %ebp
testb $0x1, %r14b
jne 0x404e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xbb8, %edi            # imm = 0xBB8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/tests/teststops.cpp
// Function: pulse(void*, void*, unsigned int, double, unsigned int, void*)
int pulse( void *outputBuffer, void * /*inputBuffer*/, unsigned int nBufferFrames,
           double /*streamTime*/, RtAudioStreamStatus status, void *mydata )
{
  // Write out a pulse signal and ignore the input buffer.
  unsigned int i, j;
  float sample;
  float *buffer = (float *) outputBuffer;
  MyData *data = (MyData *) mydata;

  if ( status ) std::cout << "Stream over/underflow detected!" << std::endl;

  for ( i=0; i<nBufferFrames; i++ ) {
    if ( data->frameCounter % data->pulseCount == 0 ) sample = 0.9f;
    else sample = 0.0;
    for ( j=0; j<data->channels; j++ )
      *buffer++ = sample;

    data->frameCounter++;
  }

  if ( data->frameCounter >= data->nFrames )
    return data->returnValue;
  else
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %edx, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0x4669
movq 0x899a(%rip), %r15      # 0xcfc8
leaq 0x4b8e(%rip), %rsi      # 0x91c3
movl $0x1f, %edx
movq %r15, %rdi
callq 0x4200
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4140
testl %ebp, %ebp
je 0x46b2
movl (%rbx), %esi
movl 0x4(%rbx), %edi
movl 0x8(%rbx), %ecx
xorl %r8d, %r8d
movss 0x4984(%rip), %xmm0     # 0x9004
movl %ecx, %eax
xorl %edx, %edx
divl %edi
movaps %xmm0, %xmm1
testl %edx, %edx
je 0x4690
xorps %xmm1, %xmm1
testl %esi, %esi
je 0x46a3
movl %esi, %eax
movss %xmm1, (%r14)
addq $0x4, %r14
decl %eax
jne 0x4696
incl %ecx
incl %r8d
cmpl %ebp, %r8d
jne 0x4680
movl %ecx, 0x8(%rbx)
jmp 0x46b5
movl 0x8(%rbx), %ecx
xorl %eax, %eax
cmpl 0xc(%rbx), %ecx
jb 0x46bf
movl 0x10(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtAudio::RtAudio(RtAudio::Api)
RtAudio :: RtAudio( RtAudio::Api api )
{
  rtapi_ = 0;

  if ( api != UNSPECIFIED ) {
    // Attempt to open the specified API.
    openRtApi( api );
    if ( rtapi_ ) return;

    // No compiled support for specified API value.  Issue a debug
    // warning and continue as if no API was specified.
    std::cerr << "\nRtAudio: no compiled support for specified API argument!\n" << std::endl;
  }

  // Iterate through the compiled APIs and return as soon as we find
  // one with at least one device or we reach the end of the list.
  std::vector< RtAudio::Api > apis;
  getCompiledApi( apis );
  for ( unsigned int i=0; i<apis.size(); i++ ) {
    openRtApi( apis[i] );
    if ( rtapi_ && rtapi_->getDeviceCount() ) break;
  }

  if ( rtapi_ ) return;

  // It should not be possible to get here because the preprocessor
  // definition __RTAUDIO_DUMMY__ is automatically defined if no
  // API-specific definitions are passed to the compiler. But just in
  // case something weird happens, we'll thow an error.
  std::string errorText = "\nRtAudio: no compiled API support found ... critical error!!\n\n";
  throw( RtAudioError( errorText, RtAudioError::UNSPECIFIED ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq $0x0, (%rdi)
testl %esi, %esi
je 0x5018
movq %rbx, %rdi
callq 0x4f26
cmpq $0x0, (%rbx)
jne 0x5094
movq 0x8013(%rip), %r14      # 0xcff0
leaq 0x45a6(%rip), %rsi      # 0x958a
movl $0x3a, %edx
movq %r14, %rdi
callq 0x4200
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x41c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4140
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %r14, %rdi
callq 0x4ee0
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x5078
movl $0x1, %ebp
xorl %ecx, %ecx
movl (%rax,%rcx,4), %esi
movq %rbx, %rdi
callq 0x4f26
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x505f
movq (%rdi), %rax
callq *0x18(%rax)
testl %eax, %eax
jne 0x5078
movl %ebp, %ecx
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x5042
cmpq $0x0, (%rbx)
je 0x509d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5094
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x41f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4518(%rip), %rsi      # 0x95c5
leaq 0x454f(%rip), %rdx      # 0x9603
leaq 0x20(%rsp), %rdi
callq 0x8298
movl $0x30, %edi
callq 0x40d0
movq %rax, %rbx
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
movl $0x2, %edx
callq 0x80a4
leaq 0x7b14(%rip), %rsi      # 0xcbf8
leaq 0x2fff(%rip), %rdx      # 0x80ea
movq %rbx, %rdi
callq 0x43a0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x5114
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x41f0
jmp 0x5114
jmp 0x5111
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x512a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x41f0
movq %rbx, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::RtApi()
RtApi :: RtApi()
{
  stream_.state = STREAM_CLOSED;
  stream_.mode = UNINITIALIZED;
  stream_.apiHandle = 0;
  stream_.userBuffer[0] = 0;
  stream_.userBuffer[1] = 0;
  MUTEX_INITIALIZE( &stream_.mutex );
  showWarnings_ = true;
  firstErrorOccurred_ = false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x780a(%rip), %rax      # 0xcc20
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x4270
leaq 0x190(%rbx), %rax
movq %rax, 0x180(%rbx)
xorl %r14d, %r14d
movq %r14, 0x188(%rbx)
movb %r14b, 0x190(%rbx)
movq %r14, 0x1d0(%rbx)
movq %r14, 0x258(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x268(%rbx)
movups %xmm0, 0x278(%rbx)
movw $0x0, 0x288(%rbx)
movups %xmm0, 0x2b0(%rbx)
movups %xmm0, 0x2c0(%rbx)
movups %xmm0, 0x2d0(%rbx)
movups %xmm0, 0x300(%rbx)
movups %xmm0, 0x310(%rbx)
movups %xmm0, 0x320(%rbx)
movabsq $0x2b6700002b67, %rax   # imm = 0x2B6700002B67
movq %rax, 0x1a8(%rbx)
movabsq $-0x310000004b, %rax    # imm = 0xFFFFFFCEFFFFFFB5
movq %rax, 0x1b8(%rbx)
movq %r14, 0x1b0(%rbx)
leaq 0x230(%rbx), %rdi
movups %xmm0, 0x1c0(%rbx)
xorl %esi, %esi
callq 0x42d0
movb $0x1, 0x1a0(%rbx)
movb %r14b, 0x348(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::error(RtAudioError::Type)
void RtApi :: error( RtAudioError::Type type )
{
  errorStream_.str(""); // clear the ostringstream

  RtAudioErrorCallback errorCallback = (RtAudioErrorCallback) stream_.callbackInfo.errorCallback;
  if ( errorCallback ) {
    // abortStream() can generate new error messages. Ignore them. Just keep original one.

    if ( firstErrorOccurred_ )
      return;

    firstErrorOccurred_ = true;
    const std::string errorMessage = errorText_;

    if ( type != RtAudioError::WARNING && stream_.state != STREAM_STOPPED) {
      stream_.callbackInfo.isRunning = false; // exit from the thread
      abortStream();
    }

    errorCallback( type, errorMessage );
    firstErrorOccurred_ = false;
    return;
  }

  if ( type == RtAudioError::WARNING && showWarnings_ == true )
    std::cerr << '\n' << errorText_ << "\n\n";
  else if ( type != RtAudioError::WARNING )
    throw( RtAudioError( errorText_, type ) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4052(%rip), %rdx      # 0x9603
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x8298
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x42e0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x55e3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41f0
movq 0x278(%rbx), %r15
testq %r15, %r15
je 0x5668
cmpb $0x0, 0x348(%rbx)
jne 0x56b8
movb $0x1, 0x348(%rbx)
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movq 0x180(%rbx), %rsi
movq 0x188(%rbx), %rdx
addq %rsi, %rdx
callq 0x8202
testl %ebp, %ebp
je 0x563e
cmpl $0x0, 0x1bc(%rbx)
je 0x563e
movb $0x0, 0x288(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
leaq 0x8(%rsp), %rsi
movl %ebp, %edi
callq *%r15
movb $0x0, 0x348(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x56b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41f0
jmp 0x56b8
testl %ebp, %ebp
jne 0x56c3
cmpb $0x1, 0x1a0(%rbx)
jne 0x56b8
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x796c(%rip), %rdi      # 0xcff0
movl $0x1, %edx
callq 0x4200
movq 0x180(%rbx), %rsi
movq 0x188(%rbx), %rdx
movq %rax, %rdi
callq 0x4200
leaq 0x3f56(%rip), %rsi      # 0x9601
movl $0x2, %edx
movq %rax, %rdi
callq 0x4200
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x40d0
movq %rax, %r14
addq $0x180, %rbx            # imm = 0x180
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x80a4
leaq 0x750d(%rip), %rsi      # 0xcbf8
leaq 0x29f8(%rip), %rdx      # 0x80ea
movq %r14, %rdi
callq 0x43a0
jmp 0x56fc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x571b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41f0
jmp 0x571b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::clearStreamInfo()
void RtApi :: clearStreamInfo()
{
  stream_.mode = UNINITIALIZED;
  stream_.state = STREAM_CLOSED;
  stream_.sampleRate = 0;
  stream_.bufferSize = 0;
  stream_.nBuffers = 0;
  stream_.userFormat = 0;
  stream_.userInterleaved = true;
  stream_.streamTime = 0.0;
  stream_.apiHandle = 0;
  stream_.deviceBuffer = 0;
  stream_.callbackInfo.callback = 0;
  stream_.callbackInfo.userData = 0;
  stream_.callbackInfo.isRunning = false;
  stream_.callbackInfo.errorCallback = 0;
  for ( int i=0; i<2; i++ ) {
    stream_.device[i] = 11111;
    stream_.doConvertBuffer[i] = false;
    stream_.deviceInterleaved[i] = true;
    stream_.doByteSwap[i] = false;
    stream_.nUserChannels[i] = 0;
    stream_.nDeviceChannels[i] = 0;
    stream_.channelOffset[i] = 0;
    stream_.deviceFormat[i] = 0;
    stream_.latency[i] = 0;
    stream_.userBuffer[i] = 0;
    stream_.convertInfo[i].channels = 0;
    stream_.convertInfo[i].inJump = 0;
    stream_.convertInfo[i].outJump = 0;
    stream_.convertInfo[i].inFormat = 0;
    stream_.convertInfo[i].outFormat = 0;
    stream_.convertInfo[i].inOffset.clear();
    stream_.convertInfo[i].outOffset.clear();
  }
}

// Assembly:
movabsq $-0x310000004b, %rax    # imm = 0xFFFFFFCEFFFFFFB5
movq %rax, 0x1b8(%rdi)
xorl %eax, %eax
movq %rax, 0x1e0(%rdi)
movl $0x0, 0x1e8(%rdi)
movq %rax, 0x218(%rdi)
movb $0x1, 0x1da(%rdi)
movq %rax, 0x330(%rdi)
movq %rax, 0x1b0(%rdi)
movq %rax, 0x1d0(%rdi)
movb $0x0, 0x288(%rdi)
leaq 0x290(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x268(%rdi)
movq %rax, 0x278(%rdi)
movb $0x1, %dl
xorl %esi, %esi
movl $0x2b67, 0x1a8(%rdi,%rsi,4) # imm = 0x2B67
movb %al, 0x1d8(%rdi,%rsi)
movb $0x1, 0x1db(%rdi,%rsi)
movb %al, 0x1dd(%rdi,%rsi)
movl %eax, 0x1ec(%rdi,%rsi,4)
movl %eax, 0x1f4(%rdi,%rsi,4)
movl %eax, 0x1fc(%rdi,%rsi,4)
movq %rax, 0x220(%rdi,%rsi,8)
movq %rax, 0x208(%rdi,%rsi,8)
movq %rax, 0x1c0(%rdi,%rsi,8)
leaq (%rsi,%rsi,4), %r9
shlq $0x4, %r9
leaq (%rcx,%r9), %rsi
movq %rax, (%rcx,%r9)
movl %eax, 0x8(%rcx,%r9)
movups %xmm0, 0x10(%rcx,%r9)
movq 0x20(%rcx,%r9), %r8
cmpq %r8, 0x28(%rcx,%r9)
je 0x5807
movq %r8, 0x28(%rsi)
movq 0x38(%rsi), %r8
cmpq %r8, 0x40(%rsi)
je 0x5815
movq %r8, 0x40(%rsi)
movl $0x1, %esi
testb $0x1, %dl
movl $0x0, %edx
jne 0x578e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::formatBytes(unsigned long)
unsigned int RtApi :: formatBytes( RtAudioFormat format )
{
  if ( format == RTAUDIO_SINT16 )
    return 2;
  else if ( format == RTAUDIO_SINT32 || format == RTAUDIO_FLOAT32 )
    return 4;
  else if ( format == RTAUDIO_FLOAT64 )
    return 8;
  else if ( format == RTAUDIO_SINT24 )
    return 3;
  else if ( format == RTAUDIO_SINT8 )
    return 1;

  errorText_ = "RtApi::formatBytes: undefined format.";
  error( RtAudioError::WARNING );

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x1(%rsi), %rax
cmpq $0x7, %rax
ja 0x5853
leaq 0x3b2e(%rip), %rcx      # 0x9370
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %r14d
jmp 0x58ae
cmpq $0x10, %rsi
je 0x5867
cmpq $0x20, %rsi
jne 0x586f
movl $0x8, %r14d
jmp 0x58ae
movl $0x4, %r14d
jmp 0x58ae
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x442b(%rip), %rcx      # 0x9caf
xorl %r14d, %r14d
movl $0x25, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5592
jmp 0x58ae
movl $0x3, %r14d
jmp 0x58ae
movl $0x2, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::getStreamLatency()
long RtApi :: getStreamLatency( void )
{
  verifyStream();

  long totalLatency = 0;
  if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX )
    totalLatency = stream_.latency[0];
  if ( stream_.mode == INPUT || stream_.mode == DUPLEX )
    totalLatency += stream_.latency[1];

  return totalLatency;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5938
movl 0x1b8(%rbx), %eax
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jne 0x591f
movq 0x208(%rbx), %rcx
jmp 0x5921
xorl %ecx, %ecx
decl %eax
cmpl $0x2, %eax
jae 0x5931
movq 0x210(%rbx), %rax
jmp 0x5933
xorl %eax, %eax
addq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApi::getStreamTime()
double RtApi :: getStreamTime( void )
{
  verifyStream();

#if defined( HAVE_GETTIMEOFDAY )
  // Return a very accurate estimate of the stream time by
  // adding in the elapsed time since the last tick.
  struct timeval then;
  struct timeval now;

  if ( stream_.state != STREAM_RUNNING || stream_.streamTime == 0.0 )
    return stream_.streamTime;

  gettimeofday( &now, NULL );
  then = stream_.lastTickTimestamp;
  return stream_.streamTime +
    ((now.tv_sec + 0.000001 * now.tv_usec) -
     (then.tv_sec + 0.000001 * then.tv_usec));     
#else
  return stream_.streamTime;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x5938
cmpl $0x2, 0x1bc(%rbx)
movsd 0x330(%rbx), %xmm0
jne 0x59fb
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x59a2
jnp 0x59fb
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x4350
xorps %xmm1, %xmm1
cvtsi2sdq (%r14), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%r14), %xmm0
movsd 0x3b4e(%rip), %xmm2     # 0x9518
mulsd %xmm2, %xmm0
cvtsi2sdq 0x338(%rbx), %xmm3
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x340(%rbx), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
subsd %xmm1, %xmm0
addsd 0x330(%rbx), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApiPulse::getDeviceInfo(unsigned int)
RtAudio::DeviceInfo RtApiPulse::getDeviceInfo( unsigned int /*device*/ )
{
  RtAudio::DeviceInfo info;
  info.probed = true;
  info.name = "PulseAudio";
  info.outputChannels = 2;
  info.inputChannels = 2;
  info.duplexChannels = 2;
  info.isDefaultOutput = true;
  info.isDefaultInput = true;

  for ( const unsigned int *sr = SUPPORTED_SAMPLERATES; *sr; ++sr )
    info.sampleRates.push_back( *sr );

  info.preferredSampleRate = 48000;
  info.nativeFormats = RTAUDIO_SINT16 | RTAUDIO_SINT32 | RTAUDIO_FLOAT32;

  return info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movq %rax, 0x58(%rbx)
movq %rax, 0x28(%rbx)
movq %rax, 0x2e(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x44(%rbx)
movb $0x1, (%rbx)
leaq 0x3d2d(%rip), %rcx      # 0x980e
movl $0xa, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4310
leaq 0x38(%rbx), %r14
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rax, 0x28(%rbx)
movl $0x2, 0x30(%rbx)
movw $0x101, 0x34(%rbx)      # imm = 0x101
leaq 0x398a(%rip), %r15      # 0x94a0
movl $0x1f40, %eax           # imm = 0x1F40
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x5b31
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x40(%rbx)
jmp 0x5b3c
movq %r14, %rdi
movq %r15, %rdx
callq 0x84b8
movl 0x4(%r15), %eax
addq $0x4, %r15
testl %eax, %eax
jne 0x5b1b
movl $0xbb80, 0x50(%rbx)     # imm = 0xBB80
movq $0x1a, 0x58(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5b62
movq %rax, %r14
movq %rbx, %rdi
callq 0x814a
movq %r14, %rdi
callq 0x43b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApiPulse::closeStream()
void RtApiPulse::closeStream( void )
{
  PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );

  stream_.callbackInfo.isRunning = false;
  if ( pah ) {
    MUTEX_LOCK( &stream_.mutex );
    if ( stream_.state == STREAM_STOPPED ) {
      pah->runnable = true;
      pthread_cond_signal( &pah->runnable_cv );
    }
    MUTEX_UNLOCK( &stream_.mutex );

    pthread_join( pah->thread, 0 );
    if ( pah->s_play ) {
      pa_simple_flush( pah->s_play, NULL );
      pa_simple_free( pah->s_play );
    }
    if ( pah->s_rec )
      pa_simple_free( pah->s_rec );

    pthread_cond_destroy( &pah->runnable_cv );
    delete pah;
    stream_.apiHandle = 0;
  }

  if ( stream_.userBuffer[0] ) {
    free( stream_.userBuffer[0] );
    stream_.userBuffer[0] = 0;
  }
  if ( stream_.userBuffer[1] ) {
    free( stream_.userBuffer[1] );
    stream_.userBuffer[1] = 0;
  }

  stream_.state = STREAM_CLOSED;
  stream_.mode = UNINITIALIZED;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1b0(%rdi), %r14
movb $0x0, 0x288(%rdi)
testq %r14, %r14
je 0x5c10
leaq 0x230(%rbx), %r15
movq %r15, %rdi
callq 0x42b0
cmpl $0x0, 0x1bc(%rbx)
jne 0x5bb7
movb $0x1, 0x48(%r14)
leaq 0x18(%r14), %rdi
callq 0x4030
movq %r15, %rdi
callq 0x4160
movq 0x10(%r14), %rdi
xorl %esi, %esi
callq 0x41a0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5be1
xorl %esi, %esi
callq 0x4080
movq (%r14), %rdi
callq 0x4370
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x5bef
callq 0x4370
leaq 0x18(%r14), %rdi
callq 0x4400
movl $0x50, %esi
movq %r14, %rdi
callq 0x41f0
movq $0x0, 0x1b0(%rbx)
movq 0x1c0(%rbx), %rdi
testq %rdi, %rdi
je 0x5c2c
callq 0x4230
movq $0x0, 0x1c0(%rbx)
movq 0x1c8(%rbx), %rdi
testq %rdi, %rdi
je 0x5c48
callq 0x4230
movq $0x0, 0x1c8(%rbx)
movabsq $-0x310000004b, %rax    # imm = 0xFFFFFFCEFFFFFFB5
movq %rax, 0x1b8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApiPulse::startStream()
void RtApiPulse::startStream( void )
{
  PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );

  if ( stream_.state == STREAM_CLOSED ) {
    errorText_ = "RtApiPulse::startStream(): the stream is not open!";
    error( RtAudioError::INVALID_USE );
    return;
  }
  if ( stream_.state == STREAM_RUNNING ) {
    errorText_ = "RtApiPulse::startStream(): the stream is already running!";
    error( RtAudioError::WARNING );
    return;
  }

  MUTEX_LOCK( &stream_.mutex );

  stream_.state = STREAM_RUNNING;

  pah->runnable = true;
  pthread_cond_signal( &pah->runnable_cv );
  MUTEX_UNLOCK( &stream_.mutex );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x1bc(%rdi), %eax
cmpl $0x2, %eax
je 0x72d0
cmpl $-0x32, %eax
jne 0x7301
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x260a(%rip), %rcx      # 0x98c3
movl $0x32, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
movl $0x7, %esi
jmp 0x72f7
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x2611(%rip), %rcx      # 0x98f6
movl $0x39, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x5592
movq 0x1b0(%rbx), %r14
leaq 0x230(%rbx), %r15
movq %r15, %rdi
callq 0x42b0
movl $0x2, 0x1bc(%rbx)
movb $0x1, 0x48(%r14)
addq $0x18, %r14
movq %r14, %rdi
callq 0x4030
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4160
nop
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApiPulse::stopStream()
void RtApiPulse::stopStream( void )
{
  PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );

  if ( stream_.state == STREAM_CLOSED ) {
    errorText_ = "RtApiPulse::stopStream(): the stream is not open!";
    error( RtAudioError::INVALID_USE );
    return;
  }
  if ( stream_.state == STREAM_STOPPED ) {
    errorText_ = "RtApiPulse::stopStream(): the stream is already stopped!";
    error( RtAudioError::WARNING );
    return;
  }

  stream_.state = STREAM_STOPPED;
  MUTEX_LOCK( &stream_.mutex );

  if ( pah && pah->s_play ) {
    int pa_error;
    if ( pa_simple_drain( pah->s_play, &pa_error ) < 0 ) {
      errorStream_ << "RtApiPulse::stopStream: error draining output device, " <<
        pa_strerror( pa_error ) << ".";
      errorText_ = errorStream_.str();
      MUTEX_UNLOCK( &stream_.mutex );
      error( RtAudioError::SYSTEM_ERROR );
      return;
    }
  }

  stream_.state = STREAM_STOPPED;
  MUTEX_UNLOCK( &stream_.mutex );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x1bc(%rdi), %eax
testl %eax, %eax
je 0x7389
cmpl $-0x32, %eax
jne 0x73c0
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x25be(%rip), %rcx      # 0x9930
movl $0x31, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
movl $0x7, %esi
jmp 0x73b0
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x25c4(%rip), %rcx      # 0x9962
movl $0x38, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
xorl %esi, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5592
movq 0x1b0(%rbx), %r15
movl $0x0, 0x1bc(%rbx)
leaq 0x230(%rbx), %r14
movq %r14, %rdi
callq 0x42b0
testq %r15, %r15
je 0x73fb
movq (%r15), %rdi
testq %rdi, %rdi
je 0x73fb
leaq 0x4(%rsp), %rsi
callq 0x40b0
testl %eax, %eax
js 0x7419
movl $0x0, 0x1bc(%rbx)
movq %r14, %rdi
callq 0x4160
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8(%rbx), %r15
leaq 0x2577(%rip), %rsi      # 0x999b
movl $0x36, %edx
movq %r15, %rdi
callq 0x4200
movl 0x4(%rsp), %edi
callq 0x4050
testq %rax, %rax
je 0x745a
movq %rax, %r12
movq %rax, %rdi
callq 0x40c0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4200
jmp 0x7472
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x4390
leaq 0x2816(%rip), %rsi      # 0x9c8f
movl $0x1, %edx
movq %r15, %rdi
callq 0x4200
leaq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4340
leaq 0x180(%rbx), %rdi
movq %r15, %rsi
callq 0x4260
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x74c0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41f0
movq %r14, %rdi
callq 0x4160
movq %rbx, %rdi
movl $0x9, %esi
callq 0x5592
jmp 0x740d
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApiPulse::abortStream()
void RtApiPulse::abortStream( void )
{
  PulseAudioHandle *pah = static_cast<PulseAudioHandle*>( stream_.apiHandle );

  if ( stream_.state == STREAM_CLOSED ) {
    errorText_ = "RtApiPulse::abortStream(): the stream is not open!";
    error( RtAudioError::INVALID_USE );
    return;
  }
  if ( stream_.state == STREAM_STOPPED ) {
    errorText_ = "RtApiPulse::abortStream(): the stream is already stopped!";
    error( RtAudioError::WARNING );
    return;
  }

  stream_.state = STREAM_STOPPED;
  MUTEX_LOCK( &stream_.mutex );

  if ( pah && pah->s_play ) {
    int pa_error;
    if ( pa_simple_flush( pah->s_play, &pa_error ) < 0 ) {
      errorStream_ << "RtApiPulse::abortStream: error flushing output device, " <<
        pa_strerror( pa_error ) << ".";
      errorText_ = errorStream_.str();
      MUTEX_UNLOCK( &stream_.mutex );
      error( RtAudioError::SYSTEM_ERROR );
      return;
    }
  }

  stream_.state = STREAM_STOPPED;
  MUTEX_UNLOCK( &stream_.mutex );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x1bc(%rdi), %eax
testl %eax, %eax
je 0x7523
cmpl $-0x32, %eax
jne 0x755a
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x24c6(%rip), %rcx      # 0x99d2
movl $0x32, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
movl $0x7, %esi
jmp 0x754a
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x24cd(%rip), %rcx      # 0x9a05
movl $0x39, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
xorl %esi, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5592
movq 0x1b0(%rbx), %r15
movl $0x0, 0x1bc(%rbx)
leaq 0x230(%rbx), %r14
movq %r14, %rdi
callq 0x42b0
testq %r15, %r15
je 0x7595
movq (%r15), %rdi
testq %rdi, %rdi
je 0x7595
leaq 0x4(%rsp), %rsi
callq 0x4080
testl %eax, %eax
js 0x75b3
movl $0x0, 0x1bc(%rbx)
movq %r14, %rdi
callq 0x4160
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8(%rbx), %r15
leaq 0x2481(%rip), %rsi      # 0x9a3f
movl $0x37, %edx
movq %r15, %rdi
callq 0x4200
movl 0x4(%rsp), %edi
callq 0x4050
testq %rax, %rax
je 0x75f4
movq %rax, %r12
movq %rax, %rdi
callq 0x40c0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4200
jmp 0x760c
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x4390
leaq 0x267c(%rip), %rsi      # 0x9c8f
movl $0x1, %edx
movq %r15, %rdi
callq 0x4200
leaq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4340
leaq 0x180(%rbx), %rdi
movq %r15, %rsi
callq 0x4260
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x765a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41f0
movq %r14, %rdi
callq 0x4160
movq %rbx, %rdi
movl $0x9, %esi
callq 0x5592
jmp 0x75a7
// File: /workspace/github_cpp_makefile_star2_O3/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: pulseaudio_callback(void*)
static void *pulseaudio_callback( void * user )
{
  CallbackInfo *cbi = static_cast<CallbackInfo *>( user );
  RtApiPulse *context = static_cast<RtApiPulse *>( cbi->object );
  volatile bool *isRunning = &cbi->isRunning;

  while ( *isRunning ) {
    pthread_testcancel();
    context->callbackEvent();
  }

  pthread_exit( NULL );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movb 0x30(%rdi), %al
cmpb $0x1, %al
jne 0x7fd8
movq %rdi, %rbx
callq 0x4130
movq %r14, %rdi
callq 0x5c60
cmpb $0x0, 0x30(%rbx)
jne 0x7fc5
xorl %edi, %edi
callq 0x43c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Razakhel[P]RaZonogram/./include/Utils.hpp
// Function: Utils::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
static void split(const std::string& str, char delim, std::vector<std::string>& elems) {
    std::stringstream ss;
    ss.str(str);

    std::string item;
    while (std::getline(ss, item, delim)) {
      if (!item.empty()) elems.push_back(item);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
callq 0x20f0
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x21b0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x3b, %edx
callq 0x2250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2a67
cmpq $0x0, 0x8(%rsp)
je 0x2a34
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35f8
jmp 0x2a34
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2a7d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x552c(%rip), %rsi      # 0x7fb0
leaq 0x20(%rsp), %rdi
callq 0x2110
leaq 0xa0(%rsp), %rdi
callq 0x2060
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x2ac8
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2ac8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x54e1(%rip), %rsi      # 0x7fb0
leaq 0x20(%rsp), %rdi
callq 0x2110
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/Razakhel[P]RaZonogram/src/Grid.cpp
// Function: Grid::isComplete()
const bool Grid::isComplete() { // TODO: finalize completion check (parse every row and check its own tiles)
  unsigned int neededClues = 0, totalClues = 0;

  for (unsigned int i = 0; i < rowClues.size(); ++i) {
    for (unsigned int width = 0; width < boardWidth; ++width)
      if (board[i][width].state == State::FILLED)
        ++totalClues;

    for (unsigned int j = 0; j < rowClues[i].size(); ++j)
      neededClues += rowClues[i][j];
  }

  std::cout << "totalClues = " << totalClues << ", neededClues = " << neededClues << std::endl;

  if (totalClues == neededClues)
    return true;

  return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rdx
subq %rax, %rdx
je 0x2e43
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movl 0x4(%rdi), %edx
movq 0x38(%rdi), %rsi
xorl %edi, %edi
xorl %r14d, %r14d
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x2e0e
leaq (%rdi,%rdi,2), %r8
movq (%rsi,%r8,8), %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpl $0x1, (%r8,%r9,4)
sete %r10b
addl %r10d, %r14d
incq %r9
cmpq %r9, %rdx
jne 0x2df7
leaq (%rdi,%rdi,2), %r9
movq (%rax,%r9,8), %r8
movq 0x8(%rax,%r9,8), %r9
subq %r8, %r9
je 0x2e36
sarq $0x2, %r9
xorl %r10d, %r10d
addl (%r8,%r10,4), %ebp
incq %r10
movl %r10d, %r11d
cmpq %r11, %r9
ja 0x2e27
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x2de7
jmp 0x2e48
xorl %ebp, %ebp
xorl %r14d, %r14d
movq 0x5179(%rip), %rbx      # 0x7fc8
leaq 0x224a(%rip), %rsi      # 0x50a0
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2190
movl %r14d, %esi
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x2236(%rip), %rsi      # 0x50ae
movl $0x10, %edx
movq %rax, %rdi
callq 0x2190
movl %ebp, %esi
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
cmpl %ebp, %r14d
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/moyix[P]pandalog_taint_parser/label_pcs.cpp
// Function: decompress_chunk(unsigned char**, unsigned char*, unsigned long*)
unsigned long decompress_chunk(uint8_t **outbuf, uint8_t *chunk, unsigned long *chunk_size) {
    unsigned long uncompressed_size = *chunk_size;
    while (true) {
        int ret = uncompress(*outbuf, &uncompressed_size, chunk, *chunk_size);
        if (ret == Z_BUF_ERROR) {
            *chunk_size *= 2;
            *outbuf = (uint8_t *) realloc(*outbuf, *chunk_size);
            uncompressed_size = *chunk_size;
        }
        else if (ret == Z_OK) {
            break;
        }
        else {
            printf("Some other zlib error, %d\n", ret);
            exit(1);
        }
    }
    return uncompressed_size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq %rsp, %r12
movq (%rbx), %rcx
movq %rcx, (%rsp)
movq %r12, %rsi
movq %r14, %rdx
callq 0x6130
cmpl $-0x5, %eax
jne 0x7003
movq (%rbx), %rsi
addq %rsi, %rsi
movq %rsi, (%rbx)
movq (%r15), %rdi
callq 0x6570
movq %rax, %rdi
movq %rax, (%r15)
jmp 0x6fd3
testl %eax, %eax
jne 0x7017
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x12002(%rip), %rdi     # 0x19020
movl %eax, %esi
xorl %eax, %eax
callq 0x6030
movl $0x1, %edi
callq 0x63c0
// File: /workspace/github_cpp_makefile_star2_O3/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_AttackPoint_plog_2eproto()
static void InitDefaultsscc_info_AttackPoint_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::panda::_AttackPoint_default_instance_;
    new (ptr) ::panda::AttackPoint();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::panda::AttackPoint::InitAsDefaultInstance();
}

// Assembly:
pushq %rax
leaq 0x116ca(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
xorps %xmm0, %xmm0
movups %xmm0, 0x1bdcb(%rip)    # 0x248a0
leaq 0x1ac4c(%rip), %rax     # 0x23728
movq %rax, 0x1bdb5(%rip)     # 0x24898
movl 0x1b847(%rip), %eax     # 0x24330
testl %eax, %eax
jne 0x8b2f
movups %xmm0, 0x1bdbc(%rip)    # 0x248b0
movl $0x0, 0x1bdc2(%rip)     # 0x248c0
leaq 0x1bd93(%rip), %rsi     # 0x24898
movq 0x1b4c4(%rip), %rdi     # 0x23fd0
callq 0x6060
leaq 0x1bbc0(%rip), %rax     # 0x246d8
movq %rax, 0x1bd91(%rip)     # 0x248b0
leaq 0x1bd12(%rip), %rax     # 0x24838
movq %rax, 0x1bd8b(%rip)     # 0x248b8
popq %rax
retq
leaq 0x1b7fa(%rip), %rdi     # 0x24330
callq 0x63d0
xorps %xmm0, %xmm0
jmp 0x8aed
// File: /workspace/github_cpp_makefile_star2_O3/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_AttackPointPri_plog_2eproto()
static void InitDefaultsscc_info_AttackPointPri_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::panda::_AttackPointPri_default_instance_;
    new (ptr) ::panda::AttackPointPri();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::panda::AttackPointPri::InitAsDefaultInstance();
}

// Assembly:
pushq %rax
leaq 0x1163e(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
xorps %xmm0, %xmm0
movups %xmm0, 0x1bc1f(%rip)    # 0x24780
leaq 0x1a850(%rip), %rax     # 0x233b8
movq %rax, 0x1bc09(%rip)     # 0x24778
movl 0x1b7e3(%rip), %eax     # 0x24358
testl %eax, %eax
jne 0x8bbb
movups %xmm0, 0x1bc10(%rip)    # 0x24790
movl $0x0, 0x1bc16(%rip)     # 0x247a0
leaq 0x1bbe7(%rip), %rsi     # 0x24778
movq 0x1b438(%rip), %rdi     # 0x23fd0
callq 0x6060
leaq 0x1bb34(%rip), %rax     # 0x246d8
movq %rax, 0x1bbe5(%rip)     # 0x24790
leaq 0x1bb8e(%rip), %rax     # 0x24740
movq %rax, 0x1bbdf(%rip)     # 0x24798
popq %rax
retq
leaq 0x1b796(%rip), %rdi     # 0x24358
callq 0x63d0
xorps %xmm0, %xmm0
jmp 0x8b79
// File: /workspace/github_cpp_makefile_star2_O3/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_LogEntry_plog_2eproto()
static void InitDefaultsscc_info_LogEntry_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::panda::_LogEntry_default_instance_;
    new (ptr) ::panda::LogEntry();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::panda::LogEntry::InitAsDefaultInstance();
}

// Assembly:
pushq %rbx
leaq 0x11522(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
xorps %xmm0, %xmm0
movups %xmm0, 0x1bd73(%rip)    # 0x249f0
leaq 0x1aec4(%rip), %rax     # 0x23b48
movq %rax, 0x1bd5d(%rip)     # 0x249e8
movl 0x1b71f(%rip), %eax     # 0x243b0
testl %eax, %eax
jne 0x8d73
movq 0x1b320(%rip), %rax     # 0x23fc0
movq %rax, 0x1bd59(%rip)     # 0x24a00
leaq 0x1bd3a(%rip), %rbx     # 0x249e8
leaq 0x1bd53(%rip), %rdi     # 0x24a08
movl $0x98, %edx
xorl %esi, %esi
callq 0x6190
movq 0x1b308(%rip), %rdi     # 0x23fd0
movq %rbx, %rsi
callq 0x6060
leaq 0x1ba01(%rip), %rax     # 0x246d8
movq %rax, 0x1bd2a(%rip)     # 0x24a08
leaq 0x1ba1b(%rip), %rax     # 0x24700
movq %rax, 0x1bd4c(%rip)     # 0x24a38
movq %rax, 0x1bd4d(%rip)     # 0x24a40
leaq 0x1baae(%rip), %rax     # 0x247a8
movq %rax, 0x1bd47(%rip)     # 0x24a48
leaq 0x1ba70(%rip), %rax     # 0x24778
movq %rax, 0x1bd41(%rip)     # 0x24a50
leaq 0x1ba2a(%rip), %rax     # 0x24740
movq %rax, 0x1bd3b(%rip)     # 0x24a58
leaq 0x1bba4(%rip), %rax     # 0x248c8
movq %rax, 0x1bcf5(%rip)     # 0x24a20
leaq 0x1bb66(%rip), %rax     # 0x24898
movq %rax, 0x1bcef(%rip)     # 0x24a28
leaq 0x1bbe8(%rip), %rax     # 0x24928
movq %rax, 0x1bcc9(%rip)     # 0x24a10
leaq 0x1bc12(%rip), %rax     # 0x24960
movq %rax, 0x1bd0b(%rip)     # 0x24a60
leaq 0x1bc2c(%rip), %rax     # 0x24988
movq %rax, 0x1bcb5(%rip)     # 0x24a18
leaq 0x1bc56(%rip), %rax     # 0x249c0
movq %rax, 0x1bcbf(%rip)     # 0x24a30
popq %rbx
retq
leaq 0x1b636(%rip), %rdi     # 0x243b0
callq 0x63d0
jmp 0x8c99
// File: /workspace/github_cpp_makefile_star2_O3/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_SrcInfo_plog_2eproto()
static void InitDefaultsscc_info_SrcInfo_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::panda::_SrcInfo_default_instance_;
    new (ptr) ::panda::SrcInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::panda::SrcInfo::InitAsDefaultInstance();
}

// Assembly:
pushq %rax
leaq 0x113fa(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
movq $0x0, 0x1ba9a(%rip) # 0x24840
leaq 0x1ba8b(%rip), %rsi     # 0x24838
leaq 0x1a814(%rip), %rax     # 0x235c8
movq %rax, 0x1ba7d(%rip)     # 0x24838
xorps %xmm0, %xmm0
movups %xmm0, 0x1ba83(%rip)    # 0x24848
movups %xmm0, 0x1ba88(%rip)    # 0x24854
movq 0x1b1fd(%rip), %rdi     # 0x23fd0
popq %rax
jmp 0x6060
// File: /workspace/github_cpp_makefile_star2_O3/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_SrcInfoPri_plog_2eproto()
static void InitDefaultsscc_info_SrcInfoPri_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::panda::_SrcInfoPri_default_instance_;
    new (ptr) ::panda::SrcInfoPri();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::panda::SrcInfoPri::InitAsDefaultInstance();
}

// Assembly:
pushq %rax
leaq 0x113a5(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
xorps %xmm0, %xmm0
movups %xmm0, 0x1b94e(%rip)    # 0x24748
leaq 0x1a507(%rip), %rax     # 0x23308
movq %rax, 0x1b938(%rip)     # 0x24740
movl 0x1b62a(%rip), %eax     # 0x24438
testl %eax, %eax
jne 0x8e50
movq 0x1b1a7(%rip), %rax     # 0x23fc0
movq %rax, 0x1b938(%rip)     # 0x24758
leaq 0x1b919(%rip), %rsi     # 0x24740
movq %rax, 0x1b932(%rip)     # 0x24760
movq $0x0, 0x1b92f(%rip) # 0x24768
movl $0x0, 0x1b92d(%rip)     # 0x24770
movq 0x1b186(%rip), %rdi     # 0x23fd0
popq %rax
jmp 0x6060
leaq 0x1b5e1(%rip), %rdi     # 0x24438
callq 0x63d0
jmp 0x8e12
// File: /workspace/github_cpp_makefile_star2_O3/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_TaintQuery_plog_2eproto()
static void InitDefaultsscc_info_TaintQuery_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::panda::_TaintQuery_default_instance_;
    new (ptr) ::panda::TaintQuery();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::panda::TaintQuery::InitAsDefaultInstance();
}

// Assembly:
pushq %rax
leaq 0x11320(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
xorps %xmm0, %xmm0
movups %xmm0, 0x1b9f1(%rip)    # 0x24870
leaq 0x1a7f2(%rip), %rax     # 0x23678
movq %rax, 0x1b9db(%rip)     # 0x24868
movl 0x1b5bd(%rip), %eax     # 0x24450
testl %eax, %eax
jne 0x8ecc
movups %xmm0, 0x1b9e2(%rip)    # 0x24880
movq $0x0, 0x1b9e7(%rip) # 0x24890
leaq 0x1b9b8(%rip), %rsi     # 0x24868
movq 0x1b119(%rip), %rdi     # 0x23fd0
callq 0x6060
leaq 0x1b945(%rip), %rax     # 0x24808
movq %rax, 0x1b9b6(%rip)     # 0x24880
popq %rax
retq
leaq 0x1b57d(%rip), %rdi     # 0x24450
callq 0x63d0
xorps %xmm0, %xmm0
jmp 0x8e97