LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc230
xorl %r14d, %r14d
jmp 0xc275
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xe75a
cmpl $0x0, 0xfc(%rax)
setne %r14b
je 0xc26e
leaq 0x240(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xfc80
leaq 0x28(%rbx), %rsi
movq %r15, %rdi
callq 0xf5c8
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_O3/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 0xc290
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xe90(%rdi)
je 0xc2ae
xorl %eax, %eax
jmp 0xc3c1
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x18(%rbp)
callq 0x49360
movq %rax, %r14
callq 0x49360
movsd -0x18(%rbp), %xmm0
maxsd 0x3138(%r14), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x3130(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x49360
movq %rax, %r14
callq 0x49360
movsd -0x28(%rbp), %xmm1
maxsd 0x3148(%r14), %xmm1
movsd 0x3140(%rax), %xmm3
movq 0x10(%rbx), %rax
movl 0x1c(%rax), %eax
addl $-0x9, %eax
cmpl $0x28, %eax
jae 0xc327
movabsq $0xf80190201f, %rcx     # imm = 0xF80190201F
btq %rax, %rcx
jb 0xc2a7
movq 0x20(%rbx), %rcx
xorl %eax, %eax
cmpb $0x1, 0x128(%rcx)
jne 0xc3c1
movsd -0x20(%rbp), %xmm2
minsd -0x18(%rbp), %xmm2
movsd 0x5cd0c(%rip), %xmm0    # 0x69058
ucomisd %xmm2, %xmm0
ja 0xc3c1
minsd %xmm1, %xmm3
movsd %xmm3, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
callq 0x49360
movsd -0x20(%rbp), %xmm0
movsd 0x3130(%rax), %xmm1
addsd 0x5cd1e(%rip), %xmm1    # 0x69098
ucomisd %xmm1, %xmm0
jbe 0xc38d
callq 0x49360
movsd 0x3130(%rax), %xmm0
leaq 0x2c0(%rbx), %r14
movq %r14, %rdi
movsd -0x18(%rbp), %xmm1
callq 0xfe08
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
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_O3/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 0xc438
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xe90(%rdi)
jne 0xc430
movl %esi, %r14d
movsd %xmm0, -0x18(%rbp)
callq 0x49360
movsd 0x3148(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
ja 0xc42e
callq 0x49360
movsd -0x18(%rbp), %xmm0
ucomisd 0x3140(%rax), %xmm0
ja 0xc42e
movq 0x20(%rbx), %rax
movl 0x124(%rax), %ecx
addl 0xc8(%rax), %ecx
jle 0xc439
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movzbl %r14b, %esi
movsd 0x5cbfb(%rip), %xmm1    # 0x69040
ucomisd 0x140(%rax,%rsi,8), %xmm1
movq 0x10(%rbx), %rax
movl 0x1c(%rax), %eax
jbe 0xc45e
cmpl $0x33, %eax
jne 0xc42e
jmp 0xc476
addl $-0x9, %eax
cmpl $0x28, %eax
jae 0xc476
movabsq $0xf80190201f, %rcx     # imm = 0xF80190201F
btq %rax, %rcx
jb 0xc42e
leaq 0x340(%rbx), %r14
movq %r14, %rdi
callq 0xffce
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
incl 0xe58(%rbx)
movb $0x1, %al
movb %al, 0xe97(%rbx)
movb %al, 0xe90(%rbx)
jmp 0xc430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc4b4
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 0xc4cf
xorl %eax, %eax
jmp 0xc4fe
leaq 0x3c0(%rbx), %r14
movq %r14, %rdi
movl $0x1, %esi
callq 0x101fa
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
incl 0xe5c(%rbx)
movb $0x1, 0xe98(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc510
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 0xc52b
xorl %eax, %eax
jmp 0xc55d
leaq 0x3c0(%rbx), %r14
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq %r14, %rdi
xorl %esi, %esi
callq 0x101fa
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
incl 0xe5c(%rbx)
movb $0x1, 0xe98(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc56e
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xe90(%rdi)
jne 0xc5bf
movsd %xmm0, -0x18(%rbp)
callq 0x49360
movsd 0x3148(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
ja 0xc5bf
callq 0x49360
movsd -0x18(%rbp), %xmm0
ucomisd 0x3140(%rax), %xmm0
ja 0xc5bf
movq 0x20(%rbx), %rax
cmpl $0x0, 0xcc(%rax)
jle 0xc5ca
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 0xc5c1
movabsq $0x3e000001074002, %rdx # imm = 0x3E000001074002
btq %rcx, %rdx
jae 0xc5c1
leaq 0x440(%rbx), %r14
movq %r14, %rdi
callq 0x103a2
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
incl 0xe60(%rbx)
movb $0x1, %al
movb %al, 0xe99(%rbx)
movb %al, 0xe90(%rbx)
jmp 0xc5c1
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc626
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xe90(%rdi)
je 0xc63d
xorl %eax, %eax
jmp 0xc66c
leaq 0x4c0(%rbx), %r14
movq %r14, %rdi
callq 0x104e6
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
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_O3/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 0xc6db
movq %rdi, %rbx
callq 0x565ee
movq 0x8(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0xc6a3
movl %r14d, 0x640(%rax)
movq 0x20(%rbx), %rax
cmpl %r14d, 0x118(%rax)
je 0xc6db
leaq 0x540(%rbx), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x10654
leaq 0x28(%rbx), %rsi
movq %r15, %rdi
callq 0xf5c8
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_O3/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 0xc731
movq %rdi, %r14
leaq 0x5c0(%rdi), %r15
movq %r15, %rdi
callq 0x1078c
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xf5c8
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_O3/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 0xc783
movq %rdi, %r14
leaq 0x640(%rdi), %r15
movq %r15, %rdi
callq 0x108cc
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xf5c8
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_O3/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 0xc7d5
movq %rdi, %r14
leaq 0x6c0(%rdi), %r15
movq %r15, %rdi
callq 0x109e6
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xf5c8
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_O3/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 0xc827
movq %rdi, %r14
leaq 0x740(%rdi), %r15
movq %r15, %rdi
callq 0x10b00
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xf5c8
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_O3/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 0xc879
movq %rdi, %r14
leaq 0x7c0(%rdi), %r15
movq %r15, %rdi
callq 0x10c1a
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xf5c8
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_O3/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 0x10d34
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
incl 0xe80(%rbx)
movb $0x1, 0xea1(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc90e
movq %rdi, %rbx
leaq 0x8c0(%rdi), %r14
movzbl %sil, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x10e9a
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
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_O3/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 0xc967
movq %rdi, %rbx
leaq 0x8c0(%rdi), %r14
movzbl %sil, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x10e9a
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
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_O3/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 0x1106a
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
incl 0xe88(%rbx)
movb $0x1, 0xea3(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x111bc
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
incl 0xe8c(%rbx)
movb $0x1, 0xea4(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xefd6
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x112e6
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xca5a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
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 0xcaa0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1148a
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
movb $0x1, 0xea5(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x115a4
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
movb $0x1, 0xea6(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xefd6
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 0x11732
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0xcba4
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x94e0
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
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 0xcbe0
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11970
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
movb $0x1, 0xea8(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11b44
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
movb $0x1, 0xea9(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11c5e
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
movb $0x1, 0xeaa(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11d78
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
movb $0x1, 0xeab(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11e92
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
movb $0x1, 0xeac(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe7f9
movsd %xmm0, -0x30(%rbp)
movsd 0x5bfdd(%rip), %xmm0    # 0x69048
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 0x43dce
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 0x5bf86(%rip), %xmm1    # 0x69060
ucomisd %xmm0, %xmm1
jbe 0xd0f4
movsd 0x5bf88(%rip), %xmm2    # 0x69070
addsd %xmm2, %xmm0
ucomisd %xmm0, %xmm1
ja 0xd0e8
jmp 0xd118
ucomisd 0x5bf4c(%rip), %xmm0    # 0x69048
jb 0xd118
movsd 0x5bf62(%rip), %xmm1    # 0x69068
movsd 0x5bf3a(%rip), %xmm2    # 0x69048
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jae 0xd10e
movapd -0x50(%rbp), %xmm1
andpd 0x5beeb(%rip), %xmm1    # 0x69010
mulsd -0x40(%rbp), %xmm1
mulsd %xmm3, %xmm1
movsd -0x30(%rbp), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, -0x30(%rbp)
mulsd 0x5bf0c(%rip), %xmm0    # 0x69050
divsd 0x5befc(%rip), %xmm0    # 0x69048
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 0x43dce
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_O3/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 0x7666c(%rip), %r14     # 0x84578
movq %r14, %rdi
callq 0x4e01a
leaq 0x28(%rbx), %r15
movq %r15, %rdi
callq 0xef08
movq %r15, 0x30(%rbx)
movq %r15, 0x28(%rbx)
xorl %r15d, %r15d
movq %r15, 0x38(%rbx)
movq %r14, %rdi
callq 0x4e036
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_O3/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 0x76609(%rip), %rdi     # 0x84578
callq 0x4e01a
leaq 0x28(%rbx), %r14
movq 0x28(%rbx), %rsi
cmpq %r14, %rsi
je 0xe01a
leaq 0x5b15c(%rip), %r15     # 0x690e8
movl 0x10(%rsi), %eax
decl %eax
cmpl $0x9, %eax
ja 0xdfcc
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movb $0x0, 0xe91(%rbx)
decl 0xe40(%rbx)
jmp 0xdffc
movb $0x0, 0xe93(%rbx)
decl 0xe48(%rbx)
jmp 0xdffc
movb $0x0, 0xe9a(%rbx)
decl 0xe64(%rbx)
jmp 0xdffc
movq (%rsi), %rsi
jmp 0xe00a
movb $0x0, 0xe92(%rbx)
decl 0xe44(%rbx)
jmp 0xdffc
movb $0x0, 0xe96(%rbx)
decl 0xe54(%rbx)
jmp 0xdffc
movb $0x0, 0xe97(%rbx)
decl 0xe58(%rbx)
movq (%rsi), %r12
movq %r14, %rdi
callq 0xf074
movq %r12, %rsi
cmpq %r14, %rsi
jne 0xdf8c
movb $0x0, 0xe90(%rbx)
leaq 0x76557(%rip), %rdi     # 0x84578
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4e036
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe07e
movq %rdi, %r14
leaq 0x76526(%rip), %rdi     # 0x84578
callq 0x4e01a
movq 0x28(%r14), %rax
addq $0x28, %r14
cmpq %r14, %rax
je 0xe072
cmpl $0xb, 0x10(%rax)
jne 0xe06d
movl 0x58(%rax), %ebx
movq (%rax), %rax
jmp 0xe05f
leaq 0x764ff(%rip), %rdi     # 0x84578
callq 0x4e036
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe0b8
movq 0x20(%rdi), %rax
movsd 0xf8(%rdi), %xmm0
xorps %xmm1, %xmm1
movq %rax, %rdi
movl $0x1, %esi
callq 0x45c5c
jmp 0xe112
cmpb $0x1, 0xe9a(%rdi)
jne 0xe0d3
movsd 0x508(%rdi), %xmm0
movsd 0x510(%rdi), %xmm1
jmp 0xe112
movq 0x20(%rdi), %rax
movq 0x68(%rax), %rbx
movl $0x1, -0x14(%rbp)
movl $0x1, %eax
cmpl $0x0, 0x668(%rbx)
jg 0xe102
leaq -0x14(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xef58
movslq (%r14), %rax
shlq $0x4, %rax
movsd 0x8(%rbx,%rax), %xmm0
movsd 0x10(%rbx,%rax), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe14e
movq 0x20(%rdi), %rax
movsd 0xf8(%rdi), %xmm0
xorps %xmm1, %xmm1
movq %rax, %rdi
movl $0x1, %esi
callq 0x45cf0
jmp 0xe1a2
xorps %xmm1, %xmm1
cmpb $0x0, 0xe9a(%rdi)
xorps %xmm0, %xmm0
jne 0xe1a2
movq 0x20(%rdi), %rax
movq 0x68(%rax), %rbx
movl $0x1, -0x14(%rbp)
movl $0x1, %eax
cmpl $0x0, 0x668(%rbx)
jg 0xe18c
leaq -0x14(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xef58
movslq (%r14), %rax
shlq $0x4, %rax
movsd 0x338(%rbx,%rax), %xmm0
movsd 0x340(%rbx,%rax), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe1e5
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 0xd200
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_O3/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 0xe23c
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 0xccec
jmp 0xe278
movq 0x18(%rdi), %rax
movq 0x68(%rax), %rbx
movl $0x1, -0x30(%rbp)
movl $0x1, %eax
cmpl $0x0, 0x668(%rbx)
jg 0xe26b
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xef58
movslq (%r14), %rax
shlq $0x4, %rax
movups 0x8(%rbx,%rax), %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_O3/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 0xe2d3
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rcx
movaps %xmm0, (%rcx)
movsd 0x2f8(%rdi), %xmm0
movsd 0x300(%rdi), %xmm1
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdi
leaq -0x30(%rbp), %rdx
movl $0x1, %r8d
callq 0xccec
jmp 0xe312
movq 0x18(%rdi), %rax
movq 0x68(%rax), %rbx
movl $0x1, -0x30(%rbp)
movl $0x1, %eax
cmpl $0x0, 0x668(%rbx)
jg 0xe302
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xef58
movslq (%r14), %rax
shlq $0x4, %rax
movups 0x338(%rbx,%rax), %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_O3/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 0xe76e
testl %eax, %eax
jne 0xe7c2
movb 0x77fa4(%rip), %al      # 0x86718
leaq 0x77e25(%rip), %rbx     # 0x865a0
testb %al, %al
jne 0xe7d8
leaq 0x77f92(%rip), %rdi     # 0x86718
callq 0x9900
testl %eax, %eax
je 0xe7d8
leaq 0x77e0a(%rip), %rbx     # 0x865a0
movq %rbx, %rdi
callq 0x454d4
leaq 0x6d3(%rip), %rdi       # 0xee78
leaq 0x75d4c(%rip), %rdx     # 0x844f8
movq %rbx, %rsi
callq 0x9410
leaq 0x77f5d(%rip), %rdi     # 0x86718
callq 0x9300
jmp 0xe7d8
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 0x77f2c(%rip), %rdi     # 0x86718
callq 0x92f0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.h
// Function: GetDashDirRate(double)
inline double GetDashDirRate(double dir) {
  dir = GetNormalizeAngleDeg(dir);

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

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

  return dir_rate;
}

// Assembly:
movsd 0x5a85f(%rip), %xmm2    # 0x69060
ucomisd %xmm0, %xmm2
jbe 0xe81b
movsd 0x5a861(%rip), %xmm1    # 0x69070
addsd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
ja 0xe80f
jmp 0xe83f
ucomisd 0x5a825(%rip), %xmm0    # 0x69048
jb 0xe83f
movsd 0x5a83b(%rip), %xmm2    # 0x69068
movsd 0x5a813(%rip), %xmm1    # 0x69048
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jae 0xe835
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movapd %xmm0, -0x20(%rbp)
callq 0x49360
movsd 0x5a7e7(%rip), %xmm0    # 0x69040
ucomisd 0x33a8(%rax), %xmm0
jbe 0xe86a
movapd -0x20(%rbp), %xmm0
jmp 0xe898
callq 0x49360
movsd 0x33a8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x49360
movapd -0x20(%rbp), %xmm0
divsd 0x33a8(%rax), %xmm0
callq 0x96b0
mulsd -0x8(%rbp), %xmm0
andpd 0x5a770(%rip), %xmm0    # 0x69010
movapd %xmm0, -0x20(%rbp)
callq 0x49360
movapd -0x20(%rbp), %xmm0
ucomisd 0x5a7f9(%rip), %xmm0    # 0x690b0
jbe 0xe916
movsd 0x33b8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x49360
movsd 0x33b8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x49360
movsd -0x28(%rbp), %xmm2
subsd 0x33b0(%rax), %xmm2
movsd 0x5a7c6(%rip), %xmm0    # 0x690b8
movapd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
divsd %xmm0, %xmm1
addsd 0x5a751(%rip), %xmm1    # 0x69058
mulsd %xmm2, %xmm1
movsd -0x8(%rbp), %xmm3
subsd %xmm1, %xmm3
jmp 0xe95a
movsd 0x33b0(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
callq 0x49360
movsd 0x5a728(%rip), %xmm0    # 0x69058
movapd %xmm0, %xmm1
subsd 0x33b0(%rax), %xmm1
movsd 0x5a774(%rip), %xmm2    # 0x690b8
movapd -0x20(%rbp), %xmm3
divsd %xmm2, %xmm3
addsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
addsd -0x8(%rbp), %xmm3
xorpd %xmm0, %xmm0
maxsd %xmm0, %xmm3
movsd 0x5a6ee(%rip), %xmm0    # 0x69058
minsd %xmm3, %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BaseState.h
// Function: MobileState::Predictor::PredictTo(int const&)
void PredictTo(const int &step) {
      for (int i = mPredictedStep + 1; i <= step; ++i) {
        mPredictedPos[i] = mPredictedPos[i - 1] + mPredictedVel[i - 1];
        mPredictedVel[i] = mPredictedVel[i - 1] * mDecay;
      }
      mPredictedStep = step;
    }

// Assembly:
movslq 0x668(%rdi), %rdx
movl (%rsi), %eax
cmpl %eax, %edx
jge 0xefce
pushq %rbp
movq %rsp, %rbp
movslq %eax, %rcx
subq %rdx, %rcx
shlq $0x4, %rdx
addq %rdi, %rdx
addq $0x350, %rdx            # imm = 0x350
movsd -0x348(%rdx), %xmm0
movsd -0x340(%rdx), %xmm1
movsd -0x18(%rdx), %xmm2
movsd -0x10(%rdx), %xmm3
addsd %xmm2, %xmm0
addsd %xmm3, %xmm1
movsd %xmm0, -0x338(%rdx)
movsd %xmm1, -0x330(%rdx)
movsd (%rdi), %xmm4
mulsd %xmm4, %xmm2
mulsd %xmm4, %xmm3
movsd %xmm2, -0x8(%rdx)
movsd %xmm3, (%rdx)
addq $0x10, %rdx
decq %rcx
jne 0xef97
popq %rbp
movl %eax, 0x668(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x732cf(%rip), %rax     # 0x82458
movq %rax, (%rdi)
callq 0xf204
xorl %r14d, %r14d
movq 0xc8(%rbx,%r14,8), %rdi
movl $0xa8, %esi
callq 0x94e0
incq %r14
cmpq $0xc, %r14
jne 0xf194
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xf1be
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xf1cd
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xf1dc
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xf1eb
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xf1fe
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_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Agent.cpp
// Function: Agent::SetHistoryActiveBehaviors()
void Agent::SetHistoryActiveBehaviors() {
  for (int type = BT_None + 1; type < BT_Max; ++type) {
    delete mLastActiveBehavior[type];

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0xc8(%rbx,%r14,8), %rdi
movl $0xa8, %esi
callq 0x94e0
movq 0x60(%rbx,%r14,8), %rax
movq %rax, 0xc8(%rbx,%r14,8)
movq $0x0, 0x60(%rbx,%r14,8)
incq %r14
cmpq $0xc, %r14
jne 0xf211
movq 0x58(%rbx), %rax
movq %rax, 0xc0(%rbx)
movq $0x0, 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq