LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: suyash[P]chan/examples/go/../../chan.hh
// Function: chan::unbuffered_chan<double>::write(double const&)
void write(const T& val) {
		std::unique_lock<std::mutex> write_lock(write_mutex);
		std::unique_lock<std::mutex> data_lock(this->data_mutex);

		if (this->is_closed) {
			throw _closed_channel_write_exception;
		}

		data = val;
		set = true;
		this->write_wait_count++;

		if (this->read_wait_count > 0) {
			this->read_available.notify_one();
		}

		// wait until data is consumed
		while (!this->is_closed && set) {
			this->write_available.wait(data_lock);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0xe0, %rsi
leaq -0x20(%rbp), %rdi
callq 0x2cc0
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
leaq -0x30(%rbp), %rdi
callq 0x2cc0
jmp 0x30eb
movq -0x48(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x3159
movl $0x8, %edi
callq 0x2080
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
leaq 0x3feb(%rip), %rsi      # 0x70f8
callq 0x32a0
movq -0x50(%rbp), %rdi
leaq 0x3a63(%rip), %rsi      # 0x6b80
leaq -0xa94(%rip), %rdx      # 0x2690
callq 0x2140
jmp 0x31f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x31e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2d40
jmp 0x31e2
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0xa8(%rax)
movb $0x1, 0xb0(%rax)
movl 0x44(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x44(%rax)
cmpl $0x0, 0x40(%rax)
jle 0x3190
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x2090
jmp 0x3192
movq -0x48(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x10(%rcx)
movb %al, -0x51(%rbp)
jne 0x31ae
movq -0x48(%rbp), %rax
movb 0xb0(%rax), %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x31b7
jmp 0x31ca
movq -0x48(%rbp), %rdi
addq $0x78, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2050
jmp 0x3192
leaq -0x30(%rbp), %rdi
callq 0x2d40
leaq -0x20(%rbp), %rdi
callq 0x2d40
addq $0x60, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x2d40
movq -0x38(%rbp), %rdi
callq 0x2170
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3340
xorb $-0x1, %al
testb $0x1, %al
jne 0x2558
jmp 0x2681
jmp 0x255a
movq 0x11a67(%rip), %rdi     # 0x13fc8
leaq 0xaa9c(%rip), %rsi      # 0xd004
callq 0x2190
movq 0x11a64(%rip), %rdi     # 0x13fd8
leaq -0xc(%rbp), %rsi
callq 0x20f0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x20f0
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x20f0
movq 0x11a2c(%rip), %rdi     # 0x13fc8
movq 0x11a15(%rip), %rsi     # 0x13fb8
callq 0x21c0
xorl %eax, %eax
cmpl $0x1, -0xc(%rbp)
movb %al, -0x21(%rbp)
jge 0x260d
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
callq 0x26c0
movl -0x28(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jbe 0x260d
xorl %eax, %eax
cmpl $0x1, -0x10(%rbp)
movb %al, -0x21(%rbp)
jge 0x260d
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x26d0
movl -0x2c(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jbe 0x260d
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x21(%rbp)
jge 0x260d
cmpl $0x2, -0x14(%rbp)
setg %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x255a
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0x26f0
movq %rax, %rdi
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2710
movq %rax, %rdi
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2730
movl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rsi
movl %ecx, (%rax)
movq 0x1196f(%rip), %rdi     # 0x13fc8
callq 0x34c0
movq %rax, %rdi
movq 0x11950(%rip), %rsi     # 0x13fb8
callq 0x21c0
movq %rax, %rdi
movq 0x11941(%rip), %rsi     # 0x13fb8
callq 0x21c0
jmp 0x2544
movq 0x11940(%rip), %rdi     # 0x13fc8
leaq 0xa9eb(%rip), %rsi      # 0xd07a
callq 0x2190
movq %rax, %rdi
movq 0x1191a(%rip), %rsi     # 0x13fb8
callq 0x21c0
movq -0x20(%rbp), %rdi
callq 0x32c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x2120
movq -0x1d8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2210
jmp 0x2d4e
leaq -0x1d0(%rbp), %rdi
callq 0x2260
movsbl -0x9(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x2330
movq %rax, -0x1e0(%rbp)
jmp 0x2d7a
movq -0x1e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2240
movb %al, -0x1e1(%rbp)
jmp 0x2d98
movb -0x1e1(%rbp), %al
testb $0x1, %al
jne 0x2da4
jmp 0x2e01
leaq -0x1d0(%rbp), %rdi
callq 0x22d0
testb $0x1, %al
jne 0x2dfc
movq -0x18(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x4450
jmp 0x2dc6
jmp 0x2dfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2e22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x2100
jmp 0x2e22
jmp 0x2d5a
leaq -0x1d0(%rbp), %rdi
callq 0x2100
leaq -0x1a0(%rbp), %rdi
callq 0x2140
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x2140
movq -0x1a8(%rbp), %rdi
callq 0x22f0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x38(%rbp)
addq $0x20, %rdi
callq 0x3eb0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x3450
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x33da
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x2710
movq %rax, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x2730
cmpl $0x1, (%rax)
jne 0x33cd
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x33cf
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3394
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x40(%rbp)
addq $0x20, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3dc0
movq %rax, %rdi
callq 0x3fb0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x3440
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3dc0
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3fd0
movl (%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x33e1
jmp 0x3442
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3369
movq 0x10b71(%rip), %rdi     # 0x13fc8
leaq 0x9c27(%rip), %rsi      # 0xd085
callq 0x2190
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x9c1b(%rip), %rsi      # 0xd093
callq 0x2190
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2250
movq %rax, %rdi
movq 0x10b26(%rip), %rsi     # 0x13fb8
callq 0x21c0
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x34a5
movb $0x1, -0x1(%rbp)
jmp 0x34a9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq -0x20(%rbp), %rsi
callq 0x6150
movl %eax, -0x24(%rbp)
cmpl $-0x5, -0x24(%rbp)
jne 0x696a
movq -0x18(%rbp), %rax
movq (%rax), %rcx
shlq %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x65e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x698d
cmpl $0x0, -0x24(%rbp)
jne 0x6972
jmp 0x698f
movl -0x24(%rbp), %esi
leaq 0x2c6a0(%rip), %rdi     # 0x3301c
movb $0x0, %al
callq 0x6040
movl $0x1, %edi
callq 0x6410
jmp 0x690f
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
leaq 0x4076d(%rip), %rdi     # 0x47720
callq 0x7e10
cmpl 0x40766(%rip), %eax     # 0x47724
je 0x7094
leaq 0x40755(%rip), %rax     # 0x47720
movq %rax, -0x8(%rbp)
movl $0x5, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0xa970
movl %eax, -0x28(%rbp)
jmp 0x6ff0
movl -0x28(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
decl %eax
subl $0x2, %eax
jb 0x701a
jmp 0x7005
movl -0x34(%rbp), %eax
subl $0x5, %eax
je 0x7025
jmp 0x700f
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x7038
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x7038
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x7038
movq %rax, %rdi
callq 0x8620
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
movl 0x406dd(%rip), %edx     # 0x47724
cvtsi2ssl -0x24(%rbp), %xmm1
cvtsi2ssl 0x406d0(%rip), %xmm0 # 0x47724
divss %xmm0, %xmm1
movss 0x2bfb8(%rip), %xmm0    # 0x33018
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2c05d(%rip), %rdi     # 0x330cc
movb $0x1, %al
callq 0x6040
movq 0x3ff1b(%rip), %rax     # 0x46f98
movq (%rax), %rdi
callq 0x63f0
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x64c0
jmp 0x6fac
leaq 0x2c0a5(%rip), %rdi     # 0x33140
movb $0x0, %al
callq 0x6040
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x250dd(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x387c3(%rip), %rax     # 0x478f8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fc40
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x1a240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x2508d(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x38653(%rip), %rax     # 0x477d8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fc90
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x13410
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x2503d(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x38563(%rip), %rax     # 0x47738
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fcb0
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0xf5c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24fed(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x3853b(%rip), %rax     # 0x47760
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fcd0
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x10270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24f9d(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x387d3(%rip), %rax     # 0x47a48
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7860
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x21a00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24f4d(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x385d3(%rip), %rax     # 0x47898
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fcf0
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x17800
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24efd(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x3848b(%rip), %rax     # 0x477a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fd10
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x11c20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24ead(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x38563(%rip), %rax     # 0x478c8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fd30
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x18ce0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24e5d(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x38573(%rip), %rax     # 0x47928
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fd50
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x1b780
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24e0d(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x38403(%rip), %rax     # 0x47808
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fd70
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x14950
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24dbd(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x38413(%rip), %rax     # 0x47868
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fd90
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x16850
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24d6d(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x384e3(%rip), %rax     # 0x47988
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fdb0
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x1d680
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24d1d(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x384cb(%rip), %rax     # 0x479c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fdd0
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x1e850
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24ccd(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x384a3(%rip), %rax     # 0x479e8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fdf0
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x1f840
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x24c7d(%rip), %rdx     # 0x34206
callq 0x6430
leaq 0x3848b(%rip), %rax     # 0x47a20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fe10
movq -0x8(%rbp), %rdi
callq 0x2fc60
callq 0x20a10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::CallStack::Clear()
void CallStack::Clear() {
// @@protoc_insertion_point(message_clear_start:panda.CallStack)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  addr_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
addq $0x10, %rdi
callq 0x6490
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0xf93d
movq -0x30(%rbp), %rdi
callq 0x31950
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x88(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdx, -0x98(%rbp)
movq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl $0x0, -0x9c(%rbp)
movl $0x0, -0xa0(%rbp)
callq 0x27840
movl %eax, -0xa4(%rbp)
movl -0xa0(%rbp), %eax
cmpl -0xa4(%rbp), %eax
jge 0xfc79
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x27860
movq -0xb0(%rbp), %rdi
movq %rax, -0x90(%rbp)
movl -0xa0(%rbp), %esi
callq 0x278b0
movq %rax, %rcx
movq -0x90(%rbp), %rax
movl $0x1, -0x6c(%rbp)
movq %rcx, -0x78(%rbp)
movq %rax, -0x80(%rbp)
movl -0x6c(%rbp), %ecx
movq -0x80(%rbp), %rax
movl %ecx, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movl -0x34(%rbp), %edi
movl -0x38(%rbp), %esi
callq 0x301e0
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x30200
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x302e0
movq %rax, -0x90(%rbp)
movl -0xa0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa0(%rbp)
jmp 0xfbad
movq -0xb0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0xfd1c
movq -0xb0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq 0x3731a(%rip), %rax     # 0x46fd0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0xfcf7
movq -0xb8(%rbp), %rdi
callq 0x310a0
addq $0x8, %rax
movq %rax, -0x50(%rbp)
jmp 0xfcfe
callq *-0x60(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x61b0
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::CallStack::ByteSizeLong() const
size_t CallStack::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:panda.CallStack)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated uint64 addr = 1;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      UInt64Size(this->addr_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_addr_size());
    total_size += data_size;
  }

  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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
addq $0x10, %rdi
callq 0x62e0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x27840
movl %eax, %edi
callq 0x278e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
shlq $0x0, %rcx
addq -0x28(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x38(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq %rcx, -0x28(%rbp)
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0xfdcd
movq -0x48(%rbp), %rdx
movq %rdx, %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
addq $0x20, %rdx
callq 0x6060
movq %rax, -0x18(%rbp)
jmp 0xfded
movq -0x28(%rbp), %rdi
callq 0x278f0
movq -0x48(%rbp), %rdi
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
callq 0xf890
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, -0x49(%rbp)
cmpq %rcx, %rax
je 0xfe2a
jmp 0xfe73
leaq 0x243d5(%rip), %rdx     # 0x34206
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x3, %esi
movl $0x33e, %ecx            # imm = 0x33E
callq 0x6590
movq -0x80(%rbp), %rdi
movb $0x1, -0x49(%rbp)
leaq 0x243ba(%rip), %rsi     # 0x34211
callq 0x65f0
movq %rax, -0x78(%rbp)
jmp 0xfe62
movq -0x78(%rbp), %rsi
leaq -0x5d(%rbp), %rdi
callq 0x64b0
jmp 0xfe71
jmp 0xfe73
testb $0x1, -0x49(%rbp)
jne 0xfe7b
jmp 0xfe84
leaq -0x48(%rbp), %rdi
callq 0x6620
movq -0x10(%rbp), %rdi
callq 0x27900
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0xfec6
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x6350
jmp 0xfed3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x49(%rbp)
jne 0xfebb
jmp 0xfec4
leaq -0x48(%rbp), %rdi
callq 0x6620
jmp 0xfedc
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xfef0
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6630
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x50(%rbp)
movq %rsi, -0x58(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movq -0x58(%rbp), %rax
movb $0x0, -0x91(%rbp)
cmpq %rcx, %rax
je 0xff20
jmp 0xff7e
leaq 0x242df(%rip), %rdx     # 0x34206
leaq -0x90(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x3, %esi
movl $0x34d, %ecx            # imm = 0x34D
callq 0x6590
movq -0xc8(%rbp), %rdi
movb $0x1, -0x91(%rbp)
leaq 0x242b8(%rip), %rsi     # 0x34211
callq 0x65f0
movq %rax, -0xc0(%rbp)
jmp 0xff67
movq -0xc0(%rbp), %rsi
leaq -0xa5(%rbp), %rdi
callq 0x64b0
jmp 0xff7c
jmp 0xff7e
testb $0x1, -0x91(%rbp)
jne 0xff89
jmp 0xff95
leaq -0x90(%rbp), %rdi
callq 0x6620
movq -0xb8(%rbp), %rcx
addq $0x8, %rcx
movq -0x58(%rbp), %rax
addq $0x8, %rax
movq %rcx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0x1003f
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0x10028
movq -0xd8(%rbp), %rdi
callq 0x310a0
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x1002f
callq *-0x30(%rbp)
movq %rax, -0x20(%rbp)
movq -0xd0(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x318d0
movq -0xb8(%rbp), %rdi
movl $0x0, -0xac(%rbp)
addq $0x10, %rdi
movq -0x58(%rbp), %rsi
addq $0x10, %rsi
callq 0x6340
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
testb $0x1, -0x91(%rbp)
jne 0x10087
jmp 0x10093
leaq -0x90(%rbp), %rdi
callq 0x6620
jmp 0x10095
movq -0xa0(%rbp), %rdi
callq 0x6630
nopw %cs:(%rax,%rax)
// File: moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::CallStack::CopyFrom(google::protobuf::Message const&)
void CallStack::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:panda.CallStack)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
jne 0x100d0
jmp 0x100e6
movq -0x18(%rbp), %rdi
callq 0xf8e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfe00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::CallStack::CopyFrom(panda::CallStack const&)
void CallStack::CopyFrom(const CallStack& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:panda.CallStack)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
jne 0x10110
jmp 0x10126
movq -0x18(%rbp), %rdi
callq 0xf8e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfef0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x3c(%rbp)
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x1082d
movl -0x3c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x107fb
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x27d40
movl -0x3c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x10813
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x27d40
movl -0x3c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1082b
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
callq 0x27d40
jmp 0x1082d
movl -0x3c(%rbp), %eax
andl $0x18, %eax
cmpl $0x0, %eax
je 0x1085c
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq %rax, %rdx
addq $0x38, %rdx
addq $0x30, %rax
subq %rax, %rdx
addq $0x8, %rdx
xorl %esi, %esi
callq 0x61a0
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x61a0
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0x108b1
movq -0x50(%rbp), %rdi
callq 0x31950
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::DwarfCall::RequiredFieldsByteSizeFallback() const
size_t DwarfCall::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:panda.DwarfCall)
  size_t total_size = 0;

  if (_internal_has_file_callee()) {
    // required string file_callee = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_file_callee());
  }

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

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

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

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

  return total_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x27aa0
testb $0x1, %al
jne 0x11107
jmp 0x11124
movq -0x18(%rbp), %rdi
callq 0x27b40
movq %rax, %rdi
callq 0x281e0
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27b60
testb $0x1, %al
jne 0x11133
jmp 0x11150
movq -0x18(%rbp), %rdi
callq 0x27ba0
movq %rax, %rdi
callq 0x281e0
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27bc0
testb $0x1, %al
jne 0x1115f
jmp 0x1117c
movq -0x18(%rbp), %rdi
callq 0x27c00
movq %rax, %rdi
callq 0x281e0
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x28210
testb $0x1, %al
jne 0x1118b
jmp 0x111a8
movq -0x18(%rbp), %rdi
callq 0x281a0
movq %rax, %rdi
callq 0x28250
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x28270
testb $0x1, %al
jne 0x111b7
jmp 0x111d4
movq -0x18(%rbp), %rdi
callq 0x281c0
movq %rax, %rdi
callq 0x28250
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, -0x49(%rbp)
cmpq %rcx, %rax
je 0x1136a
jmp 0x113b3
leaq 0x22e95(%rip), %rdx     # 0x34206
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x3, %esi
movl $0x4d0, %ecx            # imm = 0x4D0
callq 0x6590
movq -0x80(%rbp), %rdi
movb $0x1, -0x49(%rbp)
leaq 0x22e7a(%rip), %rsi     # 0x34211
callq 0x65f0
movq %rax, -0x78(%rbp)
jmp 0x113a2
movq -0x78(%rbp), %rsi
leaq -0x5d(%rbp), %rdi
callq 0x64b0
jmp 0x113b1
jmp 0x113b3
testb $0x1, -0x49(%rbp)
jne 0x113bb
jmp 0x113c4
leaq -0x48(%rbp), %rdi
callq 0x6620
movq -0x10(%rbp), %rdi
callq 0x282b0
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x11406
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x6350
jmp 0x11413
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x113fb
jmp 0x11404
leaq -0x48(%rbp), %rdi
callq 0x6620
jmp 0x1141c
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x11430
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6630
nopw %cs:(%rax,%rax)
// File: moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::DwarfCall::CopyFrom(google::protobuf::Message const&)
void DwarfCall::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:panda.DwarfCall)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
jne 0x11710
jmp 0x11726
movq -0x18(%rbp), %rdi
callq 0x107a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11340
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::DwarfCall::CopyFrom(panda::DwarfCall const&)
void DwarfCall::CopyFrom(const DwarfCall& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:panda.DwarfCall)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
jne 0x11750
jmp 0x11766
movq -0x18(%rbp), %rdi
callq 0x107a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11430
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x3c(%rbp)
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x12115
movl -0x3c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x120fb
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x27d40
movl -0x3c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x12113
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x27d40
jmp 0x12115
movl -0x3c(%rbp), %eax
andl $0x1c, %eax
cmpl $0x0, %eax
je 0x12144
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq %rax, %rdx
addq $0x30, %rdx
addq $0x28, %rax
subq %rax, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x61a0
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x61a0
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0x12199
movq -0x50(%rbp), %rdi
callq 0x31950
addq $0x50, %rsp
popq %rbp
retq
nop