LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: RtApiPulse::abortStream()
void RtApiPulse::abortStream( void )
{
  PulseAudioHandle *pah = static_cast<PulseAudioHandle*>( stream_.apiHandle );

  if ( stream_.state == STREAM_CLOSED ) {
    errorText_ = "RtApiPulse::abortStream(): the stream is not open!";
    error( RtAudioError::INVALID_USE );
    return;
  }
  if ( stream_.state == STREAM_STOPPED ) {
    errorText_ = "RtApiPulse::abortStream(): the stream is already stopped!";
    error( RtAudioError::WARNING );
    return;
  }

  stream_.state = STREAM_STOPPED;
  MUTEX_LOCK( &stream_.mutex );

  if ( pah && pah->s_play ) {
    int pa_error;
    if ( pa_simple_flush( pah->s_play, &pa_error ) < 0 ) {
      errorStream_ << "RtApiPulse::abortStream: error flushing output device, " <<
        pa_strerror( pa_error ) << ".";
      errorText_ = errorStream_.str();
      MUTEX_UNLOCK( &stream_.mutex );
      error( RtAudioError::SYSTEM_ERROR );
      return;
    }
  }

  stream_.state = STREAM_STOPPED;
  MUTEX_UNLOCK( &stream_.mutex );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x1bc(%rdi), %eax
testl %eax, %eax
je 0x74ab
cmpl $-0x32, %eax
jne 0x74e2
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x253e(%rip), %rcx      # 0x99d2
movl $0x32, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
movl $0x7, %esi
jmp 0x74d2
leaq 0x180(%rbx), %rdi
movq 0x188(%rbx), %rdx
leaq 0x2545(%rip), %rcx      # 0x9a05
movl $0x39, %r8d
xorl %esi, %esi
callq 0x4310
movq %rbx, %rdi
xorl %esi, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5584
movq 0x1b0(%rbx), %r15
movl $0x0, 0x1bc(%rbx)
leaq 0x230(%rbx), %r14
movq %r14, %rdi
callq 0x42b0
testq %r15, %r15
je 0x751d
movq (%r15), %rdi
testq %rdi, %rdi
je 0x751d
leaq 0x4(%rsp), %rsi
callq 0x4080
testl %eax, %eax
js 0x753b
movl $0x0, 0x1bc(%rbx)
movq %r14, %rdi
callq 0x4160
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8(%rbx), %r15
leaq 0x24f9(%rip), %rsi      # 0x9a3f
movl $0x37, %edx
movq %r15, %rdi
callq 0x4200
movl 0x4(%rsp), %edi
callq 0x4050
testq %rax, %rax
je 0x757c
movq %rax, %r12
movq %rax, %rdi
callq 0x40c0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4200
jmp 0x7594
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x4390
leaq 0x26f4(%rip), %rsi      # 0x9c8f
movl $0x1, %edx
movq %r15, %rdi
callq 0x4200
leaq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4340
leaq 0x180(%rbx), %rdi
movq %r15, %rsi
callq 0x4260
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x75e2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x41f0
movq %r14, %rdi
callq 0x4160
movq %rbx, %rdi
movl $0x9, %esi
callq 0x5584
jmp 0x752f
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/RtAudio.cpp
// Function: pulseaudio_callback(void*)
static void *pulseaudio_callback( void * user )
{
  CallbackInfo *cbi = static_cast<CallbackInfo *>( user );
  RtApiPulse *context = static_cast<RtApiPulse *>( cbi->object );
  volatile bool *isRunning = &cbi->isRunning;

  while ( *isRunning ) {
    pthread_testcancel();
    context->callbackEvent();
  }

  pthread_exit( NULL );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movb 0x30(%rdi), %al
cmpb $0x1, %al
jne 0x7f8c
movq %rdi, %rbx
callq 0x4130
movq %r14, %rdi
callq 0x5c40
cmpb $0x0, 0x30(%rbx)
jne 0x7f79
xorl %edi, %edi
callq 0x43c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1040
movl %ebp, 0x8(%r14)
cmpb $0x1, 0x30(%r14)
jne 0x15bc
movq 0x2a6f(%rip), %r14      # 0x3ff0
leaq 0xb54(%rip), %rsi       # 0x20dc
movl $0xe, %edx
movq %r14, %rdi
callq 0x10b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1040
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 0x1619
movq %r14, %rdi
callq 0x162c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x29af(%rip), %rdi      # 0x3ff0
leaq 0xaa3(%rip), %rsi       # 0x20eb
movl $0x1, %edx
callq 0x10b0
movl (%rbx), %eax
testl %eax, %eax
je 0x169b
cvtsi2ss %rax, %xmm0
mulss 0xc(%rbx), %xmm0
cvttss2si %xmm0, %r15
xorl %ebp, %ebp
leaq 0xa2b(%rip), %r12       # 0x209b
leaq 0xa76(%rip), %r13       # 0x20ed
movq 0x2972(%rip), %r14      # 0x3ff0
cmpl %r15d, %ebp
movq %r13, %rsi
cmovaq %r12, %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x10b0
incl %ebp
cmpl (%rbx), %ebp
jb 0x167e
movq 0x294e(%rip), %r14      # 0x3ff0
leaq 0xa46(%rip), %rsi       # 0x20ef
movl $0x2, %edx
movq %r14, %rdi
callq 0x10b0
movss 0xc(%rbx), %xmm0
mulss 0xa11(%rip), %xmm0      # 0x20d4
cvttss2si %xmm0, %rax
movl %eax, %esi
movq %r14, %rdi
callq 0x1050
leaq 0xa19(%rip), %rsi       # 0x20f2
movl $0x1, %edx
movq %rax, %rdi
callq 0x10b0
movss 0x9ea(%rip), %xmm0      # 0x20d8
ucomiss 0xc(%rbx), %xmm0
jbe 0x1709
movq 0x28f5(%rip), %rdi      # 0x3ff0
leaq 0x9f2(%rip), %rsi       # 0x20f4
movl $0x1, %edx
jmp 0x171c
movq 0x28e0(%rip), %rdi      # 0x3ff0
leaq 0x9df(%rip), %rsi       # 0x20f6
movl $0x2, %edx
callq 0x10b0
movq 0x28c8(%rip), %rdi      # 0x3ff0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
callq 0x2db8
testb %al, %al
jne 0x25c4
movq 0x5b01(%rip), %r14      # 0x7fc8
leaq 0x14(%rsp), %r13
leaq 0x10(%rsp), %rbp
leaq 0xc(%rsp), %r15
movl $0x75, %edx
movq %r14, %rdi
leaq 0x2b1f(%rip), %rsi      # 0x5004
callq 0x2190
movq 0x5ae7(%rip), %rdi      # 0x7fd8
movq %r13, %rsi
callq 0x20c0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x20c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x20c0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movslq 0x14(%rsp), %rax
movl 0xc(%rsp), %ecx
movslq 0x10(%rsp), %rdx
movq 0x38(%rbx), %rsi
leaq (%rdx,%rdx,2), %rdx
movq -0x18(%rsi,%rdx,8), %rdx
movl %ecx, -0x4(%rdx,%rax,4)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ec6
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2db8
testb %al, %al
je 0x24d6
movq 0x59fd(%rip), %r14      # 0x7fc8
leaq 0x2aa8(%rip), %rsi      # 0x507a
movl $0xa, %edx
movq %r14, %rdi
callq 0x2190
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2d68
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/Razakhel[P]RaZonogram/./include/Utils.hpp
// Function: Utils::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
static void split(const std::string& str, char delim, std::vector<std::string>& elems) {
    std::stringstream ss;
    ss.str(str);

    std::string item;
    while (std::getline(ss, item, delim)) {
      if (!item.empty()) elems.push_back(item);
    }
  }

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rdx
subq %rax, %rdx
je 0x2e45
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movl 0x4(%rdi), %edx
movq 0x38(%rdi), %rsi
xorl %edi, %edi
xorl %r14d, %r14d
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x2e10
leaq (%rdi,%rdi,2), %r8
movq (%rsi,%r8,8), %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpl $0x1, (%r8,%r9,4)
sete %r10b
addl %r10d, %r14d
incq %r9
cmpq %r9, %rdx
jne 0x2df9
leaq (%rdi,%rdi,2), %r9
movq (%rax,%r9,8), %r8
movq 0x8(%rax,%r9,8), %r9
subq %r8, %r9
je 0x2e38
sarq $0x2, %r9
xorl %r10d, %r10d
addl (%r8,%r10,4), %ebp
incq %r10
movl %r10d, %r11d
cmpq %r11, %r9
ja 0x2e29
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x2de9
jmp 0x2e4a
xorl %ebp, %ebp
xorl %r14d, %r14d
movq 0x5177(%rip), %rbx      # 0x7fc8
leaq 0x2248(%rip), %rsi      # 0x50a0
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2190
movl %r14d, %esi
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x2234(%rip), %rsi      # 0x50ae
movl $0x10, %edx
movq %rax, %rdi
callq 0x2190
movl %ebp, %esi
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
cmpl %ebp, %r14d
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsp, %r12
movq (%rbx), %rcx
movq %rcx, (%rsp)
movq (%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x6130
cmpl $-0x5, %eax
jne 0x7120
movq (%rbx), %rsi
addq %rsi, %rsi
movq %rsi, (%rbx)
movq (%r15), %rdi
callq 0x6570
movq %rax, (%r15)
jmp 0x70f0
testl %eax, %eax
jne 0x7134
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x11ee5(%rip), %rdi     # 0x19020
movl %eax, %esi
xorl %eax, %eax
callq 0x6030
movl $0x1, %edi
callq 0x63c0
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_AttackPoint_plog_2eproto()
static void InitDefaultsscc_info_AttackPoint_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rax
leaq 0x115d2(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
xorps %xmm0, %xmm0
movups %xmm0, 0x1bcd3(%rip)    # 0x248a0
leaq 0x1ab54(%rip), %rax     # 0x23728
movq %rax, 0x1bcbd(%rip)     # 0x24898
movl 0x1b74f(%rip), %eax     # 0x24330
testl %eax, %eax
jne 0x8c27
movups %xmm0, 0x1bcc4(%rip)    # 0x248b0
movl $0x0, 0x1bcca(%rip)     # 0x248c0
leaq 0x1bc9b(%rip), %rsi     # 0x24898
movq 0x1b3cc(%rip), %rdi     # 0x23fd0
callq 0x6060
leaq 0x1bac8(%rip), %rax     # 0x246d8
movq %rax, 0x1bc99(%rip)     # 0x248b0
leaq 0x1bc1a(%rip), %rax     # 0x24838
movq %rax, 0x1bc93(%rip)     # 0x248b8
popq %rax
retq
leaq 0x1b702(%rip), %rdi     # 0x24330
callq 0x63d0
xorps %xmm0, %xmm0
jmp 0x8be5
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_AttackPointPri_plog_2eproto()
static void InitDefaultsscc_info_AttackPointPri_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rax
leaq 0x11546(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
xorps %xmm0, %xmm0
movups %xmm0, 0x1bb27(%rip)    # 0x24780
leaq 0x1a758(%rip), %rax     # 0x233b8
movq %rax, 0x1bb11(%rip)     # 0x24778
movl 0x1b6eb(%rip), %eax     # 0x24358
testl %eax, %eax
jne 0x8cb3
movups %xmm0, 0x1bb18(%rip)    # 0x24790
movl $0x0, 0x1bb1e(%rip)     # 0x247a0
leaq 0x1baef(%rip), %rsi     # 0x24778
movq 0x1b340(%rip), %rdi     # 0x23fd0
callq 0x6060
leaq 0x1ba3c(%rip), %rax     # 0x246d8
movq %rax, 0x1baed(%rip)     # 0x24790
leaq 0x1ba96(%rip), %rax     # 0x24740
movq %rax, 0x1bae7(%rip)     # 0x24798
popq %rax
retq
leaq 0x1b69e(%rip), %rdi     # 0x24358
callq 0x63d0
xorps %xmm0, %xmm0
jmp 0x8c71
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1142a(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
xorps %xmm0, %xmm0
movups %xmm0, 0x1bc7b(%rip)    # 0x249f0
leaq 0x1adcc(%rip), %rax     # 0x23b48
movq %rax, 0x1bc65(%rip)     # 0x249e8
movl 0x1b627(%rip), %eax     # 0x243b0
testl %eax, %eax
jne 0x8e6b
movq 0x1b228(%rip), %rax     # 0x23fc0
movq %rax, 0x1bc61(%rip)     # 0x24a00
leaq 0x1bc42(%rip), %rbx     # 0x249e8
leaq 0x1bc5b(%rip), %rdi     # 0x24a08
movl $0x98, %edx
xorl %esi, %esi
callq 0x6190
movq 0x1b210(%rip), %rdi     # 0x23fd0
movq %rbx, %rsi
callq 0x6060
leaq 0x1b909(%rip), %rax     # 0x246d8
movq %rax, 0x1bc32(%rip)     # 0x24a08
leaq 0x1b923(%rip), %rax     # 0x24700
movq %rax, 0x1bc54(%rip)     # 0x24a38
movq %rax, 0x1bc55(%rip)     # 0x24a40
leaq 0x1b9b6(%rip), %rax     # 0x247a8
movq %rax, 0x1bc4f(%rip)     # 0x24a48
leaq 0x1b978(%rip), %rax     # 0x24778
movq %rax, 0x1bc49(%rip)     # 0x24a50
leaq 0x1b932(%rip), %rax     # 0x24740
movq %rax, 0x1bc43(%rip)     # 0x24a58
leaq 0x1baac(%rip), %rax     # 0x248c8
movq %rax, 0x1bbfd(%rip)     # 0x24a20
leaq 0x1ba6e(%rip), %rax     # 0x24898
movq %rax, 0x1bbf7(%rip)     # 0x24a28
leaq 0x1baf0(%rip), %rax     # 0x24928
movq %rax, 0x1bbd1(%rip)     # 0x24a10
leaq 0x1bb1a(%rip), %rax     # 0x24960
movq %rax, 0x1bc13(%rip)     # 0x24a60
leaq 0x1bb34(%rip), %rax     # 0x24988
movq %rax, 0x1bbbd(%rip)     # 0x24a18
leaq 0x1bb5e(%rip), %rax     # 0x249c0
movq %rax, 0x1bbc7(%rip)     # 0x24a30
popq %rbx
retq
leaq 0x1b53e(%rip), %rdi     # 0x243b0
callq 0x63d0
jmp 0x8d91
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11302(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
leaq 0x1b99e(%rip), %rsi     # 0x24838
movq $0x0, 0x1b99b(%rip) # 0x24840
leaq 0x1a71c(%rip), %rax     # 0x235c8
movq %rax, 0x1b985(%rip)     # 0x24838
xorps %xmm0, %xmm0
movups %xmm0, 0x1b98b(%rip)    # 0x24848
movups %xmm0, 0x1b990(%rip)    # 0x24854
movq 0x1b105(%rip), %rdi     # 0x23fd0
popq %rax
jmp 0x6060
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_TaintQuery_plog_2eproto()
static void InitDefaultsscc_info_TaintQuery_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rax
leaq 0x11275(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
xorps %xmm0, %xmm0
movups %xmm0, 0x1b946(%rip)    # 0x24870
leaq 0x1a747(%rip), %rax     # 0x23678
movq %rax, 0x1b930(%rip)     # 0x24868
movl 0x1b512(%rip), %eax     # 0x24450
testl %eax, %eax
jne 0x8f77
movups %xmm0, 0x1b937(%rip)    # 0x24880
movq $0x0, 0x1b93c(%rip) # 0x24890
leaq 0x1b90d(%rip), %rsi     # 0x24868
movq 0x1b06e(%rip), %rdi     # 0x23fd0
callq 0x6060
leaq 0x1b89a(%rip), %rax     # 0x24808
movq %rax, 0x1b90b(%rip)     # 0x24880
popq %rax
retq
leaq 0x1b4d2(%rip), %rdi     # 0x24450
callq 0x63d0
xorps %xmm0, %xmm0
jmp 0x8f42
// File: /workspace/github_cpp_makefile_star2_O1/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 0x111f6(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
leaq 0x1b922(%rip), %rbx     # 0x248c8
movq %rbx, %rdi
xorl %esi, %esi
callq 0xff8c
movq 0x1b019(%rip), %rdi     # 0x23fd0
movq %rbx, %rsi
callq 0x6060
leaq 0x1b712(%rip), %rax     # 0x246d8
movq %rax, 0x1b93b(%rip)     # 0x24908
leaq 0x1b864(%rip), %rax     # 0x24838
movq %rax, 0x1b935(%rip)     # 0x24910
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x111a1(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
leaq 0x1b7ad(%rip), %rbx     # 0x247a8
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc0c4
movq 0x1afc4(%rip), %rdi     # 0x23fd0
movq %rbx, %rsi
callq 0x6060
leaq 0x1b6bd(%rip), %rax     # 0x246d8
movq %rax, 0x1b7c6(%rip)     # 0x247e8
leaq 0x1b717(%rip), %rax     # 0x24740
movq %rax, 0x1b7c0(%rip)     # 0x247f0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x110f7(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
leaq 0x1b883(%rip), %rbx     # 0x24928
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11336
movq 0x1af1a(%rip), %rdi     # 0x23fd0
movq %rbx, %rsi
callq 0x6060
leaq 0x1b613(%rip), %rax     # 0x246d8
movq %rax, 0x1b88c(%rip)     # 0x24958
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x110b0(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
leaq 0x1b874(%rip), %rsi     # 0x24960
xorl %eax, %eax
movq %rax, 0x1b873(%rip)     # 0x24968
leaq 0x1a83c(%rip), %rcx     # 0x23938
movq %rcx, 0x1b85d(%rip)     # 0x24960
xorps %xmm0, %xmm0
movups %xmm0, 0x1b863(%rip)    # 0x24970
movq %rax, 0x1b86c(%rip)     # 0x24980
movq 0x1aeb5(%rip), %rdi     # 0x23fd0
popq %rax
jmp 0x6060
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_TaintedInstr_plog_2eproto()
static void InitDefaultsscc_info_TaintedInstr_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rbx
leaq 0x1105d(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
leaq 0x1b849(%rip), %rbx     # 0x24988
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1252a
movq 0x1ae80(%rip), %rdi     # 0x23fd0
movq %rbx, %rsi
callq 0x6060
leaq 0x1b579(%rip), %rax     # 0x246d8
movq %rax, 0x1b852(%rip)     # 0x249b8
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: InitDefaultsscc_info_TaintedInstrSummary_plog_2eproto()
static void InitDefaultsscc_info_TaintedInstrSummary_plog_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

// Assembly:
pushq %rax
leaq 0x11016(%rip), %rdx     # 0x1a186
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
callq 0x63e0
leaq 0x1b83a(%rip), %rsi     # 0x249c0
xorl %eax, %eax
movq %rax, 0x1b839(%rip)     # 0x249c8
leaq 0x1a902(%rip), %rcx     # 0x23a98
movq %rcx, 0x1b823(%rip)     # 0x249c0
xorps %xmm0, %xmm0
movups %xmm0, 0x1b829(%rip)    # 0x249d0
movq %rax, 0x1b832(%rip)     # 0x249e0
movq 0x1ae1b(%rip), %rdi     # 0x23fd0
popq %rax
jmp 0x6060
nop
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::CallStack::_InternalSerialize(unsigned char*, google::protobuf::io::EpsCopyOutputStream*) const
::PROTOBUF_NAMESPACE_ID::uint8* CallStack::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:panda.CallStack)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated uint64 addr = 1;
  for (int i = 0, n = this->_internal_addr_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_addr(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:panda.CallStack)
  return target;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x10(%rdi), %r13d
testl %r13d, %r13d
jle 0x95ee
leaq 0x10(%r15), %r12
xorl %ebp, %ebp
cmpq %r14, (%rbx)
jbe 0x95de
movq %r12, %rdi
movl %ebp, %esi
callq 0x6100
movq (%rax), %rcx
movb $0x8, (%r14)
cmpq $0x7f, %rcx
ja 0x958f
movb %cl, 0x1(%r14)
addq $0x2, %r14
jmp 0x95d5
movl %ecx, %eax
orb $-0x80, %al
movb %al, 0x1(%r14)
movq %rcx, %rax
shrq $0x7, %rax
cmpq $0x3fff, %rcx           # imm = 0x3FFF
ja 0x95b1
movb %al, 0x2(%r14)
addq $0x3, %r14
jmp 0x95d5
addq $0x3, %r14
movq %rax, %rcx
movl %ecx, %edx
orb $-0x80, %dl
movb %dl, -0x1(%r14)
shrq $0x7, %rax
incq %r14
cmpq $0x3fff, %rcx           # imm = 0x3FFF
ja 0x95b5
movb %al, -0x1(%r14)
incl %ebp
cmpl %r13d, %ebp
jne 0x9569
jmp 0x95ee
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6520
movq %rax, %r14
jmp 0x956e
movq 0x8(%r15), %rdi
testb $0x1, %dil
jne 0x960a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andq $-0x2, %rdi
addq $0x8, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x61a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::CallStack::MergeFrom(google::protobuf::Message const&)
void CallStack::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:panda.CallStack)
  GOOGLE_DCHECK_NE(&from, this);
  const CallStack* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CallStack>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:panda.CallStack)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:panda.CallStack)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0x96ba
leaq 0x10b09(%rip), %rdx     # 0x1a186
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x33e, %ecx            # imm = 0x33E
callq 0x6530
leaq 0x10af6(%rip), %rsi     # 0x1a191
movq %r15, %rdi
callq 0x6580
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6450
leaq 0x8(%rsp), %rdi
callq 0x65a0
cmpq %r14, %rbx
leaq 0x19ae4(%rip), %rax     # 0x231a8
cmpq %rax, (%rbx)
je 0x96d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6330
jmp 0x96e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9702
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x96ed
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x65a0
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::CallStack::MergeFrom(panda::CallStack const&)
void CallStack::MergeFrom(const CallStack& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:panda.CallStack)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  addr_.MergeFrom(from.addr_);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0x975a
leaq 0x10a69(%rip), %rdx     # 0x1a186
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x34d, %ecx            # imm = 0x34D
callq 0x6530
leaq 0x10a56(%rip), %rsi     # 0x1a191
movq %r15, %rdi
callq 0x6580
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6450
leaq 0x8(%rsp), %rdi
callq 0x65a0
cmpq %r14, %rbx
movq 0x8(%rbx), %rsi
testb $0x1, %sil
je 0x9778
leaq 0x8(%r14), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x18514
addq $0x10, %r14
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6320
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9797
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x65a0
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::DwarfCall::DwarfCall(panda::DwarfCall const&)
DwarfCall::DwarfCall(const DwarfCall& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  file_callee_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_file_callee()) {
    file_callee_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_file_callee(),
      GetArena());
  }
  function_name_callee_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_function_name_callee()) {
    function_name_callee_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_function_name_callee(),
      GetArena());
  }
  file_caller_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_file_caller()) {
    file_caller_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_file_caller(),
      GetArena());
  }
  ::memcpy(&line_number_callee_, &from.line_number_callee_,
    static_cast<size_t>(reinterpret_cast<char*>(&line_number_caller_) -
    reinterpret_cast<char*>(&line_number_callee_)) + sizeof(line_number_caller_));
  // @@protoc_insertion_point(copy_constructor:panda.DwarfCall)
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq $0x0, 0x8(%rdi)
leaq 0x1994d(%rip), %rax     # 0x23258
movq %rax, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0x9935
andq $-0x2, %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x18514
movq 0x1a684(%rip), %r12     # 0x23fc0
movq %r12, 0x18(%rbx)
testb $0x1, 0x10(%r14)
je 0x995d
leaq 0x18(%rbx), %rdi
movq 0x18(%r14), %rdx
movq (%r15), %rsi
testb $0x1, %sil
jne 0x99b4
callq 0x180fe
movq %r12, 0x20(%rbx)
testb $0x2, 0x10(%r14)
je 0x997e
leaq 0x20(%rbx), %rdi
movq 0x20(%r14), %rdx
movq (%r15), %rsi
testb $0x1, %sil
jne 0x99bd
callq 0x180fe
movq %r12, 0x28(%rbx)
testb $0x4, 0x10(%r14)
je 0x999f
leaq 0x28(%rbx), %rdi
movq 0x28(%r14), %rdx
movq (%r15), %rsi
testb $0x1, %sil
jne 0x99c6
callq 0x180fe
movups 0x30(%r14), %xmm0
movups %xmm0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0x9958
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0x9979
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0x999a
nop
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::DwarfCall::Clear()
void DwarfCall::Clear() {
// @@protoc_insertion_point(message_clear_start:panda.DwarfCall)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      file_callee_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      function_name_callee_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      file_caller_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x00000018u) {
    ::memset(&line_number_callee_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&line_number_caller_) -
        reinterpret_cast<char*>(&line_number_callee_)) + sizeof(line_number_caller_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

// Assembly:
movl 0x10(%rdi), %eax
testb $0x7, %al
je 0x9a7d
testb $0x1, %al
je 0x9a51
movq 0x18(%rdi), %rcx
movq $0x0, 0x8(%rcx)
movq (%rcx), %rcx
movb $0x0, (%rcx)
testb $0x2, %al
je 0x9a67
movq 0x20(%rdi), %rcx
movq $0x0, 0x8(%rcx)
movq (%rcx), %rcx
movb $0x0, (%rcx)
testb $0x4, %al
je 0x9a7d
movq 0x28(%rdi), %rcx
movq $0x0, 0x8(%rcx)
movq (%rcx), %rcx
movb $0x0, (%rcx)
testb $0x18, %al
je 0x9a88
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movl $0x0, 0x10(%rdi)
testb $0x1, 0x8(%rdi)
jne 0x9a96
retq
addq $0x8, %rdi
jmp 0x18542
nop
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::DwarfCall::ByteSizeLong() const
size_t DwarfCall::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:panda.DwarfCall)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0000001f) ^ 0x0000001f) == 0) {  // All required fields are present.
    // required string file_callee = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_file_callee());

    // required string function_name_callee = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_function_name_callee());

    // required string file_caller = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_file_caller());

    // required uint64 line_number_callee = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->_internal_line_number_callee());

    // required uint64 line_number_caller = 5;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->_internal_line_number_caller());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %eax
notl %eax
testb $0x1f, %al
jne 0xa1c7
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
movq 0x8(%rax), %rax
movl %eax, %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
movq 0x8(%rdx), %rdx
addq %rdx, %rax
orl $0x1, %edx
bsrl %edx, %edx
leal (%rdx,%rdx,8), %edx
addl $0x49, %edx
shrl $0x6, %edx
movq 0x28(%rbx), %rsi
movq 0x8(%rsi), %rsi
addq %rsi, %rax
orl $0x1, %esi
bsrl %esi, %esi
leal (%rsi,%rsi,8), %esi
addl $0x49, %esi
shrl $0x6, %esi
movq 0x30(%rbx), %rdi
orq $0x1, %rdi
bsrq %rdi, %rdi
leal (%rdi,%rdi,8), %edi
addl $0x49, %edi
shrl $0x6, %edi
addq %rdx, %rdi
movq 0x38(%rbx), %rdx
orq $0x1, %rdx
bsrq %rdx, %rdx
leal (%rdx,%rdx,8), %edx
addl $0x49, %edx
shrl $0x6, %edx
addq %rcx, %rax
addq %rdi, %rax
addq %rsi, %rax
addq %rdx, %rax
addq $0x5, %rax
jmp 0xa1cf
movq %rbx, %rdi
callq 0xa074
testb $0x1, 0x8(%rbx)
jne 0xa1da
movl %eax, 0x14(%rbx)
popq %rbx
retq
leaq 0x8(%rbx), %rdi
addq $0x14, %rbx
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0x6050
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::DwarfCall::MergeFrom(google::protobuf::Message const&)
void DwarfCall::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:panda.DwarfCall)
  GOOGLE_DCHECK_NE(&from, this);
  const DwarfCall* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<DwarfCall>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:panda.DwarfCall)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:panda.DwarfCall)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0xa246
leaq 0xff7d(%rip), %rdx      # 0x1a186
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x4d0, %ecx            # imm = 0x4D0
callq 0x6530
leaq 0xff6a(%rip), %rsi      # 0x1a191
movq %r15, %rdi
callq 0x6580
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6450
leaq 0x8(%rsp), %rdi
callq 0x65a0
cmpq %r14, %rbx
leaq 0x19008(%rip), %rax     # 0x23258
cmpq %rax, (%rbx)
je 0xa262
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6330
jmp 0xa26d
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa28e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xa279
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x65a0
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::DwarfCall::MergeFrom(panda::DwarfCall const&)
void DwarfCall::MergeFrom(const DwarfCall& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:panda.DwarfCall)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_file_callee(from._internal_file_callee());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_function_name_callee(from._internal_function_name_callee());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_file_caller(from._internal_file_caller());
    }
    if (cached_has_bits & 0x00000008u) {
      line_number_callee_ = from.line_number_callee_;
    }
    if (cached_has_bits & 0x00000010u) {
      line_number_caller_ = from.line_number_caller_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rdi, %rsi
jne 0xa2e7
leaq 0xfedc(%rip), %rdx      # 0x1a186
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x4df, %ecx            # imm = 0x4DF
callq 0x6530
leaq 0xfec9(%rip), %rsi      # 0x1a191
movq %r15, %rdi
callq 0x6580
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x6450
leaq 0x10(%rsp), %rdi
callq 0x65a0
cmpq %rbx, %r14
movq 0x8(%r14), %rsi
testb $0x1, %sil
je 0xa305
leaq 0x8(%rbx), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x18514
movl 0x10(%r14), %ebp
testb $0x1f, %bpl
je 0xa3e8
testb $0x1, %bpl
je 0xa351
movq 0x18(%r14), %rdx
orl $0x1, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
movq 0x8(%rbx), %rsi
testb $0x1, %sil
jne 0xa3f3
movq (%rdi), %rax
cmpq 0x19c83(%rip), %rax     # 0x23fc0
je 0xa34c
movq %rax, %rdi
movq %rdx, %rsi
callq 0x6180
jmp 0xa351
callq 0x180fe
testb $0x2, %bpl
je 0xa38f
movq 0x20(%r14), %rdx
orl $0x2, 0x10(%rbx)
leaq 0x20(%rbx), %rdi
movq 0x8(%rbx), %rsi
testb $0x1, %sil
jne 0xa3ff
movq (%rdi), %rax
cmpq 0x19c45(%rip), %rax     # 0x23fc0
je 0xa38a
movq %rax, %rdi
movq %rdx, %rsi
callq 0x6180
jmp 0xa38f
callq 0x180fe
testb $0x4, %bpl
je 0xa3c9
movq 0x28(%r14), %rdx
orl $0x4, 0x10(%rbx)
leaq 0x28(%rbx), %rdi
movq 0x8(%rbx), %rsi
testb $0x1, %sil
jne 0xa40b
movq (%rdi), %rax
cmpq 0x19c0b(%rip), %rax     # 0x23fc0
je 0xa3c4
movq %rax, %rdi
movq %rdx, %rsi
callq 0x6180
jmp 0xa3c9
callq 0x180fe
testb $0x8, %bpl
je 0xa3d7
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
testb $0x10, %bpl
je 0xa3e5
movq 0x38(%r14), %rax
movq %rax, 0x38(%rbx)
orl %ebp, 0x10(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0xa333
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0xa371
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0xa3ab
jmp 0xa416
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x65a0
movq %rbx, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::SrcInfoPri::SrcInfoPri(panda::SrcInfoPri const&)
SrcInfoPri::SrcInfoPri(const SrcInfoPri& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  filename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_filename()) {
    filename_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_filename(),
      GetArena());
  }
  astnodename_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_astnodename()) {
    astnodename_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_astnodename(),
      GetArena());
  }
  ::memcpy(&linenum_, &from.linenum_,
    static_cast<size_t>(reinterpret_cast<char*>(&ast_loc_id_) -
    reinterpret_cast<char*>(&linenum_)) + sizeof(ast_loc_id_));
  // @@protoc_insertion_point(copy_constructor:panda.SrcInfoPri)
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq $0x0, 0x8(%rdi)
leaq 0x18baf(%rip), %rax     # 0x23308
movq %rax, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0xa783
andq $-0x2, %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x18514
movq 0x19836(%rip), %r12     # 0x23fc0
movq %r12, 0x18(%rbx)
testb $0x1, 0x10(%r14)
je 0xa7ab
leaq 0x18(%rbx), %rdi
movq 0x18(%r14), %rdx
movq (%r15), %rsi
testb $0x1, %sil
jne 0xa7e7
callq 0x180fe
movq %r12, 0x20(%rbx)
testb $0x2, 0x10(%r14)
je 0xa7cc
leaq 0x20(%rbx), %rdi
movq 0x20(%r14), %rdx
movq (%r15), %rsi
testb $0x1, %sil
jne 0xa7f0
callq 0x180fe
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0xa7a6
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0xa7c7
nop
// File: /workspace/github_cpp_makefile_star2_O1/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::SrcInfoPri::Clear()
void SrcInfoPri::Clear() {
// @@protoc_insertion_point(message_clear_start:panda.SrcInfoPri)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      filename_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      astnodename_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x0000001cu) {
    ::memset(&linenum_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&ast_loc_id_) -
        reinterpret_cast<char*>(&linenum_)) + sizeof(ast_loc_id_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

// Assembly:
movl 0x10(%rdi), %eax
testb $0x3, %al
je 0xa891
testb $0x1, %al
je 0xa87b
movq 0x18(%rdi), %rcx
movq $0x0, 0x8(%rcx)
movq (%rcx), %rcx
movb $0x0, (%rcx)
testb $0x2, %al
je 0xa891
movq 0x20(%rdi), %rcx
movq $0x0, 0x8(%rcx)
movq (%rcx), %rcx
movb $0x0, (%rcx)
testb $0x1c, %al
je 0xa8a4
movl $0x0, 0x30(%rdi)
movq $0x0, 0x28(%rdi)
movl $0x0, 0x10(%rdi)
testb $0x1, 0x8(%rdi)
jne 0xa8b2
retq
addq $0x8, %rdi
jmp 0x18542
nop