LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpl $0x0, 0x10(%rax)
jge 0x5e16
movb $0x0, -0x1(%rbp)
jmp 0x5ee7
movq -0x60(%rbp), %rcx
movslq 0x20(%rcx), %rax
imulq 0x18(%rcx), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rax
imulq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq 0xc(%rcx), %rax
imulq 0x18(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x5e54
movb $0x0, -0x1(%rbp)
jmp 0x5ee7
movq -0x60(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
testb $0x1, (%rax,%rcx)
je 0x5ece
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x50(%rbp)
movq $0x4, -0x48(%rbp)
movq 0x38(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4970
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x38(%rbp)
movl 0x10(%rax), %edi
leaq -0x50(%rbp), %rsi
movl $0x2, %edx
callq 0x2100
movq -0x60(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
imulq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xc800, %edi           # imm = 0xC800
callq 0x2040
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x5fcb
movl $0x0, -0x10(%rbp)
cmpl $0x64, -0x10(%rbp)
jge 0x5fbe
movl -0xc(%rbp), %eax
movb %al, %cl
movl -0x10(%rbp), %eax
addl $0x1, %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x5fe0
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x9, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5f7d
jmp 0x5fc0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5f6d
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x3930
movq -0x40(%rbp), %rdi
leaq 0x5bfe(%rip), %rax      # 0xbd58
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x6570
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x6223
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movl $0x48, %edi
callq 0x21e0
movq %rax, -0x48(%rbp)
jmp 0x619b
movq -0x48(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x6096(%rip), %rax      # 0xc240
movq (%rax,%rcx,8), %rcx
movq 0x60a3(%rip), %r8       # 0xc258
movl -0xc(%rbp), %r9d
movl -0x10(%rbp), %edx
movq %rsp, %rax
movl %edx, (%rax)
movl $0xf0, %esi
movl $0x8, %edx
callq 0x57c0
jmp 0x61d2
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x6590
jmp 0x61e9
jmp 0x61eb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6175
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x6229
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x48, %esi
callq 0x21f0
jmp 0x6229
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x65c0
movq -0x40(%rbp), %rdi
callq 0x3d50
movq -0x28(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x639c
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x639c
cmpl $0x0, -0x10(%rbp)
jl 0x639c
movq -0x38(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x40(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jl 0x63a1
jmp 0x64a4
movl $0x28, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x20(%rbp)
movb %al, -0x41(%rbp)
jl 0x63e2
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x48(%rbp)
addq $0x8, %rdi
callq 0x6620
movq %rax, %rcx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
setl %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x63eb
jmp 0x63ed
jmp 0x640c
leaq 0x20ee(%rip), %rdi      # 0x84e2
leaq 0x2118(%rip), %rsi      # 0x8513
movl $0x44, %edx
leaq 0x2120(%rip), %rcx      # 0x8527
callq 0x2150
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0x28, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %edx, -0x4c(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
movl -0x4c(%rbp), %edx
imull %eax, %edx
movl %edx, -0x28(%rbp)
movl -0xc(%rbp), %eax
addl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x6464
movl -0x10(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0x6477
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
subl $0x1, %eax
subl -0x10(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
movl -0x50(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x8, %rdi
movslq -0x20(%rbp), %rsi
callq 0x6640
movq (%rax), %rdi
movl -0x28(%rbp), %esi
addl -0x2c(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rcx
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
testb $0x1, -0x9(%rbp)
je 0x6562
movb $0x0, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x6620
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x654a
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x6640
movq (%rax), %rdi
movl -0x10(%rbp), %esi
callq 0x5df0
andb $0x1, %al
movzbl %al, %ecx
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x64e5
movl $0xbb8, %edi            # imm = 0xBB8
callq 0x2290
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x64cf
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tobias93[P]piano/rtaudio/tests/teststops.cpp
// Function: usage()
void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications
  std::cout << "\nuseage: teststops N fs <iDevice> <oDevice> <iChannelOffset> <oChannelOffset>\n";
  std::cout << "    where N = number of channels,\n";
  std::cout << "    fs = the sample rate,\n";
  std::cout << "    iDevice = optional input device to use (default = 0),\n";
  std::cout << "    oDevice = optional output device to use (default = 0),\n";
  std::cout << "    iChannelOffset = an optional input channel offset (default = 0),\n";
  std::cout << "    and oChannelOffset = optional output channel offset (default = 0).\n\n";
  exit( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xf95d(%rip), %rdi      # 0x17fc8
leaq 0xa9b6(%rip), %rsi      # 0x13028
callq 0x8210
movq 0xf94a(%rip), %rdi      # 0x17fc8
leaq 0xa9f2(%rip), %rsi      # 0x13077
callq 0x8210
movq 0xf937(%rip), %rdi      # 0x17fc8
leaq 0xaa02(%rip), %rsi      # 0x1309a
callq 0x8210
movq 0xf924(%rip), %rdi      # 0x17fc8
leaq 0xaa0a(%rip), %rsi      # 0x130b5
callq 0x8210
movq 0xf911(%rip), %rdi      # 0x17fc8
leaq 0xaa32(%rip), %rsi      # 0x130f0
callq 0x8210
movq 0xf8fe(%rip), %rdi      # 0x17fc8
leaq 0xaa5b(%rip), %rsi      # 0x1312c
callq 0x8210
movq 0xf8eb(%rip), %rdi      # 0x17fc8
leaq 0xaa8e(%rip), %rsi      # 0x13172
callq 0x8210
xorl %edi, %edi
callq 0x82f0
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x8747
movq 0xf89c(%rip), %rdi      # 0x17fc8
leaq 0xaa88(%rip), %rsi      # 0x131bb
callq 0x8210
movq %rax, %rdi
movq 0xf866(%rip), %rsi      # 0x17fa8
callq 0x8250
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x87d2
movq -0x58(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x58(%rbp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
cmpl $0x0, %edx
jne 0x877a
movss 0xa891(%rip), %xmm0     # 0x13004
movss %xmm0, -0x44(%rbp)
jmp 0x8782
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movq -0x58(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x87b7
movss -0x44(%rbp), %xmm0
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x50(%rbp)
movss %xmm0, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x8789
movq -0x58(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x874e
movq -0x58(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x58(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x87ee
movq -0x58(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x87f5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtAudio::openRtApi(RtAudio::Api)
void RtAudio :: openRtApi( RtAudio::Api api )
{
  if ( rtapi_ )
    delete rtapi_;
  rtapi_ = 0;

#if defined(__UNIX_JACK__)
  if ( api == UNIX_JACK )
    rtapi_ = new RtApiJack();
#endif
#if defined(__LINUX_ALSA__)
  if ( api == LINUX_ALSA )
    rtapi_ = new RtApiAlsa();
#endif
#if defined(__LINUX_PULSE__)
  if ( api == LINUX_PULSE )
    rtapi_ = new RtApiPulse();
#endif
#if defined(__LINUX_OSS__)
  if ( api == LINUX_OSS )
    rtapi_ = new RtApiOss();
#endif
#if defined(__WINDOWS_ASIO__)
  if ( api == WINDOWS_ASIO )
    rtapi_ = new RtApiAsio();
#endif
#if defined(__WINDOWS_WASAPI__)
  if ( api == WINDOWS_WASAPI )
    rtapi_ = new RtApiWasapi();
#endif
#if defined(__WINDOWS_DS__)
  if ( api == WINDOWS_DS )
    rtapi_ = new RtApiDs();
#endif
#if defined(__MACOSX_CORE__)
  if ( api == MACOSX_CORE )
    rtapi_ = new RtApiCore();
#endif
#if defined(__RTAUDIO_DUMMY__)
  if ( api == RTAUDIO_DUMMY )
    rtapi_ = new RtApiDummy();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x97aa
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x97a8
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x97aa
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
cmpl $0x2, -0xc(%rbp)
jne 0x9816
movl $0x368, %edi            # imm = 0x368
movq %rdi, -0x48(%rbp)
callq 0x8220
movq -0x48(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
xorl %esi, %esi
callq 0x8130
movq -0x38(%rbp), %rdi
callq 0xfae0
jmp 0x97ed
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x9816
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x368, %esi            # imm = 0x368
callq 0x8230
jmp 0x981c
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8460
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0xddfd(%rip), %rax      # 0x17c18
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x8320
movq -0x20(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
movq %rdi, -0x28(%rbp)
callq 0x8350
movq -0x20(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0xfc80
jmp 0x9e51
movq -0x20(%rbp), %rdi
movl $0xffffffce, 0x1bc(%rdi) # imm = 0xFFFFFFCE
movl $0xffffffb5, 0x1b8(%rdi) # imm = 0xFFFFFFB5
movq $0x0, 0x1b0(%rdi)
movq $0x0, 0x1c0(%rdi)
movq $0x0, 0x1c8(%rdi)
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x83a0
movq -0x20(%rbp), %rax
movb $0x1, 0x1a0(%rax)
movb $0x0, 0x348(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8140
movq -0x30(%rbp), %rdi
callq 0x8070
movq -0x10(%rbp), %rdi
callq 0x8460
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x2, -0x18(%rbp)
jne 0xa3f8
movl $0x2, -0x4(%rbp)
jmp 0xa470
cmpq $0x8, -0x18(%rbp)
je 0xa406
cmpq $0x10, -0x18(%rbp)
jne 0xa40f
movl $0x4, -0x4(%rbp)
jmp 0xa470
cmpq $0x20, -0x18(%rbp)
jne 0xa41f
movl $0x8, -0x4(%rbp)
jmp 0xa470
cmpq $0x4, -0x18(%rbp)
jne 0xa42f
movl $0x3, -0x4(%rbp)
jmp 0xa470
cmpq $0x1, -0x18(%rbp)
jne 0xa43f
movl $0x1, -0x4(%rbp)
jmp 0xa470
jmp 0xa441
jmp 0xa443
jmp 0xa445
jmp 0xa447
movq -0x20(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x97a7(%rip), %rsi      # 0x13c00
callq 0x8330
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9f60
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xa5d0
movq -0x18(%rbp), %rax
movq $0x0, -0x10(%rbp)
cmpl $0x0, 0x1b8(%rax)
je 0xa57b
movq -0x18(%rbp), %rax
cmpl $0x2, 0x1b8(%rax)
jne 0xa58a
movq -0x18(%rbp), %rax
movq 0x208(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x1b8(%rax)
je 0xa5a4
movq -0x18(%rbp), %rax
cmpl $0x2, 0x1b8(%rax)
jne 0xa5b7
movq -0x18(%rbp), %rax
movq 0x210(%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xa5d0
movq -0x38(%rbp), %rax
cmpl $0x2, 0x1bc(%rax)
jne 0xa65d
movq -0x38(%rbp), %rax
movsd 0x330(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa670
jp 0xa670
movq -0x38(%rbp), %rax
movsd 0x330(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xa6e4
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x83f0
movq -0x38(%rbp), %rax
movq 0x338(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x340(%rax), %rcx
movq %rcx, -0x18(%rbp)
movsd 0x330(%rax), %xmm0
cvtsi2sdq -0x30(%rbp), %xmm2
cvtsi2sdq -0x28(%rbp), %xmm1
movsd 0x8cad(%rip), %xmm3     # 0x13360
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvtsi2sdq -0x20(%rbp), %xmm3
cvtsi2sdq -0x18(%rbp), %xmm2
movsd 0x8c91(%rip), %xmm4     # 0x13360
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
subsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xfdc0
movq -0x38(%rbp), %rdi
movb $0x1, (%rdi)
addq $0x8, %rdi
leaq 0x8ec5(%rip), %rsi      # 0x1371e
callq 0x8330
jmp 0xa860
movq -0x38(%rbp), %rax
movl $0x2, 0x28(%rax)
movl $0x2, 0x2c(%rax)
movl $0x2, 0x30(%rax)
movb $0x1, 0x34(%rax)
movb $0x1, 0x35(%rax)
leaq 0x8b98(%rip), %rax      # 0x13420
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0xa8cf
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movq -0x30(%rbp), %rsi
callq 0xfe30
jmp 0xa8a8
jmp 0xa8aa
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0xa88c
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xfea0
jmp 0xa8ff
movq -0x38(%rbp), %rax
movl $0xbb80, 0x50(%rax)     # imm = 0xBB80
movq $0x1a, 0x58(%rax)
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xa8f5
movq -0x38(%rbp), %rdi
callq 0xfea0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8460
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x1b0(%rax), %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, 0x288(%rax)
cmpq $0x0, -0x10(%rbp)
je 0xaa18
movq -0x18(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
callq 0x8380
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1bc(%rax)
jne 0xa97a
movq -0x10(%rbp), %rax
movb $0x1, 0x48(%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x8030
movq -0x18(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
callq 0x8190
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x81f0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa9c8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8090
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x8410
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa9e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8410
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x84c0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xaa09
movq -0x20(%rbp), %rdi
movl $0x50, %esi
callq 0x8230
movq -0x18(%rbp), %rax
movq $0x0, 0x1b0(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x1c0(%rax)
je 0xaa45
movq -0x18(%rbp), %rax
movq 0x1c0(%rax), %rdi
callq 0x82d0
movq -0x18(%rbp), %rax
movq $0x0, 0x1c0(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x1c8(%rax)
je 0xaa72
movq -0x18(%rbp), %rax
movq 0x1c8(%rax), %rdi
callq 0x82d0
movq -0x18(%rbp), %rax
movq $0x0, 0x1c8(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffce, 0x1bc(%rax) # imm = 0xFFFFFFCE
movl $0xffffffb5, 0x1b8(%rax) # imm = 0xFFFFFFB5
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x1b0(%rax), %rcx
movq %rcx, -0x10(%rbp)
cmpl $-0x32, 0x1bc(%rax)
jne 0xe1a2
movq -0x18(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x5649(%rip), %rsi      # 0x137d3
callq 0x8330
movq -0x18(%rbp), %rdi
movl $0x7, %esi
callq 0x9f60
jmp 0xe224
movq -0x18(%rbp), %rax
cmpl $0x2, 0x1bc(%rax)
jne 0xe1d3
movq -0x18(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x5645(%rip), %rsi      # 0x13806
callq 0x8330
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x9f60
jmp 0xe224
movq -0x18(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
callq 0x8380
movq -0x18(%rbp), %rax
movl $0x2, 0x1bc(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x48(%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x8030
movq -0x18(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
callq 0x8190
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x1b0(%rax), %rcx
movq %rcx, -0x10(%rbp)
cmpl $-0x32, 0x1bc(%rax)
jne 0xe282
movq -0x40(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x55d6(%rip), %rsi      # 0x13840
callq 0x8330
movq -0x40(%rbp), %rdi
movl $0x7, %esi
callq 0x9f60
jmp 0xe3bc
movq -0x40(%rbp), %rax
cmpl $0x0, 0x1bc(%rax)
jne 0xe2b6
movq -0x40(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x55d1(%rip), %rsi      # 0x13872
callq 0x8330
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x9f60
jmp 0xe3bc
movq -0x40(%rbp), %rdi
movl $0x0, 0x1bc(%rdi)
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
callq 0x8380
cmpq $0x0, -0x10(%rbp)
je 0xe39b
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe39b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x80c0
cmpl $0x0, %eax
jge 0xe399
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
leaq 0x5593(%rip), %rsi      # 0x138ab
callq 0x8210
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %edi
callq 0x8060
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x8210
movq %rax, %rdi
leaq 0x58a1(%rip), %rsi      # 0x13be0
callq 0x8210
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x8240
movq -0x40(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq -0x38(%rbp), %rsi
callq 0x8300
leaq -0x38(%rbp), %rdi
callq 0x8140
movq -0x40(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
callq 0x8190
movq -0x40(%rbp), %rdi
movl $0x9, %esi
callq 0x9f60
jmp 0xe3bc
jmp 0xe39b
movq -0x40(%rbp), %rdi
movl $0x0, 0x1bc(%rdi)
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
callq 0x8190
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x1b0(%rax), %rcx
movq %rcx, -0x10(%rbp)
cmpl $-0x32, 0x1bc(%rax)
jne 0xe422
movq -0x40(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x54d8(%rip), %rsi      # 0x138e2
callq 0x8330
movq -0x40(%rbp), %rdi
movl $0x7, %esi
callq 0x9f60
jmp 0xe55c
movq -0x40(%rbp), %rax
cmpl $0x0, 0x1bc(%rax)
jne 0xe456
movq -0x40(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq 0x54d4(%rip), %rsi      # 0x13915
callq 0x8330
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x9f60
jmp 0xe55c
movq -0x40(%rbp), %rdi
movl $0x0, 0x1bc(%rdi)
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
callq 0x8380
cmpq $0x0, -0x10(%rbp)
je 0xe53b
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe53b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x8090
cmpl $0x0, %eax
jge 0xe539
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
leaq 0x5497(%rip), %rsi      # 0x1394f
callq 0x8210
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %edi
callq 0x8060
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x8210
movq %rax, %rdi
leaq 0x5701(%rip), %rsi      # 0x13be0
callq 0x8210
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x8240
movq -0x40(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
leaq -0x38(%rbp), %rsi
callq 0x8300
leaq -0x38(%rbp), %rdi
callq 0x8140
movq -0x40(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
callq 0x8190
movq -0x40(%rbp), %rdi
movl $0x9, %esi
callq 0x9f60
jmp 0xe55c
jmp 0xe53b
movq -0x40(%rbp), %rdi
movl $0x0, 0x1bc(%rdi)
addq $0x1a8, %rdi            # imm = 0x1A8
addq $0x88, %rdi
callq 0x8190
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
testb $0x1, %al
je 0xf7a5
callq 0x8160
movq -0x18(%rbp), %rdi
callq 0xaa90
jmp 0xf78b
xorl %eax, %eax
movl %eax, %edi
callq 0x8470
nop
// File: tobias93[P]piano/rtaudio/RtAudio.h
// Function: S24::operator=(int const&)
S24& operator = ( const int& i ) {
    c3[0] = (i & 0x000000ff);
    c3[1] = (i & 0x0000ff00) >> 8;
    c3[2] = (i & 0x00ff0000) >> 16;
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
andl $0xff, %ecx
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
sarl $0x8, %ecx
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
sarl $0x10, %ecx
movb %cl, 0x2(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: tomfunkhouser[P]gaps/apps/grd2grd/grd2grd.cpp
// Function: main
int 
main(int argc, char **argv)
{
  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Read grid file
  R3Grid *grid = ReadGrid(input_name);
  if (!grid) exit(-1);

  // Apply operations
  int status1 = ApplyOperations(grid, operations, noperations);
  if (!status1) exit(-1);

  // Write grid file
  int status2 = WriteGrid(grid, output_name);
  if (!status2) exit(-1);

  // Return success
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x12570
cmpl $0x0, %eax
jne 0x124f2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x167057(%rip), %rdi    # 0x179550
callq 0x13580
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x12515
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x10(%rsp), %rdi
movl 0x167cc0(%rip), %edx    # 0x17a1e0
leaq 0x167039(%rip), %rsi    # 0x179560
callq 0x137b0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x12541
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x10(%rsp), %rdi
movq 0x167c9b(%rip), %rsi    # 0x17a1e8
callq 0x14000
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x12567
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
xorl %eax, %eax
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/apps/grd2grd/grd2grd.cpp
// Function: WriteGrid(gaps::R3Grid*, char const*)
static int 
WriteGrid(R3Grid *grid, const char *grid_name)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write grid
  int status = grid->WriteFile(grid_name);

  // Print statistics
  if (print_verbose) {
    printf("Wrote grid ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Bytes = %d\n", (int) (grid->NEntries() * sizeof(RNScalar)));
    fflush(stdout);
  }

  // Return status
  return status;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xd1630
leaq 0x8(%rsp), %rdi
callq 0x140a0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x249e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x1661b4(%rip)    # 0x17a1f0
je 0x14093
leaq 0x120381(%rip), %rdi    # 0x1343c6
movb $0x0, %al
callq 0xf070
leaq 0x8(%rsp), %rdi
callq 0xd16f0
leaq 0x120216(%rip), %rdi    # 0x134273
movb $0x1, %al
callq 0xf070
movq 0x20(%rsp), %rdi
callq 0x141c0
cltq
shlq $0x3, %rax
movl %eax, %esi
leaq 0x120359(%rip), %rdi    # 0x1343d6
movb $0x0, %al
callq 0xf070
movq 0x15bf05(%rip), %rax    # 0x16ff90
movq (%rax), %rdi
callq 0xf5d0
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/ProgressMeter.cpp
// Function: ProgressMeter::setUp()
void ProgressMeter::setUp()
{
	this->bar_width = this->calculateWidth() - 7; // 7 because of "[" and "]" and " 100%" (5 chars) at max.  At min, " 4%" (3 chars). In the middle, " 76%" (4 chars).
	
	this->data_done = 0;
	this->data_size = 0;

	this->progress = 0.0;

	sem_init(&(this->lock),0,1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1880
movq -0x10(%rbp), %rdi
subl $0x7, %eax
movl %eax, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rdi)
addq $0x10, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nop
// File: ridgelab[P]Kmer-SSR/src/ProgressMeter.cpp
// Function: ProgressMeter::initialize(unsigned int)
void ProgressMeter::initialize(uint32_t _data_size)
{
	sem_wait(&(this->lock));

	this->data_size = _data_size;

	if (this->display)
	{
		cerr << "\nFinding SSRs:" << endl;
	}

	sem_post(&(this->lock));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
callq 0x1040
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
testb $0x1, 0x30(%rax)
je 0x16b2
movq 0x2959(%rip), %rdi      # 0x3ff0
leaq 0xa2e(%rip), %rsi       # 0x20cc
callq 0x10a0
movq %rax, %rdi
movq 0x290b(%rip), %rsi      # 0x3fb8
callq 0x10b0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/ProgressMeter.cpp
// Function: ProgressMeter::updateProgress(unsigned int, bool)
void ProgressMeter::updateProgress(uint32_t additional_completed, bool update_display)
{
	sem_wait(&(this->lock));

	this->data_done += additional_completed;
	this->progress = (1.0 * this->data_done) / this->data_size;

	if (this->display && update_display)
	{
		this->updateMeter();
	}
	
	sem_post(&(this->lock));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
callq 0x1040
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movl 0x4(%rax), %ecx
addl %edx, %ecx
movl %ecx, 0x4(%rax)
movl 0x4(%rax), %edx
movl 0x8(%rax), %ecx
cvtsi2sd %rdx, %xmm0
cvtsi2sd %rcx, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rax)
testb $0x1, 0x30(%rax)
je 0x1738
testb $0x1, -0xd(%rbp)
je 0x1738
movq -0x18(%rbp), %rdi
callq 0x1750
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/ProgressMeter.cpp
// Function: ProgressMeter::updateMeter()
void ProgressMeter::updateMeter()
{
	cerr << "[";
	
	uint32_t pos = this->progress * this->bar_width;
	for (uint32_t i = 0; i < this->bar_width; ++i)
	{
		if (i <= pos)
		{
			cerr << "#";
		}
		else
		{
			cerr << " ";
		}
	}

	cerr << "] " << (uint32_t) (this->progress * 100) << "%";

	if (this->progress < 1.0)
	{
		cerr << "\r";
	}
	else //if (this->progress == 1.0)
	{
		cerr << "\n\n";
	}
	//else
	//{
	//	cerr << "\nsomething's wrong!  progress,datadone,datasize: " << this->progress << "," << this->data_done << "," << this->data_size << "\n\n";
	//}

	cerr.flush();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x2885(%rip), %rdi      # 0x3ff0
leaq 0x969(%rip), %rsi       # 0x20db
callq 0x10a0
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movl (%rax), %eax
cvtsi2ss %rax, %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jae 0x17e2
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
ja 0x17c2
movq 0x283c(%rip), %rdi      # 0x3ff0
leaq 0x922(%rip), %rsi       # 0x20dd
callq 0x10a0
jmp 0x17d5
movq 0x2827(%rip), %rdi      # 0x3ff0
leaq 0x8cb(%rip), %rsi       # 0x209b
callq 0x10a0
jmp 0x17d7
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x179a
movq 0x2807(%rip), %rdi      # 0x3ff0
leaq 0x8ef(%rip), %rsi       # 0x20df
callq 0x10a0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movss 0x8bf(%rip), %xmm1      # 0x20c8
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, %esi
callq 0x10c0
movq %rax, %rdi
leaq 0x8bf(%rip), %rsi       # 0x20e2
callq 0x10a0
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x883(%rip), %xmm0      # 0x20c0
ucomisd %xmm1, %xmm0
jbe 0x1858
movq 0x27a6(%rip), %rdi      # 0x3ff0
leaq 0x893(%rip), %rsi       # 0x20e4
callq 0x10a0
jmp 0x186b
movq 0x2791(%rip), %rdi      # 0x3ff0
leaq 0x880(%rip), %rsi       # 0x20e6
callq 0x10a0
movq 0x277e(%rip), %rdi      # 0x3ff0
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: suyash[P]chan/examples/go/pi.cc
// Function: pi(int)
double pi(int n) {
	chan::unbuffered_chan<double> ch;

	for (int k = 0; k <= n; k++) {
		std::thread(term, std::ref(ch), k).detach();
	}

	double f = 0;
	for (int k = 0; k <= n; k++) {
		double x = 0;
		ch >> x;
		f += x;
	}

	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movl %edi, -0x4(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x2740
movl $0x0, -0x114(%rbp)
movl -0x114(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x248e
leaq -0x110(%rbp), %rdi
callq 0x27b0
movq %rax, -0x128(%rbp)
leaq -0xbd(%rip), %rsi       # 0x2350
leaq -0x120(%rbp), %rdi
leaq -0x128(%rbp), %rdx
leaq -0x114(%rbp), %rcx
callq 0x27e0
jmp 0x2429
leaq -0x120(%rbp), %rdi
callq 0x2160
jmp 0x2437
leaq -0x120(%rbp), %rdi
callq 0x28b0
movl -0x114(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x23e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
jmp 0x2524
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x130(%rbp)
movl %eax, -0x134(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x28b0
jmp 0x2524
xorps %xmm0, %xmm0
movsd %xmm0, -0x140(%rbp)
movl $0x0, -0x144(%rbp)
movl -0x144(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x24f7
movq $0x0, -0x150(%rbp)
leaq -0x110(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0x28e0
jmp 0x24ce
movsd -0x150(%rbp), %xmm0
addsd -0x140(%rbp), %xmm0
movsd %xmm0, -0x140(%rbp)
movl -0x144(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
jmp 0x24a3
movsd -0x140(%rbp), %xmm0
movsd %xmm0, -0x158(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x2910
movsd -0x158(%rbp), %xmm0
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
leaq -0x110(%rbp), %rdi
callq 0x2910
movq -0x130(%rbp), %rdi
callq 0x2170
nopl (%rax)
// File: suyash[P]chan/examples/go/../../chan.hh
// Function: chan::chan<double>::close()
bool close() {
		std::unique_lock<std::mutex> data_lock(data_mutex);

		if (is_closed) {
			throw _channel_closed_exception;
		}

		is_closed = true;

		// notify any waiting read and write condition variables
		read_available.notify_all();
		write_available.notify_all();

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
addq $0x18, %rsi
leaq -0x18(%rbp), %rdi
callq 0x2cc0
movq -0x30(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x2b48
movl $0x8, %edi
callq 0x2080
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
leaq 0x45dd(%rip), %rsi      # 0x70f0
callq 0x2d00
movq -0x38(%rbp), %rdi
leaq 0x401d(%rip), %rsi      # 0x6b40
leaq -0x4fa(%rip), %rdx      # 0x2630
callq 0x2140
jmp 0x2b82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2d40
jmp 0x2b79
movq -0x30(%rbp), %rdi
movb $0x1, 0x10(%rdi)
addq $0x48, %rdi
callq 0x2130
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
callq 0x2130
leaq -0x18(%rbp), %rdi
callq 0x2d40
movb $0x1, %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2170
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suyash[P]chan/examples/go/../../chan.hh
// Function: chan::unbuffered_chan<double>::read(double&)
bool read(T& valref) {
		std::unique_lock<std::mutex> read_lock(read_mutex);
		std::unique_lock<std::mutex> data_lock(this->data_mutex);

		while (!this->is_closed && this->write_wait_count == 0) {
			this->read_wait_count++;
			this->read_available.wait(data_lock);
			this->read_wait_count--;
		}

		if (this->is_closed) {
			// TODO: figure out error here
			valref = T();
			return false;
		}

		valref = data;
		set = false;

		this->write_wait_count--;
		this->write_available.notify_one();

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
addq $0xb8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2cc0
movq -0x50(%rbp), %rsi
addq $0x18, %rsi
leaq -0x38(%rbp), %rdi
callq 0x2cc0
jmp 0x2f8b
jmp 0x2f8d
movq -0x50(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x10(%rcx)
movb %al, -0x51(%rbp)
jne 0x2faa
movq -0x50(%rbp), %rax
cmpl $0x0, 0x44(%rax)
sete %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x2fb3
jmp 0x2ff3
movq -0x50(%rbp), %rdi
movl 0x40(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x40(%rdi)
addq $0x48, %rdi
leaq -0x38(%rbp), %rsi
callq 0x2050
movq -0x50(%rbp), %rax
movl 0x40(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x40(%rax)
jmp 0x2f8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2d40
jmp 0x306a
movq -0x50(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x3015
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x304d
movq -0x50(%rbp), %rdi
movsd 0xa8(%rdi), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x0, 0xb0(%rdi)
movl 0x44(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x44(%rdi)
addq $0x78, %rdi
callq 0x2090
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2d40
leaq -0x28(%rbp), %rdi
callq 0x2d40
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2170
nopw %cs:(%rax,%rax)
nopl (%rax)