LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintQuery::InternalSwap(panda::TaintQuery*)
void TaintQuery::InternalSwap(TaintQuery* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TaintQuery, offset_)
      + sizeof(TaintQuery::offset_)
      - PROTOBUF_FIELD_OFFSET(TaintQuery, unique_label_set_)>(
          reinterpret_cast<char*>(&unique_label_set_),
          reinterpret_cast<char*>(&other->unique_label_set_));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
testb $0x1, 0x8(%rdi)
jne 0xc68e
testb $0x1, %sil
jne 0xc694
jmp 0xc6a5
testb $0x1, %sil
je 0xc6dd
andq $-0x2, %rsi
addq $0x8, %rsi
leaq 0x8(%r14), %rdi
callq 0x146c6
movl 0x10(%r14), %eax
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%r14)
movl %eax, 0x10(%rbx)
movups 0x18(%r14), %xmm0
movups 0x18(%rbx), %xmm1
movups %xmm1, 0x18(%r14)
movups %xmm0, 0x18(%rbx)
movq 0x28(%r14), %rax
movq 0x28(%rbx), %rcx
movq %rcx, 0x28(%r14)
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rbx), %rdi
callq 0x144e8
movq %rax, %rsi
jmp 0xc69c
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::AttackPoint::AttackPoint(panda::AttackPoint const&)
AttackPoint::AttackPoint(const AttackPoint& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_call_stack()) {
    call_stack_ = new ::panda::CallStack(*from.call_stack_);
  } else {
    call_stack_ = nullptr;
  }
  if (from._internal_has_src_info()) {
    src_info_ = new ::panda::SrcInfo(*from.src_info_);
  } else {
    src_info_ = nullptr;
  }
  info_ = from.info_;
  // @@protoc_insertion_point(copy_constructor:panda.AttackPoint)
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
leaq 0x14fdd(%rip), %rax     # 0x21728
movq %rax, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
andl $0x0, 0x14(%rdi)
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0xc773
leaq 0x8(%rbx), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x1466a
movq %r14, %rdi
callq 0x12538
testb %al, %al
je 0xc798
pushq $0x28
popq %rdi
callq 0x6340
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x8824
jmp 0xc79b
xorl %r15d, %r15d
movq %r15, 0x18(%rbx)
movq %r14, %rdi
callq 0x125b4
testb %al, %al
je 0xc7c4
pushq $0x30
popq %rdi
callq 0x6340
movq %rax, %r15
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0xb8f0
jmp 0xc7c7
xorl %r15d, %r15d
movq %r15, 0x20(%rbx)
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x30
jmp 0xc7e4
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x6350
movq %rbx, %rdi
callq 0x65a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::AttackPoint::Clear()
void AttackPoint::Clear() {
// @@protoc_insertion_point(message_clear_start:panda.AttackPoint)
  ::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) {
      GOOGLE_DCHECK(call_stack_ != nullptr);
      call_stack_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(src_info_ != nullptr);
      src_info_->Clear();
    }
  }
  info_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl 0x10(%rdi), %ebp
testb $0x3, %bpl
je 0xc914
testb $0x1, %bpl
je 0xc8ba
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
jne 0xc8b5
leaq 0x9900(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r14
pushq $0x3
popq %rsi
movq %r14, %rdi
movl $0xe22, %ecx            # imm = 0xE22
callq 0x6520
leaq 0x99a5(%rip), %rsi      # 0x16237
movq %r14, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
movq 0x18(%rbx), %rdi
callq 0x88e4
testb $0x2, %bpl
je 0xc914
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
jne 0xc90f
leaq 0x98a6(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r14
pushq $0x3
popq %rsi
movq %r14, %rdi
movl $0xe26, %ecx            # imm = 0xE26
callq 0x6520
leaq 0x9972(%rip), %rsi      # 0x1625e
movq %r14, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
movq 0x20(%rbx), %rdi
callq 0xb998
andl $0x0, 0x28(%rbx)
andl $0x0, 0x10(%rbx)
testb $0x1, 0x8(%rbx)
je 0xc92e
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x14698
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xc93d
jmp 0xc93d
jmp 0xc93d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6590
movq %rbx, %rdi
callq 0x65a0
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::AttackPoint::RequiredFieldsByteSizeFallback() const
size_t AttackPoint::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:panda.AttackPoint)
  size_t total_size = 0;

  if (_internal_has_call_stack()) {
    // required .panda.CallStack call_stack = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *call_stack_);
  }

  if (_internal_has_src_info()) {
    // required .panda.SrcInfo src_info = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *src_info_);
  }

  if (_internal_has_info()) {
    // required uint32 info = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_info());
  }

  return total_size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x12538
testb %al, %al
je 0xcb85
movq 0x18(%r14), %rdi
callq 0x11e20
movq %rax, %rbx
incq %rbx
jmp 0xcb87
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x125b4
testb %al, %al
je 0xcba2
movq 0x20(%r14), %rdi
callq 0x127d6
addq %rax, %rbx
incq %rbx
testb $0x4, 0x10(%r14)
je 0xcbc2
movl 0x28(%r14), %eax
orl $0x1, %eax
bsrl %eax, %eax
leal (%rax,%rax,8), %eax
addl $0x49, %eax
shrl $0x6, %eax
addq %rax, %rbx
incq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::AttackPoint::ByteSizeLong() const
size_t AttackPoint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:panda.AttackPoint)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required .panda.CallStack call_stack = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *call_stack_);

    // required .panda.SrcInfo src_info = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *src_info_);

    // required uint32 info = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_info());

  } 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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %eax
notl %eax
testb $0x7, %al
jne 0xcc11
movq 0x18(%rbx), %rdi
callq 0x11e20
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x127d6
movl 0x28(%rbx), %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
addq %r14, %rax
addq %rcx, %rax
addq $0x3, %rax
jmp 0xcc19
movq %rbx, %rdi
callq 0xcb64
testb $0x1, 0x8(%rbx)
jne 0xcc2a
movl %eax, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rbx), %rdi
addq $0x14, %rbx
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6050
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::AttackPoint::MergeFrom(google::protobuf::Message const&)
void AttackPoint::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:panda.AttackPoint)
  GOOGLE_DCHECK_NE(&from, this);
  const AttackPoint* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<AttackPoint>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:panda.AttackPoint)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:panda.AttackPoint)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0xcc9a
leaq 0x9517(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0xecb, %ecx            # imm = 0xECB
callq 0x6520
leaq 0x9506(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
leaq 0x14a87(%rip), %rax     # 0x21728
cmpq %rax, (%rbx)
je 0xccb3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
jmp 0xccbe
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcce0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xccca
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6590
movq %rbx, %rdi
callq 0x65a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::AttackPoint::MergeFrom(panda::AttackPoint const&)
void AttackPoint::MergeFrom(const AttackPoint& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:panda.AttackPoint)
  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 & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_call_stack()->::panda::CallStack::MergeFrom(from._internal_call_stack());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_src_info()->::panda::SrcInfo::MergeFrom(from._internal_src_info());
    }
    if (cached_has_bits & 0x00000004u) {
      info_ = from.info_;
    }
    _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 0xcd37
leaq 0x947a(%rip), %rdx      # 0x16176
leaq 0x10(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0xeda, %ecx            # imm = 0xEDA
callq 0x6520
leaq 0x9469(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x10(%rsp), %rdi
callq 0x6590
movq 0x8(%r14), %rsi
testb $0x1, %sil
je 0xcd52
leaq 0x8(%rbx), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x1466a
movl 0x10(%r14), %ebp
testb $0x7, %bpl
je 0xcdbc
testb $0x1, %bpl
je 0xcd84
movq %rbx, %rdi
callq 0x126fe
movq 0x18(%r14), %rcx
testq %rcx, %rcx
leaq 0x15960(%rip), %rsi     # 0x226d8
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x8b74
testb $0x2, %bpl
je 0xcdac
movq %rbx, %rdi
callq 0x127a6
movq 0x20(%r14), %rcx
testq %rcx, %rcx
leaq 0x15a98(%rip), %rsi     # 0x22838
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0xbdc4
testb $0x4, %bpl
je 0xcdb9
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
orl %ebp, 0x10(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcdc9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6590
movq %rbx, %rdi
callq 0x65a0
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::AttackPoint::InternalSwap(panda::AttackPoint*)
void AttackPoint::InternalSwap(AttackPoint* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(AttackPoint, info_)
      + sizeof(AttackPoint::info_)
      - PROTOBUF_FIELD_OFFSET(AttackPoint, call_stack_)>(
          reinterpret_cast<char*>(&call_stack_),
          reinterpret_cast<char*>(&other->call_stack_));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
testb $0x1, 0x8(%rdi)
jne 0xce78
testb $0x1, %sil
jne 0xce7e
jmp 0xce8f
testb $0x1, %sil
je 0xcec5
andq $-0x2, %rsi
addq $0x8, %rsi
leaq 0x8(%r14), %rdi
callq 0x146c6
movl 0x10(%r14), %eax
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%r14)
movl %eax, 0x10(%rbx)
movups 0x18(%r14), %xmm0
movups 0x18(%rbx), %xmm1
movups %xmm1, 0x18(%r14)
movups %xmm0, 0x18(%rbx)
movl 0x28(%r14), %eax
movl 0x28(%rbx), %ecx
movl %ecx, 0x28(%r14)
movl %eax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rbx), %rdi
callq 0x144e8
movq %rax, %rsi
jmp 0xce86
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintQueryHypercall::TaintQueryHypercall(panda::TaintQueryHypercall const&)
TaintQueryHypercall::TaintQueryHypercall(const TaintQueryHypercall& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      data_(from.data_),
      taint_query_(from.taint_query_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_call_stack()) {
    call_stack_ = new ::panda::CallStack(*from.call_stack_);
  } else {
    call_stack_ = nullptr;
  }
  if (from._internal_has_src_info()) {
    src_info_ = new ::panda::SrcInfo(*from.src_info_);
  } else {
    src_info_ = nullptr;
  }
  ::memcpy(&buf_, &from.buf_,
    static_cast<size_t>(reinterpret_cast<char*>(&num_tainted_) -
    reinterpret_cast<char*>(&buf_)) + sizeof(num_tainted_));
  // @@protoc_insertion_point(copy_constructor:panda.TaintQueryHypercall)
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
andq $0x0, 0x8(%rdi)
movq %rsi, %r12
leaq 0x14861(%rip), %rax     # 0x217d8
movq %rax, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
andl $0x0, 0x14(%rdi)
leaq 0x18(%rdi), %rbx
addq $0x18, %rsi
movq %rbx, %rdi
callq 0x63f0
leaq 0x28(%r15), %r14
leaq 0x28(%r12), %rsi
movq %r14, %rdi
callq 0x11eb0
movq 0x8(%r12), %rsi
testb $0x1, %sil
je 0xcfc1
leaq 0x8(%r15), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x1466a
movq %r12, %rdi
callq 0x12836
testb %al, %al
je 0xcfe7
pushq $0x28
popq %rdi
callq 0x6340
movq %rax, %r13
movq 0x40(%r12), %rsi
movq %rax, %rdi
callq 0x8824
jmp 0xcfea
xorl %r13d, %r13d
movq %r13, 0x40(%r15)
movq %r12, %rdi
callq 0x128b2
testb %al, %al
je 0xd014
pushq $0x30
popq %rdi
callq 0x6340
movq %rax, %r13
movq 0x48(%r12), %rsi
movq %rax, %rdi
callq 0xb8f0
jmp 0xd017
xorl %r13d, %r13d
movq %r13, 0x48(%r15)
movups 0x50(%r12), %xmm0
movups %xmm0, 0x50(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
pushq $0x30
jmp 0xd03c
movq %rax, %r15
pushq $0x28
popq %rsi
movq %r13, %rdi
callq 0x6350
jmp 0xd04f
movq %rax, %r15
jmp 0xd057
movq %rax, %r15
movq %r14, %rdi
callq 0x11e96
movq %rbx, %rdi
callq 0x6270
movq %r15, %rdi
callq 0x65a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintQueryHypercall::RequiredFieldsByteSizeFallback() const
size_t TaintQueryHypercall::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:panda.TaintQueryHypercall)
  size_t total_size = 0;

  if (_internal_has_call_stack()) {
    // required .panda.CallStack call_stack = 5;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *call_stack_);
  }

  if (_internal_has_src_info()) {
    // required .panda.SrcInfo src_info = 6;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *src_info_);
  }

  if (_internal_has_buf()) {
    // required uint64 buf = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->_internal_buf());
  }

  if (_internal_has_len()) {
    // required uint32 len = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_len());
  }

  if (_internal_has_num_tainted()) {
    // required uint32 num_tainted = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_num_tainted());
  }

  return total_size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x12836
testb %al, %al
je 0xd627
movq 0x40(%r14), %rdi
callq 0x11e20
movq %rax, %rbx
incq %rbx
jmp 0xd629
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x128b2
testb %al, %al
je 0xd644
movq 0x48(%r14), %rdi
callq 0x127d6
addq %rax, %rbx
incq %rbx
movl 0x10(%r14), %eax
testb $0x4, %al
je 0xd667
movq 0x50(%r14), %rcx
orq $0x1, %rcx
bsrq %rcx, %rcx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
addq %rcx, %rbx
incq %rbx
testb $0x8, %al
je 0xd684
movl 0x58(%r14), %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
addq %rcx, %rbx
incq %rbx
testb $0x10, %al
je 0xd6a1
movl 0x5c(%r14), %eax
orl $0x1, %eax
bsrl %eax, %eax
leal (%rax,%rax,8), %eax
addl $0x49, %eax
shrl $0x6, %eax
addq %rax, %rbx
incq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintQueryHypercall::MergeFrom(google::protobuf::Message const&)
void TaintQueryHypercall::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:panda.TaintQueryHypercall)
  GOOGLE_DCHECK_NE(&from, this);
  const TaintQueryHypercall* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TaintQueryHypercall>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:panda.TaintQueryHypercall)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:panda.TaintQueryHypercall)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0xd800
leaq 0x89b1(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x10a3, %ecx           # imm = 0x10A3
callq 0x6520
leaq 0x89a0(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
leaq 0x13fd1(%rip), %rax     # 0x217d8
cmpq %rax, (%rbx)
je 0xd819
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
jmp 0xd824
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd846
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xd830
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6590
movq %rbx, %rdi
callq 0x65a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintQueryHypercall::MergeFrom(panda::TaintQueryHypercall const&)
void TaintQueryHypercall::MergeFrom(const TaintQueryHypercall& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:panda.TaintQueryHypercall)
  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;

  data_.MergeFrom(from.data_);
  taint_query_.MergeFrom(from.taint_query_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_call_stack()->::panda::CallStack::MergeFrom(from._internal_call_stack());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_src_info()->::panda::SrcInfo::MergeFrom(from._internal_src_info());
    }
    if (cached_has_bits & 0x00000004u) {
      buf_ = from.buf_;
    }
    if (cached_has_bits & 0x00000008u) {
      len_ = from.len_;
    }
    if (cached_has_bits & 0x00000010u) {
      num_tainted_ = from.num_tainted_;
    }
    _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 0xd89d
leaq 0x8914(%rip), %rdx      # 0x16176
leaq 0x10(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x10b2, %ecx           # imm = 0x10B2
callq 0x6520
leaq 0x8903(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x10(%rsp), %rdi
callq 0x6590
movq 0x8(%r14), %rsi
testb $0x1, %sil
je 0xd8b8
leaq 0x8(%rbx), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x1466a
leaq 0x18(%rbx), %rdi
leaq 0x18(%r14), %rsi
callq 0x64c0
leaq 0x28(%rbx), %rdi
leaq 0x28(%r14), %rsi
callq 0x1489a
movl 0x10(%r14), %ebp
testb $0x1f, %bpl
je 0xd957
testb $0x1, %bpl
je 0xd904
movq %rbx, %rdi
callq 0x12a12
movq 0x40(%r14), %rcx
testq %rcx, %rcx
leaq 0x14de0(%rip), %rsi     # 0x226d8
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x8b74
testb $0x2, %bpl
je 0xd92c
movq %rbx, %rdi
callq 0x12a42
movq 0x48(%r14), %rcx
testq %rcx, %rcx
leaq 0x14f18(%rip), %rsi     # 0x22838
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0xbdc4
testb $0x4, %bpl
je 0xd93a
movq 0x50(%r14), %rax
movq %rax, 0x50(%rbx)
testb $0x8, %bpl
je 0xd947
movl 0x58(%r14), %eax
movl %eax, 0x58(%rbx)
testb $0x10, %bpl
je 0xd954
movl 0x5c(%r14), %eax
movl %eax, 0x5c(%rbx)
orl %ebp, 0x10(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd964
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6590
movq %rbx, %rdi
callq 0x65a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintQueryHypercall::InternalSwap(panda::TaintQueryHypercall*)
void TaintQueryHypercall::InternalSwap(TaintQueryHypercall* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  data_.InternalSwap(&other->data_);
  taint_query_.InternalSwap(&other->taint_query_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TaintQueryHypercall, num_tainted_)
      + sizeof(TaintQueryHypercall::num_tainted_)
      - PROTOBUF_FIELD_OFFSET(TaintQueryHypercall, call_stack_)>(
          reinterpret_cast<char*>(&call_stack_),
          reinterpret_cast<char*>(&other->call_stack_));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
testb $0x1, 0x8(%rdi)
jne 0xda24
testb $0x1, %sil
jne 0xda2a
jmp 0xda3b
testb $0x1, %sil
je 0xda8f
andq $-0x2, %rsi
addq $0x8, %rsi
leaq 0x8(%r14), %rdi
callq 0x146c6
movl 0x10(%r14), %eax
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%r14)
movl %eax, 0x10(%rbx)
leaq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x6080
leaq 0x28(%r14), %rdi
leaq 0x28(%rbx), %rsi
callq 0x14a30
movups 0x40(%r14), %xmm0
movups 0x40(%rbx), %xmm1
movups %xmm1, 0x40(%r14)
movups %xmm0, 0x40(%rbx)
movups 0x50(%r14), %xmm0
movups 0x50(%rbx), %xmm1
movups %xmm1, 0x50(%r14)
movups %xmm0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rbx), %rdi
callq 0x144e8
movq %rax, %rsi
jmp 0xda32
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranch::TaintedBranch(panda::TaintedBranch const&)
TaintedBranch::TaintedBranch(const TaintedBranch& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      taint_query_(from.taint_query_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_call_stack()) {
    call_stack_ = new ::panda::CallStack(*from.call_stack_);
  } else {
    call_stack_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:panda.TaintedBranch)
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
leaq 0x13d6e(%rip), %rax     # 0x21888
movq %rax, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
andl $0x0, 0x14(%rdi)
leaq 0x18(%rdi), %rbx
addq $0x18, %rsi
movq %rbx, %rdi
callq 0x11eb0
movq 0x8(%r15), %rsi
testb $0x1, %sil
je 0xdb52
leaq 0x8(%r14), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x1466a
movq %r15, %rdi
callq 0x12abe
testb %al, %al
je 0xdb77
pushq $0x28
popq %rdi
callq 0x6340
movq %rax, %r12
movq 0x30(%r15), %rsi
movq %rax, %rdi
callq 0x8824
jmp 0xdb7a
xorl %r12d, %r12d
movq %r12, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x28
popq %rsi
movq %r12, %rdi
callq 0x6350
jmp 0xdb9d
movq %rax, %r14
movq %rbx, %rdi
callq 0x11e96
movq %r14, %rdi
callq 0x65a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranch::Clear()
void TaintedBranch::Clear() {
// @@protoc_insertion_point(message_clear_start:panda.TaintedBranch)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  taint_query_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(call_stack_ != nullptr);
    call_stack_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x145ca
testb $0x1, 0x10(%rbx)
je 0xdc75
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
jne 0xdc70
leaq 0x8545(%rip), %rdx      # 0x16176
leaq 0x10(%rsp), %r14
pushq $0x3
popq %rsi
movq %r14, %rdi
movl $0x114a, %ecx           # imm = 0x114A
callq 0x6520
leaq 0x85ea(%rip), %rsi      # 0x16237
movq %r14, %rdi
callq 0x6570
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x10(%rsp), %rdi
callq 0x6590
movq 0x30(%rbx), %rdi
callq 0x88e4
andl $0x0, 0x10(%rbx)
testb $0x1, 0x8(%rbx)
je 0xdc8b
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x14698
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0xdc95
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6590
movq %rbx, %rdi
callq 0x65a0
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranch::_InternalSerialize(unsigned char*, google::protobuf::io::EpsCopyOutputStream*) const
::PROTOBUF_NAMESPACE_ID::uint8* TaintedBranch::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:panda.TaintedBranch)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .panda.CallStack call_stack = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::call_stack(this), target, stream);
  }

  // repeated .panda.TaintQuery taint_query = 2;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_taint_query_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, this->_internal_taint_query(i), target, stream);
  }

  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.TaintedBranch)
  return target;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r12
testb $0x1, 0x10(%rdi)
je 0xde37
movq %rbx, %rdi
callq 0x115ba
movq 0x30(%r12), %r15
movb $0xa, (%rax)
leaq 0x1(%rax), %rsi
movl 0x20(%r15), %edi
callq 0x1412e
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x8a26
movq %rax, %rsi
movl 0x20(%r12), %r14d
movq %r12, (%rsp)
leaq 0x18(%r12), %r15
xorl %ebp, %ebp
cmpl %ebp, %r14d
je 0xde8c
movq %rbx, %rdi
callq 0x115ba
movq %rax, %r12
movq %r15, %rdi
movl %ebp, %esi
callq 0x1441a
movq %rax, %r13
movb $0x12, (%r12)
incq %r12
movl 0x14(%rax), %edi
movq %r12, %rsi
callq 0x1412e
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xc28e
movq %rax, %rsi
incl %ebp
jmp 0xde47
movq (%rsp), %rax
movq 0x8(%rax), %rdi
testb $0x1, %dil
jne 0xdeac
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andq $-0x2, %rdi
addq $0x8, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x61b0
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranch::ByteSizeLong() const
size_t TaintedBranch::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:panda.TaintedBranch)
  size_t total_size = 0;

  // required .panda.CallStack call_stack = 1;
  if (_internal_has_call_stack()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *call_stack_);
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .panda.TaintQuery taint_query = 2;
  total_size += 1UL * this->_internal_taint_query_size();
  for (const auto& msg : this->taint_query_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x12abe
testb %al, %al
je 0xdef0
movq 0x30(%rbx), %rdi
callq 0x11e20
movq %rax, %r14
incq %r14
jmp 0xdef3
xorl %r14d, %r14d
movslq 0x20(%rbx), %r15
addq %r15, %r14
movq 0x28(%rbx), %rax
leaq 0x8(%rax), %r12
testq %rax, %rax
cmoveq %rax, %r12
shlq $0x3, %r15
xorl %r13d, %r13d
cmpq %r13, %r15
je 0xdf27
movq (%r12,%r13), %rdi
callq 0x121a4
addq %rax, %r14
addq $0x8, %r13
jmp 0xdf10
testb $0x1, 0x8(%rbx)
jne 0xdf3e
movl %r14d, 0x14(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8(%rbx), %rdi
addq $0x14, %rbx
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6050
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranch::MergeFrom(google::protobuf::Message const&)
void TaintedBranch::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:panda.TaintedBranch)
  GOOGLE_DCHECK_NE(&from, this);
  const TaintedBranch* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TaintedBranch>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:panda.TaintedBranch)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:panda.TaintedBranch)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0xdfb0
leaq 0x8201(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x11c3, %ecx           # imm = 0x11C3
callq 0x6520
leaq 0x81f0(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
leaq 0x138d1(%rip), %rax     # 0x21888
cmpq %rax, (%rbx)
je 0xdfc9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
jmp 0xdfd4
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdff6
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xdfe0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6590
movq %rbx, %rdi
callq 0x65a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranch::MergeFrom(panda::TaintedBranch const&)
void TaintedBranch::MergeFrom(const TaintedBranch& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:panda.TaintedBranch)
  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;

  taint_query_.MergeFrom(from.taint_query_);
  if (from._internal_has_call_stack()) {
    _internal_mutable_call_stack()->::panda::CallStack::MergeFrom(from._internal_call_stack());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0xe04c
leaq 0x8165(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x11d2, %ecx           # imm = 0x11D2
callq 0x6520
leaq 0x8154(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
movq 0x8(%rbx), %rsi
testb $0x1, %sil
je 0xe067
leaq 0x8(%r14), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x1466a
leaq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x1489a
movq %rbx, %rdi
callq 0x12abe
testb %al, %al
je 0xe0a2
movq %r14, %rdi
callq 0x12be4
movq 0x30(%rbx), %rcx
testq %rcx, %rcx
leaq 0x14642(%rip), %rsi     # 0x226d8
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x8b74
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xe0ae
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6590
movq %rbx, %rdi
callq 0x65a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranch::InternalSwap(panda::TaintedBranch*)
void TaintedBranch::InternalSwap(TaintedBranch* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  taint_query_.InternalSwap(&other->taint_query_);
  swap(call_stack_, other->call_stack_);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
testb $0x1, 0x8(%rdi)
jne 0xe142
testb $0x1, %sil
jne 0xe148
jmp 0xe159
testb $0x1, %sil
je 0xe18c
andq $-0x2, %rsi
addq $0x8, %rsi
leaq 0x8(%r14), %rdi
callq 0x146c6
movl 0x10(%r14), %eax
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%r14)
movl %eax, 0x10(%rbx)
leaq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x14a30
movq 0x30(%r14), %rax
movq 0x30(%rbx), %rcx
movq %rcx, 0x30(%r14)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rbx), %rdi
callq 0x144e8
movq %rax, %rsi
jmp 0xe150
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranchSummary::TaintedBranchSummary(panda::TaintedBranchSummary const&)
TaintedBranchSummary::TaintedBranchSummary(const TaintedBranchSummary& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&asid_, &from.asid_,
    static_cast<size_t>(reinterpret_cast<char*>(&pc_) -
    reinterpret_cast<char*>(&asid_)) + sizeof(pc_));
  // @@protoc_insertion_point(copy_constructor:panda.TaintedBranchSummary)
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
leaq 0x13764(%rip), %rax     # 0x21938
movq %rax, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
andl $0x0, 0x14(%rdi)
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0xe1fc
leaq 0x8(%rbx), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x1466a
movups 0x18(%r14), %xmm0
movups %xmm0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranchSummary::_InternalParse(char const*, google::protobuf::internal::ParseContext*)
const char* TaintedBranchSummary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required uint64 asid = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_asid(&has_bits);
          asid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required uint64 pc = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_pc(&has_bits);
          pc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %rsi, (%r15)
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
leaq 0xc(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x1153e
testb %al, %al
jne 0xe37a
movq (%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x11546
movq %rax, (%rsp)
testq %rax, %rax
je 0xe399
movl 0xc(%rsp), %ebp
movl %ebp, %ecx
shrl $0x3, %ecx
cmpl $0x2, %ecx
je 0xe306
cmpl $0x1, %ecx
jne 0xe325
cmpb $0x8, %bpl
jne 0xe325
orl $0x1, %r12d
movq %r15, %rdi
callq 0x11597
movq %rax, 0x18(%rbx)
jmp 0xe31c
cmpb $0x10, %bpl
jne 0xe325
orl $0x2, %r12d
movq %r15, %rdi
callq 0x11597
movq %rax, 0x20(%rbx)
cmpq $0x0, (%rsp)
jne 0xe2ad
jmp 0xe399
testq %rbp, %rbp
je 0xe380
movl %ebp, %ecx
andl $0x7, %ecx
cmpl $0x4, %ecx
je 0xe380
movq 0x10(%rsp), %rcx
movq (%rcx), %rsi
testb $0x1, %sil
je 0xe367
andq $-0x2, %rsi
addq $0x8, %rsi
movq %rbp, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x61c0
movq %rax, (%rsp)
testq %rax, %rax
jne 0xe2ad
jmp 0xe399
movq 0x10(%rsp), %rdi
callq 0x144e8
movq %rax, %rsi
movq (%rsp), %rax
jmp 0xe34a
movq (%rsp), %rax
jmp 0xe386
decl %ebp
movl %ebp, 0x50(%r14)
orl %r12d, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xe386
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranchSummary::_InternalSerialize(unsigned char*, google::protobuf::io::EpsCopyOutputStream*) const
::PROTOBUF_NAMESPACE_ID::uint8* TaintedBranchSummary::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:panda.TaintedBranchSummary)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required uint64 asid = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_asid(), target);
  }

  // required uint64 pc = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->_internal_pc(), 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.TaintedBranchSummary)
  return target;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl 0x10(%rdi), %ebp
testb $0x1, %bpl
je 0xe3cc
movq %rbx, %rdi
callq 0x115ba
movq 0x18(%r14), %rdi
movb $0x8, (%rax)
leaq 0x1(%rax), %rsi
callq 0x1417c
movq %rax, %rsi
testb $0x2, %bpl
je 0xe3ed
movq %rbx, %rdi
callq 0x115ba
movq 0x20(%r14), %rdi
movb $0x10, (%rax)
leaq 0x1(%rax), %rsi
callq 0x1417c
movq %rax, %rsi
movq 0x8(%r14), %rdi
testb $0x1, %dil
jne 0xe3ff
movq %rsi, %rax
popq %rbx
popq %r14
popq %rbp
retq
andq $-0x2, %rdi
addq $0x8, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x61b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranchSummary::ByteSizeLong() const
size_t TaintedBranchSummary::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:panda.TaintedBranchSummary)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required uint64 asid = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->_internal_asid());

    // required uint64 pc = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
        this->_internal_pc());

  } 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 $0x3, %al
jne 0xe49a
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
orq $0x1, %rax
bsrq %rax, %rax
leal (%rax,%rax,8), %eax
addl $0x49, %eax
shrl $0x6, %eax
orq $0x1, %rcx
bsrq %rcx, %rcx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
addq %rcx, %rax
addq $0x2, %rax
jmp 0xe4a2
movq %rbx, %rdi
callq 0xe414
testb $0x1, 0x8(%rbx)
jne 0xe4ad
movl %eax, 0x14(%rbx)
popq %rbx
retq
leaq 0x8(%rbx), %rdi
addq $0x14, %rbx
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0x6050
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranchSummary::MergeFrom(google::protobuf::Message const&)
void TaintedBranchSummary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:panda.TaintedBranchSummary)
  GOOGLE_DCHECK_NE(&from, this);
  const TaintedBranchSummary* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TaintedBranchSummary>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:panda.TaintedBranchSummary)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:panda.TaintedBranchSummary)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0xe518
leaq 0x7c99(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x12cf, %ecx           # imm = 0x12CF
callq 0x6520
leaq 0x7c88(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
leaq 0x13419(%rip), %rax     # 0x21938
cmpq %rax, (%rbx)
je 0xe531
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
jmp 0xe53c
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe55e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xe548
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6590
movq %rbx, %rdi
callq 0x65a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranchSummary::MergeFrom(panda::TaintedBranchSummary const&)
void TaintedBranchSummary::MergeFrom(const TaintedBranchSummary& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:panda.TaintedBranchSummary)
  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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      asid_ = from.asid_;
    }
    if (cached_has_bits & 0x00000002u) {
      pc_ = from.pc_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rdi, %rsi
jne 0xe5b4
leaq 0x7bfd(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x12de, %ecx           # imm = 0x12DE
callq 0x6520
leaq 0x7bec(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
movq 0x8(%r14), %rsi
testb $0x1, %sil
je 0xe5cf
leaq 0x8(%rbx), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x1466a
movl 0x10(%r14), %eax
testb $0x3, %al
je 0xe5f2
testb $0x1, %al
je 0xe5e3
movq 0x18(%r14), %rcx
movq %rcx, 0x18(%rbx)
testb $0x2, %al
je 0xe5ef
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rbx)
orl %eax, 0x10(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xe5fe
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6590
movq %rbx, %rdi
callq 0x65a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedBranchSummary::InternalSwap(panda::TaintedBranchSummary*)
void TaintedBranchSummary::InternalSwap(TaintedBranchSummary* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TaintedBranchSummary, pc_)
      + sizeof(TaintedBranchSummary::pc_)
      - PROTOBUF_FIELD_OFFSET(TaintedBranchSummary, asid_)>(
          reinterpret_cast<char*>(&asid_),
          reinterpret_cast<char*>(&other->asid_));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
testb $0x1, 0x8(%rdi)
jne 0xe68c
testb $0x1, %sil
jne 0xe692
jmp 0xe6a3
testb $0x1, %sil
je 0xe6cb
andq $-0x2, %rsi
addq $0x8, %rsi
leaq 0x8(%r14), %rdi
callq 0x146c6
movl 0x10(%r14), %eax
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%r14)
movl %eax, 0x10(%rbx)
movups 0x18(%r14), %xmm0
movups 0x18(%rbx), %xmm1
movups %xmm1, 0x18(%r14)
movups %xmm0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rbx), %rdi
callq 0x144e8
movq %rax, %rsi
jmp 0xe69a
nop