LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.h
// Function: GetTurnMoment(double, int, double)
inline AngleDeg GetTurnMoment(const AngleDeg actual_turn_angle,
                              const int player_type,
                              const double player_speed) {
  return (
      actual_turn_angle *
      (1.0 + PlayerParam::instance().HeteroPlayer(player_type).inertiaMoment() *
                 player_speed));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x798a0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x12a00
movsd -0x20(%rbp), %xmm0
movsd (%rax), %xmm1
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm1
movsd 0xb05be(%rip), %xmm2    # 0xc1010
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.h
// Function: TransformDash(double&, double&)
inline void TransformDash(double &dash_power, AngleDeg &dash_dir) {
  if (dash_power < 0.0) {
    double anti_dash_power = -dash_power * GetDashDirRate(dash_dir) /
                             GetDashDirRate(dash_dir + 180.0);
    if (anti_dash_power < ServerParam::instance().maxDashPower()) {
      dash_dir = GetNormalizeAngleDeg(dash_dir + 180.0);
      dash_power = anti_dash_power;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x10cbc
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x11440
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsd 0xb03e9(%rip), %xmm0    # 0xc1028
addsd (%rax), %xmm0
callq 0x11440
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x12b60
movsd -0x28(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x10cba
movq -0x10(%rbp), %rax
movsd 0xb039d(%rip), %xmm0    # 0xc1028
addsd (%rax), %xmm0
movsd 0xb0399(%rip), %xmm1    # 0xc1030
movsd %xmm1, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x116b0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x10cbc
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.h
// Function: GetKickRate(Vector const&, int)
inline double GetKickRate(const Vector &ball_2_player, const int player_type) {
  double dir_diff = fabs(ball_2_player.Dir());
  double dist_ball =
      ball_2_player.Mod() -
      PlayerParam::instance().HeteroPlayer(player_type).playerSize() -
      ServerParam::instance().ballSize();
  return PlayerParam::instance().HeteroPlayer(player_type).kickPowerRate() *
         (1.0 - 0.25 * dir_diff / 180.0 -
          0.25 * dist_ball /
              PlayerParam::instance()
                  .HeteroPlayer(player_type)
                  .kickableMargin());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10520
movaps 0xafe91(%rip), %xmm1    # 0xc1060
pand %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x104e0
movsd %xmm0, -0x48(%rbp)
callq 0x798a0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x12ef0
movsd -0x48(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x12f10
movsd -0x40(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x798a0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x12f30
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0xafde6(%rip), %xmm1    # 0xc1038
mulsd -0x18(%rbp), %xmm1
movsd 0xafdc9(%rip), %xmm0    # 0xc1028
divsd %xmm0, %xmm1
movsd 0xafda5(%rip), %xmm0    # 0xc1010
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0xafdbc(%rip), %xmm0    # 0xc1038
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x798a0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x12f50
movsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
divsd (%rax), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.h
// Function: GetNormalizeAngleDeg(double, double const&)
inline AngleDeg GetNormalizeAngleDeg(AngleDeg ang,
                                     const AngleDeg &min_ang = -180.0) {
  if (ang < min_ang) {
    do {
      ang += 360.0;
    } while (ang < min_ang);
  } else {
    const AngleDeg max_ang = 360.0 + min_ang;

    while (ang >= max_ang) {
      ang -= 360.0;
    }
  }
  return ang;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd -0x8(%rbp), %xmm1
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x116f9
jmp 0x116d2
movsd 0xaf96e(%rip), %xmm0    # 0xc1048
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm1
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
ja 0x116d2
jmp 0x11734
movq -0x10(%rbp), %rax
movsd 0xaf943(%rip), %xmm0    # 0xc1048
addsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0x11732
movsd -0x8(%rbp), %xmm0
movsd 0xaf921(%rip), %xmm1    # 0xc1048
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1170e
jmp 0x11734
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.h
// Function: GetTurnAngle(double, int, double)
inline AngleDeg GetTurnAngle(const AngleDeg moment, const int player_type,
                             const double player_speed) {
  return (
      GetNormalizeMoment(moment) /
      (1.0 + PlayerParam::instance().HeteroPlayer(player_type).inertiaMoment() *
                 player_speed));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movsd %xmm1, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x10aa0
movsd %xmm0, -0x20(%rbp)
callq 0x798a0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x12a00
movsd -0x20(%rbp), %xmm0
movsd (%rax), %xmm1
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm1
movsd 0xaf7fa(%rip), %xmm2    # 0xc1010
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BaseState.h
// Function: MobileState::Predictor::GetPredictedPos(int)
const Vector &GetPredictedPos(int step = 1) {
      step = Min(step, int(MAX_STEP));

      if (step <= mPredictedStep) {
        return mPredictedPos[step];
      } else {
        PredictTo(step);

        return mPredictedPos[step];
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x32, -0x18(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x13150
movq -0x30(%rbp), %rcx
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x668(%rcx), %eax
jg 0x1310e
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x13180
movq %rax, -0x8(%rbp)
jmp 0x13138
movq -0x30(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x131a0
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x13180
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl 0x668(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x132c1
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x13180
movq -0x68(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x338, %rdi            # imm = 0x338
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x13180
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x11360
movq -0x68(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x20(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x13180
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x338, %rdi            # imm = 0x338
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x13180
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x13320
movq -0x68(%rbp), %rdi
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
addq $0x338, %rdi            # imm = 0x338
movslq -0x14(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x13180
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x131c4
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x668(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BaseState.h
// Function: MobileState::Predictor::GetPredictedVel(int)
const Vector &GetPredictedVel(int step = 1) {
      step = Min(step, int(MAX_STEP));

      if (step <= mPredictedStep) {
        return mPredictedVel[step];
      } else {
        PredictTo(step);

        return mPredictedVel[step];
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x32, -0x18(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x13150
movq -0x30(%rbp), %rcx
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x668(%rcx), %eax
jg 0x133e1
movq -0x30(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x13180
movq %rax, -0x8(%rbp)
jmp 0x1340e
movq -0x30(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x131a0
movq -0x30(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x13180
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0xe8c75(%rip), %rax     # 0xfc330
movq %rax, (%rdi)
callq 0x137c0
jmp 0x136c5
movl $0x1, -0xc(%rbp)
cmpl $0xd, -0xc(%rbp)
jge 0x13720
movq -0x20(%rbp), %rdi
addq $0xc0, %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x13cb0
movq %rax, -0x28(%rbp)
jmp 0x136f4
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x13713
movq -0x30(%rbp), %rdi
movl $0xa8, %esi
callq 0xa5e0
jmp 0x13715
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x136cc
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1373c
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x13758
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x13774
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x13790
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x137ac
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x12860
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0xd, -0xc(%rbp)
jge 0x1388d
movq -0x50(%rbp), %rdi
addq $0xc0, %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x13cb0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x1381c
movq -0x58(%rbp), %rdi
movl $0xa8, %esi
callq 0xa5e0
movq -0x50(%rbp), %rdi
addq $0x58, %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x13cb0
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x60(%rbp)
addq $0xc0, %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x13cb0
movq -0x60(%rbp), %rcx
movq -0x50(%rbp), %rdi
movq %rcx, (%rax)
addq $0x58, %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x13cb0
movq $0x0, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x137db
movq -0x50(%rbp), %rdi
addq $0x58, %rdi
movq $0x0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x13cb0
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x68(%rbp)
addq $0xc0, %rdi
movq $0x0, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x13cb0
movq -0x68(%rbp), %rcx
movq -0x50(%rbp), %rdi
movq %rcx, (%rax)
addq $0x58, %rdi
movq $0x0, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x13cb0
movq $0x0, (%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13cd0
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14(%rbp)
addq $0x58, %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x13cb0
cmpq $0x0, (%rax)
je 0x13b15
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x13cb0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x13ce0
testb $0x1, %al
jne 0x13aa2
jmp 0x13b13
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x13cb0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x13ad5
movq -0x50(%rbp), %rdi
movl $0xa8, %esi
callq 0xa5e0
movl $0xa8, %edi
callq 0xa5c0
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movl $0xa8, %edx
callq 0xa4b0
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x13cb0
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x13b53
movl $0xa8, %edi
callq 0xa5c0
movq %rax, %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rsi
movl $0xa8, %edx
callq 0xa4b0
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x13cb0
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x141ea
movl $0x150, %edi            # imm = 0x150
callq 0xa5c0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x88b00
jmp 0x141c1
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x141ea
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x150, %esi            # imm = 0x150
callq 0xa5e0
jmp 0x14203
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x32ee0
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x30(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x40(%rdi)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x48(%rdi)
callq 0x143c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
addq $0x14, %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x175f0
testb $0x1, %al
jne 0x144fa
jmp 0x14500
movb $0x0, -0x1(%rbp)
jmp 0x1452d
leaq 0xea1c1(%rip), %rdi     # 0xfe6c8
callq 0x8ebb0
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x10, %rsi
callq 0x17650
leaq 0xea1a4(%rip), %rdi     # 0xfe6c8
callq 0x8ebe0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x40(%rax)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xa800
movq -0x1c8(%rbp), %rdi
leaq 0xacbec(%rip), %rsi     # 0xc11e8
callq 0xa5a0
movq %rax, -0x1c0(%rbp)
jmp 0x1460a
movq -0x1c0(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movsd 0x40(%rax), %xmm0
callq 0xab60
movq %rax, -0x1d8(%rbp)
jmp 0x1462b
movq -0x1d8(%rbp), %rdi
leaq 0xacbd7(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x14640
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa600
jmp 0x14655
movq -0x1d0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xa760
leaq -0x1b8(%rbp), %rdi
callq 0xa370
leaq -0x188(%rbp), %rdi
callq 0xa190
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa190
movq -0x190(%rbp), %rdi
callq 0xaa60
nopl (%rax,%rax)
// File: 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
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d8(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x10(%rbp), %rdi
callq 0x10af0
movq -0x1d8(%rbp), %rax
movsd %xmm0, 0x38(%rax)
leaq -0x18(%rbp), %rdi
callq 0x10b40
movq -0x1d8(%rbp), %rax
movsd %xmm0, 0x40(%rax)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0xa800
movq -0x1d0(%rbp), %rdi
leaq 0xaca4e(%rip), %rsi     # 0xc11ef
callq 0xa5a0
movq %rax, -0x1c8(%rbp)
jmp 0x147af
movq -0x1c8(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movsd 0x38(%rax), %xmm0
callq 0xab60
movq %rax, -0x1e0(%rbp)
jmp 0x147d0
movq -0x1e0(%rbp), %rdi
leaq 0xb04fe(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x1e8(%rbp)
jmp 0x147ec
movq -0x1e8(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movsd 0x40(%rax), %xmm0
callq 0xab60
movq %rax, -0x1f0(%rbp)
jmp 0x1480d
movq -0x1f0(%rbp), %rdi
leaq 0xac9f5(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x14822
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xa600
jmp 0x14837
movq -0x1d8(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xa760
leaq -0x1c0(%rbp), %rdi
callq 0xa370
leaq -0x190(%rbp), %rdi
callq 0xa190
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0xa190
movq -0x198(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x10(%rbp), %rdi
callq 0x11830
movq -0x1d0(%rbp), %rax
movsd %xmm0, 0x40(%rax)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xa800
movq -0x1c8(%rbp), %rdi
leaq 0xac88f(%rip), %rsi     # 0xc11f6
callq 0xa5a0
movq %rax, -0x1c0(%rbp)
jmp 0x14975
movq -0x1c0(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movsd 0x40(%rax), %xmm0
callq 0xab60
movq %rax, -0x1d8(%rbp)
jmp 0x14996
movq -0x1d8(%rbp), %rdi
leaq 0xac86c(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x149ab
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa600
jmp 0x149c0
movq -0x1d0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xa760
leaq -0x1b8(%rbp), %rdi
callq 0xa370
leaq -0x188(%rbp), %rdi
callq 0xa190
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa190
movq -0x190(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: 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
subq $0x200, %rsp            # imm = 0x200
movq %rsi, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c8(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x188(%rbp), %rdi
callq 0xa800
callq 0x798a0
movq %rax, -0x1c0(%rbp)
jmp 0x14ae1
movq -0x1c0(%rbp), %rdi
callq 0x10de0
movq %rax, -0x1d8(%rbp)
jmp 0x14af6
movq -0x1d8(%rbp), %rax
testb $0x1, (%rax)
je 0x14b74
leaq 0xac6f9(%rip), %rsi     # 0xc1202
leaq -0x188(%rbp), %rdi
callq 0xa5a0
movq %rax, -0x1e0(%rbp)
jmp 0x14b1e
movq -0x1d0(%rbp), %rsi
movq -0x1e0(%rbp), %rdi
callq 0xa4f0
movq %rax, -0x1e8(%rbp)
jmp 0x14b3a
movq -0x1e8(%rbp), %rdi
leaq 0xac6c8(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x14b4f
jmp 0x14bc3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa190
jmp 0x14c14
leaq 0xac68d(%rip), %rsi     # 0xc1208
leaq -0x188(%rbp), %rdi
callq 0xa5a0
movq %rax, -0x1f0(%rbp)
jmp 0x14b90
movq -0x1d0(%rbp), %rsi
movq -0x1f0(%rbp), %rdi
callq 0xa4f0
movq %rax, -0x1f8(%rbp)
jmp 0x14bac
movq -0x1f8(%rbp), %rdi
leaq 0xac655(%rip), %rsi     # 0xc120f
callq 0xa5a0
jmp 0x14bc1
jmp 0x14bc3
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa600
jmp 0x14bd8
movq -0x1c8(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xa760
leaq -0x1b8(%rbp), %rdi
callq 0xa370
leaq -0x188(%rbp), %rdi
callq 0xa190
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0xaa60
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x188(%rbp), %rdi
callq 0xa800
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x14d0d
leaq 0xac53b(%rip), %rsi     # 0xc1212
leaq -0x188(%rbp), %rdi
callq 0xa5a0
jmp 0x14ce5
jmp 0x14dad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa190
jmp 0x14dfe
cmpl $0x0, -0x10(%rbp)
jge 0x14d60
leaq 0xac50a(%rip), %rsi     # 0xc1224
leaq -0x188(%rbp), %rdi
callq 0xa5a0
movq %rax, -0x1c8(%rbp)
jmp 0x14d2f
movq -0x1c8(%rbp), %rdi
movl -0x10(%rbp), %esi
negl %esi
callq 0xaa40
movq %rax, -0x1d0(%rbp)
jmp 0x14d49
movq -0x1d0(%rbp), %rdi
leaq 0xac4b9(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x14d5e
jmp 0x14dab
leaq 0xac4cf(%rip), %rsi     # 0xc1236
leaq -0x188(%rbp), %rdi
callq 0xa5a0
movq %rax, -0x1d8(%rbp)
jmp 0x14d7c
movq -0x1d8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xaa40
movq %rax, -0x1e0(%rbp)
jmp 0x14d94
movq -0x1e0(%rbp), %rdi
leaq 0xac46e(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x14da9
jmp 0x14dab
jmp 0x14dad
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa600
jmp 0x14dc2
movq -0x1c0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xa760
leaq -0x1b8(%rbp), %rdi
callq 0xa370
leaq -0x188(%rbp), %rdi
callq 0xa190
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0xaa60
nopw (%rax,%rax)
// File: 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
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d8(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x10(%rbp), %rdi
callq 0x10e80
movq -0x1d8(%rbp), %rax
movsd %xmm0, 0x38(%rax)
leaq -0x18(%rbp), %rdi
callq 0x10aa0
movq -0x1d8(%rbp), %rax
movsd %xmm0, 0x40(%rax)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0xa800
movq -0x1d0(%rbp), %rdi
leaq 0xac357(%rip), %rsi     # 0xc1248
callq 0xa5a0
movq %rax, -0x1c8(%rbp)
jmp 0x14eff
movq -0x1c8(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movsd 0x38(%rax), %xmm0
callq 0xab60
movq %rax, -0x1e0(%rbp)
jmp 0x14f20
movq -0x1e0(%rbp), %rdi
leaq 0xafdae(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x1e8(%rbp)
jmp 0x14f3c
movq -0x1e8(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movsd 0x40(%rax), %xmm0
callq 0xab60
movq %rax, -0x1f0(%rbp)
jmp 0x14f5d
movq -0x1f0(%rbp), %rdi
leaq 0xac2a5(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x14f72
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xa600
jmp 0x14f87
movq -0x1d8(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xa760
leaq -0x1c0(%rbp), %rdi
callq 0xa370
leaq -0x190(%rbp), %rdi
callq 0xa190
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0xa190
movq -0x198(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: 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
subq $0x240, %rsp            # imm = 0x240
movb %sil, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0xa820
movq -0x1e8(%rbp), %rdi
movb -0x11(%rbp), %cl
leaq 0xac1c7(%rip), %rax     # 0xc124f
leaq 0xac1c6(%rip), %rsi     # 0xc1255
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0xa560
jmp 0x1509d
movq -0x1f0(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, -0x1f8(%rbp)
jmp 0x150b6
movq -0x1f8(%rbp), %rdi
callq 0x12100
movq %rax, -0x200(%rbp)
jmp 0x150cb
movq -0x1f0(%rbp), %rax
movq -0x200(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x10(%rbp), %rdi
callq 0x10aa0
movsd %xmm0, -0x208(%rbp)
jmp 0x150f3
movq -0x1f0(%rbp), %rax
movsd -0x208(%rbp), %xmm0
movsd %xmm0, 0x40(%rax)
leaq -0x1c0(%rbp), %rdi
callq 0xa800
jmp 0x15115
callq 0x798a0
movq %rax, -0x210(%rbp)
jmp 0x15123
movq -0x210(%rbp), %rdi
callq 0x176d0
movq %rax, -0x218(%rbp)
jmp 0x15138
movq -0x218(%rbp), %rax
movsd (%rax), %xmm0
movsd 0xac095(%rip), %xmm1    # 0xc11e0
ucomisd %xmm1, %xmm0
jbe 0x151f3
leaq 0xac100(%rip), %rsi     # 0xc125c
leaq -0x1c0(%rbp), %rdi
callq 0xa5a0
movq %rax, -0x220(%rbp)
jmp 0x15171
movq -0x220(%rbp), %rdi
movq -0x1f0(%rbp), %rax
movsd 0x40(%rax), %xmm0
callq 0xab60
movq %rax, -0x228(%rbp)
jmp 0x15192
movq -0x228(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa4f0
movq %rax, -0x230(%rbp)
jmp 0x151ab
movq -0x230(%rbp), %rdi
leaq 0xac057(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x151c0
jmp 0x15247
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x152a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0xa190
jmp 0x152a1
leaq 0xac062(%rip), %rsi     # 0xc125c
leaq -0x1c0(%rbp), %rdi
callq 0xa5a0
movq %rax, -0x238(%rbp)
jmp 0x1520f
movq -0x238(%rbp), %rdi
movq -0x1f0(%rbp), %rax
movsd 0x40(%rax), %xmm0
callq 0xab60
movq %rax, -0x240(%rbp)
jmp 0x15230
movq -0x240(%rbp), %rdi
leaq 0xabfd2(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x15245
jmp 0x15247
leaq -0x1e0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xa600
jmp 0x1525c
movq -0x1f0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xa760
leaq -0x1e0(%rbp), %rdi
callq 0xa370
leaq -0x1c0(%rbp), %rdi
callq 0xa190
leaq -0x38(%rbp), %rdi
callq 0xa370
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xa370
movq -0x40(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1f0, %rsp            # imm = 0x1F0
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x198(%rbp), %rdi
callq 0xa800
testb $0x1, -0x9(%rbp)
je 0x15440
movq -0x1d0(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x40(%rax)
leaq 0xabecf(%rip), %rsi     # 0xc1265
leaq -0x198(%rbp), %rdi
callq 0xa5a0
movq %rax, -0x1d8(%rbp)
jmp 0x153ab
movq -0x1d8(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movsd 0x30(%rax), %xmm0
callq 0xab60
movq %rax, -0x1e0(%rbp)
jmp 0x153cc
movq -0x1e0(%rbp), %rdi
leaq 0xaf902(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x1e8(%rbp)
jmp 0x153e8
movq -0x1e8(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movsd 0x40(%rax), %xmm0
callq 0xab60
movq %rax, -0x1f0(%rbp)
jmp 0x15409
movq -0x1f0(%rbp), %rdi
leaq 0xabdf9(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x1541e
jmp 0x15457
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa190
jmp 0x154a8
leaq 0xabe28(%rip), %rsi     # 0xc126f
leaq -0x198(%rbp), %rdi
callq 0xa5a0
jmp 0x15455
jmp 0x15457
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa600
jmp 0x1546c
movq -0x1d0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xa760
leaq -0x1c8(%rbp), %rdi
callq 0xa370
leaq -0x198(%rbp), %rdi
callq 0xa190
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x40(%rax)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xa800
movq -0x1c8(%rbp), %rdi
leaq 0xabd01(%rip), %rsi     # 0xc127d
callq 0xa5a0
movq %rax, -0x1c0(%rbp)
jmp 0x1558a
movq -0x1c0(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movsd 0x40(%rax), %xmm0
callq 0xab60
movq %rax, -0x1d8(%rbp)
jmp 0x155ab
movq -0x1d8(%rbp), %rdi
leaq 0xabc57(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x155c0
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa600
jmp 0x155d5
movq -0x1d0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xa760
leaq -0x1b8(%rbp), %rdi
callq 0xa370
leaq -0x188(%rbp), %rdi
callq 0xa190
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa190
movq -0x190(%rbp), %rdi
callq 0xaa60
nopl (%rax,%rax)
// File: 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
subq $0x200, %rsp            # imm = 0x200
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d8(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
movups -0x10(%rbp), %xmm0
movups %xmm0, 0x48(%rax)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0xa800
movq -0x1d0(%rbp), %rdi
leaq 0xabb86(%rip), %rsi     # 0xc1285
callq 0xa5a0
movq %rax, -0x1c8(%rbp)
jmp 0x1570d
movq -0x1d8(%rbp), %rdi
addq $0x48, %rdi
callq 0x176f0
movq %rax, -0x1e0(%rbp)
jmp 0x15726
movq -0x1c8(%rbp), %rdi
movq -0x1e0(%rbp), %rax
movsd (%rax), %xmm0
callq 0xab60
movq %rax, -0x1e8(%rbp)
jmp 0x15746
movq -0x1e8(%rbp), %rdi
leaq 0xaf588(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x1f0(%rbp)
jmp 0x15762
movq -0x1d8(%rbp), %rdi
addq $0x48, %rdi
callq 0x17700
movq %rax, -0x1f8(%rbp)
jmp 0x1577b
movq -0x1f0(%rbp), %rdi
movq -0x1f8(%rbp), %rax
movsd (%rax), %xmm0
callq 0xab60
movq %rax, -0x200(%rbp)
jmp 0x1579b
movq -0x200(%rbp), %rdi
leaq 0xaba67(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x157b0
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xa600
jmp 0x157c5
movq -0x1d8(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xa760
leaq -0x1c0(%rbp), %rdi
callq 0xa370
leaq -0x190(%rbp), %rdi
callq 0xa190
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0xa190
movq -0x198(%rbp), %rdi
callq 0xaa60
nopl (%rax,%rax)
// File: 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
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c8(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x58(%rax)
leaq -0x188(%rbp), %rdi
callq 0xa800
movq -0x1c8(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x1bc(%rbp)
subl $0x1, %eax
je 0x15902
jmp 0x158e8
movl -0x1bc(%rbp), %eax
subl $0x2, %eax
je 0x1593c
jmp 0x158f5
movl -0x1bc(%rbp), %eax
subl $0x3, %eax
je 0x15953
jmp 0x1596a
leaq 0xab983(%rip), %rsi     # 0xc128c
leaq -0x188(%rbp), %rdi
callq 0xa5a0
jmp 0x15917
jmp 0x1596c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa190
jmp 0x159bd
leaq 0xab95e(%rip), %rsi     # 0xc12a1
leaq -0x188(%rbp), %rdi
callq 0xa5a0
jmp 0x15951
jmp 0x1596c
leaq 0xab95c(%rip), %rsi     # 0xc12b6
leaq -0x188(%rbp), %rdi
callq 0xa5a0
jmp 0x15968
jmp 0x1596c
jmp 0x1596c
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa600
jmp 0x15981
movq -0x1c8(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xa760
leaq -0x1b8(%rbp), %rdi
callq 0xa370
leaq -0x188(%rbp), %rdi
callq 0xa190
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x14(%rax)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xa800
movq -0x1c8(%rbp), %rdi
leaq 0xab843(%rip), %rsi     # 0xc12c9
callq 0xa5a0
movq %rax, -0x1c0(%rbp)
jmp 0x15a94
movq -0x1c0(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movl 0x14(%rax), %esi
callq 0xaa40
movq %rax, -0x1d8(%rbp)
jmp 0x15ab3
movq -0x1d8(%rbp), %rdi
leaq 0xab74f(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x15ac8
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa600
jmp 0x15add
movq -0x1d0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xa760
leaq -0x1b8(%rbp), %rdi
callq 0xa370
leaq -0x188(%rbp), %rdi
callq 0xa190
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa190
movq -0x190(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xa800
movq -0x1b8(%rbp), %rdi
leaq 0xab6da(%rip), %rsi     # 0xc12d7
callq 0xa5a0
jmp 0x15c04
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xa600
jmp 0x15c19
movq -0x1c0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa760
leaq -0x1b0(%rbp), %rdi
callq 0xa370
leaq -0x180(%rbp), %rdi
callq 0xa190
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa190
movq -0x188(%rbp), %rdi
callq 0xaa60
nop
// File: 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
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xa800
movq -0x1b8(%rbp), %rdi
leaq 0xab5b7(%rip), %rsi     # 0xc12e4
callq 0xa5a0
jmp 0x15d34
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xa600
jmp 0x15d49
movq -0x1c0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa760
leaq -0x1b0(%rbp), %rdi
callq 0xa370
leaq -0x180(%rbp), %rdi
callq 0xa190
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa190
movq -0x188(%rbp), %rdi
callq 0xaa60
nop
// File: 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
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xa800
movq -0x1b8(%rbp), %rdi
leaq 0xab48f(%rip), %rsi     # 0xc12ec
callq 0xa5a0
jmp 0x15e64
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xa600
jmp 0x15e79
movq -0x1c0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa760
leaq -0x1b0(%rbp), %rdi
callq 0xa370
leaq -0x180(%rbp), %rdi
callq 0xa190
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa190
movq -0x188(%rbp), %rdi
callq 0xaa60
nop