LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::AttackPoint::SharedCtor()
void AttackPoint::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AttackPoint_plog_2eproto.base);
  ::memset(&call_stack_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&info_) -
      reinterpret_cast<char*>(&call_stack_)) + sizeof(info_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1c49d(%rip), %rdi     # 0x47388
callq 0x27560
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq %rax, %rdx
addq $0x28, %rdx
addq $0x18, %rax
subq %rax, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x61a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x2, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x20(%rax)
jne 0x2b482
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30e40
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::TaintQueryHypercall::SharedCtor()
void TaintQueryHypercall::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TaintQueryHypercall_plog_2eproto.base);
  ::memset(&call_stack_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&num_tainted_) -
      reinterpret_cast<char*>(&call_stack_)) + sizeof(num_tainted_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1be1d(%rip), %rdi     # 0x474c8
callq 0x27560
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x40, %rdi
movq %rax, %rdx
addq $0x5c, %rdx
addq $0x40, %rax
subq %rax, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x61a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x30(%rax)
jne 0x2c252
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30ae0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x30(%rax)
jne 0x2ca42
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30ae0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: moyix[P]pandalog_taint_parser/plog.pb.cc
// Function: panda::LogEntry::SharedCtor()
void LogEntry::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_LogEntry_plog_2eproto.base);
  process_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&call_stack_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&total_instr_) -
      reinterpret_cast<char*>(&call_stack_)) + sizeof(total_instr_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1a4ed(%rip), %rdi     # 0x47408
callq 0x27560
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
callq 0x27a80
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x27a60
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq %rax, %rdx
addq $0xb0, %rdx
addq $0x20, %rax
subq %rax, %rdx
addq $0x8, %rdx
xorl %esi, %esi
callq 0x61a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x2, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x20(%rax)
jne 0x2e282
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30ae0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x4, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x28(%rax)
jne 0x2e3c2
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30e60
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x8, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x30(%rax)
jne 0x2e502
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30e80
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x10, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x38(%rax)
jne 0x2e642
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30ea0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x20, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x40(%rax)
jne 0x2e782
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30ec0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x40, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x48(%rax)
jne 0x2e8c2
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30ee0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x80, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x50(%rax)
jne 0x2ea35
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30f00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x100, %esi            # imm = 0x100
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x58(%rax)
jne 0x2eab5
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30f00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x200, %esi            # imm = 0x200
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x60(%rax)
jne 0x2ec05
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30f20
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x400, %esi            # imm = 0x400
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x68(%rax)
jne 0x2ed55
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30f40
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x800, %esi            # imm = 0x800
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x70(%rax)
jne 0x2edd5
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30b00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x1000, %esi           # imm = 0x1000
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x78(%rax)
jne 0x2ef25
movq -0x28(%rbp), %rdi
callq 0x27600
movq %rax, %rdi
callq 0x30f60
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x78(%rax)
movq -0x28(%rbp), %rax
movq 0x78(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: DaSnek[P]TicTacToe-AI/./board.hpp
// Function: Board::check_for_tie() const
bool check_for_tie() const {
		int c = 0;
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				if (!board[i][j]) {
					c++;
				}
			}
		}
		return c == 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x1aca
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x1abd
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x10(%rbp), %rsi
callq 0x31b0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x31d0
cmpl $0x0, (%rax)
jne 0x1ab0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ab2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a7f
jmp 0x1abf
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a72
cmpl $0x0, -0xc(%rbp)
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: DaSnek[P]TicTacToe-AI/./board.hpp
// Function: Board::print_board() const
void print_board() const {
        for (auto& v : board) {
            for (int p : v) {
                std::cout << (p == AI ? 'X' : (!p ? '.' : 'O')) << ' ';
            }
            std::cout << std::endl;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3220
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3250
testb $0x1, %al
jne 0x1b28
jmp 0x1bf5
leaq -0x18(%rbp), %rdi
callq 0x3290
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2d00
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2d30
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x32b0
testb $0x1, %al
jne 0x1b6a
jmp 0x1bd4
leaq -0x38(%rbp), %rdi
callq 0x32f0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0x1, -0x44(%rbp)
jne 0x1b85
movb $0x58, %al
movb %al, -0x45(%rbp)
jmp 0x1baa
cmpl $0x0, -0x44(%rbp)
setne %cl
xorb $-0x1, %cl
movb $0x2e, %al
movb $0x4f, %dl
movb %dl, -0x47(%rbp)
testb $0x1, %cl
movb %al, -0x46(%rbp)
jne 0x1ba4
movb -0x47(%rbp), %al
movb %al, -0x46(%rbp)
movb -0x46(%rbp), %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
movq 0x541c(%rip), %rdi      # 0x6fd0
movsbl %al, %esi
callq 0x1100
movq %rax, %rdi
movl $0x20, %esi
callq 0x1100
leaq -0x38(%rbp), %rdi
callq 0x3310
jmp 0x1b57
movq 0x53f5(%rip), %rdi      # 0x6fd0
movq 0x53de(%rip), %rsi      # 0x6fc0
callq 0x10f0
leaq -0x18(%rbp), %rdi
callq 0x3330
jmp 0x1b12
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DaSnek[P]TicTacToe-AI/./board.hpp
// Function: Board::place_move(int, int)
bool place_move(int row, int col) {
        if (!is_pos_valid(row, col)) {
            return false;
        }

        if (get_pos(row, col)) {
            return false;
        }

        get_pos(row, col) = cur_player;
        cur_player *= -1;
        //spaces_filled++;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x36f0
testb $0x1, %al
jne 0x1c9f
movb $0x0, -0x1(%rbp)
jmp 0x1ce2
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3730
cmpl $0x0, (%rax)
je 0x1cb9
movb $0x0, -0x1(%rbp)
jmp 0x1ce2
movq -0x20(%rbp), %rdi
movl (%rdi), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3730
movl -0x24(%rbp), %edx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %edx, (%rcx)
imull $-0x1, (%rax), %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: DaSnek[P]TicTacToe-AI/AI.cpp
// Function: make_move(Board)
Coor make_move(Board board) {
	assert(board.get_cur_player() == AI);
	int best_score = -10000000;
	int op_i, op_j;

	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) {
			int tree_depth = 0;
			if (!board.get_pos(i, j)) {
				board.get_pos(i, j) = AI;
				board.switch_player();
				int s = score_pos(board, tree_depth); 
				board.switch_player();
				if (s > best_score) {
					op_i = i;
					op_j = j;
					best_score = s;
				}			
				board.get_pos(i, j) = 0; 
			}
		}
	}
	std::cout << "move: " << op_i << ' ' << op_j << std::endl;
	return {op_i, op_j};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x1c00
cmpl $0x1, %eax
jne 0x37fc
jmp 0x381b
leaq 0x896(%rip), %rdi       # 0x4099
leaq 0x8ac(%rip), %rsi       # 0x40b6
movl $0x57, %edx
leaq 0x8a7(%rip), %rcx       # 0x40bd
callq 0x1090
movl $0xff676980, -0x14(%rbp) # imm = 0xFF676980
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x38e4
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x38d4
movq -0x38(%rbp), %rdi
movl $0x0, -0x28(%rbp)
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x3730
cmpl $0x0, (%rax)
jne 0x38c4
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x3730
movq -0x38(%rbp), %rdi
movl $0x1, (%rax)
callq 0x3ac0
movq -0x38(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x3940
movq -0x38(%rbp), %rdi
movl %eax, -0x2c(%rbp)
callq 0x3ac0
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x38af
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x3730
movl $0x0, (%rax)
jmp 0x38c6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x383a
jmp 0x38d6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3829
movq 0x36e5(%rip), %rdi      # 0x6fd0
leaq 0x7e1(%rip), %rsi       # 0x40d3
callq 0x10c0
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x1170
movq %rax, %rdi
movl $0x20, %esi
callq 0x1100
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x1170
movq %rax, %rdi
movq 0x369c(%rip), %rsi      # 0x6fc0
callq 0x10f0
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: DaSnek[P]TicTacToe-AI/AI.cpp
// Function: score_pos(Board&, int)
static int score_pos(Board& board, int tree_depth) {
//function is unfinished, TODO:
	int winner = board.check_for_win();
	bool tie = board.check_for_tie();
	
	if (winner) {
		//std::cout << "! ";
		return winner;
	}
	
	if (tie) {
		//std::cout << "? ";
		return 0;
	}

	int best_score = (board.get_cur_player() == AI ? -100000 : 100000);
	int op_i, op_j;

	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) {
			if (!board.get_pos(i, j)) {
				board.get_pos(i, j) = board.get_cur_player();			

//				print_indent(tree_depth);
//				print_board_line(board);
//				std::cout << '\n';
				//std::cout << board.get_cur_player() << ": " << s << '\n';

				board.switch_player();

				int s = score_pos(board, tree_depth + 1); 

				board.switch_player();

				if (board.get_cur_player() == AI) {
					if (s > best_score) {
						op_i = i;
						op_j = j;
						best_score = s;
					}
				} else {
					if (s < best_score) {
						op_i = i;
						op_j = j;
						best_score = s;
					}
				}
				board.get_pos(i, j) = 0;			
			}
		}
	}
	return best_score;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16a0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a50
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x397a
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3aa9
testb $0x1, -0x19(%rbp)
je 0x398c
movl $0x0, -0x4(%rbp)
jmp 0x3aa9
movq -0x10(%rbp), %rdi
callq 0x1c00
movl %eax, %edx
movl $0x186a0, %eax          # imm = 0x186A0
movl $0xfffe7960, %ecx       # imm = 0xFFFE7960
cmpl $0x1, %edx
cmovel %ecx, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jge 0x3aa3
movl $0x0, -0x30(%rbp)
cmpl $0x3, -0x30(%rbp)
jge 0x3a93
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x3730
cmpl $0x0, (%rax)
jne 0x3a83
movq -0x10(%rbp), %rdi
callq 0x1c00
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x3730
movl -0x38(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3ac0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x3940
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3ac0
movq -0x10(%rbp), %rdi
callq 0x1c00
cmpl $0x1, %eax
jne 0x3a52
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x3a50
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3a6e
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x3a6c
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3a6e
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x3730
movl $0x0, (%rax)
jmp 0x3a85
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x39c2
jmp 0x3a95
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x39b1
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xfbfa(%rip), %rdi      # 0x12250
callq 0x5260
leaq 0xfbee(%rip), %rdi      # 0x12250
callq 0x49d0
leaq 0xfbe2(%rip), %rdi      # 0x12250
callq 0x4b20
leaq 0xfbd6(%rip), %rdi      # 0x12250
callq 0x4f80
leaq 0xfbca(%rip), %rdi      # 0x12250
callq 0x50a0
jmp 0x265b
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x318, %rdi            # imm = 0x318
callq 0x5660
movq -0x70(%rbp), %rsi
movq %rsi, %rax
addq $0x48, %rax
movq %rax, -0x68(%rbp)
addq $0x50, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x9ec0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x20(%rbp), %rdi
movl $0x2c, %ecx
callq 0xa450
jmp 0x4a2b
leaq -0x40(%rbp), %rdi
callq 0x2140
movl $0x0, -0x50(%rbp)
movslq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5680
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x4af3
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x318, %rcx            # imm = 0x318
movq %rcx, -0x90(%rbp)
addq $0x48, %rax
movq %rax, -0x88(%rbp)
movslq -0x50(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x56d0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0xa600
movl %eax, -0x7c(%rbp)
jmp 0x4a9d
movq -0x90(%rbp), %rdi
movl -0x7c(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x54(%rbp), %rsi
callq 0x56a0
jmp 0x4ab5
jmp 0x4ab7
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x4a3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2140
jmp 0x4b05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43a0
jmp 0x4b05
leaq -0x20(%rbp), %rdi
callq 0x43a0
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x23c0
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x410, %rdi            # imm = 0x410
callq 0x56f0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x470, %rdi            # imm = 0x470
callq 0x5830
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x5090
movq -0x18(%rbp), %rdi
addq $0x378, %rdi            # imm = 0x378
movslq -0xc(%rbp), %rsi
callq 0x5780
movq -0x18(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x470, %rdi            # imm = 0x470
movslq -0xc(%rbp), %rsi
callq 0x5860
movsd -0x38(%rbp), %xmm0
movq -0x18(%rbp), %rdi
movsd %xmm0, 0x28(%rax)
movsd 0x408(%rdi), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0x470, %rdi            # imm = 0x470
movslq -0xc(%rbp), %rsi
callq 0x5860
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rdi
movsd %xmm0, 0x40(%rax)
addq $0x470, %rdi            # imm = 0x470
movslq -0xc(%rbp), %rsi
callq 0x5860
movq %rax, %rdi
callq 0xb2d0
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x410, %rax            # imm = 0x410
movq %rax, -0x28(%rbp)
addq $0x470, %rdi            # imm = 0x470
movslq -0xc(%rbp), %rsi
callq 0x5860
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x30, %rsi
callq 0x57a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4fa7
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x440, %rdi            # imm = 0x440
callq 0x5880
movq -0x80(%rbp), %rdi
addq $0x458, %rdi            # imm = 0x458
callq 0x58a0
movl $0x0, -0xc(%rbp)
movq -0x80(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x410, %rdi            # imm = 0x410
callq 0x5810
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x51d8
movq -0x80(%rbp), %rdi
movq %rdi, %rax
addq $0x440, %rax            # imm = 0x440
movq %rax, -0xa8(%rbp)
addq $0x410, %rdi            # imm = 0x410
movslq -0xc(%rbp), %rsi
callq 0x5780
movsd (%rax), %xmm0
callq 0x20c0
movq -0xa8(%rbp), %rdi
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x58c0
movq -0x80(%rbp), %rax
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
addq $0x458, %rcx            # imm = 0x458
movq %rcx, -0x98(%rbp)
addq $0x48, %rax
movq %rax, -0xa0(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x5920
movq -0xa0(%rbp), %rsi
movl (%rax), %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xa690
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x58f0
jmp 0x51aa
leaq -0x30(%rbp), %rdi
callq 0x2140
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x50da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2140
jmp 0x524a
movq -0x80(%rbp), %rsi
movq %rsi, %rax
addq $0x50, %rax
movq %rax, -0xb8(%rbp)
addq $0x458, %rsi            # imm = 0x458
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5940
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0xa180
jmp 0x521a
leaq -0x60(%rbp), %rdi
callq 0x2140
leaq -0x78(%rbp), %rdi
callq 0x43a0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x43a0
movq -0x38(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rcx, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x21(%rbp)
leaq -0x22(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x23d0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x256e(%rip), %rsi      # 0xc311
callq 0x3360
jmp 0x9daa
leaq -0x22(%rbp), %rdi
callq 0x2250
movq -0x48(%rbp), %rdi
callq 0x2030
movq -0x48(%rbp), %rdi
addq %rax, %rax
leaq (%rax,%rax,4), %rsi
callq 0x2370
jmp 0x9dce
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x2410
jmp 0x9ddd
movq -0x68(%rbp), %rdi
callq 0xa330
testb $0x1, %al
jne 0x9e80
movl $0x0, -0x38(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x5680
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x9e7e
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x1a0, %rsi            # imm = 0x1A0
callq 0x2410
jmp 0x9e28
movq -0x68(%rbp), %rdi
movslq -0x38(%rbp), %rsi
callq 0x56d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2410
jmp 0x9e43
jmp 0x9e45
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9df5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x2250
jmp 0x9eb3
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x2140
jmp 0x9eb3
jmp 0x9e80
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x1c0, %rsi            # imm = 0x1C0
callq 0x2410
jmp 0x9e96
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x9ea9
movq -0x48(%rbp), %rdi
callq 0x2140
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x23c0
nopl (%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x98(%rbp)
addq $0x1e0, %rsi            # imm = 0x1E0
leaq -0x50(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x20d0
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3080
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0x9d50
jmp 0x9f45
leaq -0x30(%rbp), %rdi
callq 0x20b0
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, 0x168(%rax)
leaq -0x30(%rbp), %rdi
callq 0x2140
leaq -0x70(%rbp), %rdi
callq 0x43a0
leaq -0x50(%rbp), %rdi
callq 0x2140
movq -0x98(%rbp), %rdi
movq 0x168(%rdi), %rsi
callq 0xbb40
movq -0x98(%rbp), %rax
imull $0x3e8, 0x160(%rax), %edi # imm = 0x3E8
callq 0x2310
movq -0x98(%rbp), %rdi
callq 0xbbe0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
addq $0x170, %rdi            # imm = 0x170
callq 0x22f0
movq -0x98(%rbp), %rsi
movq -0xa8(%rbp), %rdi
addq $0x170, %rsi            # imm = 0x170
callq 0x20d0
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x43a0
leaq -0x50(%rbp), %rdi
callq 0x2140
movq -0x78(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdx, -0x88(%rbp)
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x90(%rbp)
addq $0x280, %rsi            # imm = 0x280
leaq -0x58(%rbp), %rdi
callq 0x20d0
movq -0x88(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x5940
jmp 0xa1dc
movq -0x90(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
leaq -0x70(%rbp), %rcx
callq 0x9d50
jmp 0xa1f6
leaq -0x38(%rbp), %rdi
callq 0x20b0
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x168(%rax)
leaq -0x38(%rbp), %rdi
callq 0x2140
leaq -0x70(%rbp), %rdi
callq 0x43a0
leaq -0x58(%rbp), %rdi
callq 0x2140
movq -0x90(%rbp), %rdi
movq 0x168(%rdi), %rsi
callq 0xbb40
movq -0x90(%rbp), %rax
imull $0x3e8, 0x160(%rax), %edi # imm = 0x3E8
callq 0x2310
movq -0x90(%rbp), %rdi
callq 0xbbe0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
addq $0x170, %rdi            # imm = 0x170
callq 0x22f0
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rdi
addq $0x170, %rsi            # imm = 0x170
callq 0x20d0
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xa2c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x43a0
leaq -0x58(%rbp), %rdi
callq 0x2140
movq -0x78(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x20b0
movq -0x20(%rbp), %rdi
movq %rax, 0x118(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x10(%rdi)
callq 0xb7f0
movq -0x20(%rbp), %rdi
callq 0xb860
addq $0x30, %rsp
popq %rbp
retq
// File: msu-starx[P]starx/converter.cpp
// Function: Converter::splitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> Converter::splitString(const std::string &str, char delimiter){
    std::vector<std::string> tokens = {};
    std::string token = "";
    std::stringstream stream(str);
    while(std::getline(stream, token, delimiter)) {
        tokens.push_back(token);
    }
    return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x1f8(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x3080
leaq -0x41(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x23d0
movq -0x1e8(%rbp), %rdx
leaq 0x1e5f(%rip), %rsi      # 0xc311
leaq -0x40(%rbp), %rdi
callq 0x3360
jmp 0xa4bd
leaq -0x41(%rbp), %rdi
callq 0x2250
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0xa6c0
movl %eax, -0x1fc(%rbp)
jmp 0xa4e8
movl -0x1fc(%rbp), %edx
movq -0x208(%rbp), %rsi
leaq -0x1e0(%rbp), %rdi
callq 0x2380
jmp 0xa503
jmp 0xa505
movsbl -0x19(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x23f0
movq %rax, -0x210(%rbp)
jmp 0xa522
movq -0x210(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x22d0
movb %al, -0x211(%rbp)
jmp 0xa540
movb -0x211(%rbp), %al
testb $0x1, %al
jne 0xa54c
jmp 0xa59f
movq -0x1f8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xa6e0
jmp 0xa55e
jmp 0xa505
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x2250
jmp 0xa5e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xa5c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x2180
jmp 0xa5c0
movb $0x1, -0x1a(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x2180
leaq -0x40(%rbp), %rdi
callq 0x2140
testb $0x1, -0x1a(%rbp)
jne 0xa5d7
jmp 0xa5cb
leaq -0x40(%rbp), %rdi
callq 0x2140
jmp 0xa5e7
movq -0x1f8(%rbp), %rdi
callq 0x43a0
movq -0x1f0(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1f8(%rbp), %rdi
callq 0x43a0
movq -0x50(%rbp), %rdi
callq 0x23c0
nopl (%rax)
// File: msu-starx[P]starx/pid.cpp
// Function: PID::computeValues()
bool PID::computeValues(void){
    if(!inAuto) return false;
    unsigned long currentTime = this->millis();
    unsigned long elapsedTime = currentTime - lastTime;
    if(elapsedTime >= sampleTime) {
        errorValue = setPoint - inputValue;
        iTerm += kiGain * errorValue;
        if(iTerm > outMax) iTerm = outMax;
        else if(iTerm < outMin) iTerm = outMin;
        dInput = inputValue - lastInput;
        // PID Equation
        outputValue = (kpGain * errorValue) + (iTerm) - (kdGain * dInput);
        //
        if(outputValue > outMax) outputValue = outMax;
        else if(outputValue < outMin) outputValue = outMin;
        lastInput = inputValue;
        lastTime = currentTime;
        return true;
    }
    else return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x10(%rax)
jne 0xb2f3
movb $0x0, -0x1(%rbp)
jmp 0xb451
movq -0x28(%rbp), %rdi
callq 0xb280
movq -0x28(%rbp), %rcx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
subq 0x20(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x18(%rcx), %rax
jb 0xb44d
movq -0x28(%rbp), %rax
movsd 0x40(%rax), %xmm0
subsd 0x28(%rax), %xmm0
movsd %xmm0, 0x38(%rax)
movsd 0x68(%rax), %xmm0
movsd 0x38(%rax), %xmm2
movsd 0x48(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rax)
movsd 0x48(%rax), %xmm0
ucomisd 0x80(%rax), %xmm0
jbe 0xb36f
movq -0x28(%rbp), %rax
movsd 0x80(%rax), %xmm0
movsd %xmm0, 0x48(%rax)
jmp 0xb393
movq -0x28(%rbp), %rax
movsd 0x48(%rax), %xmm1
movsd 0x78(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb391
movq -0x28(%rbp), %rax
movsd 0x78(%rax), %xmm0
movsd %xmm0, 0x48(%rax)
jmp 0xb393
movq -0x28(%rbp), %rax
movsd 0x28(%rax), %xmm0
subsd 0x58(%rax), %xmm0
movsd %xmm0, 0x50(%rax)
movsd 0x60(%rax), %xmm1
movsd 0x38(%rax), %xmm2
movsd 0x48(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x70(%rax), %xmm0
movsd 0x50(%rax), %xmm2
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rax)
movsd 0x30(%rax), %xmm0
ucomisd 0x80(%rax), %xmm0
jbe 0xb40d
movq -0x28(%rbp), %rax
movsd 0x80(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
jmp 0xb431
movq -0x28(%rbp), %rax
movsd 0x30(%rax), %xmm1
movsd 0x78(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb42f
movq -0x28(%rbp), %rax
movsd 0x78(%rax), %xmm0
movsd %xmm0, 0x30(%rax)
jmp 0xb431
movq -0x28(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x58(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xb451
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: msu-starx[P]starx/pid.cpp
// Function: PID::setTunings(double, double, double)
void PID::setTunings(double Kp, double Ki, double Kd){
    if(Kp < 0 || Ki < 0 || Kd < 0) return;
    double sampleTimeInSec = ((double)sampleTime) / 1000;
    kpGain = Kp;
    kiGain = Ki * sampleTimeInSec;
    kdGain = Kd / sampleTimeInSec;
    if(controllerDirection == REVERSE) {
        kpGain = (0 - kpGain);
        kiGain = (0 - kiGain);
        kdGain = (0 - kdGain);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
ja 0xb49d
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
ja 0xb49d
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0xb4a2
jmp 0xb539
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %xmm0
movaps 0xd5e(%rip), %xmm1      # 0xc210
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xd62(%rip), %xmm1      # 0xc220
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0xd2b(%rip), %xmm1      # 0xc200
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x60(%rcx)
movsd -0x18(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x68(%rcx)
movsd -0x20(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x70(%rcx)
movl 0x14(%rcx), %eax
cmpl 0xc(%rcx), %eax
jne 0xb539
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
subsd 0x60(%rax), %xmm0
movsd %xmm0, 0x60(%rax)
xorps %xmm0, %xmm0
subsd 0x68(%rax), %xmm0
movsd %xmm0, 0x68(%rax)
xorps %xmm0, %xmm0
subsd 0x70(%rax), %xmm0
movsd %xmm0, 0x70(%rax)
popq %rbp
retq
nopl (%rax,%rax)