LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.h
// Function: GetDashDirRate(double)
inline double GetDashDirRate(double dir) {
  dir = GetNormalizeAngleDeg(dir);

  if (ServerParam::instance().dashAngleStep() < FLOAT_EPS) {
    // players can dash in any direction.
  } else {
    // The dash direction is discretized by server::dash_angle_step
    dir = ServerParam::instance().dashAngleStep() *
          Rint(dir / ServerParam::instance().dashAngleStep());
  }

  double dir_rate = (std::fabs(dir) > 90.0
                         ? ServerParam::instance().backDashRate() -
                               ((ServerParam::instance().backDashRate() -
                                 ServerParam::instance().sideDashRate()) *
                                (1.0 - (std::fabs(dir) - 90.0) / 90.0))
                         : ServerParam::instance().sideDashRate() +
                               ((1.0 - ServerParam::instance().sideDashRate()) *
                                (1.0 - std::fabs(dir) / 90.0)));
  dir_rate = MinMax(0.0, dir_rate, 1.0);

  return dir_rate;
}

// Assembly:
movsd 0x5c75f(%rip), %xmm2    # 0x6b060
ucomisd %xmm0, %xmm2
jbe 0xe91b
movsd 0x5c761(%rip), %xmm1    # 0x6b070
addsd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
ja 0xe90f
jmp 0xe93f
ucomisd 0x5c725(%rip), %xmm0    # 0x6b048
jb 0xe93f
movsd 0x5c73b(%rip), %xmm2    # 0x6b068
movsd 0x5c713(%rip), %xmm1    # 0x6b048
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jae 0xe935
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movapd %xmm0, -0x20(%rbp)
callq 0x4a75c
movsd 0x5c6e7(%rip), %xmm0    # 0x6b040
ucomisd 0x33a8(%rax), %xmm0
jbe 0xe96a
movapd -0x20(%rbp), %xmm0
jmp 0xe998
callq 0x4a75c
movsd 0x33a8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x4a75c
movapd -0x20(%rbp), %xmm0
divsd 0x33a8(%rax), %xmm0
callq 0x96b0
mulsd -0x8(%rbp), %xmm0
andpd 0x5c670(%rip), %xmm0    # 0x6b010
movapd %xmm0, -0x20(%rbp)
callq 0x4a75c
movapd -0x20(%rbp), %xmm0
ucomisd 0x5c6f9(%rip), %xmm0    # 0x6b0b0
jbe 0xea16
movsd 0x33b8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x4a75c
movsd 0x33b8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x4a75c
movsd -0x28(%rbp), %xmm2
subsd 0x33b0(%rax), %xmm2
movsd 0x5c6c6(%rip), %xmm0    # 0x6b0b8
movapd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
divsd %xmm0, %xmm1
addsd 0x5c651(%rip), %xmm1    # 0x6b058
mulsd %xmm2, %xmm1
movsd -0x8(%rbp), %xmm3
subsd %xmm1, %xmm3
jmp 0xea5a
movsd 0x33b0(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x4a75c
movsd 0x5c628(%rip), %xmm0    # 0x6b058
movapd %xmm0, %xmm1
subsd 0x33b0(%rax), %xmm1
movsd 0x5c674(%rip), %xmm2    # 0x6b0b8
movapd -0x20(%rbp), %xmm3
divsd %xmm2, %xmm3
addsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
addsd -0x8(%rbp), %xmm3
xorpd %xmm0, %xmm0
maxsd %xmm0, %xmm3
movsd 0x5c5ee(%rip), %xmm0    # 0x6b058
minsd %xmm3, %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/BaseState.h
// Function: MobileState::Predictor::PredictTo(int const&)
void PredictTo(const int &step) {
      for (int i = mPredictedStep + 1; i <= step; ++i) {
        mPredictedPos[i] = mPredictedPos[i - 1] + mPredictedVel[i - 1];
        mPredictedVel[i] = mPredictedVel[i - 1] * mDecay;
      }
      mPredictedStep = step;
    }

// Assembly:
movslq 0x668(%rdi), %rdx
movl (%rsi), %eax
cmpl %eax, %edx
jge 0xf0d8
pushq %rbp
movq %rsp, %rbp
movslq %eax, %rcx
subq %rdx, %rcx
shlq $0x4, %rdx
addq %rdi, %rdx
addq $0x350, %rdx            # imm = 0x350
movsd -0x18(%rdx), %xmm0
movsd -0x10(%rdx), %xmm1
movsd -0x348(%rdx), %xmm2
addsd %xmm0, %xmm2
movsd -0x340(%rdx), %xmm3
addsd %xmm1, %xmm3
movsd %xmm2, -0x338(%rdx)
movsd %xmm3, -0x330(%rdx)
movsd (%rdi), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
movsd %xmm0, -0x8(%rdx)
movsd %xmm1, (%rdx)
addq $0x10, %rdx
decq %rcx
jne 0xf087
popq %rbp
movl %eax, 0x668(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Agent.cpp
// Function: Agent::~Agent()
Agent::~Agent() {
  SetHistoryActiveBehaviors();

  for (int type = BT_None + 1; type < BT_Max; ++type) {
    delete mLastActiveBehavior[type];
  }

  delete mpInfoState;
  delete mpFormation;
  delete mpActionEffector;
  delete mpStrategy;
  delete mpAnalyser;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x760a7(%rip), %rax     # 0x85338
movq %rax, (%rdi)
callq 0xf310
xorl %r14d, %r14d
movq 0xc8(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0xf2b3
movl $0xa8, %esi
callq 0x94e0
incq %r14
cmpq $0xc, %r14
jne 0xf29c
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xf2cb
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xf2da
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xf2e9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xf2f8
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xf30b
movq (%rdi), %rax
popq %rbx
popq %r14
popq %rbp
jmpq *0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Agent.cpp
// Function: Agent::SetHistoryActiveBehaviors()
void Agent::SetHistoryActiveBehaviors() {
  for (int type = BT_None + 1; type < BT_Max; ++type) {
    delete mLastActiveBehavior[type];

    mLastActiveBehavior[type] = mActiveBehavior[type];
    mActiveBehavior[type] = 0;
  }

  mLastActiveBehavior[0] = mActiveBehavior[0];
  mActiveBehavior[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0xc8(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0xf334
movl $0xa8, %esi
callq 0x94e0
movq 0x60(%rbx,%r14,8), %rax
movq %rax, 0xc8(%rbx,%r14,8)
movq $0x0, 0x60(%rbx,%r14,8)
incq %r14
cmpq $0xc, %r14
jne 0xf31d
movq 0x58(%rbx), %rax
movq %rax, 0xc0(%rbx)
movq $0x0, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf475
movsd 0x10(%r14), %xmm0
ucomisd 0x10(%rdi), %xmm0
jbe 0xf497
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_O1/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
cmpq $0x0, (%rsi)
jne 0xf5f5
movq %rdi, %r15
movl $0x150, %edi            # imm = 0x150
callq 0x94c0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x4c89c
movq %r14, (%rbx)
movq (%rbx), %rdi
callq 0x22946
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/BaseState.cpp
// Function: MobileState::UpdateVel(Vector const&, int, double)
void MobileState::UpdateVel(const Vector &vel, int delay, double conf) {
  mVel.mValue = vel;
  mVel.mCycleDelay = delay;
  mVel.mConf = conf;

  ResetPredictor();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movups (%rsi), %xmm1
movups %xmm1, 0x30(%rdi)
movl %edx, 0x40(%rdi)
movsd %xmm0, 0x48(%rdi)
movq 0x68(%rdi), %rax
movups 0x8(%rdi), %xmm0
movups %xmm0, 0x8(%rax)
movups 0x30(%rdi), %xmm0
movups %xmm0, 0x338(%rax)
movl $0x0, 0x668(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf73a
movq %rsi, %rbx
movq %rdi, %r15
addq $0x10, %r15
leaq 0x77e68(%rip), %r12     # 0x87578
movq %r12, %rdi
callq 0x4f686
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12740
movq %rax, %rdi
movq %rbx, %rsi
callq 0x90b0
incq 0x10(%rbx)
movq %r12, %rdi
callq 0x4f6a2
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ba9a(%rip), %rsi     # 0x6b260
movl $0x6, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
leaq -0x1a8(%rbp), %rdi
callq 0x97d0
leaq 0x5ba9d(%rip), %rsi     # 0x6b288
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 0xf833
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x7777e(%rip), %rsi     # 0x86fb8
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 0xf860
movq %rax, %rbx
movq 0x7774e(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a75c
movq %rax, %r14
callq 0x4a75c
movsd 0x33c0(%rax), %xmm0
movsd -0x18(%rbp), %xmm1
maxsd 0x33c8(%r14), %xmm1
minsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rbx)
callq 0x4a75c
movq %rax, %r14
callq 0x4a75c
movsd 0x3398(%rax), %xmm0
movsd -0x20(%rbp), %xmm1
maxsd 0x33a0(%r14), %xmm1
minsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rbx)
leaq -0x1b8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x5b900(%rip), %rsi     # 0x6b267
movl $0x6, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x38(%rbx), %xmm0
leaq -0x1b8(%rbp), %rdi
callq 0x97d0
movq %rax, %r14
leaq 0x5f265(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
movq %r14, %rdi
callq 0x97d0
leaq 0x5b8d8(%rip), %rsi     # 0x6b288
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 0xf9f8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x775b9(%rip), %rsi     # 0x86fb8
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 0xfa25
movq %rax, %rbx
movq 0x77589(%rip), %rsi     # 0x86fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a75c
movq %rax, %r14
callq 0x4a75c
movsd 0x3150(%rax), %xmm0
movsd -0x18(%rbp), %xmm1
maxsd 0x3158(%r14), %xmm1
minsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rbx)
leaq -0x1b0(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x5b772(%rip), %rsi     # 0x6b26e
movl $0xb, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
leaq -0x1b0(%rbp), %rdi
callq 0x97d0
leaq 0x5b767(%rip), %rsi     # 0x6b288
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 0xfb69
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x77448(%rip), %rsi     # 0x86fb8
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 0xfb96
movq %rax, %rbx
movq 0x77418(%rip), %rsi     # 0x86fb8
leaq -0x1b0(%rbp), %rdi
callq 0x9290
leaq -0x140(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x450ba
cmpb $0x1, 0x31a5(%rax)
jne 0xfc7b
leaq 0x5b631(%rip), %rsi     # 0x6b27a
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 0x5b60f(%rip), %rsi     # 0x6b288
jmp 0xfcb2
leaq 0x5b5fe(%rip), %rsi     # 0x6b280
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 0x5b5d5(%rip), %rsi     # 0x6b287
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 0xfcf5
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x772bc(%rip), %rsi     # 0x86fb8
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 0xfd22
movq %rax, %rbx
movq 0x7728c(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfdee
testl %r14d, %r14d
js 0xfdfc
leaq 0x5b4d3(%rip), %rsi     # 0x6b2ae
leaq -0x1b8(%rbp), %rdi
movl $0x11, %edx
callq 0x9560
jmp 0xfe17
movl $0x11, %edx
leaq 0x5b490(%rip), %rsi     # 0x6b28a
jmp 0xfe35
leaq 0x5b499(%rip), %rsi     # 0x6b29c
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 0x5b453(%rip), %rsi     # 0x6b288
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 0xfe78
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x77139(%rip), %rsi     # 0x86fb8
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 0xfea9
movq %rax, %rbx
movq 0x77105(%rip), %rsi     # 0x86fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a75c
movq %rax, %r14
callq 0x4a75c
movsd 0x3130(%rax), %xmm0
movsd -0x18(%rbp), %xmm1
maxsd 0x3138(%r14), %xmm1
minsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rbx)
callq 0x4a75c
movq %rax, %r14
callq 0x4a75c
movsd 0x3140(%rax), %xmm0
movsd -0x20(%rbp), %xmm1
maxsd 0x3148(%r14), %xmm1
minsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rbx)
leaq -0x1b8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x5b30f(%rip), %rsi     # 0x6b2c0
movl $0x6, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x38(%rbx), %xmm0
leaq -0x1b8(%rbp), %rdi
callq 0x97d0
movq %rax, %r14
leaq 0x5ec1b(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
movq %r14, %rdi
callq 0x97d0
leaq 0x5b28e(%rip), %rsi     # 0x6b288
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 0x10042
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x76f6f(%rip), %rsi     # 0x86fb8
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 0x1006f
movq %rax, %rbx
movq 0x76f3f(%rip), %rsi     # 0x86fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b1b6(%rip), %rcx     # 0x6b2c7
leaq 0x5b1b5(%rip), %rax     # 0x6b2cd
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 0x4a75c
movq %rax, %r14
callq 0x4a75c
movsd 0x3140(%rax), %xmm0
movsd -0x20(%rbp), %xmm1
maxsd 0x3148(%r14), %xmm1
minsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rbx)
leaq -0x1d8(%rbp), %rdi
callq 0x9660
callq 0x450ba
movsd 0x31a8(%rax), %xmm0
ucomisd 0x5b0d1(%rip), %xmm0    # 0x6b258
jbe 0x101c4
leaq 0x5b144(%rip), %rsi     # 0x6b2d4
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 0x101ed
leaq 0x5b109(%rip), %rsi     # 0x6b2d4
leaq -0x1d8(%rbp), %rdi
movl $0x8, %edx
callq 0x9560
movsd 0x40(%rbx), %xmm0
leaq -0x1d8(%rbp), %rdi
callq 0x97d0
leaq 0x5b094(%rip), %rsi     # 0x6b288
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 0x1023c
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x76d75(%rip), %rsi     # 0x86fb8
leaq -0x1d8(%rbp), %rdi
callq 0x9290
leaq -0x168(%rbp), %rdi
callq 0x91c0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x10270
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10287
jmp 0x10282
movq %rax, %rbx
jmp 0x102a9
movq %rax, %rbx
movq 0x76d27(%rip), %rsi     # 0x86fb8
leaq -0x1d8(%rbp), %rdi
callq 0x9290
leaq -0x168(%rbp), %rdi
callq 0x91c0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x102be
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x103c1
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x30(%rbx)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x40(%rbx)
leaq 0x5af74(%rip), %rsi     # 0x6b2dd
leaq -0x1c0(%rbp), %rdi
movl $0x9, %edx
callq 0x9560
movsd 0x30(%rbx), %xmm0
leaq -0x1c0(%rbp), %rdi
callq 0x97d0
movq %rax, %r15
leaq 0x5e85f(%rip), %rsi     # 0x6ebf4
movl $0x1, %r14d
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
movq %r15, %rdi
callq 0x97d0
movq %rax, %r15
leaq 0x5aec9(%rip), %rsi     # 0x6b288
jmp 0x103ce
movl $0xd, %r14d
leaq 0x5af19(%rip), %rsi     # 0x6b2e7
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 0x10414
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x76b9d(%rip), %rsi     # 0x86fb8
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 0x10443
movq %rax, %rbx
movq 0x76b6b(%rip), %rsi     # 0x86fb8
leaq -0x1c0(%rbp), %rdi
callq 0x9290
leaq -0x150(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ae07(%rip), %rsi     # 0x6b2f5
movl $0x7, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x40(%rbx), %xmm0
leaq -0x1a8(%rbp), %rdi
callq 0x97d0
leaq 0x5ad75(%rip), %rsi     # 0x6b288
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 0x1055b
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x76a56(%rip), %rsi     # 0x86fb8
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 0x10588
movq %rax, %rbx
movq 0x76a26(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5acc6(%rip), %rsi     # 0x6b2fd
movl $0x6, %edx
movq %r14, %rdi
callq 0x9560
movsd 0x48(%rbx), %xmm0
leaq -0x1a8(%rbp), %rdi
callq 0x97d0
movq %rax, %r14
leaq 0x5e595(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x50(%rbx), %xmm0
movq %r14, %rdi
callq 0x97d0
leaq 0x5ac08(%rip), %rsi     # 0x6b288
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 0x106c8
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x768e9(%rip), %rsi     # 0x86fb8
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 0x106f5
movq %rax, %rbx
movq 0x768b9(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x107c5
movl %eax, %eax
leaq 0x5ad81(%rip), %rcx     # 0x6b528
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x5ad83(%rip), %rcx     # 0x6b538
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 0x10800
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x767b1(%rip), %rsi     # 0x86fb8
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 0x1082d
movq %rax, %rbx
movq 0x76781(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5aa6b(%rip), %rsi     # 0x6b341
movl $0xd, %edx
movq %r14, %rdi
callq 0x9560
movl 0x14(%rbx), %esi
leaq -0x1a8(%rbp), %rdi
callq 0x9880
leaq 0x5a98f(%rip), %rsi     # 0x6b288
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 0x10941
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x76670(%rip), %rsi     # 0x86fb8
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 0x1096e
movq %rax, %rbx
movq 0x76640(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a93c(%rip), %rsi     # 0x6b34f
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 0x10a5b
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x76556(%rip), %rsi     # 0x86fb8
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 0x10a88
movq %rax, %rbx
movq 0x76526(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a82f(%rip), %rsi     # 0x6b35c
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 0x10b75
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x7643c(%rip), %rsi     # 0x86fb8
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 0x10ba2
movq %rax, %rbx
movq 0x7640c(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a71d(%rip), %rsi     # 0x6b364
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 0x10c8f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x76322(%rip), %rsi     # 0x86fb8
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 0x10cbc
movq %rax, %rbx
movq 0x762f2(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a609(%rip), %rsi     # 0x6b36a
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 0x10da9
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x76208(%rip), %rsi     # 0x86fb8
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 0x10dd6
movq %rax, %rbx
movq 0x761d8(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a4f0(%rip), %rsi     # 0x6b371
movl $0xc, %edx
movq %r14, %rdi
callq 0x9560
movl 0x18(%rbx), %esi
leaq -0x1a8(%rbp), %rdi
callq 0x9880
movq %rax, %r14
leaq 0x5dd4d(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movl 0x1c(%rbx), %esi
movq %r14, %rdi
callq 0x9880
leaq 0x5bb61(%rip), %rsi     # 0x6ca27
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 0x10f0e
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x760a3(%rip), %rsi     # 0x86fb8
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 0x10f3b
movq %rax, %rbx
movq 0x76073(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a3a3(%rip), %rax     # 0x6b37e
leaq 0x5a3a1(%rip), %r15     # 0x6b383
testl %edx, %edx
cmovneq %rax, %r15
cmpl $0x2, %ecx
leaq 0x5a39f(%rip), %rax     # 0x6b391
leaq 0x5b7a7(%rip), %rdx     # 0x6c7a0
cmoveq %rax, %rdx
cmpl $0x1, %ecx
leaq 0x5a381(%rip), %r14     # 0x6b388
cmovneq %rdx, %r14
leaq -0x1c0(%rbp), %r13
movq %r13, %rdi
callq 0x9660
leaq 0x5a37a(%rip), %rsi     # 0x6b39b
movl $0x6, %edx
movq %r13, %rdi
callq 0x9560
leaq 0x5e2b2(%rip), %rax     # 0x6f2e7
leaq 0x5e298(%rip), %rsi     # 0x6f2d4
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 0x5b99b(%rip), %rsi     # 0x6ca27
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 0x110d8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x75ed9(%rip), %rsi     # 0x86fb8
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 0x1110b
movq %rax, %rbx
movq 0x75ea3(%rip), %rsi     # 0x86fb8
leaq -0x1c0(%rbp), %rdi
callq 0x9290
leaq -0x150(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a1ef(%rip), %rsi     # 0x6b3a2
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 0x111fe
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 0x1122d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x75d84(%rip), %rsi     # 0x86fb8
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 0x1125e
jmp 0x1125e
movq %rax, %rbx
movq 0x75d50(%rip), %rsi     # 0x86fb8
leaq -0x1b0(%rbp), %rdi
callq 0x9290
leaq -0x140(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a0a1(%rip), %rsi     # 0x6b3ae
movl $0x14, %edx
movq %r12, %rdi
callq 0x9560
leaq -0x1b8(%rbp), %rdi
movl %r15d, %esi
callq 0x9880
movq %rax, %r15
leaq 0x5d8c1(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movl %r14d, %esi
callq 0x9880
leaq 0x59f36(%rip), %rsi     # 0x6b288
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 0x1139a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x75c17(%rip), %rsi     # 0x86fb8
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 0x113cb
movq %rax, %rbx
movq 0x75be3(%rip), %rsi     # 0x86fb8
leaq -0x1b8(%rbp), %rdi
callq 0x9290
leaq -0x148(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x59f6b(%rip), %rsi     # 0x6b3ae
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 0x5d785(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r12, %rdi
movl %r15d, %esi
callq 0x9880
movq %rax, %r15
leaq 0x5d763(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movl %r14d, %esi
callq 0x9880
leaq 0x59dd8(%rip), %rsi     # 0x6b288
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 0x114f8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x75ab9(%rip), %rsi     # 0x86fb8
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 0x1152b
movq %rax, %rbx
movq 0x75a83(%rip), %rsi     # 0x86fb8
leaq -0x1c0(%rbp), %rdi
callq 0x9290
leaq -0x150(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x59df2(%rip), %rsi     # 0x6b3c3
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 0x11619
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x75998(%rip), %rsi     # 0x86fb8
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 0x11646
movq %rax, %rbx
movq 0x75968(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0