LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Agent.cpp
// Function: Agent::SaveActiveBehavior(ActiveBehavior const&)
void Agent::SaveActiveBehavior(const ActiveBehavior &beh) {
  BehaviorType type = beh.GetType();

  Assert(type > BT_None && type < BT_Max);

  if (mActiveBehavior[type] != 0) {
    if (*mActiveBehavior[type] < beh) {
      delete mActiveBehavior[type];
      mActiveBehavior[type] = new ActiveBehavior(beh);
    }
  } else {
    mActiveBehavior[type] = new ActiveBehavior(beh);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %r12d
movq 0x58(%rdi,%r12,8), %rdi
testq %rdi, %rdi
je 0xf363
movsd 0x10(%r14), %xmm0
ucomisd 0x10(%rdi), %xmm0
jbe 0xf385
movl $0xa8, %esi
callq 0x94e0
movl $0xa8, %edi
callq 0x94c0
movq %rax, %r15
movl $0xa8, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x93e0
movq %r15, 0x58(%rbx,%r12,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Agent.h
// Function: Strategy& Agent::GetDecisionData<Strategy>(Strategy**)
DecisionDataDerived &GetDecisionData(DecisionDataDerived **xptr) {
    if (*xptr == 0) {
      *xptr = new DecisionDataDerived(*this);
    }
    (*xptr)->Update();
    return **xptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r14
testq %r14, %r14
jne 0xf4e3
movq %rdi, %r15
movl $0x150, %edi            # imm = 0x150
callq 0x94c0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x4b438
movq %r14, (%rbx)
movq %r14, %rdi
callq 0x2227e
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x150, %esi            # imm = 0x150
movq %r14, %rdi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: BasicCommand::Execute(std::__cxx11::list<CommandInfo, std::allocator<CommandInfo>>&)
bool BasicCommand::Execute(std::list<CommandInfo> &command_queue) {
  if (mCommandInfo.mTime != mAgent.GetWorldState().CurrentTime()) {
    return false;
  }

  ActionEffector::CMD_QUEUE_MUTEX.Lock();
  command_queue.push_back(mCommandInfo);
  ActionEffector::CMD_QUEUE_MUTEX.UnLock();

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movl 0x28(%rdi), %ecx
xorl 0x14(%rax), %ecx
movl 0x10(%rax), %eax
xorl 0x24(%rdi), %eax
orl %ecx, %eax
sete %r14b
jne 0xf62a
movq %rsi, %rbx
movq %rdi, %r15
addq $0x10, %r15
leaq 0x74f78(%rip), %r12     # 0x84578
movq %r12, %rdi
callq 0x4e01a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12630
movq %rax, %rdi
movq %rbx, %rsi
callq 0x90b0
incq 0x10(%rbx)
movq %r12, %rdi
callq 0x4e036
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Turn::Plan(double)
void Turn::Plan(double moment) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mAngle = moment;
  std::ostringstream cmd_str;
  cmd_str << "(turn " << mCommandInfo.mAngle << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
movsd %xmm0, 0x40(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x59baa(%rip), %rsi     # 0x69260
movl $0x6, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
leaq -0x1a8(%rbp), %rdi
callq 0x97d0
leaq 0x59bad(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0xf723
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x7488e(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xf750
movq %rax, %rbx
movq 0x7485e(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Dash::Plan(double, double)
void Dash::Plan(double power, AngleDeg dir) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mPower = GetNormalizeDashPower(power);
  mCommandInfo.mAngle = GetNormalizeDashAngle(dir);
  std::ostringstream cmd_str;
  cmd_str << "(dash " << mCommandInfo.mPower << " " << mCommandInfo.mAngle
          << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
callq 0x49360
movq %rax, %r14
callq 0x49360
movsd -0x18(%rbp), %xmm1
maxsd 0x33c8(%r14), %xmm1
movsd 0x33c0(%rax), %xmm0
minsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rbx)
callq 0x49360
movq %rax, %r14
callq 0x49360
movsd -0x20(%rbp), %xmm1
maxsd 0x33a0(%r14), %xmm1
movsd 0x3398(%rax), %xmm0
minsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rbx)
leaq -0x1b8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x59a10(%rip), %rsi     # 0x69267
movl $0x6, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x38(%rbx), %xmm0
leaq -0x1b8(%rbp), %rdi
callq 0x97d0
movq %rax, %r14
leaq 0x5d345(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
movq %r14, %rdi
callq 0x97d0
leaq 0x599e8(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0xf8e8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x746c9(%rip), %rsi     # 0x83fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xf915
movq %rax, %rbx
movq 0x74699(%rip), %rsi     # 0x83fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: TurnNeck::Plan(double)
void TurnNeck::Plan(double moment) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mAngle = GetNormalizeNeckMoment(moment);
  std::ostringstream cmd_str;
  cmd_str << "(turn_neck " << mCommandInfo.mAngle << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
callq 0x49360
movq %rax, %r14
callq 0x49360
movsd -0x18(%rbp), %xmm1
maxsd 0x3158(%r14), %xmm1
movsd 0x3150(%rax), %xmm0
minsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rbx)
leaq -0x1b0(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x59882(%rip), %rsi     # 0x6926e
movl $0xb, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
leaq -0x1b0(%rbp), %rdi
callq 0x97d0
leaq 0x59877(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0xfa59
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x74558(%rip), %rsi     # 0x83fb8
leaq -0x1b0(%rbp), %rdi
callq 0x9290
leaq -0x140(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xfa86
movq %rax, %rbx
movq 0x74528(%rip), %rsi     # 0x83fb8
leaq -0x1b0(%rbp), %rdi
callq 0x9290
leaq -0x140(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Say::Plan(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Say::Plan(std::string msg) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  if (PlayerParam::instance().isCoach()) {
    cmd_str << "(say " << msg << ")";
  } else {
    cmd_str << "(say \"" << msg << "\")";
  }
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1a8(%rbp), %rdi
callq 0x9660
callq 0x43dce
cmpb $0x1, 0x31a5(%rax)
jne 0xfb6b
leaq 0x59741(%rip), %rsi     # 0x6927a
leaq -0x1a8(%rbp), %rdi
movl $0x5, %edx
callq 0x9560
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x1a8(%rbp), %rdi
callq 0x9560
movl $0x1, %edx
leaq 0x5971f(%rip), %rsi     # 0x69288
jmp 0xfba2
leaq 0x5970e(%rip), %rsi     # 0x69280
leaq -0x1a8(%rbp), %rdi
movl $0x6, %edx
callq 0x9560
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x1a8(%rbp), %rdi
callq 0x9560
movl $0x2, %edx
leaq 0x596e5(%rip), %rsi     # 0x69287
movq %rax, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0xfbe5
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x743cc(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xfc12
movq %rax, %rbx
movq 0x7439c(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Attentionto::Plan(bool, int)
void Attentionto::Plan(bool on, Unum num) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  if (on == false) {
    cmd_str << "(attentionto off)";
  } else {
    if (num < 0) {
      cmd_str << "(attentionto opp " << -num << ")";
    } else {
      cmd_str << "(attentionto our " << num << ")";
    }
  }
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1b8(%rbp), %r15
movq %r15, %rdi
callq 0x9660
testl %r12d, %r12d
je 0xfcde
testl %r14d, %r14d
js 0xfcec
leaq 0x595e3(%rip), %rsi     # 0x692ae
leaq -0x1b8(%rbp), %rdi
movl $0x11, %edx
callq 0x9560
jmp 0xfd07
movl $0x11, %edx
leaq 0x595a0(%rip), %rsi     # 0x6928a
jmp 0xfd25
leaq 0x595a9(%rip), %rsi     # 0x6929c
leaq -0x1b8(%rbp), %rdi
movl $0x11, %edx
callq 0x9560
negl %r14d
leaq -0x1b8(%rbp), %rdi
movl %r14d, %esi
callq 0x9880
movq %rax, %r15
movl $0x1, %edx
leaq 0x59563(%rip), %rsi     # 0x69288
movq %r15, %rdi
callq 0x9560
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0xfd68
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x74249(%rip), %rsi     # 0x83fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfd99
movq %rax, %rbx
movq 0x74215(%rip), %rsi     # 0x83fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Kick::Plan(double, double)
void Kick::Plan(double power, double dir) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mPower = GetNormalizeKickPower(power);
  mCommandInfo.mAngle = GetNormalizeMoment(dir);
  std::ostringstream cmd_str;
  cmd_str << "(kick " << mCommandInfo.mPower << " " << mCommandInfo.mAngle
          << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
callq 0x49360
movq %rax, %r14
callq 0x49360
movsd -0x18(%rbp), %xmm1
maxsd 0x3138(%r14), %xmm1
movsd 0x3130(%rax), %xmm0
minsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rbx)
callq 0x49360
movq %rax, %r14
callq 0x49360
movsd -0x20(%rbp), %xmm1
maxsd 0x3148(%r14), %xmm1
movsd 0x3140(%rax), %xmm0
minsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rbx)
leaq -0x1b8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x5941f(%rip), %rsi     # 0x692c0
movl $0x6, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x38(%rbx), %xmm0
leaq -0x1b8(%rbp), %rdi
callq 0x97d0
movq %rax, %r14
leaq 0x5ccfb(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
movq %r14, %rdi
callq 0x97d0
leaq 0x5939e(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0xff32
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x7407f(%rip), %rsi     # 0x83fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xff5f
movq %rax, %rbx
movq 0x7404f(%rip), %rsi     # 0x83fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Tackle::Plan(double, bool)
void Tackle::Plan(double dir, const bool foul) {
  std::string foul_signal;
  foul_signal += (foul) ? " true" : " false";
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mAngle = GetNormalizeMoment(dir);
  std::ostringstream cmd_str;
  if (PlayerParam::instance().playerVersion() > 14)
    cmd_str << "(tackle " << mCommandInfo.mAngle << foul_signal << ")";
  else
    cmd_str << "(tackle " << mCommandInfo.mAngle << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x592c6(%rip), %rcx     # 0x692c7
leaq 0x592c5(%rip), %rax     # 0x692cd
testl %esi, %esi
cmovneq %rcx, %rax
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x9970
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rbx)
callq 0x49360
movq %rax, %r14
callq 0x49360
movsd -0x20(%rbp), %xmm1
maxsd 0x3148(%r14), %xmm1
movsd 0x3140(%rax), %xmm0
minsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rbx)
leaq -0x1d8(%rbp), %rdi
callq 0x9660
callq 0x43dce
movsd 0x31a8(%rax), %xmm0
ucomisd 0x591e1(%rip), %xmm0    # 0x69258
jbe 0x100b4
leaq 0x59254(%rip), %rsi     # 0x692d4
leaq -0x1d8(%rbp), %rdi
movl $0x8, %edx
callq 0x9560
movsd 0x40(%rbx), %xmm0
leaq -0x1d8(%rbp), %rdi
callq 0x97d0
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rax, %rdi
callq 0x9560
jmp 0x100dd
leaq 0x59219(%rip), %rsi     # 0x692d4
leaq -0x1d8(%rbp), %rdi
movl $0x8, %edx
callq 0x9560
movsd 0x40(%rbx), %xmm0
leaq -0x1d8(%rbp), %rdi
callq 0x97d0
leaq 0x591a4(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1d0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x1012c
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x73e85(%rip), %rsi     # 0x83fb8
leaq -0x1d8(%rbp), %rdi
callq 0x9290
leaq -0x168(%rbp), %rdi
callq 0x91c0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x10160
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10177
jmp 0x10172
movq %rax, %rbx
jmp 0x10199
movq %rax, %rbx
movq 0x73e37(%rip), %rsi     # 0x83fb8
leaq -0x1d8(%rbp), %rdi
callq 0x9290
leaq -0x168(%rbp), %rdi
callq 0x91c0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x101ae
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Pointto::Plan(bool, double, double)
void Pointto::Plan(bool on, double dist, double dir) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;

  if (on) {
    mCommandInfo.mDist = dist;
    mCommandInfo.mAngle = dir;
    cmd_str << "(pointto " << mCommandInfo.mDist << " " << mCommandInfo.mAngle
            << ")";
  } else {
    cmd_str << "(pointto off)";
  }
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1c0(%rbp), %r15
movq %r15, %rdi
callq 0x9660
testl %r14d, %r14d
je 0x102b1
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x30(%rbx)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x40(%rbx)
leaq 0x59084(%rip), %rsi     # 0x692dd
leaq -0x1c0(%rbp), %rdi
movl $0x9, %edx
callq 0x9560
movsd 0x30(%rbx), %xmm0
leaq -0x1c0(%rbp), %rdi
callq 0x97d0
movq %rax, %r15
leaq 0x5c93f(%rip), %rsi     # 0x6cbc4
movl $0x1, %r14d
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
movq %r15, %rdi
callq 0x97d0
movq %rax, %r15
leaq 0x58fd9(%rip), %rsi     # 0x69288
jmp 0x102be
movl $0xd, %r14d
leaq 0x59029(%rip), %rsi     # 0x692e7
movq %r15, %rdi
movq %r14, %rdx
callq 0x9560
leaq -0x1b8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x48(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x10304
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x73cad(%rip), %rsi     # 0x83fb8
leaq -0x1c0(%rbp), %rdi
callq 0x9290
leaq -0x150(%rbp), %rdi
callq 0x91c0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10333
movq %rax, %rbx
movq 0x73c7b(%rip), %rsi     # 0x83fb8
leaq -0x1c0(%rbp), %rdi
callq 0x9290
leaq -0x150(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Catch::Plan(double)
void Catch::Plan(double dir) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mAngle = dir;
  std::ostringstream cmd_str;
  cmd_str << "(catch " << mCommandInfo.mAngle << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
movsd %xmm0, 0x40(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x58f17(%rip), %rsi     # 0x692f5
movl $0x7, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
leaq -0x1a8(%rbp), %rdi
callq 0x97d0
leaq 0x58e85(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x1044b
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x73b66(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10478
movq %rax, %rbx
movq 0x73b36(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Move::Plan(Vector)
void Move::Plan(Vector pos) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mMovePos = pos;
  std::ostringstream cmd_str;
  cmd_str << "(move " << mCommandInfo.mMovePos.X() << " "
          << mCommandInfo.mMovePos.Y() << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
movsd %xmm0, 0x48(%rdi)
movsd %xmm1, 0x50(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x58dd6(%rip), %rsi     # 0x692fd
movl $0x6, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x48(%rbx), %xmm0
leaq -0x1a8(%rbp), %rdi
callq 0x97d0
movq %rax, %r14
leaq 0x5c675(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x50(%rbx), %xmm0
movq %r14, %rdi
callq 0x97d0
leaq 0x58d18(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x105b8
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x739f9(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x105e5
movq %rax, %rbx
movq 0x739c9(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: ChangeView::Plan(ViewWidth)
void ChangeView::Plan(ViewWidth view_width) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mViewWidth = view_width;
  std::ostringstream cmd_str;

  switch (mCommandInfo.mViewWidth) {
  case VW_Narrow:
    cmd_str << "(change_view narrow)";
    break;
  case VW_Normal:
    cmd_str << "(change_view normal)";
    break;
  case VW_Wide:
    cmd_str << "(change_view wide)";
    break;
  default:
    break;
  }
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
movl %esi, 0x58(%rdi)
leaq -0x1a8(%rbp), %rdi
callq 0x9660
movl 0x58(%rbx), %eax
decl %eax
cmpl $0x3, %eax
jae 0x106b5
movl %eax, %eax
leaq 0x58e91(%rip), %rcx     # 0x69528
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x58e93(%rip), %rcx     # 0x69538
movq (%rcx,%rax,8), %rdx
leaq -0x1a8(%rbp), %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x106f0
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x738c1(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1071d
movq %rax, %rbx
movq 0x73891(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Compression::Plan(int)
void Compression::Plan(int level) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mLevel = level;
  std::ostringstream cmd_str;
  cmd_str << "(compression " << mCommandInfo.mLevel << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
movl %esi, 0x14(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x58b7b(%rip), %rsi     # 0x69341
movl $0xd, %edx
movq %r14, %rdi
callq 0x9560
movl 0x14(%rbx), %esi
leaq -0x1a8(%rbp), %rdi
callq 0x9880
leaq 0x58a9f(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x10831
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x73780(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1085e
movq %rax, %rbx
movq 0x73750(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: SenseBody::Plan()
void SenseBody::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(sense_body)";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x58a4c(%rip), %rsi     # 0x6934f
movl $0xc, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x1094b
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x73666(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10978
movq %rax, %rbx
movq 0x73636(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Score::Plan()
void Score::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(score)";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x5893f(%rip), %rsi     # 0x6935c
movl $0x7, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x10a65
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x7354c(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10a92
movq %rax, %rbx
movq 0x7351c(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Bye::Plan()
void Bye::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(bye)";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x5882d(%rip), %rsi     # 0x69364
movl $0x5, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x10b7f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x73432(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10bac
movq %rax, %rbx
movq 0x73402(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Done::Plan()
void Done::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(done)";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x58719(%rip), %rsi     # 0x6936a
movl $0x6, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x10c99
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x73318(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10cc6
movq %rax, %rbx
movq 0x732e8(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Clang::Plan(int, int)
void Clang::Plan(int min_ver, int max_ver) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mMinVer = min_ver;
  mCommandInfo.mMaxVer = max_ver;
  std::ostringstream cmd_str;
  cmd_str << "(clang (ver " << mCommandInfo.mMinVer << " "
          << mCommandInfo.mMaxVer << "))";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
movl %esi, 0x18(%rdi)
movl %edx, 0x1c(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x58600(%rip), %rsi     # 0x69371
movl $0xc, %edx
movq %r14, %rdi
callq 0x9560
movl 0x18(%rbx), %esi
leaq -0x1a8(%rbp), %rdi
callq 0x9880
movq %rax, %r14
leaq 0x5be2d(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movl 0x1c(%rbx), %esi
movq %r14, %rdi
callq 0x9880
leaq 0x59c61(%rip), %rsi     # 0x6aa17
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x10dfe
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x731b3(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10e2b
movq %rax, %rbx
movq 0x73183(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Ear::Plan(bool, bool, EarMode)
void Ear::Plan(bool on, bool our_side, EarMode ear_mode) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();

  const char *on_string;
  const char *side_string;
  const char *ear_mode_string;

  if (on == true) {
    on_string = "on";
  } else {
    on_string = "off";
  }

  if (our_side) {
    side_string = " our";
  } else {
    side_string = " opp";
  }

  if (ear_mode == EM_Partial) {
    ear_mode_string = " partial";
  } else if (ear_mode == EM_Complete) {
    ear_mode_string = " complete";
  } else {
    ear_mode_string = "";
  }

  std::ostringstream cmd_str;
  cmd_str << "(ear (" << on_string << side_string << ear_mode_string << "))";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %esi, %r12d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq 0x584b3(%rip), %rax     # 0x6937e
leaq 0x584b1(%rip), %r15     # 0x69383
testl %edx, %edx
cmovneq %rax, %r15
cmpl $0x2, %ecx
leaq 0x584af(%rip), %rax     # 0x69391
leaq 0x598a7(%rip), %rdx     # 0x6a790
cmoveq %rax, %rdx
cmpl $0x1, %ecx
leaq 0x58491(%rip), %r14     # 0x69388
cmovneq %rdx, %r14
leaq -0x1c0(%rbp), %r13
movq %r13, %rdi
callq 0x9660
leaq 0x5848a(%rip), %rsi     # 0x6939b
movl $0x6, %edx
movq %r13, %rdi
callq 0x9560
leaq 0x5c392(%rip), %rax     # 0x6d2b7
leaq 0x5c378(%rip), %rsi     # 0x6d2a4
testb %r12b, %r12b
cmovneq %rax, %rsi
movzbl %r12b, %edx
xorq $0x3, %rdx
leaq -0x1c0(%rbp), %rdi
callq 0x9560
leaq -0x1c0(%rbp), %rdi
movl $0x4, %edx
movq %r15, %rsi
callq 0x9560
movq %r14, %rdi
callq 0x9200
leaq -0x1c0(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9560
leaq 0x59a9b(%rip), %rsi     # 0x6aa17
leaq -0x1c0(%rbp), %rdi
movl $0x2, %edx
callq 0x9560
leaq -0x1b8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x48(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x10fc8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x72fe9(%rip), %rsi     # 0x83fb8
leaq -0x1c0(%rbp), %rdi
callq 0x9290
leaq -0x150(%rbp), %rdi
callq 0x91c0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10ffb
movq %rax, %rbx
movq 0x72fb3(%rip), %rsi     # 0x83fb8
leaq -0x1c0(%rbp), %rdi
callq 0x9290
leaq -0x150(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: SynchSee::Plan()
void SynchSee::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(synch_see)";
  mCommandInfo.mString = cmd_str.str();
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1b0(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x582ff(%rip), %rsi     # 0x693a2
movl $0xb, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1a8(%rbp), %r14
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x97a0
addq $0x60, %rbx
leaq -0x38(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x95f0
movq (%r15), %rdi
leaq -0x28(%rbp), %r15
cmpq %r15, %rdi
je 0x110ee
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x94e0
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x97a0
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x1111d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x72e94(%rip), %rsi     # 0x83fb8
leaq -0x1b0(%rbp), %rdi
callq 0x9290
leaq -0x140(%rbp), %rdi
callq 0x91c0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1114e
jmp 0x1114e
movq %rax, %rbx
movq 0x72e60(%rip), %rsi     # 0x83fb8
leaq -0x1b0(%rbp), %rdi
callq 0x9290
leaq -0x140(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: ChangePlayerType::Plan(int, int)
void ChangePlayerType::Plan(Unum num, int player_type) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(change_player_type " << num << " " << player_type << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1b8(%rbp), %r12
movq %r12, %rdi
callq 0x9660
leaq 0x581b1(%rip), %rsi     # 0x693ae
movl $0x14, %edx
movq %r12, %rdi
callq 0x9560
leaq -0x1b8(%rbp), %rdi
movl %r15d, %esi
callq 0x9880
movq %rax, %r15
leaq 0x5b9a1(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movl %r14d, %esi
callq 0x9880
leaq 0x58046(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x1128a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x72d27(%rip), %rsi     # 0x83fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x112bb
movq %rax, %rbx
movq 0x72cf3(%rip), %rsi     # 0x83fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: ChangePlayerType::Plan(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void ChangePlayerType::Plan(std::string teamname, Unum num, int player_type) {
  mCommandInfo.mType = CT_ChangePlayerTypeForTrainer;
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(change_player_type " << teamname << " " << num << " "
          << player_type << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movl $0x15, 0x10(%rdi)
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1c0(%rbp), %r13
movq %r13, %rdi
callq 0x9660
leaq 0x5807b(%rip), %rsi     # 0x693ae
movl $0x14, %edx
movq %r13, %rdi
callq 0x9560
movq (%r12), %rsi
movq 0x8(%r12), %rdx
leaq -0x1c0(%rbp), %rdi
callq 0x9560
movq %rax, %r12
leaq 0x5b865(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r12, %rdi
movl %r15d, %esi
callq 0x9880
movq %rax, %r15
leaq 0x5b843(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movl %r14d, %esi
callq 0x9880
leaq 0x57ee8(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1b8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x48(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x113e8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x72bc9(%rip), %rsi     # 0x83fb8
leaq -0x1c0(%rbp), %rdi
callq 0x9290
leaq -0x150(%rbp), %rdi
callq 0x91c0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1141b
movq %rax, %rbx
movq 0x72b93(%rip), %rsi     # 0x83fb8
leaq -0x1c0(%rbp), %rdi
callq 0x9290
leaq -0x150(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Start::Plan()
void Start::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(start)";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x57f02(%rip), %rsi     # 0x693c3
movl $0x7, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x11509
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x72aa8(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x11536
movq %rax, %rbx
movq 0x72a78(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: ChangePlayMode::Plan(ServerPlayMode)
void ChangePlayMode::Plan(ServerPlayMode spm) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(change_mode "
          << ServerPlayModeMap::instance().GetPlayModeString(spm) << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1b0(%rbp), %r15
movq %r15, %rdi
callq 0x9660
leaq 0x57deb(%rip), %rsi     # 0x693cb
movl $0xd, %edx
movq %r15, %rdi
callq 0x9560
callq 0x546f6
movq %rax, %rdi
movl %r14d, %esi
callq 0x55a98
movq %rax, %r14
testq %rax, %rax
je 0x11621
movq %r14, %rdi
callq 0x9200
leaq -0x1b0(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x11642
movq -0x1b0(%rbp), %rax
movq -0x18(%rax), %rax
leaq (%rax,%rbp), %rdi
addq $-0x1b0, %rdi           # imm = 0xFE50
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x9860
leaq 0x57c3f(%rip), %rsi     # 0x69288
leaq -0x1b0(%rbp), %rdi
movl $0x1, %edx
callq 0x9560
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x11695
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x7291c(%rip), %rsi     # 0x83fb8
leaq -0x1b0(%rbp), %rdi
callq 0x9290
leaq -0x140(%rbp), %rdi
callq 0x91c0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x116c4
movq %rax, %rbx
movq 0x728ea(%rip), %rsi     # 0x83fb8
leaq -0x1b0(%rbp), %rdi
callq 0x9290
leaq -0x140(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: MovePlayer::Plan(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, Vector, Vector, double)
void MovePlayer::Plan(std::string team_name, Unum num, Vector pos, Vector vel,
                      AngleDeg dir) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(move (player " << team_name << " " << num << ") " << pos.X()
          << " " << pos.Y() << " " << dir << " " << vel.X() << " " << vel.Y()
          << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movsd %xmm4, -0x38(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm1, -0x40(%rbp)
movsd %xmm0, -0x48(%rbp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1e0(%rbp), %r12
movq %r12, %rdi
callq 0x9660
leaq 0x57c4d(%rip), %rsi     # 0x693d9
movl $0xe, %edx
movq %r12, %rdi
callq 0x9560
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq -0x1e0(%rbp), %rdi
callq 0x9560
movq %rax, %r15
leaq 0x5b40e(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movl %r14d, %esi
callq 0x9880
movq %rax, %r14
leaq 0x5b789(%rip), %rsi     # 0x6cf61
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x48(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5b3c8(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x40(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5b3a4(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x38(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5b380(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5b35c(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x97d0
leaq 0x579ff(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1d8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x68(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x118d1
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x726e0(%rip), %rsi     # 0x83fb8
leaq -0x1e0(%rbp), %rdi
callq 0x9290
leaq -0x170(%rbp), %rdi
callq 0x91c0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11902
movq %rax, %rbx
movq 0x726ac(%rip), %rsi     # 0x83fb8
leaq -0x1e0(%rbp), %rdi
callq 0x9290
leaq -0x170(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0