LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetTurnAction(double)
bool ActionEffector::SetTurnAction(AngleDeg turn_angle) {
  if (mIsTurn == true || mIsMutex == true) {
    return false;
  }

  AngleDeg moment = GetTurnMoment(turn_angle, mSelfState.GetPlayerType(),
                                  mSelfState.GetVel().Mod());

  moment = GetNormalizeMoment(moment);

  if (fabs(moment) < FLOAT_EPS) {
    return false;
  }

  mTurn.Plan(moment);
  mTurn.Execute(mCommandQueue);
  ++mTurnCount;
  mIsTurn = true;
  mIsMutex = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpb $0x0, 0xe91(%rdi)
jne 0xbc5a
movq %rdi, %rbx
cmpb $0x0, 0xe90(%rdi)
je 0xbc6b
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movsd %xmm0, -0x28(%rbp)
movq 0x20(%rbx), %rax
movslq 0x114(%rax), %r14
movsd 0x30(%rax), %xmm0
movsd 0x38(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xbca1
sqrtsd %xmm0, %xmm0
jmp 0xbca6
callq 0x93c0
movsd %xmm0, -0x20(%rbp)
callq 0x450ba
movq 0x5c38(%rax), %rax
imulq $0x3700, %r14, %rcx     # imm = 0x3700
movsd -0x20(%rbp), %xmm0
mulsd 0x3028(%rax,%rcx), %xmm0
addsd 0x5f384(%rip), %xmm0    # 0x6b058
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x4a75c
movq %rax, %r14
callq 0x4a75c
movsd 0x3140(%rax), %xmm0
movsd -0x20(%rbp), %xmm1
maxsd 0x3148(%r14), %xmm1
minsd %xmm1, %xmm0
movapd 0x5f303(%rip), %xmm1    # 0x6b010
andpd %xmm0, %xmm1
movsd 0x5f327(%rip), %xmm2    # 0x6b040
ucomisd %xmm1, %xmm2
setbe %r14b
ja 0xbc5d
leaq 0x40(%rbx), %r15
movq %r15, %rdi
callq 0xf78a
leaq 0x28(%rbx), %rsi
movq %r15, %rdi
callq 0xf6d8
incl 0xe40(%rbx)
movw $0x101, 0xe90(%rbx)     # imm = 0x101
jmp 0xbc5d
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetTurnNeckAction(double)
bool ActionEffector::SetTurnNeckAction(AngleDeg angle) {
  if (mIsTurnNeck == true) {
    return false;
  }

  if (angle < ServerParam::instance().minNeckMoment() ||
      angle > ServerParam::instance().maxNeckMoment()) {
    return false;
  }

  mTurnNeck.Plan(angle);
  mTurnNeck.Execute(mCommandQueue);
  ++mTurnNeckCount;
  mIsTurnNeck = true;
  return true;
}

// Assembly:
cmpb $0x0, 0xe93(%rdi)
je 0xc112
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, -0x18(%rbp)
callq 0x4a75c
movsd 0x3158(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
ja 0xc14d
callq 0x4a75c
movsd -0x18(%rbp), %xmm0
ucomisd 0x3150(%rax), %xmm0
jbe 0xc151
xorl %eax, %eax
jmp 0xc17b
leaq 0x140(%rbx), %r14
movq %r14, %rdi
callq 0xfa94
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe48(%rbx)
movb $0x1, 0xe93(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetSayAction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ActionEffector::SetSayAction(std::string msg) {
  if (mIsSay == true) {
    return false;
  }

  if (PlayerParam::instance().isCoach()) {
    if (msg.length() > ServerParam::instance().freeformMsgSize()) {
      // false;
    }
  } else {
    if (msg.length() > ServerParam::instance().sayMsgSize()) {
      return false;
    }
  }

  mSay.Plan(msg);
  mSay.Execute(mCommandQueue);
  ++mSayCount;
  mIsSay = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpb $0x0, 0xe94(%rdi)
je 0xc1a3
xorl %eax, %eax
jmp 0xc233
movq %rsi, %r15
movq %rdi, %rbx
callq 0x450ba
cmpb $0x1, 0x31a5(%rax)
jne 0xc1be
callq 0x4a75c
jmp 0xc1d2
movq 0x8(%r15), %r14
callq 0x4a75c
movl 0x32e8(%rax), %eax
cmpq %rax, %r14
ja 0xc19c
leaq 0x1c0(%rbx), %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xf0e0
movq %r14, %rdi
movq %r15, %rsi
callq 0xfc04
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc218
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe4c(%rbx)
movb $0x1, 0xe94(%rbx)
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc258
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetAttentiontoAction(int)
bool ActionEffector::SetAttentiontoAction(Unum num) {
  if (mIsAttentionto == true) {
    return false;
  }

  if (num == 0 || num == mAgent.GetSelfUnum() || num < -TEAMSIZE ||
      num > TEAMSIZE) {
    return false;
  }

  if (mAgent.GetSelf().GetFocusOnUnum() == num) {
    mIsAttentionto = true; // 本周期不再attentionto
    return false;
  }

  mAttentionto.Plan(true, num);
  mAttentionto.Execute(mCommandQueue);
  ++mAttentiontoCount;
  mIsAttentionto = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r14d, %r14d
testl %esi, %esi
je 0xc2d9
movq %rdi, %rbx
cmpb $0x0, 0xe95(%rdi)
jne 0xc2d9
movl %esi, %r15d
leal -0xc(%r15), %eax
xorl %r14d, %r14d
cmpl $-0x17, %eax
jb 0xc2d9
movq 0x8(%rbx), %rdi
cmpl %r15d, 0x8(%rdi)
je 0xc2d9
callq 0xe85a
cmpl %r15d, 0xfc(%rax)
setne %r14b
je 0xc2d2
leaq 0x240(%rbx), %r12
movq %r12, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0xfd90
leaq 0x28(%rbx), %rsi
movq %r12, %rdi
callq 0xf6d8
incl 0xe50(%rbx)
movb $0x1, 0xe95(%rbx)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetAttentiontoOffAction()
bool ActionEffector::SetAttentiontoOffAction() {
  if (mIsAttentionto == true) {
    return false;
  }

  if (mAgent.GetSelf().GetFocusOnUnum() == 0) {
    mIsAttentionto = true; // 本周期不再attentionto
    return false;
  }

  mAttentionto.Plan(false);
  mAttentionto.Execute(mCommandQueue);
  ++mAttentiontoCount;
  mIsAttentionto = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0xe95(%rdi)
je 0xc2fe
xorl %r14d, %r14d
jmp 0xc343
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xe85a
cmpl $0x0, 0xfc(%rax)
setne %r14b
je 0xc33c
leaq 0x240(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xfd90
leaq 0x28(%rbx), %rsi
movq %r15, %rdi
callq 0xf6d8
incl 0xe50(%rbx)
movb $0x1, 0xe95(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetKickAction(double, double)
bool ActionEffector::SetKickAction(double power, AngleDeg angle) {
  if (mIsKick == true || mIsMutex == true) {
    return false;
  }

  power = GetNormalizeKickPower(power);
  angle = GetNormalizeMoment(angle);

  if (mWorldState.GetPlayMode() == PM_Before_Kick_Off ||
      mWorldState.GetPlayMode() == PM_Goal_Ours ||
      mWorldState.GetPlayMode() == PM_Goal_Opps ||
      mWorldState.GetPlayMode() == PM_Opp_Offside_Kick ||
      mWorldState.GetPlayMode() == PM_Our_Offside_Kick ||
      mWorldState.GetPlayMode() == PM_Our_Foul_Charge_Kick ||
      mWorldState.GetPlayMode() == PM_Opp_Foul_Charge_Kick ||
      mWorldState.GetPlayMode() == PM_Our_Back_Pass_Kick ||
      mWorldState.GetPlayMode() == PM_Opp_Back_Pass_Kick ||
      mWorldState.GetPlayMode() == PM_Our_Free_Kick_Fault_Kick ||
      mWorldState.GetPlayMode() == PM_Opp_Free_Kick_Fault_Kick ||
      mWorldState.GetPlayMode() == PM_Our_CatchFault_Kick ||
      mWorldState.GetPlayMode() == PM_Opp_CatchFault_Kick ||
      mWorldState.GetPlayMode() == PM_Time_Over) {
    return false;
  }

  if (mSelfState.IsKickable() == false) {
    return false;
  }

  if (power < 1.0) // 避免不必要的kick
  {
    return false;
  }

  if (power > ServerParam::instance().maxPower() - 1.0) {
    power = ServerParam::instance().maxPower();
  }

  mKick.Plan(power, angle);
  mKick.Execute(mCommandQueue);
  ++mKickCount;
  mIsKick = true;
  mIsMutex = true;
  return true;
}

// Assembly:
cmpb $0x0, 0xe96(%rdi)
je 0xc35e
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xe90(%rdi)
je 0xc37c
xorl %eax, %eax
jmp 0xc48f
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x18(%rbp)
callq 0x4a75c
movq %rax, %r14
callq 0x4a75c
movsd 0x3130(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
maxsd 0x3138(%r14), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x4a75c
movq %rax, %r14
callq 0x4a75c
movsd -0x28(%rbp), %xmm2
movsd 0x3140(%rax), %xmm3
maxsd 0x3148(%r14), %xmm2
movq 0x10(%rbx), %rax
movl 0x1c(%rax), %eax
addl $-0x9, %eax
cmpl $0x28, %eax
jae 0xc3f5
movabsq $0xf80190201f, %rcx     # imm = 0xF80190201F
btq %rax, %rcx
jb 0xc375
movq 0x20(%rbx), %rcx
xorl %eax, %eax
cmpb $0x1, 0x128(%rcx)
jne 0xc48f
movsd -0x20(%rbp), %xmm1
minsd -0x18(%rbp), %xmm1
movsd 0x5ec3e(%rip), %xmm0    # 0x6b058
ucomisd %xmm1, %xmm0
ja 0xc48f
minsd %xmm2, %xmm3
movsd %xmm3, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
callq 0x4a75c
movsd -0x20(%rbp), %xmm0
movsd 0x3130(%rax), %xmm1
addsd 0x5ec50(%rip), %xmm1    # 0x6b098
ucomisd %xmm1, %xmm0
jbe 0xc45b
callq 0x4a75c
movsd 0x3130(%rax), %xmm0
leaq 0x2c0(%rbx), %r14
movq %r14, %rdi
movsd -0x18(%rbp), %xmm1
callq 0xff18
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe54(%rbx)
movb $0x1, %al
movb %al, 0xe96(%rbx)
movb %al, 0xe90(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetTackleAction(double, bool)
bool ActionEffector::SetTackleAction(AngleDeg angle, const bool foul) {
  if (mIsTackle == true || mIsMutex == true) {
    return true;
  }

  if (angle < ServerParam::instance().minMoment() ||
      angle > ServerParam::instance().maxMoment()) {
    return false;
  }

  if (mSelfState.GetIdleCycle() > 0) {
    return false;
  }

  double tackle_prob = mSelfState.GetTackleProb(foul);
  if (tackle_prob < FLOAT_EPS &&
      mWorldState.GetPlayMode() !=
          PM_Opp_Penalty_Taken) // 守门员防点球时能tackle就tackle
  {
    return false;
  }

  if (mWorldState.GetPlayMode() == PM_Before_Kick_Off ||
      mWorldState.GetPlayMode() == PM_Goal_Ours ||
      mWorldState.GetPlayMode() == PM_Goal_Opps ||
      mWorldState.GetPlayMode() == PM_Opp_Offside_Kick ||
      mWorldState.GetPlayMode() == PM_Our_Offside_Kick ||
      mWorldState.GetPlayMode() == PM_Our_Foul_Charge_Kick ||
      mWorldState.GetPlayMode() == PM_Opp_Foul_Charge_Kick ||
      mWorldState.GetPlayMode() == PM_Our_Back_Pass_Kick ||
      mWorldState.GetPlayMode() == PM_Opp_Back_Pass_Kick ||
      mWorldState.GetPlayMode() == PM_Our_Free_Kick_Fault_Kick ||
      mWorldState.GetPlayMode() == PM_Opp_Free_Kick_Fault_Kick ||
      mWorldState.GetPlayMode() == PM_Our_CatchFault_Kick ||
      mWorldState.GetPlayMode() == PM_Opp_CatchFault_Kick ||
      mWorldState.GetPlayMode() == PM_Time_Over) {
    return false;
  }

  mTackle.Plan(angle, foul);
  mTackle.Execute(mCommandQueue);
  ++mTackleCount;
  mIsTackle = true;
  mIsMutex = true;
  return true;
}

// Assembly:
movb $0x1, %al
cmpb $0x0, 0xe97(%rdi)
jne 0xc506
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xe90(%rdi)
jne 0xc4fe
movl %esi, %r14d
movsd %xmm0, -0x18(%rbp)
callq 0x4a75c
movsd 0x3148(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
ja 0xc4fc
callq 0x4a75c
movsd -0x18(%rbp), %xmm0
ucomisd 0x3140(%rax), %xmm0
ja 0xc4fc
movq 0x20(%rbx), %rax
movl 0x124(%rax), %ecx
addl 0xc8(%rax), %ecx
jle 0xc507
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movzbl %r14b, %esi
movsd 0x5eb2d(%rip), %xmm1    # 0x6b040
ucomisd 0x140(%rax,%rsi,8), %xmm1
jbe 0xc528
movq 0x10(%rbx), %rax
cmpl $0x33, 0x1c(%rax)
jne 0xc4fc
movq 0x10(%rbx), %rax
movl 0x1c(%rax), %eax
addl $-0x9, %eax
cmpl $0x28, %eax
jae 0xc547
movabsq $0xf80190201f, %rcx     # imm = 0xF80190201F
btq %rax, %rcx
jb 0xc4fc
leaq 0x340(%rbx), %r14
movq %r14, %rdi
callq 0x100de
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe58(%rbx)
movb $0x1, %al
movb %al, 0xe97(%rbx)
movb %al, 0xe90(%rbx)
jmp 0xc4fe
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetPointtoAction(double, double)
bool ActionEffector::SetPointtoAction(double dist, AngleDeg angle) {
  if (mIsPointto == true) {
    return false;
  }

  if (mSelfState.GetArmPointMovableBan() > 0) {
    return false;
  }

  mPointto.Plan(true, dist, angle);
  mPointto.Execute(mCommandQueue);
  ++mPointtoCount;
  mIsPointto = true;
  return true;
}

// Assembly:
cmpb $0x0, 0xe98(%rdi)
je 0xc584
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpl $0x0, 0xd0(%rax)
jle 0xc59f
xorl %eax, %eax
jmp 0xc5ce
leaq 0x3c0(%rbx), %r14
movq %r14, %rdi
movl $0x1, %esi
callq 0x1030a
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe5c(%rbx)
movb $0x1, 0xe98(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetPointtoOffAction()
bool ActionEffector::SetPointtoOffAction() {
  if (mIsPointto == true) {
    return false;
  }

  if (mSelfState.GetArmPointMovableBan() > 0) {
    return false;
  }

  mPointto.Plan(false);
  mPointto.Execute(mCommandQueue);
  ++mPointtoCount;
  mIsPointto = true;
  return true;
}

// Assembly:
cmpb $0x0, 0xe98(%rdi)
je 0xc5e0
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpl $0x0, 0xd0(%rax)
jle 0xc5fb
xorl %eax, %eax
jmp 0xc62d
leaq 0x3c0(%rbx), %r14
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %r14, %rdi
xorl %esi, %esi
callq 0x1030a
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe5c(%rbx)
movb $0x1, 0xe98(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetCatchAction(double)
bool ActionEffector::SetCatchAction(AngleDeg angle) {
  if (mIsCatch == true || mIsMutex == true) {
    return false;
  }

  if (angle < ServerParam::instance().minMoment() ||
      angle > ServerParam::instance().maxMoment()) {
    return false;
  }

  //    if (mSelfState.IsGoalie() == false) //FIXME
  //    {
  //        return false;
  //    }

  if (mSelfState.GetCatchBan() > 0) {
    return false;
  }

  if (mWorldState.GetPlayMode() != PM_Play_On &&
      mWorldState.GetPlayMode() != PM_Our_Penalty_Setup &&
      mWorldState.GetPlayMode() != PM_Opp_Penalty_Setup &&
      mWorldState.GetPlayMode() != PM_Our_Penalty &&
      mWorldState.GetPlayMode() != PM_Opp_Penalty_Ready &&
      mWorldState.GetPlayMode() != PM_Our_Penalty_Taken &&
      mWorldState.GetPlayMode() != PM_Opp_Penalty_Taken &&
      mWorldState.GetPlayMode() != PM_Our_Penalty_Miss &&
      mWorldState.GetPlayMode() != PM_Opp_Penalty_Miss &&
      mWorldState.GetPlayMode() != PM_Our_Penalty_Score &&
      mWorldState.GetPlayMode() != PM_Opp_Penalty_Score) {
    return false;
  }

  /*if (mSelfState.IsBallCatchable() == false)
  {
      return false;
  }*/

  mCatch.Plan(angle);
  mCatch.Execute(mCommandQueue);
  ++mCatchCount;
  mIsCatch = true;
  mIsMutex = true;
  return true;
}

// Assembly:
cmpb $0x0, 0xe99(%rdi)
je 0xc63e
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xe90(%rdi)
jne 0xc68f
movsd %xmm0, -0x18(%rbp)
callq 0x4a75c
movsd 0x3148(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
ja 0xc68f
callq 0x4a75c
movsd -0x18(%rbp), %xmm0
ucomisd 0x3140(%rax), %xmm0
ja 0xc68f
movq 0x20(%rbx), %rax
cmpl $0x0, 0xcc(%rax)
jle 0xc69a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x10(%rbx), %rax
movl 0x1c(%rax), %ecx
xorl %eax, %eax
cmpq $0x35, %rcx
ja 0xc691
movabsq $0x3e000001074002, %rdx # imm = 0x3E000001074002
btq %rcx, %rdx
jae 0xc691
leaq 0x440(%rbx), %r14
movq %r14, %rdi
callq 0x104b2
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe60(%rbx)
movb $0x1, %al
movb %al, 0xe99(%rbx)
movb %al, 0xe90(%rbx)
jmp 0xc691
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetMoveAction(Vector)
bool ActionEffector::SetMoveAction(Vector pos) {
  if (mIsMove == true || mIsMutex == true) {
    return false;
  }

  // goalie move, see SoccerServer player.cpp

  mMove.Plan(pos);
  mMove.Execute(mCommandQueue);
  ++mMoveCount;
  mIsMove = true;
  mIsMutex = true;
  return true;
}

// Assembly:
cmpb $0x0, 0xe9a(%rdi)
je 0xc6f6
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xe90(%rdi)
je 0xc70d
xorl %eax, %eax
jmp 0xc73c
leaq 0x4c0(%rbx), %r14
movq %r14, %rdi
callq 0x105f6
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe64(%rbx)
movb $0x1, %al
movb %al, 0xe9a(%rbx)
movb %al, 0xe90(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetChangeViewAction(ViewWidth)
bool ActionEffector::SetChangeViewAction(ViewWidth view_width) {
  if (view_width != VW_Narrow && view_width != VW_Normal &&
      view_width != VW_Wide) {
    return false;
  }

  VisualSystem::instance().ChangeViewWidth(mAgent, view_width); //与视觉系统同步

  if (view_width == mSelfState.GetViewWidth()) {
    return true;
  }

  mChangeView.Plan(view_width);
  mChangeView.Execute(mCommandQueue);
  ++mChangeViewCount;
  mIsChangeView = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
leal -0x1(%r14), %r12d
cmpl $0x2, %r12d
ja 0xc7ab
movq %rdi, %rbx
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0xc773
movl %r14d, 0x640(%rax)
movq 0x20(%rbx), %rax
cmpl %r14d, 0x118(%rax)
je 0xc7ab
leaq 0x540(%rbx), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x10764
leaq 0x28(%rbx), %rsi
movq %r15, %rdi
callq 0xf6d8
incl 0xe68(%rbx)
movb $0x1, 0xe9b(%rbx)
cmpl $0x3, %r12d
setb %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetCompressionAction(int)
bool ActionEffector::SetCompressionAction(int level) {
  if (mIsCompression == true) {
    return false;
  }

  if (level > 9) {
    return false;
  }

  mCompression.Plan(level);
  mCompression.Execute(mCommandQueue);
  ++mCompressionCount;
  mIsCompression = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0xa, %esi
setge %bl
orb 0xe9c(%rdi), %bl
jne 0xc801
movq %rdi, %r14
leaq 0x5c0(%rdi), %r15
movq %r15, %rdi
callq 0x1089c
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xf6d8
incl 0xe6c(%r14)
movb $0x1, 0xe9c(%r14)
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetSenseBodyAction()
bool ActionEffector::SetSenseBodyAction() {
  if (mIsSenseBody == true) {
    return false;
  }

  mSenseBody.Plan();
  mSenseBody.Execute(mCommandQueue);
  ++mSenseBodyCount;
  mIsSenseBody = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb 0xe9d(%rdi), %bl
testb %bl, %bl
jne 0xc853
movq %rdi, %r14
leaq 0x640(%rdi), %r15
movq %r15, %rdi
callq 0x109dc
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xf6d8
incl 0xe70(%r14)
movb $0x1, 0xe9d(%r14)
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetScoreAction()
bool ActionEffector::SetScoreAction() {
  if (mIsScore == true) {
    return false;
  }

  mScore.Plan();
  mScore.Execute(mCommandQueue);
  ++mScoreCount;
  mIsScore = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb 0xe9e(%rdi), %bl
testb %bl, %bl
jne 0xc8a5
movq %rdi, %r14
leaq 0x6c0(%rdi), %r15
movq %r15, %rdi
callq 0x10af6
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xf6d8
incl 0xe74(%r14)
movb $0x1, 0xe9e(%r14)
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetByeAction()
bool ActionEffector::SetByeAction() {
  if (mIsBye == true) {
    return false;
  }

  mBye.Plan();
  mBye.Execute(mCommandQueue);
  ++mByeCount;
  mIsBye = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb 0xe9f(%rdi), %bl
testb %bl, %bl
jne 0xc8f7
movq %rdi, %r14
leaq 0x740(%rdi), %r15
movq %r15, %rdi
callq 0x10c10
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xf6d8
incl 0xe78(%r14)
movb $0x1, 0xe9f(%r14)
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetDoneAction()
bool ActionEffector::SetDoneAction() {
  if (mIsDone == true) {
    return false;
  }

  mDone.Plan();
  mDone.Execute(mCommandQueue);
  ++mDoneCount;
  mIsDone = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb 0xea0(%rdi), %bl
testb %bl, %bl
jne 0xc949
movq %rdi, %r14
leaq 0x7c0(%rdi), %r15
movq %r15, %rdi
callq 0x10d2a
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xf6d8
incl 0xe7c(%r14)
movb $0x1, 0xea0(%r14)
xorb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetClangAction(int, int)
bool ActionEffector::SetClangAction(int min_ver, int max_ver) {
  //    if (mIsClang == true)
  //    {
  //        return false;
  //    }

  mClang.Plan(min_ver, max_ver);
  mClang.Execute(mCommandQueue);
  ++mClangCount;
  mIsClang = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x840(%rdi), %r14
movq %r14, %rdi
callq 0x10e44
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe80(%rbx)
movb $0x1, 0xea1(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetEarOnAction(bool, EarMode)
bool ActionEffector::SetEarOnAction(bool our_side, EarMode ear_mode) {
  // ear命令一个周期可以发多个
  if (ear_mode != EM_Partial && ear_mode != EM_Complete) {
    return false;
  }

  mEar.Plan(true, our_side, ear_mode);
  mEar.Execute(mCommandQueue);
  ++mEarCount;
  mIsEar = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ecx
leal -0x1(%rcx), %r15d
cmpl $0x1, %r15d
ja 0xc9de
movq %rdi, %rbx
leaq 0x8c0(%rdi), %r14
movzbl %sil, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x10faa
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe84(%rbx)
movb $0x1, 0xea2(%rbx)
cmpl $0x2, %r15d
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetEarOffAction(bool, EarMode)
bool ActionEffector::SetEarOffAction(bool our_side, EarMode ear_mode) {
  // ear命令一个周期可以发多个
  if (ear_mode != EM_Partial && ear_mode != EM_Complete && ear_mode != EM_All) {
    return false;
  }

  mEar.Plan(false, our_side, ear_mode);
  mEar.Execute(mCommandQueue);
  ++mEarCount;
  mIsEar = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ecx
leal -0x1(%rcx), %r15d
cmpl $0x2, %r15d
ja 0xca37
movq %rdi, %rbx
leaq 0x8c0(%rdi), %r14
movzbl %sil, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x10faa
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe84(%rbx)
movb $0x1, 0xea2(%rbx)
cmpl $0x3, %r15d
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetSynchSeeAction()
bool ActionEffector::SetSynchSeeAction() {
  //    if (mIsSynchSee == true)
  //    {
  //        return false;
  //    }

  mSynchSee.Plan();
  mSynchSee.Execute(mCommandQueue);
  ++mSynchSeeCount;
  mIsSynchSee = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x940(%rdi), %r14
movq %r14, %rdi
callq 0x1117a
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe88(%rbx)
movb $0x1, 0xea3(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetChangePlayerTypeAction(int, int)
bool ActionEffector::SetChangePlayerTypeAction(Unum num, int player_type) {
  mChangePlayerType.Plan(num, player_type);
  mChangePlayerType.Execute(mCommandQueue);
  ++mChangePlayerTypeCount;
  mIsChangePlayerType = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x9c0(%rdi), %r14
movq %r14, %rdi
callq 0x112cc
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe8c(%rbx)
movb $0x1, 0xea4(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetChangePlayerTypeAction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
bool ActionEffector::SetChangePlayerTypeAction(std::string teamname, Unum num,
                                               int player_type) {
  mChangePlayerType.Plan(teamname, num, player_type);
  mChangePlayerType.Execute(mCommandQueue);
  ++mChangePlayerTypeCount;
  mIsChangePlayerType = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %rbx
leaq 0x9c0(%rdi), %r14
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x113f6
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xcb2a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
incl 0xe8c(%rbx)
movb $0x1, 0xea4(%rbx)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xcb70
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetStartAction()
bool ActionEffector::SetStartAction() {
  mStart.Plan();
  mStart.Execute(mCommandQueue);
  mIsStart = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xa40(%rdi), %r14
movq %r14, %rdi
callq 0x1159a
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
movb $0x1, 0xea5(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetChangePlayModeAction(ServerPlayMode)
bool ActionEffector::SetChangePlayModeAction(ServerPlayMode spm) {
  mChangePlayMode.Plan(spm);
  mChangePlayMode.Execute(mCommandQueue);
  mIsChangePlayMode = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xac0(%rdi), %r14
movq %r14, %rdi
callq 0x116b4
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
movb $0x1, 0xea6(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm4, -0x50(%rbp)
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
movl %edx, %r15d
movq %rdi, %rbx
leaq 0xb40(%rdi), %r14
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0xf0e0
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
movsd -0x48(%rbp), %xmm3
movsd -0x50(%rbp), %xmm4
callq 0x11842
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0xcc74
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x94e0
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
movb $0x1, 0xea7(%rbx)
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0xccb0
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11a80
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
movb $0x1, 0xea8(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11c54
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
movb $0x1, 0xea9(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11d6e
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
movb $0x1, 0xeaa(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11e88
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
movb $0x1, 0xeab(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11fa2
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf6d8
movb $0x1, 0xeac(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movapd %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movapd %xmm1, %xmm0
callq 0xe8f9
movsd %xmm0, -0x30(%rbp)
movsd 0x5df07(%rip), %xmm0    # 0x6b048
movapd -0x40(%rbp), %xmm2
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
movapd -0x50(%rbp), %xmm3
cmpltsd %xmm1, %xmm3
andpd %xmm3, %xmm0
andnpd %xmm2, %xmm3
orpd %xmm0, %xmm3
movapd %xmm3, -0x60(%rbp)
movsd 0x80(%r14), %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x450ba
movapd -0x60(%rbp), %xmm0
movq 0x5c38(%rax), %rax
movslq 0x114(%r14), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
addsd 0xb0(%r14), %xmm0
movsd 0x3030(%rax,%rcx), %xmm3
movsd 0x5deb0(%rip), %xmm1    # 0x6b060
ucomisd %xmm0, %xmm1
jbe 0xd1ca
movsd 0x5deb2(%rip), %xmm2    # 0x6b070
addsd %xmm2, %xmm0
ucomisd %xmm0, %xmm1
ja 0xd1be
jmp 0xd1ee
ucomisd 0x5de76(%rip), %xmm0    # 0x6b048
jb 0xd1ee
movsd 0x5de8c(%rip), %xmm1    # 0x6b068
movsd 0x5de64(%rip), %xmm2    # 0x6b048
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jae 0xd1e4
movapd -0x50(%rbp), %xmm1
andpd 0x5de15(%rip), %xmm1    # 0x6b010
mulsd -0x40(%rbp), %xmm1
mulsd %xmm3, %xmm1
movsd -0x30(%rbp), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, -0x30(%rbp)
mulsd 0x5de36(%rip), %xmm0    # 0x6b050
divsd 0x5de26(%rip), %xmm0    # 0x6b048
leaq -0x70(%rbp), %r12
leaq -0x68(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x92d0
movsd (%r13), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd %xmm1, %xmm0
mulsd (%r12), %xmm1
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)
callq 0x450ba
movq 0x5c38(%rax), %rax
movslq 0x114(%r14), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd 0x3020(%rax,%rcx), %xmm0
mulsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd 0x3020(%rax,%rcx), %xmm0
mulsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::Reset()
void ActionEffector::Reset() {
  ActionEffector::CMD_QUEUE_MUTEX.Lock();
  mCommandQueue.clear();
  ActionEffector::CMD_QUEUE_MUTEX.UnLock();

  mIsMutex = false;

  mIsTurn = false;
  mIsDash = false;
  mIsTurnNeck = false;
  mIsSay = false;
  mIsAttentionto = false;
  mIsKick = false;
  mIsTackle = false;
  mIsPointto = false;
  mIsCatch = false;
  mIsMove = false;
  mIsChangeView = false;
  mIsCompression = false;
  mIsSenseBody = false;
  mIsScore = false;
  mIsBye = false;
  mIsDone = false;
  mIsClang = false;
  mIsEar = false;
  mIsSynchSee = false;
  mIsChangePlayerType = false;

  mIsSayMissed = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x79584(%rip), %r14     # 0x87578
movq %r14, %rdi
callq 0x4f686
leaq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0xf012
movq %r15, 0x30(%rbx)
movq %r15, 0x28(%rbx)
xorl %r15d, %r15d
movq %r15, 0x38(%rbx)
movq %r14, %rdi
callq 0x4f6a2
movb $0x0, 0xead(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xe90(%rbx)
movq %r15, 0xe9d(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x79521(%rip), %rdi     # 0x87578
callq 0x4f686
leaq 0x28(%rbx), %r14
movq 0x28(%rbx), %rsi
cmpq %r14, %rsi
je 0xe102
leaq 0x5d074(%rip), %r15     # 0x6b0e8
movl 0x10(%rsi), %eax
decl %eax
cmpl $0x9, %eax
ja 0xe0b4
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movb $0x0, 0xe91(%rbx)
decl 0xe40(%rbx)
jmp 0xe0e4
movb $0x0, 0xe93(%rbx)
decl 0xe48(%rbx)
jmp 0xe0e4
movb $0x0, 0xe9a(%rbx)
decl 0xe64(%rbx)
jmp 0xe0e4
movq (%rsi), %rsi
jmp 0xe0f2
movb $0x0, 0xe92(%rbx)
decl 0xe44(%rbx)
jmp 0xe0e4
movb $0x0, 0xe96(%rbx)
decl 0xe54(%rbx)
jmp 0xe0e4
movb $0x0, 0xe97(%rbx)
decl 0xe58(%rbx)
movq (%rsi), %r12
movq %r14, %rdi
callq 0xf17a
movq %r12, %rsi
cmpq %r14, %rsi
jne 0xe074
movb $0x0, 0xe90(%rbx)
leaq 0x7946f(%rip), %rdi     # 0x87578
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4f6a2
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe166
movq %rdi, %r14
leaq 0x7943e(%rip), %rdi     # 0x87578
callq 0x4f686
movq 0x28(%r14), %rax
addq $0x28, %r14
cmpq %r14, %rax
je 0xe15a
cmpl $0xb, 0x10(%rax)
jne 0xe155
movl 0x58(%rax), %ebx
movq (%rax), %rax
jmp 0xe147
leaq 0x79417(%rip), %rdi     # 0x87578
callq 0x4f6a2
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x1, 0xe92(%rdi)
jne 0xe1a0
movq 0x20(%rdi), %rax
movsd 0xf8(%rdi), %xmm0
xorps %xmm1, %xmm1
movq %rax, %rdi
movl $0x1, %esi
callq 0x46fba
jmp 0xe1ff
cmpb $0x1, 0xe9a(%rdi)
jne 0xe1bb
movsd 0x508(%rdi), %xmm0
movsd 0x510(%rdi), %xmm1
jmp 0xe1ff
movq 0x20(%rdi), %rax
movq 0x68(%rax), %rbx
movl $0x1, -0x14(%rbp)
cmpl $0x0, 0x668(%rbx)
jle 0xe1d9
addq $0x18, %rbx
jmp 0xe1f6
leaq -0x14(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf062
movslq (%r14), %rax
shlq $0x4, %rax
addq %rax, %rbx
addq $0x8, %rbx
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x1, 0xe92(%rdi)
jne 0xe23a
movq 0x20(%rdi), %rax
movsd 0xf8(%rdi), %xmm0
xorps %xmm1, %xmm1
movq %rax, %rdi
movl $0x1, %esi
callq 0x4704e
jmp 0xe293
xorps %xmm1, %xmm1
cmpb $0x0, 0xe9a(%rdi)
xorps %xmm0, %xmm0
jne 0xe293
movq 0x20(%rdi), %rax
movq 0x68(%rax), %rbx
movl $0x1, -0x14(%rbp)
cmpl $0x0, 0x668(%rbx)
jle 0xe26a
addq $0x348, %rbx            # imm = 0x348
jmp 0xe28a
leaq -0x14(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf062
movslq (%r14), %rax
shlq $0x4, %rax
addq %rax, %rbx
addq $0x338, %rbx            # imm = 0x338
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe2d5
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
movq $0x0, (%rbx)
movsd 0x80(%rdi), %xmm0
movq 0x20(%rdi), %rdi
movq %rbx, %rsi
callq 0xd2d6
movsd (%rbx), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x20(%rdi), %rax
movsd 0xb0(%rax), %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0xe96(%rdi)
jne 0xe32c
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
leaq -0x30(%rbp), %rcx
movaps %xmm0, (%rcx)
movsd 0x2f8(%rdi), %xmm0
movsd 0x300(%rdi), %xmm1
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdi
movl $0x1, %r8d
callq 0xcdbc
jmp 0xe36e
movq 0x18(%rdi), %rax
movq 0x68(%rax), %rbx
movl $0x1, -0x30(%rbp)
cmpl $0x0, 0x668(%rbx)
jle 0xe34a
addq $0x18, %rbx
jmp 0xe367
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf062
movslq (%r14), %rax
shlq $0x4, %rax
addq %rax, %rbx
addq $0x8, %rbx
movups (%rbx), %xmm0
movaps %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0xe96(%rdi)
jne 0xe3cc
xorps %xmm0, %xmm0
leaq -0x30(%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
movl $0x1, %r8d
callq 0xcdbc
jmp 0xe414
movq 0x18(%rdi), %rax
movq 0x68(%rax), %rbx
movl $0x1, -0x30(%rbp)
cmpl $0x0, 0x668(%rbx)
jle 0xe3ed
addq $0x348, %rbx            # imm = 0x348
jmp 0xe40d
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf062
movslq (%r14), %rax
shlq $0x4, %rax
addq %rax, %rbx
addq $0x338, %rbx            # imm = 0x338
movups (%rbx), %xmm0
movaps %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe86e
testl %eax, %eax
jne 0xe8c2
movb 0x7aea4(%rip), %al      # 0x89718
leaq 0x7ad25(%rip), %rbx     # 0x895a0
testb %al, %al
jne 0xe8d8
leaq 0x7ae92(%rip), %rdi     # 0x89718
callq 0x9900
testl %eax, %eax
je 0xe8d8
leaq 0x7ad0a(%rip), %rbx     # 0x895a0
movq %rbx, %rdi
callq 0x46810
leaq 0x6d1(%rip), %rdi       # 0xef76
leaq 0x78c4c(%rip), %rdx     # 0x874f8
movq %rbx, %rsi
callq 0x9410
leaq 0x7ae5d(%rip), %rdi     # 0x89718
callq 0x9300
jmp 0xe8d8
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 0x7ae2c(%rip), %rdi     # 0x89718
callq 0x92f0
movq %rbx, %rdi
callq 0x98b0