LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetMovePlayerAction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, Vector, Vector, double)
bool ActionEffector::SetMovePlayerAction(std::string team_name, Unum num,
                                         Vector pos, Vector vel, AngleDeg dir) {
  mMovePlayer.Plan(team_name, num, pos, vel, dir);
  mMovePlayer.Execute(mCommandQueue);
  mIsMovePlayer = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movsd %xmm4, -0x48(%rbp)
movsd %xmm3, -0x40(%rbp)
movsd %xmm2, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %edx, %r15d
movq %rdi, %rbx
leaq 0xb40(%rdi), %r14
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x9680
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
movsd -0x48(%rbp), %xmm4
callq 0xf5e6
leaq -0x68(%rbp), %rdi
callq 0x9240
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xde70
movb $0x1, 0xea7(%rbx)
movb $0x1, %al
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetMoveBallAction(Vector, Vector)
bool ActionEffector::SetMoveBallAction(Vector pos, Vector vel) {
  mMoveBall.Plan(pos, vel);
  mMoveBall.Execute(mCommandQueue);
  mIsMoveBall = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xbc0(%rdi), %r14
movq %r14, %rdi
callq 0xf792
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xde70
movb $0x1, 0xea8(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetLookAction()
bool ActionEffector::SetLookAction() {
  mLook.Plan();
  mLook.Execute(mCommandQueue);
  mIsLook = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xc40(%rdi), %r14
movq %r14, %rdi
callq 0xf8ea
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xde70
movb $0x1, 0xea9(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetTeamNamesAction()
bool ActionEffector::SetTeamNamesAction() {
  mTeamNames.Plan();
  mTeamNames.Execute(mCommandQueue);
  mIsTeamNames = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xcc0(%rdi), %r14
movq %r14, %rdi
callq 0xf9b0
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xde70
movb $0x1, 0xeaa(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetRecoverAction()
bool ActionEffector::SetRecoverAction() {
  mRecover.Plan();
  mRecover.Execute(mCommandQueue);
  mIsRecover = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xd40(%rdi), %r14
movq %r14, %rdi
callq 0xfa76
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xde70
movb $0x1, 0xeab(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetCheckBallAction()
bool ActionEffector::SetCheckBallAction() {
  mCheckBall.Plan();
  mCheckBall.Execute(mCommandQueue);
  mIsCheckBall = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xdc0(%rdi), %r14
movq %r14, %rdi
callq 0xfb3c
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xde70
movb $0x1, 0xeac(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::ComputeInfoAfterKick(double, double, PlayerState const&, BallState const&, Vector&, Vector&, bool)
void ActionEffector::ComputeInfoAfterKick(const double kick_power,
                                          const double kick_angle,
                                          const PlayerState &player_state,
                                          const BallState &ball_state,
                                          Vector &ball_pos, Vector &ball_vel,
                                          bool is_self) {
  double power = GetNormalizeKickPower(kick_power);
  double dir = GetNormalizeMoment(kick_angle);

  Vector ball_2_player = (ball_state.GetPos() - player_state.GetPos())
                             .Rotate(-player_state.GetBodyDir());
  double eff_power =
      power * (is_self
                   ? player_state.GetKickRate()
                   : GetKickRate(ball_2_player, player_state.GetPlayerType()));
  Vector accel = Polar2Vector(eff_power, player_state.GetBodyDir() + dir);

  ball_vel = ball_state.GetVel() + accel;
  ball_pos = ball_state.GetPos() + ball_vel;
  ball_vel *= ServerParam::instance().ballDecay();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %r13d
movq %rcx, %rbx
movq %rdx, -0x40(%rbp)
movq %rsi, %r15
movq %rdi, %r12
leaq -0x78(%rbp), %rdi
movsd %xmm0, (%rdi)
leaq -0x70(%rbp), %r14
movsd %xmm1, (%r14)
callq 0xcff7
movsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
callq 0xce36
movsd %xmm0, -0x30(%rbp)
movsd 0x8(%r15), %xmm0
movsd 0x10(%r15), %xmm1
subsd 0x8(%r12), %xmm0
subsd 0x10(%r12), %xmm1
leaq -0x68(%rbp), %rdi
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd 0xb0(%r12), %xmm0
xorpd 0x4b478(%rip), %xmm0    # 0x57020
leaq -0x48(%rbp), %rsi
movlpd %xmm0, (%rsi)
callq 0xd02c
movsd %xmm0, -0x58(%rbp)
movsd %xmm1, -0x50(%rbp)
testl %r13d, %r13d
je 0xbbd0
movsd 0x130(%r12), %xmm0
jmp 0xbbe1
movl 0x114(%r12), %esi
leaq -0x58(%rbp), %rdi
callq 0xd05c
movsd -0x38(%rbp), %xmm1
mulsd %xmm0, %xmm1
leaq -0x68(%rbp), %rdi
movsd %xmm1, (%rdi)
movsd -0x30(%rbp), %xmm0
addsd 0xb0(%r12), %xmm0
leaq -0x48(%rbp), %rsi
movsd %xmm0, (%rsi)
callq 0xd15b
addsd 0x30(%r15), %xmm0
addsd 0x38(%r15), %xmm1
movsd %xmm0, (%rbx)
movsd %xmm1, 0x8(%rbx)
addsd 0x8(%r15), %xmm0
addsd 0x10(%r15), %xmm1
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
callq 0x3db2c
movsd 0x30e0(%rax), %xmm0
mulsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd 0x30e0(%rax), %xmm0
mulsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::ComputeInfoAfterDash(double, double, PlayerState const&, Vector&, Vector&)
void ActionEffector::ComputeInfoAfterDash(const double dash_power,
                                          double dash_dir,
                                          const PlayerState &player_state,
                                          Vector &player_pos,
                                          Vector &player_vel) {
  double dir_rate = GetDashDirRate(dash_dir);

  if (dash_power < 0.0) {
    dash_dir += 180.0;
  }
  double eff_dash_power = fabs(dash_power) * player_state.GetEffort() *
                          player_state.GetDashPowerRate() * dir_rate;

  Vector accel =
      Polar2Vector(eff_dash_power,
                   GetNormalizeAngleDeg(player_state.GetBodyDir() + dash_dir));

  player_vel = player_state.GetVel() + accel;
  player_pos = player_state.GetPos() + player_vel;
  player_vel *= player_state.GetPlayerDecay();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movapd %xmm1, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movapd %xmm1, %xmm0
callq 0xd187
movsd %xmm0, -0x48(%rbp)
movsd 0x4b3bf(%rip), %xmm0    # 0x57068
movapd -0x30(%rbp), %xmm4
addsd %xmm4, %xmm0
xorpd %xmm1, %xmm1
movapd -0x40(%rbp), %xmm3
movapd %xmm3, %xmm2
cmpltsd %xmm1, %xmm2
andpd %xmm2, %xmm0
andnpd %xmm4, %xmm2
orpd %xmm0, %xmm2
movapd %xmm2, -0x30(%rbp)
movapd %xmm3, %xmm0
andpd 0x4b32f(%rip), %xmm0    # 0x57010
mulsd 0x80(%r14), %xmm0
movapd %xmm0, -0x40(%rbp)
movq %r14, %rdi
callq 0xd2d2
movapd -0x40(%rbp), %xmm0
mulsd (%rax), %xmm0
mulsd -0x48(%rbp), %xmm0
leaq -0x60(%rbp), %r12
movsd %xmm0, (%r12)
movapd -0x30(%rbp), %xmm0
addsd 0xb0(%r14), %xmm0
movabsq $-0x3f99800000000000, %rax # imm = 0xC066800000000000
leaq -0x50(%rbp), %rdi
movq %rax, (%rdi)
callq 0xd305
leaq -0x58(%rbp), %rsi
movsd %xmm0, (%rsi)
movq %r12, %rdi
callq 0xd15b
addsd 0x30(%r14), %xmm0
addsd 0x38(%r14), %xmm1
movsd %xmm0, (%rbx)
movsd %xmm1, 0x8(%rbx)
addsd 0x8(%r14), %xmm0
addsd 0x10(%r14), %xmm1
movsd %xmm0, (%r15)
movsd %xmm1, 0x8(%r15)
movq %r14, %rdi
callq 0xd344
movsd (%rax), %xmm0
mulsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd (%rax), %xmm0
mulsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::ResetForScan()
void ActionEffector::ResetForScan() {
  //清空互斥命令
  //清除turn neck命令
  ActionEffector::CMD_QUEUE_MUTEX.Lock();
  if (!mCommandQueue.empty()) {
    for (std::list<CommandInfo>::iterator it = mCommandQueue.begin();
         it != mCommandQueue.end();) {
      switch (it->mType) {
      case CT_Kick:
        mIsKick = false;
        --mKickCount;
        it = mCommandQueue.erase(it);
        break;
      case CT_Dash:
        mIsDash = false;
        --mDashCount;
        it = mCommandQueue.erase(it);
        break;
      case CT_Move:
        mIsMove = false;
        --mMoveCount;
        it = mCommandQueue.erase(it);
        break;
      case CT_Turn:
        mIsTurn = false;
        --mTurnCount;
        it = mCommandQueue.erase(it);
        break;
      case CT_TurnNeck:
        mIsTurnNeck = false;
        --mTurnNeckCount;
        it = mCommandQueue.erase(it);
        break;
      case CT_Tackle:
        mIsTackle = false;
        --mTackleCount;
        it = mCommandQueue.erase(it);
        break;
      default:
        ++it;
        break;
      }
    }
    mIsMutex = false;
  }
  ActionEffector::CMD_QUEUE_MUTEX.UnLock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6ae5e(%rip), %rdi     # 0x77578
callq 0x4206e
leaq 0x28(%rbx), %r14
movq 0x28(%rbx), %rax
cmpq %r14, %rax
je 0xc7c7
leaq 0x4a9a1(%rip), %r15     # 0x570d8
cmpq %r14, %rax
je 0xc7c0
movl 0x10(%rax), %ecx
decl %ecx
cmpl $0x9, %ecx
ja 0xc780
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movb $0x0, 0xe91(%rbx)
decl 0xe40(%rbx)
jmp 0xc7b0
movb $0x0, 0xe93(%rbx)
decl 0xe48(%rbx)
jmp 0xc7b0
movb $0x0, 0xe9a(%rbx)
decl 0xe64(%rbx)
jmp 0xc7b0
movq (%rax), %rax
jmp 0xc737
movb $0x0, 0xe92(%rbx)
decl 0xe44(%rbx)
jmp 0xc7b0
movb $0x0, 0xe96(%rbx)
decl 0xe54(%rbx)
jmp 0xc7b0
movb $0x0, 0xe97(%rbx)
decl 0xe58(%rbx)
movq %r14, %rdi
movq %rax, %rsi
callq 0xd4a8
jmp 0xc737
movb $0x0, 0xe90(%rbx)
leaq 0x6adaa(%rip), %rdi     # 0x77578
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4208a
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetSelfViewWidthWithQueuedActions()
ViewWidth ActionEffector::GetSelfViewWidthWithQueuedActions() {
  if (IsChangeView()) {
    ViewWidth view_width = mSelfState.GetViewWidth();
    ActionEffector::CMD_QUEUE_MUTEX.Lock();
    for (std::list<CommandInfo>::iterator it = mCommandQueue.begin();
         it != mCommandQueue.end(); ++it) {
      if (it->mType == CT_ChangeView) {
        view_width = it->mViewWidth;
      }
    }
    ActionEffector::CMD_QUEUE_MUTEX.UnLock();
    return view_width;
  } else {
    return mSelfState.GetViewWidth();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
movl 0x118(%rax), %ebx
cmpb $0x1, 0xe9b(%rdi)
jne 0xc82d
movq %rdi, %r14
leaq 0x6ad76(%rip), %rdi     # 0x77578
callq 0x4206e
addq $0x28, %r14
movq %r14, %rax
movq (%rax), %rax
cmpq %r14, %rax
je 0xc821
cmpl $0xb, 0x10(%rax)
jne 0xc80e
movl 0x58(%rax), %ebx
jmp 0xc80e
leaq 0x6ad50(%rip), %rdi     # 0x77578
callq 0x4208a
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetSelfPosWithQueuedActions()
Vector ActionEffector::GetSelfPosWithQueuedActions() {
  if (IsDash()) {
    return mSelfState.GetPredictedPosWithDash(1, mDash.GetPower());
  } else if (IsMove()) {
    Vector player_pos = Vector(0.0, 0.0);
    Vector player_vel = Vector(0.0, 0.0);
    ComputeInfoAfterMove(mMove.GetMovePos(), player_pos, player_vel);
    return player_pos;
  } else
    return mSelfState.GetPredictedPos();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0xe92(%rdi)
jne 0xc85d
movq 0x20(%rdi), %rax
movsd 0xf8(%rdi), %xmm0
pushq $0x1
popq %rsi
xorps %xmm1, %xmm1
movq %rax, %rdi
callq 0x3a78a
jmp 0xc88d
cmpb $0x1, 0xe9a(%rdi)
jne 0xc878
movsd 0x508(%rdi), %xmm0
movsd 0x510(%rdi), %xmm1
jmp 0xc88d
movq 0x20(%rdi), %rdi
pushq $0x1
popq %rsi
callq 0xd4c0
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetSelfVelWithQueuedActions()
Vector ActionEffector::GetSelfVelWithQueuedActions() {
  if (IsDash()) {
    return mSelfState.GetPredictedVelWithDash(1, mDash.GetPower());
  } else if (IsMove()) {
    Vector player_pos = Vector(0.0, 0.0);
    Vector player_vel = Vector(0.0, 0.0);
    ComputeInfoAfterMove(mMove.GetMovePos(), player_pos, player_vel);
    return player_vel;
  } else
    return mSelfState.GetPredictedVel();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0xe92(%rdi)
jne 0xc8b9
movq 0x20(%rdi), %rax
movsd 0xf8(%rdi), %xmm0
pushq $0x1
popq %rsi
xorps %xmm1, %xmm1
movq %rax, %rdi
callq 0x3a82c
jmp 0xc8dd
xorps %xmm1, %xmm1
cmpb $0x0, 0xe9a(%rdi)
xorps %xmm0, %xmm0
jne 0xc8dd
movq 0x20(%rdi), %rdi
pushq $0x1
popq %rsi
callq 0xd4ce
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetSelfBodyDirWithQueuedActions()
AngleDeg ActionEffector::GetSelfBodyDirWithQueuedActions() {
  if (IsTurn()) {
    AngleDeg body_dir = 0.0;
    ComputeInfoAfterTurn(mTurn.GetAngle(), mSelfState, body_dir);
    return body_dir;
  } else
    return mSelfState.GetBodyDir();
}

// Assembly:
cmpb $0x1, 0xe91(%rdi)
jne 0xc916
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
andq $0x0, (%rbx)
movsd 0x80(%rdi), %xmm0
movq 0x20(%rdi), %rdi
movq %rbx, %rsi
callq 0xbdb0
movsd (%rbx), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x20(%rdi), %rax
movsd 0xb0(%rax), %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetBallPosWithQueuedActions()
Vector ActionEffector::GetBallPosWithQueuedActions() {
  if (IsKick()) {
    Vector ball_pos = Vector(0.0, 0.0);
    Vector ball_vel = Vector(0.0, 0.0);
    ComputeInfoAfterKick(mKick.GetPower(), mKick.GetAngle(), mSelfState,
                         mBallState, ball_pos, ball_vel);
    return ball_pos;
  } else
    return mBallState.GetPredictedPos();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpb $0x1, 0xe96(%rdi)
jne 0xc969
xorps %xmm0, %xmm0
leaq -0x10(%rbp), %rdx
movaps %xmm0, (%rdx)
leaq -0x20(%rbp), %rcx
movaps %xmm0, (%rcx)
movsd 0x2f8(%rdi), %xmm0
movsd 0x300(%rdi), %xmm1
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdi
pushq $0x1
popq %r8
callq 0xbb26
jmp 0xc97c
movq 0x18(%rdi), %rdi
pushq $0x1
popq %rsi
callq 0xd4c0
movups (%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetBallVelWithQueuedActions()
Vector ActionEffector::GetBallVelWithQueuedActions() {
  if (IsKick()) {
    Vector ball_pos = Vector(0.0, 0.0);
    Vector ball_vel = Vector(0.0, 0.0);
    ComputeInfoAfterKick(mKick.GetPower(), mKick.GetAngle(), mSelfState,
                         mBallState, ball_pos, ball_vel);
    return ball_vel;
  } else
    return mBallState.GetPredictedVel();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpb $0x1, 0xe96(%rdi)
jne 0xc9ce
xorps %xmm0, %xmm0
leaq -0x10(%rbp), %rcx
movaps %xmm0, (%rcx)
movsd 0x2f8(%rdi), %xmm0
movsd 0x300(%rdi), %xmm1
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdi
leaq -0x20(%rbp), %rdx
pushq $0x1
popq %r8
callq 0xbb26
jmp 0xc9e1
movq 0x18(%rdi), %rdi
pushq $0x1
popq %rsi
callq 0xd4ce
movups (%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Agent.h
// Function: Agent::GetSelf() const
const PlayerState &GetSelf() const {
    if (!mSelfUnum || mSelfUnum == TRAINER_UNUM) {
      static PlayerState coach; // dummy player state for coach
      return coach;
    }

    return GetWorldState().GetTeammate(mSelfUnum);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq 0x8(%rdi), %rax
cmpq $0xc, %rax
je 0xcd56
testl %eax, %eax
jne 0xcdaa
movb 0x6c9bc(%rip), %al      # 0x79718
leaq 0x6c83d(%rip), %rbx     # 0x795a0
testb %al, %al
jne 0xcdc0
leaq 0x6c9aa(%rip), %rdi     # 0x79718
callq 0x9900
testl %eax, %eax
je 0xcdc0
leaq 0x6c822(%rip), %rbx     # 0x795a0
movq %rbx, %rdi
callq 0x3a294
leaq 0x989(%rip), %rdi       # 0xd716
leaq 0x6a764(%rip), %rdx     # 0x774f8
movq %rbx, %rsi
callq 0x9420
leaq 0x6c975(%rip), %rdi     # 0x79718
callq 0x9310
jmp 0xcdc0
movq 0x18(%rdi), %rcx
imulq $0x178, %rax, %rax      # imm = 0x178
leaq (%rax,%rcx), %rbx
addq $-0xd0, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x6c944(%rip), %rdi     # 0x79718
callq 0x9300
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, -0x10(%rbp)
movl %edi, %ebx
movsd %xmm0, -0x18(%rbp)
callq 0x38d94
movq 0x5c38(%rax), %rax
movslq %ebx, %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd -0x10(%rbp), %xmm0
mulsd 0x3028(%rax,%rcx), %xmm0
addsd 0x4a226(%rip), %xmm0    # 0x57048
movsd -0x18(%rbp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd (%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xcf85
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorpd 0x4a120(%rip), %xmm1    # 0x57020
movapd %xmm1, -0x20(%rbp)
movsd (%rsi), %xmm0
callq 0xd187
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd (%r14), %xmm0
addsd 0x4a143(%rip), %xmm0    # 0x57068
callq 0xd187
movsd -0x20(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
callq 0x3db2c
movsd 0x33c0(%rax), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0xcf7d
movsd (%r14), %xmm0
addsd 0x4a10f(%rip), %xmm0    # 0x57068
movabsq $-0x3f99800000000000, %rax # imm = 0xC066800000000000
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
callq 0xd305
movsd %xmm0, (%r14)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0xcd30
andps 0x49f98(%rip), %xmm0    # 0x57010
movaps %xmm0, -0x30(%rbp)
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x38d94
movq 0x5c38(%rax), %rax
movslq %ebx, %rcx
imulq $0x3700, %rcx, %rbx     # imm = 0x3700
movsd -0x18(%rbp), %xmm0
subsd 0x3038(%rax,%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x3db2c
movsd -0x18(%rbp), %xmm0
subsd 0x30d8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x38d94
movq 0x5c38(%rax), %rax
movsd 0x49f88(%rip), %xmm0    # 0x57078
movapd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
divsd 0x49f7f(%rip), %xmm1    # 0x57080
movsd 0x3068(%rax,%rbx), %xmm2
movsd %xmm2, -0x38(%rbp)
addsd 0x49f31(%rip), %xmm1    # 0x57048
movapd %xmm1, -0x30(%rbp)
movsd -0x18(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
callq 0x38d94
movq 0x5c38(%rax), %rax
movsd -0x18(%rbp), %xmm1
divsd 0x3040(%rax,%rbx), %xmm1
movapd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
mulsd -0x38(%rbp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movabsq $-0x3f99800000000000, %rax # imm = 0xC066800000000000
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
callq 0xd305
movaps %xmm0, -0x20(%rbp)
callq 0x3db2c
movsd 0x49e8a(%rip), %xmm0    # 0x57040
ucomisd 0x33a8(%rax), %xmm0
jbe 0xd1c7
movapd -0x20(%rbp), %xmm0
jmp 0xd1f5
callq 0x3db2c
movsd 0x33a8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x3db2c
movapd -0x20(%rbp), %xmm0
divsd 0x33a8(%rax), %xmm0
callq 0x96d0
mulsd -0x8(%rbp), %xmm0
andpd 0x49e13(%rip), %xmm0    # 0x57010
movapd %xmm0, -0x20(%rbp)
callq 0x3db2c
movapd -0x20(%rbp), %xmm0
ucomisd 0x49e74(%rip), %xmm0    # 0x57088
jbe 0xd273
movsd 0x33b8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x3db2c
movsd 0x33b8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x3db2c
movsd -0x28(%rbp), %xmm2
subsd 0x33b0(%rax), %xmm2
movsd 0x49e41(%rip), %xmm0    # 0x57090
movapd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
divsd %xmm0, %xmm1
addsd 0x49de4(%rip), %xmm1    # 0x57048
mulsd %xmm2, %xmm1
movsd -0x8(%rbp), %xmm3
subsd %xmm1, %xmm3
jmp 0xd2b7
movsd 0x33b0(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x3db2c
movsd 0x49dbb(%rip), %xmm0    # 0x57048
movapd %xmm0, %xmm1
subsd 0x33b0(%rax), %xmm1
movsd 0x49def(%rip), %xmm2    # 0x57090
movapd -0x20(%rbp), %xmm3
divsd %xmm2, %xmm3
addsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
addsd -0x8(%rbp), %xmm3
xorpd %xmm0, %xmm0
maxsd %xmm0, %xmm3
movsd 0x49d81(%rip), %xmm0    # 0x57048
minsd %xmm3, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 (%rdi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd327
movsd 0x49d7d(%rip), %xmm2    # 0x57098
addsd %xmm2, %xmm0
ucomisd %xmm0, %xmm1
ja 0xd31b
popq %rbp
retq
addsd 0x49d69(%rip), %xmm1    # 0x57098
movsd 0x49d69(%rip), %xmm2    # 0x570a0
ucomisd %xmm1, %xmm0
jb 0xd325
addsd %xmm2, %xmm0
jmp 0xd337
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, -0x18(%rbp)
movl %edi, %ebx
leaq -0x20(%rbp), %rdi
movsd %xmm0, (%rdi)
callq 0xce36
movsd %xmm0, -0x10(%rbp)
callq 0x38d94
movq 0x5c38(%rax), %rax
movslq %ebx, %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd -0x18(%rbp), %xmm0
mulsd 0x3028(%rax,%rcx), %xmm0
addsd 0x49c83(%rip), %xmm0    # 0x57048
movsd -0x10(%rbp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.h
// Function: SinCos(double const&)
inline SinCosT SinCos(const AngleDeg &x) {
  double sine, cosine;

  sincos(Deg2Rad(x), &sine, &cosine); // faster way to calculate sine and cosine
                                      // of the same angle x simultaneously

  return std::make_pair(sine, cosine);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd (%rdi), %xmm0
mulsd 0x498a9(%rip), %xmm0    # 0x570a8
divsd 0x49861(%rip), %xmm0    # 0x57068
leaq -0x20(%rbp), %rbx
leaq -0x18(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x92e0
movsd (%rbx), %xmm0
movsd (%r14), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x32, %esi
pushq $0x32
popq %rax
cmovll %esi, %eax
movq %rdi, %rbx
movl %eax, -0x14(%rbp)
cmpl 0x668(%rdi), %eax
jle 0xd860
leaq -0x14(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd876
movl (%r14), %eax
cltq
shlq $0x4, %rax
addq %rbx, %rax
addq $0x8, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movslq 0x668(%rdi), %rcx
movl (%rsi), %eax
movslq %eax, %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
addq %rdi, %rsi
addq $0x350, %rsi            # imm = 0x350
cmpq %rdx, %rcx
jge 0xd8ec
incq %rcx
movsd -0x18(%rsi), %xmm0
movsd -0x10(%rsi), %xmm1
movsd -0x348(%rsi), %xmm2
addsd %xmm0, %xmm2
movsd -0x340(%rsi), %xmm3
addsd %xmm1, %xmm3
movsd %xmm2, -0x338(%rsi)
movsd %xmm3, -0x330(%rsi)
movsd (%rdi), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm1
movsd %xmm0, -0x8(%rsi)
movsd %xmm1, (%rsi)
addq $0x10, %rsi
jmp 0xd897
movl %eax, 0x668(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x32, %esi
pushq $0x32
popq %rax
cmovll %esi, %eax
movq %rdi, %rbx
movl %eax, -0x14(%rbp)
cmpl 0x668(%rdi), %eax
jle 0xd928
leaq -0x14(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd876
movl (%r14), %eax
cltq
shlq $0x4, %rax
addq %rbx, %rax
addq $0x338, %rax            # imm = 0x338
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x67997(%rip), %rax     # 0x753c8
movq %rax, (%rdi)
callq 0xdaae
xorl %r14d, %r14d
cmpq $0xc, %r14
je 0xda59
movq 0xc8(%rbx,%r14,8), %rdi
movl $0xa8, %esi
callq 0x94f0
incq %r14
jmp 0xda3c
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xda68
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xda77
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xda86
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xda95
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xdaa8
movq (%rdi), %rax
popq %rbx
popq %r14
popq %rbp
jmpq *0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0xc, %r14
je 0xdaeb
movq 0xc8(%rbx,%r14,8), %rdi
movl $0xa8, %esi
callq 0x94f0
movq 0x60(%rbx,%r14,8), %rax
movq %rax, 0xc8(%rbx,%r14,8)
andq $0x0, 0x60(%rbx,%r14,8)
incq %r14
jmp 0xdabb
movq 0x58(%rbx), %rax
movq %rax, 0xc0(%rbx)
andq $0x0, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xdc09
movsd 0x10(%r14), %xmm0
ucomisd 0x10(%rdi), %xmm0
jbe 0xdc2b
movl $0xa8, %esi
callq 0x94f0
movl $0xa8, %edi
callq 0x94d0
movq %rax, %r15
movl $0xa8, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x9400
movq %r15, 0x58(%rbx,%r12,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Agent.h
// Function: Strategy& Agent::GetDecisionData<Strategy>(Strategy**)
DecisionDataDerived &GetDecisionData(DecisionDataDerived **xptr) {
    if (*xptr == 0) {
      *xptr = new DecisionDataDerived(*this);
    }
    (*xptr)->Update();
    return **xptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r14
testq %r14, %r14
jne 0xdd91
movq %rdi, %r15
movl $0x150, %edi            # imm = 0x150
callq 0x94d0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x3fa58
movq %r14, (%rbx)
movq %r14, %rdi
callq 0x1ce3e
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 0x94f0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andl $0x0, 0x668(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15b
jne 0xdec3
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %r14
leaq 0x696d0(%rip), %r12     # 0x77578
movq %r12, %rdi
callq 0x4206e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfbd8
movq %r12, %rdi
callq 0x4208a
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9670
leaq 0x492f2(%rip), %rsi     # 0x57228
movq %r14, %rdi
callq 0x94b0
movsd 0x40(%rbx), %xmm0
movq %rax, %rdi
callq 0x97e0
leaq 0x492fe(%rip), %rsi     # 0x57250
movq %rax, %rdi
callq 0x94b0
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97b0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq %r14, %rdi
callq 0x9240
leaq -0x1a8(%rbp), %rdi
callq 0x9160
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xdf9f
movq %rax, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x9160
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
leaq -0x20(%rbp), %rdi
movsd %xmm0, (%rdi)
leaq -0x18(%rbp), %r14
movsd %xmm1, (%r14)
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rbx)
callq 0xce6b
movsd %xmm0, 0x38(%rbx)
movq %r14, %rdi
callq 0xcea0
movsd %xmm0, 0x40(%rbx)
leaq -0x1b8(%rbp), %r14
movq %r14, %rdi
callq 0x9670
leaq 0x491f0(%rip), %rsi     # 0x5722f
movq %r14, %rdi
callq 0x94b0
movsd 0x38(%rbx), %xmm0
movq %rax, %rdi
callq 0x97e0
leaq 0x4cb49(%rip), %rsi     # 0x5aba4
movq %rax, %rdi
callq 0x94b0
movsd 0x40(%rbx), %xmm0
movq %rax, %rdi
callq 0x97e0
leaq 0x491d9(%rip), %rsi     # 0x57250
movq %rax, %rdi
callq 0x94b0
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x97b0
addq $0x60, %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq %r14, %rdi
callq 0x9240
leaq -0x1b8(%rbp), %rdi
callq 0x9160
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xe0c4
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x9160
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
leaq -0x18(%rbp), %rdi
movsd %xmm0, (%rdi)
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rbx)
callq 0xd3d9
movsd %xmm0, 0x40(%rbx)
leaq -0x1b0(%rbp), %r14
movq %r14, %rdi
callq 0x9670
leaq 0x490e7(%rip), %rsi     # 0x57236
movq %r14, %rdi
callq 0x94b0
movsd 0x40(%rbx), %xmm0
movq %rax, %rdi
callq 0x97e0
leaq 0x490e5(%rip), %rsi     # 0x57250
movq %rax, %rdi
callq 0x94b0
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x97b0
addq $0x60, %rbx
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq %r14, %rdi
callq 0x9240
leaq -0x1b0(%rbp), %rdi
callq 0x9160
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xe1b8
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x9160
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9670
callq 0x38d94
cmpb $0x1, 0x31a5(%rax)
jne 0xe25f
leaq 0x49003(%rip), %rsi     # 0x57242
leaq -0x1a8(%rbp), %rdi
callq 0x94b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x9430
leaq 0x48ff3(%rip), %rsi     # 0x57250
jmp 0xe284
leaq 0x48fe2(%rip), %rsi     # 0x57248
leaq -0x1a8(%rbp), %rdi
callq 0x94b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x9430
leaq 0x48fcb(%rip), %rsi     # 0x5724f
movq %rax, %rdi
callq 0x94b0
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97b0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq %r14, %rdi
callq 0x9240
leaq -0x1a8(%rbp), %rdi
callq 0x9160
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xe2d1
movq %rax, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x9160
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9670
testl %r12d, %r12d
je 0xe36b
testl %r14d, %r14d
js 0xe374
leaq 0x48f19(%rip), %rsi     # 0x57276
leaq -0x1b8(%rbp), %rdi
callq 0x94b0
jmp 0xe38a
leaq 0x48ee0(%rip), %rsi     # 0x57252
jmp 0xe39f
leaq 0x48ee9(%rip), %rsi     # 0x57264
leaq -0x1b8(%rbp), %rdi
callq 0x94b0
negl %r14d
movq %rax, %rdi
movl %r14d, %esi
callq 0x9890
movq %rax, %r15
leaq 0x48eb1(%rip), %rsi     # 0x57250
movq %r15, %rdi
callq 0x94b0
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x97b0
addq $0x60, %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq %r14, %rdi
callq 0x9240
leaq -0x1b8(%rbp), %rdi
callq 0x9160
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe3f0
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x9160
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
leaq -0x20(%rbp), %rdi
movsd %xmm0, (%rdi)
leaq -0x18(%rbp), %r14
movsd %xmm1, (%r14)
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rbx)
callq 0xcff7
movsd %xmm0, 0x38(%rbx)
movq %r14, %rdi
callq 0xce36
movsd %xmm0, 0x40(%rbx)
leaq -0x1b8(%rbp), %r14
movq %r14, %rdi
callq 0x9670
leaq 0x48df7(%rip), %rsi     # 0x57288
movq %r14, %rdi
callq 0x94b0
movsd 0x38(%rbx), %xmm0
movq %rax, %rdi
callq 0x97e0
leaq 0x4c6f7(%rip), %rsi     # 0x5aba4
movq %rax, %rdi
callq 0x94b0
movsd 0x40(%rbx), %xmm0
movq %rax, %rdi
callq 0x97e0
leaq 0x48d87(%rip), %rsi     # 0x57250
movq %rax, %rdi
callq 0x94b0
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x97b0
addq $0x60, %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq %r14, %rdi
callq 0x9240
leaq -0x1b8(%rbp), %rdi
callq 0x9160
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xe516
movq %rax, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x9160
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movsd %xmm0, -0x18(%rbp)
movb $0x0, (%rax)
leaq 0x48d0a(%rip), %rcx     # 0x5728f
leaq 0x48d09(%rip), %rax     # 0x57295
testl %esi, %esi
cmovneq %rcx, %rax
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x9960
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rbx)
leaq -0x18(%rbp), %rdi
callq 0xce36
movsd %xmm0, 0x40(%rbx)
leaq -0x1d0(%rbp), %rdi
callq 0x9670
callq 0x38d94
movsd 0x31a8(%rax), %xmm0
ucomisd 0x48c43(%rip), %xmm0    # 0x57220
jbe 0xe60d
leaq 0x48cb6(%rip), %rsi     # 0x5729c
leaq -0x1d0(%rbp), %rdi
callq 0x94b0
movsd 0x40(%rbx), %xmm0
movq %rax, %rdi
callq 0x97e0
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x9430
jmp 0xe62d
leaq 0x48c88(%rip), %rsi     # 0x5729c
leaq -0x1d0(%rbp), %rdi
callq 0x94b0
movsd 0x40(%rbx), %xmm0
movq %rax, %rdi
callq 0x97e0
leaq 0x48c1c(%rip), %rsi     # 0x57250
movq %rax, %rdi
callq 0x94b0
leaq -0x1c8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x97b0
addq $0x60, %rbx
leaq -0x58(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq %r14, %rdi
callq 0x9240
leaq -0x1d0(%rbp), %rdi
callq 0x9160
leaq -0x38(%rbp), %rdi
callq 0x9240
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xe691
jmp 0xe68c
movq %rax, %rbx
jmp 0xe6a0
movq %rax, %rbx
leaq -0x1d0(%rbp), %rdi
callq 0x9160
leaq -0x38(%rbp), %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x98b0
nop