LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x79eb(%rip), %rax      # 0xcc28
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x4260
leaq 0x190(%rbx), %rax
movq %rax, 0x180(%rbx)
andq $0x0, 0x188(%rbx)
leaq 0x180(%rbx), %r15
movb $0x0, 0x190(%rbx)
leaq 0x1a8(%rbx), %rdi
callq 0x7862
movabsq $-0x310000004b, %rax    # imm = 0xFFFFFFCEFFFFFFB5
movq %rax, 0x1b8(%rbx)
andq $0x0, 0x1b0(%rbx)
leaq 0x230(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x1c0(%rbx)
xorl %esi, %esi
callq 0x42c0
movb $0x1, 0x1a0(%rbx)
movb $0x0, 0x348(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x40c0
movq %r14, %rdi
callq 0x4050
movq %rbx, %rdi
callq 0x4390
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x42c5(%rip), %rsi      # 0x9603
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x77ae
leaq 0x10(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x42d0
leaq 0x10(%rsp), %rdi
callq 0x40c0
movq 0x278(%rbx), %r14
testq %r14, %r14
je 0x53d0
cmpb $0x0, 0x348(%rbx)
jne 0x540d
movb $0x1, 0x348(%rbx)
leaq 0x180(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x4270
testl %ebp, %ebp
je 0x53b3
cmpl $0x0, 0x1bc(%rbx)
je 0x53b3
movb $0x0, 0x288(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
leaq 0x10(%rsp), %rsi
movl %ebp, %edi
callq *%r14
movb $0x0, 0x348(%rbx)
leaq 0x10(%rsp), %rdi
callq 0x40c0
jmp 0x540d
testl %ebp, %ebp
jne 0x5416
cmpb $0x1, 0x1a0(%rbx)
jne 0x540d
movq 0x7c0c(%rip), %rdi      # 0xcff0
pushq $0xa
popq %rsi
callq 0x41f0
addq $0x180, %rbx            # imm = 0x180
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4190
leaq 0x41fc(%rip), %rsi      # 0x9601
movq %rax, %rdi
callq 0x41c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x40e0
movq %rax, %r14
addq $0x180, %rbx            # imm = 0x180
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x7812
leaq 0x77c4(%rip), %rsi      # 0xcc00
leaq 0x23ff(%rip), %rdx      # 0x7842
movq %r14, %rdi
callq 0x4380
jmp 0x544d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x40c0
jmp 0x545f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x1e0(%rdi)
andl $0x0, 0x1e8(%rdi)
andq $0x0, 0x218(%rdi)
movb $0x1, 0x1da(%rdi)
andq $0x0, 0x330(%rdi)
andq $0x0, 0x1b0(%rdi)
andq $0x0, 0x1d0(%rdi)
movb $0x0, 0x288(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x278(%rdi)
movups %xmm0, 0x268(%rdi)
pushq $0x5a
popq %rax
movl $0x1dd, %ecx            # imm = 0x1DD
xorl %edx, %edx
cmpq $0x6e, %rax
je 0x5562
movl $0x2b67, -0x5cc(%rdi,%rcx,4) # imm = 0x2B67
movb %dl, -0x5(%rdi,%rcx)
movb $0x1, -0x2(%rdi,%rcx)
movb %dl, (%rdi,%rcx)
andl $0x0, -0x588(%rdi,%rcx,4)
andl $0x0, -0x580(%rdi,%rcx,4)
andl $0x0, -0x578(%rdi,%rcx,4)
andq $0x0, -0xcc8(%rdi,%rcx,8)
andq $0x0, -0xce0(%rdi,%rcx,8)
andq $0x0, -0xd28(%rdi,%rcx,8)
andq $0x0, -0x40(%rdi,%rax,8)
andl $0x0, -0x38(%rdi,%rax,8)
movups %xmm0, -0x30(%rdi,%rax,8)
movq -0x20(%rdi,%rax,8), %rsi
cmpq %rsi, -0x18(%rdi,%rax,8)
je 0x5547
movq %rsi, -0x18(%rdi,%rax,8)
movq -0x8(%rdi,%rax,8), %rsi
cmpq %rsi, (%rdi,%rax,8)
je 0x5556
movq %rsi, (%rdi,%rax,8)
addq $0xa, %rax
incq %rcx
jmp 0x54d2
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x1(%rsi), %rax
cmpq $0x7, %rax
ja 0x5588
leaq 0x3df5(%rip), %rcx      # 0x9370
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x1
jmp 0x55c3
cmpq $0x10, %rsi
je 0x5598
cmpq $0x20, %rsi
jne 0x559c
pushq $0x8
jmp 0x55c3
pushq $0x4
jmp 0x55c3
leaq 0x180(%rbx), %rdi
leaq 0x4705(%rip), %rsi      # 0x9caf
callq 0x43e0
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x532a
jmp 0x55c4
pushq $0x3
jmp 0x55c3
pushq $0x2
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x564c
movl 0x1b8(%rbx), %eax
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jne 0x5633
movq 0x208(%rbx), %rcx
jmp 0x5635
xorl %ecx, %ecx
decl %eax
cmpl $0x2, %eax
jae 0x5645
movq 0x210(%rbx), %rax
jmp 0x5647
xorl %eax, %eax
addq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x564c
cmpl $0x2, 0x1bc(%rbx)
movsd 0x330(%rbx), %xmm0
jne 0x56f6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x56a6
jnp 0x56f6
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x4330
cvtsi2sdq (%r14), %xmm1
cvtsi2sdq 0x8(%r14), %xmm0
movsd 0x3e50(%rip), %xmm2     # 0x9518
mulsd %xmm2, %xmm0
cvtsi2sdq 0x338(%rbx), %xmm3
addsd %xmm1, %xmm0
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
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
andq $0x0, 0x58(%rdi)
andq $0x0, 0x28(%rdi)
addq $0x8, %rdi
andq $0x0, 0x2e(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x44(%rbx)
movb $0x1, (%rbx)
leaq 0x4033(%rip), %rsi      # 0x980e
callq 0x43e0
leaq 0x38(%rbx), %r14
movabsq $0x200000002, %rax      # imm = 0x200000002
movq %rax, 0x28(%rbx)
movl $0x2, 0x30(%rbx)
movw $0x101, 0x34(%rbx)      # imm = 0x101
leaq 0x3c9a(%rip), %r15      # 0x94a0
cmpl $0x0, (%r15)
je 0x581d
movq %r14, %rdi
movq %r15, %rsi
callq 0x7914
addq $0x4, %r15
jmp 0x5806
movl $0xbb80, 0x50(%rbx)     # imm = 0xBB80
movq $0x1a, 0x58(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5837
movq %rax, %r14
movq %rbx, %rdi
callq 0x7932
movq %r14, %rdi
callq 0x4390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x58df
leaq 0x230(%rbx), %r15
movq %r15, %rdi
callq 0x42a0
cmpl $0x0, 0x1bc(%rbx)
jne 0x588b
movb $0x1, 0x48(%r14)
leaq 0x18(%r14), %rdi
callq 0x4030
movq %r15, %rdi
callq 0x4150
movq 0x10(%r14), %rdi
xorl %esi, %esi
callq 0x41a0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x58b5
xorl %esi, %esi
callq 0x4070
movq (%r14), %rdi
callq 0x4350
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x58c3
callq 0x4350
leaq 0x18(%r14), %rdi
callq 0x43f0
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x41e0
andq $0x0, 0x1b0(%rbx)
movq 0x1c0(%rbx), %rdi
testq %rdi, %rdi
je 0x58f8
callq 0x4220
andq $0x0, 0x1c0(%rbx)
movq 0x1c8(%rbx), %rdi
testq %rdi, %rdi
je 0x5911
callq 0x4220
andq $0x0, 0x1c8(%rbx)
movabsq $-0x310000004b, %rax    # imm = 0xFFFFFFCEFFFFFFB5
movq %rax, 0x1b8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6cb5
cmpl $-0x32, %eax
jne 0x6cd7
leaq 0x180(%rbx), %rdi
leaq 0x2c1b(%rip), %rsi      # 0x98c3
callq 0x43e0
pushq $0x7
popq %rsi
movq %rbx, %rdi
jmp 0x6ccd
leaq 0x180(%rbx), %rdi
leaq 0x2c33(%rip), %rsi      # 0x98f6
callq 0x43e0
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x532a
movq 0x1b0(%rbx), %r14
leaq 0x230(%rbx), %r15
movq %r15, %rdi
callq 0x42a0
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 0x4150
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x1bc(%rdi), %eax
testl %eax, %eax
je 0x6d4c
cmpl $-0x32, %eax
jne 0x6d72
leaq 0x180(%rbx), %rdi
leaq 0x2bf1(%rip), %rsi      # 0x9930
callq 0x43e0
pushq $0x7
popq %rsi
movq %rbx, %rdi
jmp 0x6d64
leaq 0x180(%rbx), %rdi
leaq 0x2c08(%rip), %rsi      # 0x9962
callq 0x43e0
movq %rbx, %rdi
xorl %esi, %esi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x532a
movq 0x1b0(%rbx), %r15
andl $0x0, 0x1bc(%rbx)
leaq 0x230(%rbx), %r14
movq %r14, %rdi
callq 0x42a0
testq %r15, %r15
je 0x6daa
movq (%r15), %rdi
testq %rdi, %rdi
je 0x6daa
leaq 0xc(%rsp), %rsi
callq 0x40a0
testl %eax, %eax
js 0x6dc3
andl $0x0, 0x1bc(%rbx)
movq %r14, %rdi
callq 0x4150
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rbx), %rdi
leaq 0x2bcd(%rip), %rsi      # 0x999b
callq 0x41c0
movq %rax, %r15
movl 0xc(%rsp), %edi
callq 0x4040
movq %r15, %rdi
movq %rax, %rsi
callq 0x41c0
leaq 0x2e9e(%rip), %rsi      # 0x9c8f
movq %rax, %rdi
callq 0x41c0
leaq 0x10(%rbx), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x4320
leaq 0x180(%rbx), %rdi
movq %r15, %rsi
callq 0x4250
movq %r15, %rdi
callq 0x40c0
movq %r14, %rdi
callq 0x4150
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x532a
jmp 0x6db9
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x1bc(%rdi), %eax
testl %eax, %eax
je 0x6e6c
cmpl $-0x32, %eax
jne 0x6e92
leaq 0x180(%rbx), %rdi
leaq 0x2b73(%rip), %rsi      # 0x99d2
callq 0x43e0
pushq $0x7
popq %rsi
movq %rbx, %rdi
jmp 0x6e84
leaq 0x180(%rbx), %rdi
leaq 0x2b8b(%rip), %rsi      # 0x9a05
callq 0x43e0
movq %rbx, %rdi
xorl %esi, %esi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x532a
movq 0x1b0(%rbx), %r15
andl $0x0, 0x1bc(%rbx)
leaq 0x230(%rbx), %r14
movq %r14, %rdi
callq 0x42a0
testq %r15, %r15
je 0x6eca
movq (%r15), %rdi
testq %rdi, %rdi
je 0x6eca
leaq 0xc(%rsp), %rsi
callq 0x4070
testl %eax, %eax
js 0x6ee3
andl $0x0, 0x1bc(%rbx)
movq %r14, %rdi
callq 0x4150
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rbx), %rdi
leaq 0x2b51(%rip), %rsi      # 0x9a3f
callq 0x41c0
movq %rax, %r15
movl 0xc(%rsp), %edi
callq 0x4040
movq %r15, %rdi
movq %rax, %rsi
callq 0x41c0
leaq 0x2d7e(%rip), %rsi      # 0x9c8f
movq %rax, %rdi
callq 0x41c0
leaq 0x10(%rbx), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x4320
leaq 0x180(%rbx), %rdi
movq %r15, %rsi
callq 0x4250
movq %r15, %rdi
callq 0x40c0
movq %r14, %rdi
callq 0x4150
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x532a
jmp 0x6ed9
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq (%rdi), %r14
movb 0x30(%rbx), %al
cmpb $0x1, %al
jne 0x76f6
callq 0x4130
movq %r14, %rdi
callq 0x5928
jmp 0x76e0
xorl %edi, %edi
callq 0x43a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/grd2grd/grd2grd.cpp
// Function: ReadGrid(char const*)
static R3Grid *
ReadGrid(const char *input_name)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate a grid
  R3Grid *grid = new R3Grid();
  if (!grid) {
    RNFail("Unable to allocate grid");
    return NULL;
  }

  // Read grid
  int status = grid->ReadFile(input_name);
  if (!status) {
    RNFail("Unable to read grid file %s", input_name);
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read grid ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  Resolution = %d %d %d\n", grid->XResolution(), grid->YResolution(), grid->ZResolution());
    printf("  Spacing = %g\n", grid->GridToWorldScaleFactor());
    printf("  Cardinality = %d\n", grid->Cardinality());
    printf("  Volume = %g\n", grid->Volume());
    RNInterval grid_range = grid->Range();
    printf("  Minimum = %g\n", grid_range.Min());
    printf("  Maximum = %g\n", grid_range.Max());
    printf("  L1Norm = %g\n", grid->L1Norm());
    printf("  L2Norm = %g\n", grid->L2Norm());
    fflush(stdout);
  }

  // Return success
  return grid;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6639e
movq %rbx, %rdi
callq 0x112a4
movl $0x250, %edi            # imm = 0x250
callq 0xe450
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x112f4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17a8c
testl %eax, %eax
je 0x1126d
cmpb $0x1, 0xcb745(%rip)     # 0xdc8b0
jne 0x11280
leaq 0x8321b(%rip), %rdi     # 0x94393
callq 0xe720
leaq 0x8(%rsp), %rdi
callq 0x663d8
leaq 0x83091(%rip), %rdi     # 0x9421f
movb $0x1, %al
callq 0xe070
movl 0x238(%rbx), %esi
movl 0x23c(%rbx), %edx
movl 0x240(%rbx), %ecx
leaq 0x83088(%rip), %rdi     # 0x94236
xorl %eax, %eax
callq 0xe070
movsd 0x228(%rbx), %xmm0
leaq 0x8308b(%rip), %rdi     # 0x9424f
movb $0x1, %al
callq 0xe070
movq %rbx, %rdi
callq 0x11df2
leaq 0x83085(%rip), %rdi     # 0x9425f
movl %eax, %esi
xorl %eax, %eax
callq 0xe070
movq %rbx, %rdi
callq 0x112ac
leaq 0x83081(%rip), %rdi     # 0x94273
movb $0x1, %al
callq 0xe070
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11d42
movsd (%r14), %xmm0
leaq 0x8306d(%rip), %rdi     # 0x94282
movb $0x1, %al
callq 0xe070
movsd 0x8(%r14), %xmm0
leaq 0x83069(%rip), %rdi     # 0x94292
movb $0x1, %al
callq 0xe070
movq %rbx, %rdi
callq 0x11d9a
leaq 0x83063(%rip), %rdi     # 0x942a2
movb $0x1, %al
callq 0xe070
movq %rbx, %rdi
callq 0x112d6
leaq 0x8305c(%rip), %rdi     # 0x942b1
movb $0x1, %al
callq 0xe070
movq 0xc9d1d(%rip), %rax     # 0xdaf80
movq (%rax), %rdi
callq 0xe540
jmp 0x11280
leaq 0x82f8f(%rip), %rdi     # 0x94203
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x687a6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x250, %esi            # imm = 0x250
movq %rbx, %rdi
callq 0xe460
movq %r14, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x1060
movl %ebp, 0x8(%r14)
cmpb $0x1, 0x30(%r14)
jne 0x145d
movq 0x2ba7(%rip), %rdi      # 0x3ff0
leaq 0xc8c(%rip), %rsi       # 0x20dc
callq 0x10b0
movq %rax, %rdi
callq 0x1050
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x1060
addl 0x4(%r14), %r15d
cvtsi2sd %r15, %xmm0
movl %r15d, 0x4(%r14)
movl 0x8(%r14), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%r14)
andb 0x30(%r14), %bpl
cmpb $0x1, %bpl
jne 0x14bb
movq %r14, %rdi
callq 0x14ce
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2b0d(%rip), %r14      # 0x3ff0
leaq 0xc01(%rip), %rsi       # 0x20eb
movq %r14, %rdi
callq 0x10b0
movl (%rbx), %eax
cvtsi2ss %rax, %xmm0
mulss 0xc(%rbx), %xmm0
cvttss2si %xmm0, %r15
xorl %ebp, %ebp
leaq 0xb8f(%rip), %r12       # 0x209b
leaq 0xbda(%rip), %r13       # 0x20ed
cmpl %eax, %ebp
jae 0x152f
cmpl %r15d, %ebp
movq %r13, %rsi
cmovaq %r12, %rsi
movq %r14, %rdi
callq 0x10b0
incl %ebp
movl (%rbx), %eax
jmp 0x1513
movq 0x2aba(%rip), %r14      # 0x3ff0
leaq 0xbb2(%rip), %rsi       # 0x20ef
movq %r14, %rdi
callq 0x10b0
movss 0xc(%rbx), %xmm0
mulss 0xb82(%rip), %xmm0      # 0x20d4
cvttss2si %xmm0, %rcx
movl %ecx, %esi
movq %rax, %rdi
callq 0x1070
leaq 0xb8a(%rip), %rsi       # 0x20f2
movq %rax, %rdi
callq 0x10b0
movss 0xb60(%rip), %xmm0      # 0x20d8
ucomiss 0xc(%rbx), %xmm0
leaq 0xb71(%rip), %rax       # 0x20f4
leaq 0xb6c(%rip), %rsi       # 0x20f6
cmovaq %rax, %rsi
movq %r14, %rdi
callq 0x10b0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/Razakhel[P]RaZonogram/src/Game.cpp
// Function: Game::play()
void Game::play() { //TODO: implement game loop
  int x, y, state;

  // Asks for a move until the grid is completed
  while (!grid.isComplete()) {
    // Keeps asking while the user hasn't picked correct numbers yet
    do {
      std::cout << "Choose 2 numbers (column and row) followed by 0, 1 or 2 (empty, filled or denied respectively), in the form 'x y z': ";
      std::cin >> x >> y >> state;
      std::cout << std::endl;
    } while (x < 1 && x > grid.getBoardHeight()
             && y < 1 && y > grid.getBoardWidth()
             && state < 0 && state > 2);

    // Defines the chosen tile's state to the one chosen
    grid.getBoard()[y - 1][x - 1].state = static_cast<State>(state);
    std::cout << grid << std::endl << std::endl;
  }

  std::cout << "Well done!" << std::endl;
  grid.clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x5bbe(%rip), %r14      # 0x7fc8
movq 0x5bc7(%rip), %r12      # 0x7fd8
leaq 0x14(%rsp), %r13
leaq 0x10(%rsp), %rbp
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
callq 0x2a28
testb %al, %al
jne 0x24a0
movq %r14, %rdi
leaq 0x2bce(%rip), %rsi      # 0x5004
callq 0x2150
movq %r12, %rdi
movq %r13, %rsi
callq 0x20c0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x20c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x20c0
movq %r14, %rdi
callq 0x20a0
movslq 0x14(%rsp), %rax
movl 0xc(%rsp), %ecx
movslq 0x10(%rsp), %rdx
movq 0x38(%rbx), %rsi
imulq $0x18, %rdx, %rdx
movq -0x18(%rsi,%rdx), %rdx
movl %ecx, -0x4(%rdx,%rax,4)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2aea
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
callq 0x20a0
jmp 0x2420
movq 0x5b21(%rip), %rdi      # 0x7fc8
leaq 0x2bcc(%rip), %rsi      # 0x507a
callq 0x2150
movq %rax, %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x29f8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x21c0
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %r14
movq %rsp, %r15
pushq $0x3b
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2260
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x281d
cmpq $0x0, 0x8(%rsp)
je 0x27ed
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2f9a
jmp 0x27ed
movq %rsp, %rdi
callq 0x2090
leaq 0x20(%rsp), %rdi
callq 0x2100
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x284d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2090
leaq 0x20(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/Razakhel[P]RaZonogram/src/Grid.cpp
// Function: Grid::solve()
Grid& Grid::solve() { //TODO: implement solver
  Grid& solvedGrid = *this;
  std::vector<int> totalRowClues(rowClues.size());
  std::vector<int> totalColClues(colClues.size());
  std::vector<int>::iterator rowMax, colMax;

  // Calculates the cumulated amount of clues for each row
  for (unsigned int i = 0; i < rowClues.size(); ++i)
    for (unsigned int j = 0; j < rowClues[i].size(); ++j)
      totalRowClues[i] += rowClues[i][j];

  // Same for each column
  for (unsigned int i = 0; i < colClues.size(); ++i)
    for (unsigned int j = 0; j < colClues[i].size(); ++j)
      totalColClues[i] += colClues[i][j];

  rowMax = std::max_element(totalRowClues.begin(), totalRowClues.end());
  colMax = std::max_element(totalColClues.begin(), totalColClues.end());
  std::cout << std::distance(totalRowClues.begin(), rowMax) << std::endl;
  std::cout << std::distance(totalColClues.begin(), colMax) << std::endl;

  return solvedGrid;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
subq 0x20(%rdi), %rax
pushq $0x18
popq %r14
cqto
idivq %r14
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %rax, %rsi
callq 0x2f26
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
cqto
idivq %r14
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x2f26
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r14
xorl %edx, %edx
movl %edx, %edx
cmpq %rdx, %rax
jbe 0x28fc
imulq $0x18, %rdx, %rdi
movq (%rcx,%rdi), %rsi
movq 0x8(%rcx,%rdi), %rdi
subq %rsi, %rdi
sarq $0x2, %rdi
xorl %r9d, %r9d
movq 0x28(%rsp), %r8
movl %r9d, %r9d
cmpq %r9, %rdi
jbe 0x28f8
movl (%rsi,%r9,4), %r10d
addl %r10d, (%r8,%rdx,4)
incl %r9d
jmp 0x28e3
incl %edx
jmp 0x28c0
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r14
xorl %edx, %edx
movl %edx, %edx
cmpq %rdx, %rax
jbe 0x294a
imulq $0x18, %rdx, %rdi
movq (%rcx,%rdi), %rsi
movq 0x8(%rcx,%rdi), %rdi
subq %rsi, %rdi
sarq $0x2, %rdi
xorl %r9d, %r9d
movq 0x10(%rsp), %r8
movl %r9d, %r9d
cmpq %r9, %rdi
jbe 0x2946
movl (%rsi,%r9,4), %r10d
addl %r10d, (%r8,%rdx,4)
incl %r9d
jmp 0x2931
incl %edx
jmp 0x290e
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x31e7
movq %rax, %r15
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x31e7
movq %rax, %r14
subq 0x28(%rsp), %r15
sarq $0x2, %r15
movq 0x564a(%rip), %rdi      # 0x7fc8
movq %r15, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x20a0
subq 0x10(%rsp), %r14
sarq $0x2, %r14
movq 0x562a(%rip), %rdi      # 0x7fc8
movq %r14, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x20a0
leaq 0x10(%rsp), %rdi
callq 0x33bc
leaq 0x28(%rsp), %rdi
callq 0x33bc
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x29d8
jmp 0x29d8
movq %rax, %rbx
jmp 0x29e5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x33bc
leaq 0x28(%rsp), %rdi
callq 0x33bc
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28(%rdi), %rax
movq 0x20(%rdi), %rcx
subq %rcx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movl 0x4(%rdi), %edx
movq 0x38(%rdi), %rsi
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %edi, %edi
movl %edi, %edi
cmpq %rdi, %rax
jbe 0x2aa2
imulq $0x18, %rdi, %r8
leaq (%rsi,%r8), %r9
xorl %r10d, %r10d
cmpq %r10, %rdx
je 0x2a7a
movq (%r9), %r11
xorl %r14d, %r14d
cmpl $0x1, (%r11,%r10,4)
sete %r14b
addl %r14d, %ebp
incq %r10
jmp 0x2a5e
movq (%rcx,%r8), %r9
movq 0x8(%rcx,%r8), %r8
subq %r9, %r8
sarq $0x2, %r8
xorl %r10d, %r10d
movl %r10d, %r10d
cmpq %r10, %r8
jbe 0x2a9e
addl (%r9,%r10,4), %ebx
incl %r10d
jmp 0x2a8d
incl %edi
jmp 0x2a4c
movq 0x551f(%rip), %rdi      # 0x7fc8
leaq 0x25f0(%rip), %rsi      # 0x50a0
callq 0x2150
movl %ebp, %esi
movq %rax, %rdi
callq 0x20d0
leaq 0x25e8(%rip), %rsi      # 0x50ae
movq %rax, %rdi
callq 0x2150
movl %ebx, %esi
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x20a0
cmpl %ebx, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6140
cmpl $-0x5, %eax
jne 0x6863
movq (%rbx), %rsi
addq %rsi, %rsi
movq %rsi, (%rbx)
movq (%r15), %rdi
callq 0x6560
movq %rax, %rdi
movq %rax, (%r15)
jmp 0x6833
testl %eax, %eax
jne 0x6877
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xe78a(%rip), %rdi      # 0x15008
movl %eax, %esi
xorl %eax, %eax
callq 0x6030
pushq $0x1
popq %rdi
callq 0x63a0
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/label_pcs.cpp
// Function: progress_func(void*)
void *progress_func(void *arg) {
    while (processed != total_chunks) {
        int p = processed.load();
        printf("\r%4d / %4d chunks processed (%3.2f%%).", p, total_chunks, 100*((float)p/total_chunks));
        fflush(stdout);
        usleep(500000);
    }
    printf("\n");
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xe4ba(%rip), %rbx      # 0x150b8
movq 0x1b3b3(%rip), %r14     # 0x21fb8
movl 0x1bab5(%rip), %eax     # 0x226c0
cmpl 0x1bab3(%rip), %eax     # 0x226c4
je 0x6c55
movl 0x1baa7(%rip), %esi     # 0x226c0
cvtsi2ss %esi, %xmm0
movl 0x1baa1(%rip), %edx     # 0x226c4
cvtsi2ss %edx, %xmm1
divss %xmm1, %xmm0
mulss 0xe3d1(%rip), %xmm0     # 0x15004
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
movb $0x1, %al
callq 0x6030
movq (%r14), %rdi
callq 0x6380
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x6450
jmp 0x6c05
pushq $0xa
popq %rdi
callq 0x6430
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
leaq 0xdd5e(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
leaq 0x1a46a(%rip), %rbx     # 0x22898
movq %rbx, %rdi
callq 0x13fe2
movq %rbx, %rdi
callq 0x13fe9
leaq 0x1a293(%rip), %rax     # 0x226d8
movq %rax, 0x1a464(%rip)     # 0x228b0
leaq 0x1a3e5(%rip), %rax     # 0x22838
movq %rax, 0x1a45e(%rip)     # 0x228b8
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
leaq 0xdd12(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
leaq 0x1a2fe(%rip), %rbx     # 0x22778
movq %rbx, %rdi
callq 0x13ff8
movq %rbx, %rdi
callq 0x13fe9
leaq 0x1a247(%rip), %rax     # 0x226d8
movq %rax, 0x1a2f8(%rip)     # 0x22790
leaq 0x1a2a1(%rip), %rax     # 0x22740
movq %rax, 0x1a2f2(%rip)     # 0x22798
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_CallStack_plog_2eproto()
static void InitDefaultsscc_info_CallStack_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rax
leaq 0xdcc6(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
andq $0x0, 0x1a219(%rip)     # 0x226e0
leaq 0x1a20a(%rip), %rdi     # 0x226d8
leaq 0x18cd3(%rip), %rax     # 0x211a8
movq %rax, 0x1a1fc(%rip)     # 0x226d8
xorps %xmm0, %xmm0
movups %xmm0, 0x1a202(%rip)    # 0x226e8
andl $0x0, 0x1a20b(%rip)     # 0x226f8
popq %rax
jmp 0x13fe9
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_DwarfCall_plog_2eproto()
static void InitDefaultsscc_info_DwarfCall_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rbx
leaq 0xdc7b(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
leaq 0x1a1ef(%rip), %rbx     # 0x22700
movq %rbx, %rdi
callq 0x14000
movq %rbx, %rdi
popq %rbx
jmp 0x13fe9
// File: /workspace/github_cpp_makefile_star2_O2/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 0xdc4c(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
leaq 0x1a4a8(%rip), %rbx     # 0x229e8
movq %rbx, %rdi
callq 0x700c
movq %rbx, %rdi
callq 0x13fe9
popq %rbx
jmp 0xf31c
// File: /workspace/github_cpp_makefile_star2_O2/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 0xdc18(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
andq $0x0, 0x1a2cb(%rip)     # 0x22840
leaq 0x1a2bc(%rip), %rdi     # 0x22838
leaq 0x19045(%rip), %rax     # 0x215c8
movq %rax, 0x1a2ae(%rip)     # 0x22838
xorps %xmm0, %xmm0
movups %xmm0, 0x1a2b4(%rip)    # 0x22848
movups %xmm0, 0x1a2b9(%rip)    # 0x22854
popq %rax
jmp 0x13fe9
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
leaq 0xdbcd(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
leaq 0x1a181(%rip), %rbx     # 0x22740
movq %rbx, %rdi
callq 0x14008
movq %rbx, %rdi
popq %rbx
jmp 0x13fe9
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
leaq 0xdb9e(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
leaq 0x1a27a(%rip), %rbx     # 0x22868
movq %rbx, %rdi
callq 0x14010
movq %rbx, %rdi
callq 0x13fe9
leaq 0x1a203(%rip), %rax     # 0x22808
movq %rax, 0x1a274(%rip)     # 0x22880
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_TaintQueryHypercall_plog_2eproto()
static void InitDefaultsscc_info_TaintQueryHypercall_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rbx
leaq 0xdb60(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
leaq 0x1a29c(%rip), %rbx     # 0x228c8
movq %rbx, %rdi
callq 0x14018
movq %rbx, %rdi
callq 0x13fe9
leaq 0x1a095(%rip), %rax     # 0x226d8
movq %rax, 0x1a2be(%rip)     # 0x22908
leaq 0x1a1e7(%rip), %rax     # 0x22838
movq %rax, 0x1a2b8(%rip)     # 0x22910
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_TaintQueryPri_plog_2eproto()
static void InitDefaultsscc_info_TaintQueryPri_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rbx
leaq 0xdb14(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
leaq 0x1a130(%rip), %rbx     # 0x227a8
movq %rbx, %rdi
callq 0x14020
movq %rbx, %rdi
callq 0x13fe9
leaq 0x1a049(%rip), %rax     # 0x226d8
movq %rax, 0x1a152(%rip)     # 0x227e8
leaq 0x1a0a3(%rip), %rax     # 0x22740
movq %rax, 0x1a14c(%rip)     # 0x227f0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_TaintQueryUniqueLabelSet_plog_2eproto()
static void InitDefaultsscc_info_TaintQueryUniqueLabelSet_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rax
leaq 0xdac8(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
andq $0x0, 0x1a14b(%rip)     # 0x22810
leaq 0x1a13c(%rip), %rdi     # 0x22808
leaq 0x18e45(%rip), %rax     # 0x21518
movq %rax, 0x1a12e(%rip)     # 0x22808
xorps %xmm0, %xmm0
movups %xmm0, 0x1a134(%rip)    # 0x22818
movups %xmm0, 0x1a13d(%rip)    # 0x22828
popq %rax
jmp 0x13fe9
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_TaintedBranch_plog_2eproto()
static void InitDefaultsscc_info_TaintedBranch_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rbx
leaq 0xda7d(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
leaq 0x1a219(%rip), %rbx     # 0x22928
movq %rbx, %rdi
callq 0x14028
movq %rbx, %rdi
callq 0x13fe9
leaq 0x19fb2(%rip), %rax     # 0x226d8
movq %rax, 0x1a22b(%rip)     # 0x22958
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_TaintedBranchSummary_plog_2eproto()
static void InitDefaultsscc_info_TaintedBranchSummary_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rax
leaq 0xda3f(%rip), %rdx      # 0x16176
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63c0
andq $0x0, 0x1a21a(%rip)     # 0x22968
leaq 0x1a20b(%rip), %rdi     # 0x22960
leaq 0x191dc(%rip), %rax     # 0x21938
movq %rax, 0x1a1fd(%rip)     # 0x22960
xorps %xmm0, %xmm0
movups %xmm0, 0x1a203(%rip)    # 0x22970
andq $0x0, 0x1a20b(%rip)     # 0x22980
popq %rax
jmp 0x13fe9