LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedInstr::TaintedInstr(panda::TaintedInstr const&)
TaintedInstr::TaintedInstr(const TaintedInstr& 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.TaintedInstr)
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
leaq 0x13292(%rip), %rax     # 0x219e8
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 0xe78e
leaq 0x8(%r14), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x1466a
movq %r15, %rdi
callq 0x12cf2
testb %al, %al
je 0xe7b3
pushq $0x28
popq %rdi
callq 0x6340
movq %rax, %r12
movq 0x30(%r15), %rsi
movq %rax, %rdi
callq 0x8824
jmp 0xe7b6
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 0xe7d9
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::TaintedInstr::Clear()
void TaintedInstr::Clear() {
// @@protoc_insertion_point(message_clear_start:panda.TaintedInstr)
  ::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 0xe8b1
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
jne 0xe8ac
leaq 0x7909(%rip), %rdx      # 0x16176
leaq 0x10(%rsp), %r14
pushq $0x3
popq %rsi
movq %r14, %rdi
movl $0x1365, %ecx           # imm = 0x1365
callq 0x6520
leaq 0x79ae(%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 0xe8c7
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x14698
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0xe8d1
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::TaintedInstr::_InternalSerialize(unsigned char*, google::protobuf::io::EpsCopyOutputStream*) const
::PROTOBUF_NAMESPACE_ID::uint8* TaintedInstr::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:panda.TaintedInstr)
  ::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.TaintedInstr)
  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 0xea73
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 0xeac8
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 0xea83
movq (%rsp), %rax
movq 0x8(%rax), %rdi
testb $0x1, %dil
jne 0xeae8
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::TaintedInstr::MergeFrom(google::protobuf::Message const&)
void TaintedInstr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:panda.TaintedInstr)
  GOOGLE_DCHECK_NE(&from, this);
  const TaintedInstr* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TaintedInstr>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:panda.TaintedInstr)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:panda.TaintedInstr)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0xebec
leaq 0x75c5(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x13de, %ecx           # imm = 0x13DE
callq 0x6520
leaq 0x75b4(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
leaq 0x12df5(%rip), %rax     # 0x219e8
cmpq %rax, (%rbx)
je 0xec05
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
jmp 0xec10
movq %r14, %rdi
movq %rbx, %rsi
callq 0xec32
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xec1c
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::TaintedInstr::MergeFrom(panda::TaintedInstr const&)
void TaintedInstr::MergeFrom(const TaintedInstr& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:panda.TaintedInstr)
  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 0xec88
leaq 0x7529(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x13ed, %ecx           # imm = 0x13ED
callq 0x6520
leaq 0x7518(%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 0xeca3
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 0x12cf2
testb %al, %al
je 0xecde
movq %r14, %rdi
callq 0x12e18
movq 0x30(%rbx), %rcx
testq %rcx, %rcx
leaq 0x13a06(%rip), %rsi     # 0x226d8
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x8b74
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xecea
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::TaintedInstr::InternalSwap(panda::TaintedInstr*)
void TaintedInstr::InternalSwap(TaintedInstr* 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 0xed7e
testb $0x1, %sil
jne 0xed84
jmp 0xed95
testb $0x1, %sil
je 0xedc8
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 0xed8c
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintedInstrSummary::TaintedInstrSummary(panda::TaintedInstrSummary const&)
TaintedInstrSummary::TaintedInstrSummary(const TaintedInstrSummary& 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.TaintedInstrSummary)
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
leaq 0x12c88(%rip), %rax     # 0x21a98
movq %rax, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
andl $0x0, 0x14(%rdi)
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0xee38
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::TaintedInstrSummary::_InternalSerialize(unsigned char*, google::protobuf::io::EpsCopyOutputStream*) const
::PROTOBUF_NAMESPACE_ID::uint8* TaintedInstrSummary::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:panda.TaintedInstrSummary)
  ::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.TaintedInstrSummary)
  return target;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl 0x10(%rdi), %ebp
testb $0x1, %bpl
je 0xf008
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 0xf029
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 0xf03b
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::TaintedInstrSummary::MergeFrom(google::protobuf::Message const&)
void TaintedInstrSummary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:panda.TaintedInstrSummary)
  GOOGLE_DCHECK_NE(&from, this);
  const TaintedInstrSummary* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TaintedInstrSummary>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:panda.TaintedInstrSummary)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:panda.TaintedInstrSummary)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0xf154
leaq 0x705d(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x14ea, %ecx           # imm = 0x14EA
callq 0x6520
leaq 0x704c(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
leaq 0x1293d(%rip), %rax     # 0x21a98
cmpq %rax, (%rbx)
je 0xf16d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
jmp 0xf178
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf19a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf184
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::TaintedInstrSummary::MergeFrom(panda::TaintedInstrSummary const&)
void TaintedInstrSummary::MergeFrom(const TaintedInstrSummary& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:panda.TaintedInstrSummary)
  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 0xf1f0
leaq 0x6fc1(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x14f9, %ecx           # imm = 0x14F9
callq 0x6520
leaq 0x6fb0(%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 0xf20b
leaq 0x8(%rbx), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x1466a
movl 0x10(%r14), %eax
testb $0x3, %al
je 0xf22e
testb $0x1, %al
je 0xf21f
movq 0x18(%r14), %rcx
movq %rcx, 0x18(%rbx)
testb $0x2, %al
je 0xf22b
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rbx)
orl %eax, 0x10(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf23a
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::TaintedInstrSummary::InternalSwap(panda::TaintedInstrSummary*)
void TaintedInstrSummary::InternalSwap(TaintedInstrSummary* 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(TaintedInstrSummary, pc_)
      + sizeof(TaintedInstrSummary::pc_)
      - PROTOBUF_FIELD_OFFSET(TaintedInstrSummary, 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 0xf2c8
testb $0x1, %sil
jne 0xf2ce
jmp 0xf2df
testb $0x1, %sil
je 0xf307
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 0xf2d6
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::LogEntry::MergeFrom(google::protobuf::Message const&)
void LogEntry::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:panda.LogEntry)
  GOOGLE_DCHECK_NE(&from, this);
  const LogEntry* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<LogEntry>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:panda.LogEntry)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:panda.LogEntry)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0x10838
leaq 0x5979(%rip), %rdx      # 0x16176
leaq 0x8(%rsp), %r15
pushq $0x3
popq %rsi
movq %r15, %rdi
movl $0x18c1, %ecx           # imm = 0x18C1
callq 0x6520
leaq 0x5968(%rip), %rsi      # 0x16181
movq %r15, %rdi
callq 0x6570
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x8(%rsp), %rdi
callq 0x6590
leaq 0x11309(%rip), %rax     # 0x21b48
cmpq %rax, (%rbx)
je 0x10851
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
jmp 0x1085c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1087e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x10868
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::LogEntry::InternalSwap(panda::LogEntry*)
void LogEntry::InternalSwap(LogEntry* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  process_name_.Swap(&other->process_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(LogEntry, total_instr_)
      + sizeof(LogEntry::total_instr_)
      - PROTOBUF_FIELD_OFFSET(LogEntry, call_stack_)>(
          reinterpret_cast<char*>(&call_stack_),
          reinterpret_cast<char*>(&other->call_stack_));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x8(%rsi), %rsi
testb $0x1, %r15b
jne 0x10d85
testb $0x1, %sil
jne 0x10d8f
movb $0x1, %al
jmp 0x10dad
testb $0x1, %sil
je 0x10e38
andq $-0x2, %rsi
addq $0x8, %rsi
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x146c6
movq (%r15), %r15
testb $0x1, %r15b
sete %al
movl 0x10(%r14), %ecx
movl 0x10(%rbx), %edx
movl %edx, 0x10(%r14)
movl %ecx, 0x10(%rbx)
leaq 0x18(%r14), %rdi
testb %al, %al
je 0x10e2f
leaq 0x18(%rbx), %r12
movq (%rdi), %rax
cmpq 0x111ef(%rip), %rax     # 0x21fc0
jne 0x10de0
movq (%r12), %rax
cmpq 0x111e2(%rip), %rax     # 0x21fc0
je 0x10e0e
movq 0x111d9(%rip), %r13     # 0x21fc0
movq %r13, %rsi
movq %r15, %rdx
callq 0x142ea
movq %rax, %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x142ea
movq %rbp, %rdi
movq %rax, %rsi
callq 0x6220
addq $0x20, %r14
addq $0x20, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x13e73
andq $-0x2, %r15
movq (%r15), %r15
jmp 0x10dc3
leaq 0x8(%rbx), %rdi
callq 0x144e8
movq %rax, %rsi
jmp 0x10d97
nop
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::DwarfCall::SharedDtor()
void DwarfCall::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  file_callee_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  function_name_callee_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  file_caller_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testb $0x1, %al
jne 0x116cf
testq %rax, %rax
je 0x11699
leaq 0x4b18(%rip), %rdx      # 0x16176
leaq 0x10(%rsp), %r14
pushq $0x3
popq %rsi
movq %r14, %rdi
movl $0x3bd, %ecx            # imm = 0x3BD
callq 0x6520
leaq 0x4e3c(%rip), %rsi      # 0x164b6
movq %r14, %rdi
callq 0x6570
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x6440
leaq 0x10(%rsp), %rdi
callq 0x6590
leaq 0x18(%rbx), %rdi
movq 0x1091c(%rip), %r14     # 0x21fc0
movq %r14, %rsi
callq 0x142c6
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x142c6
addq $0x28, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x142c6
addq $0x48, %rsp
popq %rbx
popq %r14
retq
andq $-0x2, %rax
movq (%rax), %rax
jmp 0x11652
jmp 0x116dd
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.h
// Function: panda::AttackPointPri::_internal_mutable_call_stack()
inline ::panda::CallStack* AttackPointPri::_internal_mutable_call_stack() {
  _has_bits_[0] |= 0x00000001u;
  if (call_stack_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::CallStack>(GetArena());
    call_stack_ = p;
  }
  return call_stack_;
}

// Assembly:
orb $0x1, 0x10(%rdi)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x11d56
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x11d6f
callq 0x10e50
movq %rax, 0x18(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x11d64
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::AttackPointPri::_internal_mutable_src_info()
inline ::panda::SrcInfoPri* AttackPointPri::_internal_mutable_src_info() {
  _has_bits_[0] |= 0x00000002u;
  if (src_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::SrcInfoPri>(GetArena());
    src_info_ = p;
  }
  return src_info_;
}

// Assembly:
orb $0x2, 0x10(%rdi)
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x11dfe
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x11e17
callq 0x10f2c
movq %rax, 0x20(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x11e0c
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::TaintQueryPri::_internal_mutable_call_stack()
inline ::panda::CallStack* TaintQueryPri::_internal_mutable_call_stack() {
  _has_bits_[0] |= 0x00000001u;
  if (call_stack_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::CallStack>(GetArena());
    call_stack_ = p;
  }
  return call_stack_;
}

// Assembly:
orb $0x1, 0x10(%rdi)
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x120cc
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x120e5
callq 0x10e50
movq %rax, 0x40(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x120da
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::TaintQueryPri::_internal_mutable_src_info()
inline ::panda::SrcInfoPri* TaintQueryPri::_internal_mutable_src_info() {
  _has_bits_[0] |= 0x00000002u;
  if (src_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::SrcInfoPri>(GetArena());
    src_info_ = p;
  }
  return src_info_;
}

// Assembly:
orb $0x2, 0x10(%rdi)
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x120fc
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x12115
callq 0x10f2c
movq %rax, 0x48(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x1210a
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::TaintQuery::_internal_mutable_unique_label_set()
inline ::panda::TaintQueryUniqueLabelSet* TaintQuery::_internal_mutable_unique_label_set() {
  _has_bits_[0] |= 0x00000001u;
  if (unique_label_set_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::TaintQueryUniqueLabelSet>(GetArena());
    unique_label_set_ = p;
  }
  return unique_label_set_;
}

// Assembly:
orb $0x1, 0x10(%rdi)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x124bc
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x124d5
callq 0x11076
movq %rax, 0x18(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x124ca
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::AttackPoint::_internal_mutable_call_stack()
inline ::panda::CallStack* AttackPoint::_internal_mutable_call_stack() {
  _has_bits_[0] |= 0x00000001u;
  if (call_stack_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::CallStack>(GetArena());
    call_stack_ = p;
  }
  return call_stack_;
}

// Assembly:
orb $0x1, 0x10(%rdi)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x1270c
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x12725
callq 0x10e50
movq %rax, 0x18(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x1271a
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::AttackPoint::_internal_mutable_src_info()
inline ::panda::SrcInfo* AttackPoint::_internal_mutable_src_info() {
  _has_bits_[0] |= 0x00000002u;
  if (src_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::SrcInfo>(GetArena());
    src_info_ = p;
  }
  return src_info_;
}

// Assembly:
orb $0x2, 0x10(%rdi)
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x127b4
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x127cd
callq 0x110ea
movq %rax, 0x20(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x127c2
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::TaintQueryHypercall::_internal_mutable_call_stack()
inline ::panda::CallStack* TaintQueryHypercall::_internal_mutable_call_stack() {
  _has_bits_[0] |= 0x00000001u;
  if (call_stack_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::CallStack>(GetArena());
    call_stack_ = p;
  }
  return call_stack_;
}

// Assembly:
orb $0x1, 0x10(%rdi)
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x12a20
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x12a39
callq 0x10e50
movq %rax, 0x40(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x12a2e
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::TaintQueryHypercall::_internal_mutable_src_info()
inline ::panda::SrcInfo* TaintQueryHypercall::_internal_mutable_src_info() {
  _has_bits_[0] |= 0x00000002u;
  if (src_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::SrcInfo>(GetArena());
    src_info_ = p;
  }
  return src_info_;
}

// Assembly:
orb $0x2, 0x10(%rdi)
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x12a50
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x12a69
callq 0x110ea
movq %rax, 0x48(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x12a5e
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::TaintedBranch::_internal_mutable_call_stack()
inline ::panda::CallStack* TaintedBranch::_internal_mutable_call_stack() {
  _has_bits_[0] |= 0x00000001u;
  if (call_stack_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::CallStack>(GetArena());
    call_stack_ = p;
  }
  return call_stack_;
}

// Assembly:
orb $0x1, 0x10(%rdi)
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x12bf2
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x12c0b
callq 0x10e50
movq %rax, 0x30(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x12c00
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::TaintedInstr::_internal_mutable_call_stack()
inline ::panda::CallStack* TaintedInstr::_internal_mutable_call_stack() {
  _has_bits_[0] |= 0x00000001u;
  if (call_stack_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::CallStack>(GetArena());
    call_stack_ = p;
  }
  return call_stack_;
}

// Assembly:
orb $0x1, 0x10(%rdi)
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x12e26
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x12e3f
callq 0x10e50
movq %rax, 0x30(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x12e34
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_call_stack()
inline ::panda::CallStack* LogEntry::_internal_mutable_call_stack() {
  _has_bits_[0] |= 0x00000002u;
  if (call_stack_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::CallStack>(GetArena());
    call_stack_ = p;
  }
  return call_stack_;
}

// Assembly:
orb $0x2, 0x10(%rdi)
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x136e4
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x136fd
callq 0x10e50
movq %rax, 0x20(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x136f2
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_tainted_branch()
inline ::panda::TaintedBranch* LogEntry::_internal_mutable_tainted_branch() {
  _has_bits_[0] |= 0x00000004u;
  if (tainted_branch_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::TaintedBranch>(GetArena());
    tainted_branch_ = p;
  }
  return tainted_branch_;
}

// Assembly:
orb $0x4, 0x10(%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1378c
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x137a5
callq 0x1128c
movq %rax, 0x28(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x1379a
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_tainted_instr()
inline ::panda::TaintedInstr* LogEntry::_internal_mutable_tainted_instr() {
  _has_bits_[0] |= 0x00000008u;
  if (tainted_instr_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::TaintedInstr>(GetArena());
    tainted_instr_ = p;
  }
  return tainted_instr_;
}

// Assembly:
orb $0x8, 0x10(%rdi)
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x13834
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x1384d
callq 0x11352
movq %rax, 0x30(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x13842
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_taint_query_hypercall()
inline ::panda::TaintQueryHypercall* LogEntry::_internal_mutable_taint_query_hypercall() {
  _has_bits_[0] |= 0x00000010u;
  if (taint_query_hypercall_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::TaintQueryHypercall>(GetArena());
    taint_query_hypercall_ = p;
  }
  return taint_query_hypercall_;
}

// Assembly:
orb $0x10, 0x10(%rdi)
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x138dc
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x138f5
callq 0x1121e
movq %rax, 0x38(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x138ea
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_attack_point()
inline ::panda::AttackPoint* LogEntry::_internal_mutable_attack_point() {
  _has_bits_[0] |= 0x00000020u;
  if (attack_point_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::AttackPoint>(GetArena());
    attack_point_ = p;
  }
  return attack_point_;
}

// Assembly:
orb $0x20, 0x10(%rdi)
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x13984
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x1399d
callq 0x111b0
movq %rax, 0x40(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x13992
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_tainted_instr_summary()
inline ::panda::TaintedInstrSummary* LogEntry::_internal_mutable_tainted_instr_summary() {
  _has_bits_[0] |= 0x00000040u;
  if (tainted_instr_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::TaintedInstrSummary>(GetArena());
    tainted_instr_summary_ = p;
  }
  return tainted_instr_summary_;
}

// Assembly:
orb $0x40, 0x10(%rdi)
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x13a2c
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x13a45
callq 0x113c0
movq %rax, 0x48(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x13a3a
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_dwarf_call()
inline ::panda::DwarfCall* LogEntry::_internal_mutable_dwarf_call() {
  _has_bits_[0] |= 0x00000080u;
  if (dwarf_call_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::DwarfCall>(GetArena());
    dwarf_call_ = p;
  }
  return dwarf_call_;
}

// Assembly:
orb $-0x80, 0x10(%rdi)
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x13ad4
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x13aed
callq 0x10ebe
movq %rax, 0x50(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x13ae2
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_dwarf_ret()
inline ::panda::DwarfCall* LogEntry::_internal_mutable_dwarf_ret() {
  _has_bits_[0] |= 0x00000100u;
  if (dwarf_ret_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::DwarfCall>(GetArena());
    dwarf_ret_ = p;
  }
  return dwarf_ret_;
}

// Assembly:
orb $0x1, 0x11(%rdi)
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x13b04
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x13b1d
callq 0x10ebe
movq %rax, 0x58(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x13b12
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_taint_query_pri()
inline ::panda::TaintQueryPri* LogEntry::_internal_mutable_taint_query_pri() {
  _has_bits_[0] |= 0x00000200u;
  if (taint_query_pri_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::TaintQueryPri>(GetArena());
    taint_query_pri_ = p;
  }
  return taint_query_pri_;
}

// Assembly:
orb $0x2, 0x11(%rdi)
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0x13bac
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x13bc5
callq 0x11008
movq %rax, 0x60(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x13bba
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_attack_point_pri()
inline ::panda::AttackPointPri* LogEntry::_internal_mutable_attack_point_pri() {
  _has_bits_[0] |= 0x00000400u;
  if (attack_point_pri_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::AttackPointPri>(GetArena());
    attack_point_pri_ = p;
  }
  return attack_point_pri_;
}

// Assembly:
orb $0x4, 0x11(%rdi)
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x13c54
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x13c6d
callq 0x10f9a
movq %rax, 0x68(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x13c62
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_pri_trace_src_info()
inline ::panda::SrcInfoPri* LogEntry::_internal_mutable_pri_trace_src_info() {
  _has_bits_[0] |= 0x00000800u;
  if (pri_trace_src_info_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::SrcInfoPri>(GetArena());
    pri_trace_src_info_ = p;
  }
  return pri_trace_src_info_;
}

// Assembly:
orb $0x8, 0x11(%rdi)
movq 0x70(%rdi), %rax
testq %rax, %rax
je 0x13c84
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x13c9d
callq 0x10f2c
movq %rax, 0x70(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x13c92
// File: /workspace/github_cpp_makefile_star2_O2/moyix[P]pandalog_taint_parser/./plog.pb.h
// Function: panda::LogEntry::_internal_mutable_tainted_branch_summary()
inline ::panda::TaintedBranchSummary* LogEntry::_internal_mutable_tainted_branch_summary() {
  _has_bits_[0] |= 0x00001000u;
  if (tainted_branch_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::panda::TaintedBranchSummary>(GetArena());
    tainted_branch_summary_ = p;
  }
  return tainted_branch_summary_;
}

// Assembly:
orb $0x10, 0x11(%rdi)
movq 0x78(%rdi), %rax
testq %rax, %rax
je 0x13d2c
retq
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testb $0x1, %dil
jne 0x13d45
callq 0x112fa
movq %rax, 0x78(%rbx)
popq %rbx
retq
andq $-0x2, %rdi
movq (%rdi), %rdi
jmp 0x13d3a
// File: /workspace/github_cpp_makefile_star2_O2/msu-starx[P]starx/main.cpp
// Function: main
int main(){
    sparty.initialize();
    while(1) {
        sparty.updateADC();
        sparty.updateSensors();
        sparty.updatePressurePID();
        sparty.updatePWM();
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x7ca7(%rip), %rbx      # 0xa1e0
movq %rbx, %rdi
callq 0x33a4
movq %rbx, %rdi
callq 0x2e28
movq %rbx, %rdi
callq 0x2f04
movq %rbx, %rdi
callq 0x31d4
movq %rbx, %rdi
callq 0x3288
jmp 0x2541
nop
// File: /workspace/github_cpp_makefile_star2_O2/msu-starx[P]starx/exosuit.cpp
// Function: ExoSuit::updateADC()
void ExoSuit::updateADC(void){
    adcValues.clear();
    std::vector<std::string> str = cvt.splitString(board.getADC(), ',');
    for(int i = 0; i < str.size(); i++) {
        adcValues.push_back(cvt.stringToInt(str[i]));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x318(%rdi), %rax
cmpq %rax, 0x320(%rdi)
je 0x2e53
movq %rax, 0x320(%rbx)
leaq 0x48(%rbx), %r14
leaq 0x50(%rbx), %rsi
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x48fe
leaq -0x40(%rbp), %rdi
pushq $0x2c
popq %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0x4bea
addq $0x318, %rbx            # imm = 0x318
movq %r15, %rdi
callq 0x20b0
xorl %r12d, %r12d
xorl %r13d, %r13d
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x2ec4
addq %r12, %rsi
movq %r14, %rdi
callq 0x4ccc
movl %eax, -0x60(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3888
incq %r13
addq $0x20, %r12
jmp 0x2e8e
leaq -0x40(%rbp), %rdi
callq 0x2d12
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20b0
jmp 0x2ef6
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2d12
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/msu-starx[P]starx/exosuit.cpp
// Function: ExoSuit::updatePressurePID()
void ExoSuit::updatePressurePID(void){
    outputStates.clear();
    for(int i = 0; i < pressurePID.size(); i++) {
        pressurePID[i].inputValue = pressureStates[i];
        pressurePID[i].setPoint = setpointValue;
        pressurePID[i].computeValues();
        outputStates.push_back(pressurePID[i].outputValue);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x410(%rdi), %rax
cmpq %rax, 0x418(%rdi)
je 0x31fc
movq %rax, 0x418(%rbx)
leaq 0x410(%rbx), %r14
xorl %r15d, %r15d
movl $0x88, %r12d
xorl %r13d, %r13d
movq 0x470(%rbx), %rcx
movq 0x478(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x3279
movq 0x378(%rbx), %rax
movsd (%rax,%r13,8), %xmm0
leaq (%rcx,%r15), %rdi
movsd %xmm0, 0x28(%rcx,%r15)
movsd 0x408(%rbx), %xmm0
movsd %xmm0, 0x40(%rcx,%r15)
callq 0x5262
movq 0x470(%rbx), %rax
leaq (%rax,%r15), %rsi
addq $0x30, %rsi
movq %r14, %rdi
callq 0x36d8
incq %r13
addq $0x88, %r15
jmp 0x320f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/msu-starx[P]starx/exosuit.cpp
// Function: ExoSuit::updatePWM()
void ExoSuit::updatePWM(void){
    dutyCycleStates.clear();
    dutyCycles.clear();
    for(int i = 0; i < outputStates.size(); i++) {
        dutyCycleStates.push_back((int)std::round(outputStates[i]));
        dutyCycles.push_back(cvt.intToString(dutyCycleStates[i]));
    }
    board.setPWM(dutyCycles);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x440(%rdi), %rax
cmpq %rax, 0x448(%rdi)
je 0x32b3
movq %rax, 0x448(%rbx)
leaq 0x440(%rbx), %r15
leaq 0x458(%rbx), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3702
leaq 0x48(%rbx), %r12
xorl %r14d, %r14d
leaq -0x68(%rbp), %r13
movq 0x410(%rbx), %rax
movq 0x418(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x3337
movsd (%rax,%r14,8), %xmm0
callq 0x2090
cvttsd2si %xmm0, %eax
movl %eax, -0x68(%rbp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x3c74
movq (%r15), %rax
movl (%rax,%r14,4), %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x4d00
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x3e0c
movq %r13, %rdi
callq 0x20b0
incq %r14
jmp 0x32d5
addq $0x50, %rbx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x3710
leaq -0x88(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4aae
leaq -0x88(%rbp), %rdi
callq 0x20b0
leaq -0x48(%rbp), %rdi
callq 0x2d12
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2d12
jmp 0x339b
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/msu-starx[P]starx/arduinomicro.cpp
// Function: ArduinoMicro::createPacket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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>>>>)
std::string ArduinoMicro::createPacket(std::string command, std::vector<std::string> parameters = {}){
    std::string message = "";
    message.reserve(message.capacity() * 10); // Increase message capacity for appending parameters
    message.append(command);
    if(!parameters.empty()) {
        for(int i = 0; i < parameters.size(); i++) {
            message.append(PacketDelimiterString);
            message.append(parameters[i]);
        }
    }
    message.append(PacketTerminatorString);
    return message;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
leaq 0x1acb(%rip), %rsi      # 0x630c
leaq -0x29(%rbp), %rdx
callq 0x2aea
leaq 0x10(%rbx), %rax
imulq $0xa, 0x10(%rbx), %rcx
cmpq %rax, (%rbx)
movl $0x96, %esi
cmovneq %rcx, %rsi
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2350
movq (%r15), %rcx
movq 0x8(%r15), %rax
cmpq %rax, %rcx
je 0x48c4
movq -0x38(%rbp), %rdx
leaq 0x1a0(%rdx), %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
subq %rcx, %rax
sarq $0x5, %rax
cmpq %r14, %rax
jbe 0x48c4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2350
movq (%r15), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x2350
incq %r14
movq (%r15), %rcx
movq 0x8(%r15), %rax
addq $0x20, %r13
jmp 0x488f
movq -0x38(%rbp), %rsi
addq $0x1c0, %rsi            # imm = 0x1C0
movq %rbx, %rdi
callq 0x2350
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48eb
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/msu-starx[P]starx/arduinomicro.cpp
// Function: ArduinoMicro::getADC[abi:cxx11]()
std::string ArduinoMicro::getADC(void){
    packet = this->createPacket(GetADCValuesString).c_str();
    arduinoPort.writePort(packet);
    usleep(waitTime * 1000); // Delay before reading buffer
    data = arduinoPort.readPort();
    return std::string(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x1e0, %rsi            # imm = 0x1E0
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2220
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x481c
leaq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq %rax, 0x168(%r14)
callq 0x20b0
leaq -0x30(%rbp), %rdi
callq 0x2d12
leaq -0x50(%rbp), %rdi
callq 0x20b0
movq 0x168(%r14), %rsi
movq %r14, %rdi
callq 0x56f6
imull $0x3e8, 0x160(%r14), %edi # imm = 0x3E8
callq 0x2240
movq %r14, %rdi
callq 0x5776
addq $0x170, %r14            # imm = 0x170
movq %r14, %rdi
movq %rax, %rsi
callq 0x2340
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2d12
leaq -0x50(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/msu-starx[P]starx/arduinomicro.cpp
// Function: ArduinoMicro::setPWM(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>>>>)
std::string ArduinoMicro::setPWM(std::vector<std::string> dutyCycles){
    packet = this->createPacket(SetPWMDutyCycleString, dutyCycles).c_str();
    arduinoPort.writePort(packet);
    usleep(waitTime * 1000); // Delay before reading buffer
    data = arduinoPort.readPort();
    return std::string(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
addq $0x280, %rsi            # imm = 0x280
leaq -0x50(%rbp), %rdi
callq 0x2220
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x3710
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movq %r14, %rsi
callq 0x481c
leaq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq %rax, 0x168(%r14)
callq 0x20b0
leaq -0x30(%rbp), %rdi
callq 0x2d12
leaq -0x50(%rbp), %rdi
callq 0x20b0
movq 0x168(%r14), %rsi
movq %r14, %rdi
callq 0x56f6
imull $0x3e8, 0x160(%r14), %edi # imm = 0x3E8
callq 0x2240
movq %r14, %rdi
callq 0x5776
addq $0x170, %r14            # imm = 0x170
movq %r14, %rdi
movq %rax, %rsi
callq 0x2340
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2d12
jmp 0x4b7c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/msu-starx[P]starx/arduinomicro.cpp
// Function: ArduinoMicro::setupSerial(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void ArduinoMicro::setupSerial(std::string portName, int baudRate){
    arduinoPort.portName = portName.c_str();
    arduinoPort.baudRate = baudRate;
    arduinoPort.openPort();
    arduinoPort.setPort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x118(%rdi)
movl %edx, 0x10(%rdi)
callq 0x54f4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5546
nop