LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetTeammateWithBall()
Unum PositionInfo::GetTeammateWithBall() {
  if (mpWorldState->GetBall().GetPosConf() < FLOAT_EPS) {
    return 0;
  }

  if (GetPlayerWithBallList().empty()) {
    return 0;
  } else {
    for (unsigned int i = 0; i < GetPlayerWithBallList().size(); ++i) {
      if (GetPlayerWithBallList()[i] > 0) {
        return GetPlayerWithBallList()[i];
      }
    }
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
xorl %r14d, %r14d
movsd 0x20ec7(%rip), %xmm0    # 0x69040
ucomisd 0x50(%rax), %xmm0
ja 0x481ef
movq %rdi, %rbx
callq 0x47e2a
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x481ef
movq %rbx, %rdi
callq 0x47e2a
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x481ef
movl $0x1, %r15d
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x47e2a
movq (%rax), %rax
cmpl $0x0, (%rax,%r14,4)
jg 0x481e0
movl %r15d, %r14d
movq %rbx, %rdi
callq 0x47e2a
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
incl %r15d
cmpq %r14, %rcx
ja 0x481ab
xorl %r14d, %r14d
jmp 0x481ef
movq %rbx, %rdi
callq 0x47e2a
movq (%rax), %rax
movl (%rax,%r14,4), %r14d
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/PositionInfo.cpp
// Function: PositionInfo::GetOpponentWithBall()
Unum PositionInfo::GetOpponentWithBall() {
  if (mpWorldState->GetBall().GetPosConf() < FLOAT_EPS) {
    return 0;
  }

  if (GetPlayerWithBallList().empty()) {
    return 0;
  } else {
    for (unsigned int i = 0; i < GetPlayerWithBallList().size(); ++i) {
      if (GetPlayerWithBallList()[i] < 0) {
        return -GetPlayerWithBallList()[i];
      }
    }
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
xorl %r14d, %r14d
movsd 0x20e29(%rip), %xmm0    # 0x69040
ucomisd 0x50(%rax), %xmm0
ja 0x48290
movq %rdi, %rbx
callq 0x47e2a
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x48290
movq %rbx, %rdi
callq 0x47e2a
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x48290
movl $0x1, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x47e2a
movq (%rax), %rax
cmpl $0x0, (%rax,%r15,4)
js 0x4827e
movl %r14d, %r15d
movq %rbx, %rdi
callq 0x47e2a
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
incl %r14d
cmpq %r15, %rcx
ja 0x48249
xorl %r14d, %r14d
jmp 0x48290
movq %rbx, %rdi
callq 0x47e2a
movq (%rax), %rax
xorl %r14d, %r14d
subl (%rax,%r15,4), %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/ServerParam.cpp
// Function: ServerParam::init(int, char**)
void ServerParam::init(int argc, char **argv) {
  // std::cout << "Parsing Server Param From Cmd Line 1st Time..." << std::endl;
  ParseFromCmdLine(
      argc, argv); //首先分析命令行，因为有可能命令行里面改了配置文件的路径
  // std::cout << "Parsing Server Param From Config File " <<
  // M_server_conf_file.c_str() << "..." << std::endl;
  ParseFromConfigFile(M_server_conf_file.c_str()); //分析配置文件
  // std::cout << "Parsing Server Param From Cmd Line 2nd Time..." << std::endl;
  ParseFromCmdLine(
      argc, argv); //再次分析命令行，因为命令行有权更改配置文件里面的默认设置
  MaintainConsistency();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
callq 0x3d196
movq 0x33f0(%r15), %rsi
movq %r15, %rdi
callq 0x3d2f4
movq %r15, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x3d196
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x494ca
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Simulator.cpp
// Function: Simulator::Player::Act(AtomicAction const&)
void Simulator::Player::Act(const AtomicAction &act) {
  switch (act.mType) {
  case CT_Turn:
    Turn(GetTurnMoment(act.mTurnAngle, mPlayerType, mVel.Mod()));
    break;
  case CT_Dash:
    Dash(act.mDashPower, Dasher::GetDashDirIdx(act.mDashDir));
    break;
  case CT_Kick:
    Step();
    break;
  case CT_None:
    break;
  default:
    Assert(0);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x4(%rsi), %eax
cmpl $0x6, %eax
je 0x4b079
cmpl $0x2, %eax
je 0x4b04c
cmpl $0x1, %eax
jne 0x4b043
movsd 0x18(%rsi), %xmm0
movsd %xmm0, -0x18(%rbp)
movslq 0x38(%rbx), %r14
movsd 0x10(%rbx), %xmm0
movsd 0x18(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x43dce
movq 0x5c38(%rax), %rax
imulq $0x3700, %r14, %rcx     # imm = 0x3700
movsd -0x20(%rbp), %xmm0
mulsd 0x3028(%rax,%rcx), %xmm0
addsd 0x1e02a(%rip), %xmm0    # 0x69058
mulsd -0x18(%rbp), %xmm0
leaq -0x28(%rbp), %rsi
movsd %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x4b0fa
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movsd 0x20(%rsi), %xmm0
movsd %xmm0, -0x18(%rbp)
addq $0x28, %rsi
movq %rsi, %rdi
callq 0x22022
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
movl %eax, %esi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4ad88
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4b08a
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Simulator.h
// Function: Simulator::Player::Turn(double const&)
void Turn(const AngleDeg &moment) {
      mBodyDir = GetNormalizeAngleDeg(
          mBodyDir +
          GetNormalizeMoment(moment) / (1.0 + PlayerParam::instance()
                                                      .HeteroPlayer(mPlayerType)
                                                      .inertiaMoment() *
                                                  mVel.Mod()));
      Step();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x20(%rdi), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x49360
movq %rax, %r15
callq 0x49360
movsd (%r14), %xmm0
maxsd 0x3148(%r15), %xmm0
movsd 0x3140(%rax), %xmm1
minsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
callq 0x43dce
movsd -0x20(%rbp), %xmm2
movq 0x5c38(%rax), %rax
movslq 0x38(%rbx), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd 0x10(%rbx), %xmm0
movsd 0x18(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
mulsd 0x3028(%rax,%rcx), %xmm0
addsd 0x1dece(%rip), %xmm0    # 0x69058
divsd %xmm0, %xmm2
addsd -0x28(%rbp), %xmm2
movsd 0x1dec5(%rip), %xmm0    # 0x69060
ucomisd %xmm2, %xmm0
jbe 0x4b1b5
movsd 0x1dec7(%rip), %xmm1    # 0x69070
addsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
ja 0x4b1a9
jmp 0x4b1d9
ucomisd 0x1de8b(%rip), %xmm2    # 0x69048
jb 0x4b1d9
movsd 0x1dea1(%rip), %xmm0    # 0x69068
movsd 0x1de79(%rip), %xmm1    # 0x69048
addsd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
jae 0x4b1cf
movsd %xmm2, 0x20(%rbx)
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4b08a
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Strategy.cpp
// Function: Strategy::Strategy(Agent&)
Strategy::Strategy(Agent &agent) : DecisionData(agent) {
  mSituation = ST_Defense;
  mLastController = 0;

  mIsBallActuralKickable = false;
  mIsBallFree = false;
  mController = 0;
  mChallenger = 0;

  mForbiddenDribble = false;

  mIsPenaltyFirstStep = false;
  mPenaltyTaker = 0;
  mPenaltySetupTime = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x22218
leaq 0x387f3(%rip), %rax     # 0x83c40
movq %rax, (%rbx)
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
movq %rax, 0x54(%rbx)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0xb0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movq %rax, 0x108(%rbx)
xorl %eax, %eax
movq %rax, 0x110(%rbx)
movl $0x3e8, 0x124(%rbx)     # imm = 0x3E8
movabsq $0x408f400000000000, %rcx # imm = 0x408F400000000000
movq %rcx, 0x128(%rbx)
movq %rcx, 0x130(%rbx)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x138(%rbx)
movl $0x2, 0xa4(%rbx)
movl %eax, 0x5c(%rbx)
movw $0x0, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movb %al, 0xa8(%rbx)
movb %al, 0x140(%rbx)
movl %eax, 0x148(%rbx)
movl %eax, 0x144(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Strategy.cpp
// Function: Strategy::PenaltyAnalyze()
void Strategy::PenaltyAnalyze() {
  if (IsPenaltyPlayMode() == false) {
    return;
  }

  if (mWorldState.GetPlayModeTime() == mWorldState.CurrentTime()) {
    static Unum penalty_taker_seq[] = {1, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2};
    const PlayMode &play_mode = mWorldState.GetPlayMode();
    if (play_mode == PM_Our_Penalty_Setup) {
      while (penalty_taker_seq[++mPenaltySetupTime % TEAMSIZE] ==
             mWorldState.GetTeammateGoalieUnum())
        ;
      mPenaltyTaker = penalty_taker_seq[mPenaltySetupTime % TEAMSIZE];
    } else if (play_mode == PM_Opp_Penalty_Setup) {
      mPenaltyTaker = -1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movl 0x1c(%rax), %ecx
cmpq $0x35, %rcx
ja 0x4b782
movabsq $0x3e00000487c000, %rdx # imm = 0x3E00000487C000
btq %rcx, %rdx
jae 0x4b782
movl 0x28(%rax), %edx
cmpl 0x14(%rax), %edx
jne 0x4b782
movl 0x10(%rax), %edx
cmpl %edx, 0x24(%rax)
jne 0x4b782
cmpl $0x31, %ecx
je 0x4b777
cmpl $0xe, %ecx
jne 0x4b782
movl 0x2110(%rax), %ecx
movl 0x144(%rdi), %eax
leaq 0x21400(%rip), %rdx     # 0x6cb40
incl %eax
movslq %eax, %rsi
imulq $0x2e8ba2e9, %rsi, %r8  # imm = 0x2E8BA2E9
movq %r8, %r9
shrq $0x3f, %r9
sarq $0x21, %r8
addl %r9d, %r8d
leal (%r8,%r8,4), %r9d
leal (%r8,%r9,2), %r8d
subl %r8d, %esi
movslq %esi, %rsi
movl (%rdx,%rsi,4), %esi
cmpl %ecx, %esi
je 0x4b740
movl %eax, 0x144(%rdi)
jmp 0x4b77c
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %esi, 0x148(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Strategy.cpp
// Function: Strategy::SetPlayAnalyse()
bool Strategy::SetPlayAnalyse() {
  PlayMode play_mode = mWorldState.GetPlayMode();
  if (play_mode == PM_Before_Kick_Off) {
    mIsBallFree = true;
    mController = mInfoState.GetPositionInfo().GetClosestPlayerToBall();
    return true;
  } else if (play_mode < PM_Our_Mode && play_mode > PM_Play_On) {
    mIsBallFree = true;
    if (mBallState.GetVel().Mod() < 0.16) { //如果有球速，说明已经发球了
      mController = mInfoState.GetPositionInfo().GetClosestTeammateToBall();
    }
    return true;
  } else if (play_mode > PM_Opp_Mode) {
    mIsBallFree = true;
    if (mBallState.GetVel().Mod() < 0.16) { //如果有球速，说明已经发球了
      mController = -mInfoState.GetPositionInfo().GetClosestOpponentToBall();
    }
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movl 0x1c(%rax), %eax
cmpl $0x16, %eax
jne 0x4c436
movb $0x1, 0x41(%rbx)
movq 0x30(%rbx), %rdi
callq 0x2a4b4
movq %rax, %rdi
callq 0x4c95a
movl %eax, 0x48(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leal -0x2(%rax), %ecx
cmpl $0x12, %ecx
ja 0x4c483
movb $0x1, 0x41(%rbx)
movq 0x20(%rbx), %rax
movsd 0x30(%rax), %xmm0
movsd 0x38(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movb $0x1, %al
movsd 0x1e49e(%rip), %xmm1    # 0x6a908
ucomisd %xmm0, %xmm1
jbe 0x4c42f
movq 0x30(%rbx), %rdi
callq 0x2a4b4
movq %rax, %rdi
callq 0x13ab2
jmp 0x4c42a
cmpl $0x25, %eax
jl 0x4c4d6
movb $0x1, 0x41(%rbx)
movq 0x20(%rbx), %rax
movsd 0x30(%rax), %xmm0
movsd 0x38(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movb $0x1, %al
movsd 0x1e454(%rip), %xmm1    # 0x6a908
ucomisd %xmm0, %xmm1
jbe 0x4c42f
movq 0x30(%rbx), %rdi
callq 0x2a4b4
movq %rax, %rdi
callq 0x14f02
negl %eax
jmp 0x4c42a
xorl %eax, %eax
jmp 0x4c42f
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Strategy.cpp
// Function: Strategy::GetTeammateSBSPPosition(int, Vector const&)
Vector Strategy::GetTeammateSBSPPosition(Unum t, const Vector &ballpos) {
  Vector position;

  if (mController > 0 || (mController == 0 && mBallInterPos.X() > 10.0)) {
    position = mAgent.GetFormation().GetTeammateFormationPoint(t, mController,
                                                               ballpos);
  } else {
    position = mAgent.GetFormation().GetTeammateFormationPoint(t);
  }

  double x =
      Min(position.X(), mInfoState.GetPositionInfo().GetTeammateOffsideLine() -
                            PlayerParam::instance().AtPointBuffer());
  if (mAgent.GetFormation().GetTeammateRoleType(t).mLineType ==
      LT_Defender) { //后卫不过中场，便于回防
    position.SetX(Min(0.0, x));
  } else if (mAgent.GetFormation().GetTeammateRoleType(t).mLineType ==
             LT_Forward) { //前锋不回场，便于进攻…………
    position.SetX(Max(-1.0, x));
  } else
    position.SetX(x);

  return position;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x0, 0x48(%rdi)
jg 0x4c516
jne 0x4c5ee
movsd 0x90(%rbx), %xmm0
ucomisd 0x1d250(%rip), %xmm0    # 0x69760
jbe 0x4c5ee
movq 0x10(%rbx), %rdi
callq 0x13432
movl 0x48(%rbx), %edx
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movq %rax, %rdi
movl %r14d, %esi
callq 0x26914
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movq 0x30(%rbx), %rdi
callq 0x2a4b4
movsd 0x17a0(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x43dce
movsd -0x20(%rbp), %xmm0
subsd 0x5c68(%rax), %xmm0
minsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x10(%rbx), %rdi
callq 0x13432
movq 0x10(%rax), %rax
movslq %r14d, %r14
movslq 0x350(%rax,%r14,4), %rcx
shlq $0x4, %rcx
cmpl $0x1, 0x58(%rcx,%rax)
jne 0x4c5aa
xorpd %xmm0, %xmm0
movsd -0x20(%rbp), %xmm1
minsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x4c5de
movq 0x10(%rbx), %rdi
callq 0x13432
movq 0x10(%rax), %rax
movslq 0x350(%rax,%r14,4), %rcx
shlq $0x4, %rcx
cmpl $0x3, 0x58(%rcx,%rax)
jne 0x4c5d9
movsd -0x20(%rbp), %xmm0
maxsd 0x1cac1(%rip), %xmm0    # 0x69098
jmp 0x4c5de
movsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %rdi
callq 0x13432
movsd 0x1d3c1(%rip), %xmm0    # 0x699c0
movq %rax, %rdi
movl %r14d, %esi
callq 0x2670c
jmp 0x4c538
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Strategy.cpp
// Function: Strategy::IsPenaltyPlayMode() const
bool Strategy::IsPenaltyPlayMode() const {
  const PlayMode &play_mode = mWorldState.GetPlayMode();
  return (play_mode == PM_Penalty_On_Our_Field) ||
         (play_mode == PM_Penalty_On_Opp_Field) ||
         (play_mode >= PM_Our_Penalty_Setup &&
          play_mode <= PM_Our_Penalty_Miss) ||
         (play_mode >= PM_Opp_Penalty_Setup &&
          play_mode <= PM_Opp_Penalty_Miss);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movl 0x1c(%rax), %ecx
movb $0x1, %al
cmpl $0x17, %ecx
je 0x4c958
cmpl $0x1a, %ecx
je 0x4c958
leal -0xe(%rcx), %edx
cmpl $0x5, %edx
jb 0x4c958
addl $-0x31, %ecx
cmpl $0x5, %ecx
setb %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Tackler.cpp
// Function: Tackler::GetBallVelAfterTackle(Agent const&, double)
Vector Tackler::GetBallVelAfterTackle(const Agent &agent,
                                      AngleDeg tackle_angle) {
  UpdateTackleData(agent);

  tackle_angle = GetNormalizeAngleDeg(tackle_angle, 0.0);
  int idx1 = ang2idx(tackle_angle);       //下界
  int idx2 = ang2idx(tackle_angle + 1.0); //上界
  double rate = MinMax(0.0, idx2 - tackle_angle, 1.0);

  return mBallVelAfterTackle[idx1] * rate +
         mBallVelAfterTackle[idx2] * (1.0 - rate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsd %xmm0, -0x10(%rbp)
movq %rdi, %rbx
callq 0x4ca1c
movsd -0x10(%rbp), %xmm4
xorpd %xmm0, %xmm0
ucomisd %xmm4, %xmm0
jbe 0x4d018
movsd 0x1c064(%rip), %xmm1    # 0x69070
addsd %xmm1, %xmm4
ucomisd %xmm4, %xmm0
ja 0x4d00c
jmp 0x4d03c
ucomisd 0x1c050(%rip), %xmm4    # 0x69070
jb 0x4d03c
movsd 0x1c03e(%rip), %xmm0    # 0x69068
movsd 0x1c03e(%rip), %xmm1    # 0x69070
addsd %xmm0, %xmm4
ucomisd %xmm1, %xmm4
jae 0x4d032
xorpd %xmm1, %xmm1
ucomisd %xmm4, %xmm1
jbe 0x4d05e
movsd 0x1c022(%rip), %xmm2    # 0x69070
movapd %xmm4, %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm0, %xmm1
ja 0x4d052
jmp 0x4d08a
ucomisd 0x1c00a(%rip), %xmm4    # 0x69070
movapd %xmm4, %xmm0
jb 0x4d08a
movsd 0x1bff4(%rip), %xmm1    # 0x69068
movsd 0x1bff4(%rip), %xmm2    # 0x69070
movapd %xmm4, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jae 0x4d080
movsd 0x1bfc6(%rip), %xmm1    # 0x69058
addsd %xmm4, %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x4d0b4
movsd 0x1bfc8(%rip), %xmm3    # 0x69070
addsd %xmm3, %xmm1
ucomisd %xmm1, %xmm2
ja 0x4d0a8
jmp 0x4d0d8
ucomisd 0x1bfb4(%rip), %xmm1    # 0x69070
jb 0x4d0d8
movsd 0x1bfa2(%rip), %xmm2    # 0x69068
movsd 0x1bfa2(%rip), %xmm3    # 0x69070
addsd %xmm2, %xmm1
ucomisd %xmm3, %xmm1
jae 0x4d0ce
cvttsd2si %xmm0, %eax
cvttsd2si %xmm1, %ecx
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm4, %xmm0
xorpd %xmm1, %xmm1
maxsd %xmm1, %xmm0
movsd 0x1bf5c(%rip), %xmm1    # 0x69058
movapd %xmm1, %xmm2
minsd %xmm0, %xmm2
cltq
shlq $0x4, %rax
movsd 0xb58(%rbx,%rax), %xmm3
mulsd %xmm2, %xmm3
subsd %xmm2, %xmm1
mulsd 0xb60(%rbx,%rax), %xmm2
movslq %ecx, %rax
shlq $0x4, %rax
movsd 0xb58(%rbx,%rax), %xmm0
mulsd %xmm1, %xmm0
mulsd 0xb60(%rbx,%rax), %xmm1
addsd %xmm3, %xmm0
addsd %xmm2, %xmm1
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Tackler.cpp
// Function: Tackler::TackleToDir(Agent&, double const&, bool)
bool Tackler::TackleToDir(Agent &agent, const AngleDeg &dir, bool foul) {
  AngleDeg tackle_angle;
  if (GetTackleAngleToDir(agent, dir, &tackle_angle)) {
    agent.Tackle(tackle_angle, foul);
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rsi, %r14
movsd (%rdx), %xmm0
leaq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4d160
movl %eax, %r15d
testb %al, %al
je 0x4d6ce
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
callq 0xee28
movzbl %bl, %esi
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
callq 0xc3ca
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Thread.cpp
// Function: ThreadCondition::Wait(int)
bool ThreadCondition::Wait(int ms) {
  while (pthread_mutex_lock(&mMutex)) {
  }

  int ret = ETIMEDOUT;
  if (ms > 0) {
    timespec timeout;
    RealTime outtime = GetRealTime();
    outtime = outtime + ms;
    timeout.tv_sec = outtime.GetSec();
    timeout.tv_nsec = outtime.GetUsec() * 1000;
    while ((ret = pthread_cond_timedwait(&mCond, &mMutex, &timeout)) == EINTR) {
    }
  } else {
    ret = pthread_cond_wait(&mCond, &mMutex);
  }

  while (pthread_mutex_unlock(&mMutex)) {
  }
  return (ret == ETIMEDOUT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %r15d
movq %rdi, %r14
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0x96f0
testl %eax, %eax
jne 0x4df3d
testl %r15d, %r15d
jle 0x4df9d
callq 0x543e4
leaq -0x30(%rbp), %r12
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movq %r12, %rdi
movl %r15d, %esi
callq 0x5454e
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
leaq -0x40(%rbp), %r12
movq %rax, (%r12)
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
movq %rax, 0x8(%r12)
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x9740
cmpl $0x4, %eax
je 0x4df88
jmp 0x4dfa8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9760
movl %eax, %r15d
movq %rbx, %rdi
callq 0x9380
testl %eax, %eax
jne 0x4dfab
cmpl $0x6e, %r15d
sete %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/TimeTest.cpp
// Function: TimeTest::Update(Time)
void TimeTest::Update(Time current_time) {
  if (PlayerParam::instance().TimeTest()) {
    if (mUpdateTime == current_time) {
      return;
    }

    long last_num = 0;
    double last_ave_cost = 0;
    long cycle_time_cost = 0;
    for (unsigned i = 0; i < mEventQueue.size(); ++i) {
      if (mIsExecute[i] == false) {
        continue;
      }

      last_num = mRecordQueue[i].mEachCycle.mNum;
      last_ave_cost = mRecordQueue[i].mEachCycle.mAveCost;
      cycle_time_cost = mRecordQueue[i].mCycleTimeCost;

      if (cycle_time_cost > mRecordQueue[i].mEachCycle.mMaxCost) {
        mRecordQueue[i].mEachCycle.mMaxCost = cycle_time_cost;
        mRecordQueue[i].mEachCycle.mMaxTime = mUpdateTime;
      }
      if (cycle_time_cost < mRecordQueue[i].mEachCycle.mMinCost) {
        mRecordQueue[i].mEachCycle.mMinCost = cycle_time_cost;
        mRecordQueue[i].mEachCycle.mMinTime = mUpdateTime;
      }

      mRecordQueue[i].mEachCycle.mAveCost =
          (last_ave_cost * last_num + cycle_time_cost) / (last_num + 1);
      ++mRecordQueue[i].mEachCycle.mNum;
      mRecordQueue[i].mCycleTimeCost = 0;
      mIsExecute[i] = false;
    }

    mUpdateTime = current_time;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x43dce
cmpb $0x1, 0x5c48(%rax)
jne 0x4e9ac
movq %rbx, %rax
shrq $0x20, %rax
cmpl %eax, 0x84(%r14)
jne 0x4e8b2
cmpl %ebx, 0x80(%r14)
je 0x4e9ac
movq (%r14), %rdx
movq 0x8(%r14), %rsi
cmpq %rdx, %rsi
je 0x4e9a5
movq 0x30(%r14), %rdi
movl $0x1, %eax
xorl %ecx, %ecx
movl $0x1, %r8d
shlq %cl, %r8
leal -0x1(%rax), %r9d
shrl $0x6, %r9d
movq (%rdi,%r9,8), %r10
btq %rcx, %r10
jae 0x4e98e
movq 0x18(%r14), %r10
imulq $0x78, %rcx, %rcx
movq 0x70(%r10,%rcx), %rsi
movq %r10, %rdx
cmpq 0x18(%r10,%rcx), %rsi
jle 0x4e91a
leaq (%r10,%rcx), %rdx
movq %rsi, 0x18(%rdx)
movq 0x80(%r14), %rdi
movq %rdi, 0x10(%rdx)
movq 0x18(%r14), %rdx
movq (%r10,%rcx), %rdi
movsd 0x8(%r10,%rcx), %xmm0
cmpq 0x28(%rdx,%rcx), %rsi
jge 0x4e942
addq %rcx, %rdx
movq %rsi, 0x28(%rdx)
movq 0x80(%r14), %r10
movq %r10, 0x20(%rdx)
movq 0x18(%r14), %rdx
xorps %xmm1, %xmm1
cvtsi2sd %rdi, %xmm1
mulsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %rsi, %xmm1
addsd %xmm0, %xmm1
incq %rdi
xorps %xmm0, %xmm0
cvtsi2sd %rdi, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdx,%rcx)
incq (%rdx,%rcx)
movq $0x0, 0x70(%rdx,%rcx)
movq 0x30(%r14), %rdi
notq %r8
andq %r8, (%rdi,%r9,8)
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movl %eax, %ecx
movq %rsi, %r8
subq %rdx, %r8
sarq $0x5, %r8
incl %eax
cmpq %rcx, %r8
ja 0x4e8cd
movq %rbx, 0x80(%r14)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/TimeTest.cpp
// Function: TimeTest::Begin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int TimeTest::Begin(std::string func_name) {
  int i = 0;
  if (PlayerParam::instance().TimeTest()) {
    for (; i < (int)mEventQueue.size(); ++i) {
      if (mEventQueue[i] == func_name) {
        break;
      }
    }

    if (i == (int)mEventQueue.size()) {
      TimeRecord time_record;
      mEventQueue.push_back(func_name);
      mRecordQueue.push_back(time_record);
      mIsExecute.push_back(false);
      mIsBegin.push_back(true);
      mRecordQueue[i].mBeginTime = GetRealTime();
    } else if (mIsBegin[i] == false) {
      mIsBegin[i] = true;
      mRecordQueue[i].mBeginTime = GetRealTime();
    } else {
      i = -1;
    }
  }
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
callq 0x43dce
xorl %r15d, %r15d
cmpb $0x1, 0x5c48(%rax)
jne 0x4eb63
movq (%r14), %rbx
movq %r14, -0x38(%rbp)
movq 0x8(%r14), %r15
subq %rbx, %r15
shrq $0x5, %r15
testl %r15d, %r15d
jle 0x4ea41
movq -0x30(%rbp), %rax
movq 0x8(%rax), %r13
movl %r15d, %r14d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
addq $0x8, %rbx
xorl %r12d, %r12d
cmpq %r13, (%rbx)
jne 0x4ea33
testq %r13, %r13
je 0x4ea44
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbx), %rdi
movq %r13, %rdx
callq 0x94f0
testl %eax, %eax
je 0x4ea44
incq %r12
addq $0x20, %rbx
cmpq %r12, %r14
jne 0x4ea12
jmp 0x4ea4d
xorl %r12d, %r12d
cmpl %r15d, %r12d
jne 0x4eace
xorps %xmm0, %xmm0
movaps %xmm0, -0xb0(%rbp)
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
movq %rax, -0xa0(%rbp)
xorl %ecx, %ecx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
movl $0xf4240, %edx          # imm = 0xF4240
movq %rdx, -0x88(%rbp)
movaps %xmm0, -0x80(%rbp)
movq %rax, -0x70(%rbp)
movq %rcx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movaps %xmm0, -0x50(%rbp)
movq %rcx, -0x40(%rbp)
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
callq 0x27a4e
movq 0x20(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x4eb1d
leaq -0xb0(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, 0x20(%rbx)
jmp 0x4eb30
movq -0x38(%rbp), %r14
movq 0x58(%r14), %rax
movl %r12d, %edx
movl $0x1, %esi
movl %r12d, %ecx
shlq %cl, %rsi
shrl $0x6, %edx
movq (%rax,%rdx,8), %rcx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
btq %r12, %rcx
jb 0x4eb63
movl %r12d, %ebx
orq %rsi, %rcx
movq %rcx, (%rax,%rdx,8)
callq 0x543e4
movq 0x18(%r14), %rcx
imulq $0x78, %rbx, %rsi
movq %rax, 0x60(%rcx,%rsi)
movq %rdx, 0x68(%rcx,%rsi)
movl %r12d, %r15d
jmp 0x4eb63
leaq 0x18(%rbx), %rdi
leaq -0xb0(%rbp), %rdx
movq %rax, %rsi
callq 0x4ee5e
leaq 0x30(%rbx), %rdi
xorl %esi, %esi
callq 0x4ed80
leaq 0x58(%rbx), %rdi
movl $0x1, %esi
callq 0x4ed80
callq 0x543e4
movl %r15d, %ecx
movq 0x18(%rbx), %rsi
imulq $0x78, %rcx, %rcx
movq %rax, 0x60(%rsi,%rcx)
movq %rdx, 0x68(%rsi,%rcx)
movl %r15d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/TimeTest.cpp
// Function: TimeTest::End(int)
void TimeTest::End(int event_id) {
  if (PlayerParam::instance().TimeTest()) {
    RealTime end_time = GetRealTime();
    long cost_time = end_time.Sub(mRecordQueue[event_id].mBeginTime);
    long last_num = mRecordQueue[event_id].mEachTime.mNum;
    double last_ave_cost = mRecordQueue[event_id].mEachTime.mAveCost;
    if (cost_time > mRecordQueue[event_id].mEachTime.mMaxCost) {
      mRecordQueue[event_id].mEachTime.mMaxCost = cost_time;
      mRecordQueue[event_id].mEachTime.mMaxTime = mUpdateTime;
    }
    if (cost_time < mRecordQueue[event_id].mEachTime.mMinCost) {
      mRecordQueue[event_id].mEachTime.mMinCost = cost_time;
      mRecordQueue[event_id].mEachTime.mMinTime = mUpdateTime;
    }

    mRecordQueue[event_id].mEachTime.mAveCost =
        (last_ave_cost * last_num + cost_time) / (last_num + 1);
    ++mRecordQueue[event_id].mEachTime.mNum;
    mRecordQueue[event_id].mCycleTimeCost += cost_time;
    mIsExecute[event_id] = true;
    mIsBegin[event_id] = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x43dce
cmpb $0x1, 0x5c48(%rax)
jne 0x4eca0
callq 0x543e4
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movslq %r14d, %r14
movq 0x18(%rbx), %rax
imulq $0x78, %r14, %r15
leaq (%rax,%r15), %rsi
addq $0x60, %rsi
callq 0x545fa
movq 0x18(%rbx), %rsi
movq %rsi, %rcx
cmpq 0x48(%rsi,%r15), %rax
jle 0x4ebea
leaq (%rsi,%r15), %rcx
movq %rax, 0x48(%rcx)
movq 0x80(%rbx), %rdx
movq %rdx, 0x40(%rcx)
movq 0x18(%rbx), %rcx
movq 0x30(%rsi,%r15), %rdx
movsd 0x38(%rsi,%r15), %xmm0
cmpq 0x58(%rcx,%r15), %rax
jge 0x4ec13
addq %r15, %rcx
movq %rax, 0x58(%rcx)
movq 0x80(%rbx), %rsi
movq %rsi, 0x50(%rcx)
movq 0x18(%rbx), %rcx
cvtsi2sd %rdx, %xmm1
mulsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
addsd %xmm0, %xmm1
incq %rdx
xorps %xmm0, %xmm0
cvtsi2sd %rdx, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x38(%rcx,%r15)
incq 0x30(%rcx,%r15)
addq %rax, 0x70(%rcx,%r15)
leal 0x3f(%r14), %eax
testl %r14d, %r14d
cmovnsl %r14d, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
movq 0x30(%rbx), %rdx
addq %rax, %rdx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
leaq 0x3f(%rcx), %rsi
andq %r14, %rsi
xorl %edi, %edi
cmpq %rcx, %rsi
setbe %dil
movl $0x1, %esi
movl %r14d, %ecx
shlq %cl, %rsi
orq %rsi, -0x8(%rdx,%rdi,8)
addq 0x58(%rbx), %rax
movq $-0x2, %rdx
rolq %cl, %rdx
andq %rdx, -0x8(%rax,%rdi,8)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Trainer()
Trainer::Trainer() {
  mTrainTime = 0;
  mTrainCount = 0;
  mInitialized = false;
  mConverse = false;
  mPrepared = false;
  mHaveRcg = 0;
  mpEndCondition = new Trainer::Condition(this, ET_Null, 0, 0, 0x0, mConverse);
  mLastStopTime = 0;
  mpObserver->SetSelfUnum(TRAINER_UNUM);
  mInitialTime = 0;
  mPlayerStatesList.clear();
  mBallStateList.clear();
  mNeedOpponentList.clear();
  if (!PlayerParam::instance().ForcePenaltyMode()) {
    ReadConfigFile();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1b988
leaq 0x348b3(%rip), %rax     # 0x83c80
movq %rax, (%rbx)
leaq 0x120(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x120(%rbx)
xorl %r13d, %r13d
movq %r13, 0x130(%rbx)
leaq 0x140(%rbx), %r15
movups %xmm0, 0x140(%rbx)
movq %r13, 0x150(%rbx)
leaq 0x160(%rbx), %r12
movq %r13, 0x98(%rbx)
movl $0x0, 0x30(%rbx)
movups %xmm0, 0x160(%rbx)
movups %xmm0, 0x170(%rbx)
movups %xmm0, 0x180(%rbx)
movl $0x58, %edi
callq 0x94c0
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movq %rbx, 0x38(%rax)
movl %r13d, (%rax)
movabsq $0x177000000000, %rcx   # imm = 0x177000000000
movq %rcx, 0x40(%rax)
movups %xmm0, 0x8(%rax)
movq %r13, 0x48(%rax)
movq %r13, 0x4d(%rax)
movq %rax, 0x158(%rbx)
movl %r13d, 0x194(%rbx)
movq 0x8(%rbx), %rax
movl $0xc, 0x2c(%rax)
movl %r13d, 0x138(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x53568
movq 0x160(%rbx), %rax
cmpq %rax, 0x168(%rbx)
je 0x4f4a1
movq %rax, 0x168(%rbx)
movq 0x140(%rbx), %rax
cmpq %rax, 0x148(%rbx)
je 0x4f4b8
movq %rax, 0x148(%rbx)
callq 0x43dce
cmpb $0x0, 0x5c41(%rax)
jne 0x4f4ce
movq %rbx, %rdi
callq 0x4f522
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq 0x178(%rbx), %rdi
testq %rdi, %rdi
je 0x4f4fb
movq 0x188(%rbx), %rsi
subq %rdi, %rsi
callq 0x94e0
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xa38c
movq %r14, %rdi
callq 0x52c0c
movq %rbx, %rdi
callq 0x1badc
movq %r13, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Record()
void Trainer::Record() {
  //记录统计信息
  ofstream os;
  os.open("./train/train.report");
  if (mConverse)
    os << "Converse Train!!" << endl;
  os << "Total Train Count:" << mTrainCount << endl;
  mpEndCondition->Report(os);
  os.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq -0x210(%rbp), %r14
movq %r14, %rdi
callq 0x9870
leaq 0x1d873(%rip), %rsi     # 0x6d194
movq %r14, %rdi
movl $0x10, %edx
callq 0x9090
cmpb $0x1, 0x33(%rbx)
jne 0x4f977
leaq 0x1d86e(%rip), %rsi     # 0x6d1a9
movl $0x10, %edx
movq %r14, %rdi
callq 0x9560
movq -0x210(%rbp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
leaq -0x210(%rbp), %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
leaq 0x1d83c(%rip), %rsi     # 0x6d1ba
leaq -0x210(%rbp), %rdi
movl $0x12, %edx
callq 0x9560
movl 0x9c(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x9320
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movq 0x158(%rbx), %rdi
leaq -0x210(%rbp), %rsi
callq 0x5282a
leaq -0x210(%rbp), %rdi
callq 0x96c0
movq 0x345bf(%rip), %rax     # 0x83fb0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x9400
leaq -0x118(%rbp), %rdi
callq 0x91c0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x9700
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::SendOptionToServer()
void Trainer::SendOptionToServer() {
  while (!mpParser->IsEyeOnOk()) {
    UDPSocket::instance().Send("(eye on)");
    WaitFor(200);
  }

  while (!mpParser->IsEarOnOk()) {
    cout << "Send (ear on)" << endl;
    UDPSocket::instance().Send("(ear on)");
    WaitFor(200);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r15
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x4e01a
movb 0x4f(%r15), %r15b
movq %r14, %rdi
callq 0x4e036
testb %r15b, %r15b
jne 0x4fadc
leaq 0x1a619(%rip), %r14     # 0x6a0b8
callq 0x54038
movq %rax, %rdi
movq %r14, %rsi
callq 0x5432c
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x9690
movq 0x20(%rbx), %r12
leaq 0x20(%r12), %r15
movq %r15, %rdi
callq 0x4e01a
movb 0x4f(%r12), %r12b
movq %r15, %rdi
callq 0x4e036
testb %r12b, %r12b
je 0x4fa9f
movq 0x20(%rbx), %r15
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x4e01a
movb 0x50(%r15), %r15b
movq %r14, %rdi
callq 0x4e036
testb %r15b, %r15b
jne 0x4fb86
movq 0x344b8(%rip), %r14     # 0x83fc0
leaq 0x1d2c2(%rip), %r12     # 0x6cdd1
movl $0xd, %edx
movq %r14, %rdi
leaq 0x1d2ae(%rip), %rsi     # 0x6cdcc
callq 0x9560
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
callq 0x54038
movq %rax, %rdi
movq %r12, %rsi
callq 0x5432c
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x9690
movq 0x20(%rbx), %r15
leaq 0x20(%r15), %r13
movq %r13, %rdi
callq 0x4e01a
movb 0x50(%r15), %r15b
movq %r13, %rdi
callq 0x4e036
cmpb $0x1, %r15b
jne 0x4fb0f
addq $0x8, %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/Trainer.cpp
// Function: Trainer::Run()
void Trainer::Run() {
  // TIMETEST("coach_run");

  mpObserver->Lock();

  /** 下面几个更新顺序不能变 */
  mpAgent->CheckCommands(mpObserver); // 检查上周期发送命令情况
  mpWorldModel->Update(mpObserver);

  mpObserver->UnLock();

  DoDecisionMaking();

  Logger::instance().LogSight();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x3548, %r14d          # imm = 0x3548
movq 0x8(%rdi), %rdi
addq %r14, %rdi
callq 0x4e01a
movq 0x8(%rbx), %r15
movq 0x18(%rbx), %rdi
movb 0x3382(%r15), %al
movb %al, 0x28(%rdi)
movq 0x1838(%r15), %rax
movq %rax, 0x2c(%rdi)
callq 0xee28
movq %rax, %rdi
movq %r15, %rsi
callq 0xd632
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
callq 0x5a124
addq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x4e036
movq %rbx, %rdi
callq 0x4fc1a
callq 0x34c60
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35042
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::DoDecisionMaking()
void Trainer::DoDecisionMaking() {
  switch (mpAgent->World().GetPlayMode()) {
  case PM_Our_Penalty:
  case PM_Opp_Penalty:
  case PM_Penalty_On_Our_Field:
  case PM_Penalty_On_Opp_Field:
  case PM_Our_Penalty_Setup:
  case PM_Our_Penalty_Ready:
  case PM_Our_Penalty_Taken:
  case PM_Our_Penalty_Score:
  case PM_Our_Penalty_Miss:
  case PM_Our_Penalty_Foul:
  case PM_Our_Penalty_Winner:
  case PM_Opp_Penalty_Setup:
  case PM_Opp_Penalty_Ready:
  case PM_Opp_Penalty_Taken:
  case PM_Opp_Penalty_Score:
  case PM_Opp_Penalty_Miss:
  case PM_Opp_Penalty_Foul:
  case PM_Opp_Penalty_Winner:
    return;
  default:
    break;
  }

  if (PlayerParam::instance()
          .ForcePenaltyMode()) //普通比赛，临近结束时强制进行点球
  {
    if (mpAgent->World().GetPlayMode() == PM_Before_Kick_Off &&
        mpAgent->World().GetLastPlayMode() == PM_Play_On)
      mPrepared = false;

    if (mpAgent->World().GetTeammateScore() !=
            mpAgent->World().GetOpponentScore() &&
        !mPrepared)

      mpAgent->World().GetTeammateScore() < mpAgent->World().GetOpponentScore()
          ? Score(true)
          : Score(false);
  } else if (CheckOpponent()) {
    if (!mInitialized) {
      InitializeStadium();
    }
    if (mpEndCondition->CheckState(mpAgent->World()) ||
        mpAgent->World().GetPlayMode() == PM_Before_Kick_Off) {
      mPrepared = false;
    }
    if (!mPrepared && mInitialized) {
      PrepareForTrain();
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %eax
cmpq $0x37, %rax
ja 0x4fc4b
movabsq $0xfe0000079fc000, %rcx # imm = 0xFE0000079FC000
btq %rax, %rcx
jae 0x4fc4b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x43dce
cmpb $0x1, 0x5c41(%rax)
jne 0x4fc95
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
cmpl $0x16, 0x1c(%rax)
jne 0x4fc71
cmpl $0x1, 0x20(%rax)
jne 0x4fc71
movb $0x0, 0x31(%rbx)
movl 0x2118(%rax), %ecx
movl 0x211c(%rax), %eax
cmpl %eax, %ecx
je 0x4fc44
cmpb $0x0, 0x31(%rbx)
jne 0x4fc44
movq %rbx, %rdi
cmpl %eax, %ecx
jge 0x4fcf1
movl $0x1, %esi
jmp 0x4fcf3
movq %rbx, %rdi
callq 0x4fe18
testb %al, %al
je 0x4fc44
cmpb $0x0, 0x30(%rbx)
jne 0x4fcaf
movq %rbx, %rdi
callq 0x4fe6c
movq 0x18(%rbx), %rax
movq 0x158(%rbx), %rdi
movq 0x18(%rax), %rsi
callq 0x4ff24
testb %al, %al
jne 0x4fcd5
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
cmpl $0x16, 0x1c(%rax)
jne 0x4fcfe
movb $0x0, 0x31(%rbx)
cmpb $0x1, 0x30(%rbx)
jne 0x4fc44
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x504ce
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4fd0a
testb $0x1, 0x31(%rbx)
jne 0x4fc44
jmp 0x4fcd9
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Score(bool)
void Trainer::Score(bool isLeft) {
  if (mpAgent->World().GetPlayMode() != PM_Play_On) {
    ChangePlayMode(PM_Play_On);
  }
  Vector tmp = FindValidPoint(isLeft) - mpAgent->World().Ball().GetVel();
  if (isLeft) {
    tmp.SetX(Min(tmp.X(), ServerParam::instance().PITCH_LENGTH / 2 - 3.1));
  } else {
    tmp.SetX(Max(tmp.X(), -ServerParam::instance().PITCH_LENGTH / 2 + 3.1));
  }
  MoveBall(tmp, Vector(isLeft ? ServerParam::instance().ballSpeedMax()
                              : -ServerParam::instance().ballSpeedMax(),
                       0));
  mPrepared = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %rax
cmpl $0x1, 0x1c(%rax)
je 0x4fd3b
callq 0xee28
movq %rax, %rdi
movl $0x3, %esi
callq 0xcadc
movzbl %r14b, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x52a7c
movsd %xmm1, -0x20(%rbp)
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
subsd 0x60(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x68(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x49360
leaq 0x1c171(%rip), %rax     # 0x6bee8
movsd (%rax), %xmm0
mulsd 0x19af5(%rip), %xmm0    # 0x69878
movsd %xmm0, -0x18(%rbp)
callq 0x49360
movsd 0x30f8(%rax), %xmm1
testb %r14b, %r14b
je 0x4fdb7
movsd -0x18(%rbp), %xmm0
addsd 0x1ce99(%rip), %xmm0    # 0x6cc40
minsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movaps %xmm1, -0x30(%rbp)
jmp 0x4fdd9
movsd 0x1ce79(%rip), %xmm0    # 0x6cc38
subsd -0x18(%rbp), %xmm0
maxsd -0x30(%rbp), %xmm0
xorps 0x19250(%rip), %xmm1    # 0x69020
movaps %xmm1, -0x30(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x18(%rbx), %rdi
callq 0xee28
xorps %xmm3, %xmm3
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movaps -0x30(%rbp), %xmm2
callq 0xcbe8
movb $0x1, 0x31(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::CheckOpponent() const
bool Trainer::CheckOpponent() const {
  WorldState &world = mpAgent->World();
  if (world.CurrentTime().T() > 1) {
    return true; //已经开场之后，如果有人不齐的话，估计就是死了……
  }
  for (std::vector<Unum>::const_iterator it = mNeedOpponentList.begin();
       it != mNeedOpponentList.end(); it++) {
    if (!world.GetOpponent(*it).IsAlive())
      return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movq 0x18(%rax), %rcx
movb $0x1, %al
cmpl $0x1, 0x10(%rcx)
jg 0x4fe69
movq 0x140(%rdi), %rsi
movq 0x148(%rdi), %rdx
cmpq %rdx, %rsi
je 0x4fe69
addq $0x10d0, %rcx           # imm = 0x10D0
addq $0x4, %rsi
movslq -0x4(%rsi), %rax
imulq $0x178, %rax, %rax      # imm = 0x178
movb -0x66(%rax,%rcx), %al
cmpb $0x1, %al
jne 0x4fe69
leaq 0x4(%rsi), %rdi
cmpq %rdx, %rsi
movq %rdi, %rsi
jne 0x4fe4a
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::InitializeStadium()
void Trainer::InitializeStadium() {
  for (std::vector<Trainer::PlayerState>::const_iterator it =
           mPlayerStatesList[0].begin();
       it != mPlayerStatesList[0].end(); it++) {
    //		ChangePlayerType(it->mUnum,
    //it->mPlayerType);让教练自己选择异构吧
  }

  for (vector<vector<Trainer::PlayerState>>::iterator it =
           mPlayerStatesList.begin();
       it != mPlayerStatesList.end(); it++) {
    for (std::vector<Trainer::PlayerState>::iterator it2 = it->begin();
         it2 != it->end(); it2++) {
      it2->mVel /=
          PlayerParam::instance().HeteroPlayer(it2->mPlayerType).playerDecay();
      it2->mPos -= it2->mVel;
    }
  }
  mInitialized = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x120(%rdi), %r14
movq 0x128(%rdi), %rax
cmpq %rax, %r14
je 0x4ff14
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x4ff0b
callq 0x43dce
movq 0x5c38(%rax), %rax
movslq 0x30(%r15), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd 0x18(%r15), %xmm0
divsd 0x3020(%rax,%rcx), %xmm0
movsd %xmm0, 0x18(%r15)
movsd 0x20(%r15), %xmm1
divsd 0x3020(%rax,%rcx), %xmm1
movsd %xmm1, 0x20(%r15)
movsd 0x8(%r15), %xmm2
movsd 0x10(%r15), %xmm3
subsd %xmm0, %xmm2
movsd %xmm2, 0x8(%r15)
subsd %xmm1, %xmm3
movsd %xmm3, 0x10(%r15)
addq $0x38, %r15
cmpq 0x8(%r14), %r15
jne 0x4fe99
movq 0x128(%rbx), %rax
addq $0x18, %r14
jmp 0x4fe87
movb $0x1, 0x30(%rbx)
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/Trainer.cpp
// Function: Trainer::MovePlayer(int, Vector, Vector, double)
void Trainer::MovePlayer(Unum num, Vector pos, Vector vel, AngleDeg dir) {
  if (num > 0) {
    mpAgent->MovePlayer(PlayerParam::instance().teamName(), num, pos, vel, dir);
  } else {
    mpAgent->MovePlayer(PlayerParam::instance().opponentTeamName(), -num, pos,
                        vel, dir);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movsd %xmm4, -0x48(%rbp)
movsd %xmm3, -0x40(%rbp)
movsd %xmm2, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %esi, %ebx
movq 0x18(%rdi), %r14
callq 0x43dce
testl %ebx, %ebx
jle 0x50cd5
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x3138(%rax), %rsi
movq 0x3140(%rax), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0xefd6
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
movsd -0x48(%rbp), %xmm4
callq 0x52c6e
movq -0x88(%rbp), %rdi
jmp 0x50d27
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x3160(%rax), %rsi
movq 0x3168(%rax), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0xefd6
negl %ebx
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
movsd -0x48(%rbp), %xmm4
callq 0x52c6e
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x50d38
movq (%r12), %rsi
incq %rsi
callq 0x94e0
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
jmp 0x50d58
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x50d69
movq (%r12), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::ChangePlayerType(int, int)
void Trainer::ChangePlayerType(Unum num, int player_type) {
  if (num > 0) {
    mpAgent->ChangePlayerType(PlayerParam::instance().teamName(), num,
                              player_type);
    mpObserver->SetTeammateType(num, player_type);
  } else {
    mpAgent->ChangePlayerType(PlayerParam::instance().opponentTeamName(), -num,
                              player_type);
    mpObserver->SetOpponentType(-num, player_type);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, -0x30(%rbp)
movq 0x18(%rdi), %r12
callq 0x43dce
testl %r14d, %r14d
jle 0x50e99
leaq -0x60(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x3138(%rax), %rsi
movq 0x3140(%rax), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %r13
movq %r13, %rdi
callq 0xefd6
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movl %r15d, %ecx
callq 0x52d2e
movq -0x70(%rbp), %rdi
cmpq %rbx, %rdi
je 0x50e84
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x94e0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
decl %r14d
leaq (%rax,%r14,4), %rax
addq $0x3c, %rax
jmp 0x50efc
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x3160(%rax), %rsi
movq 0x3168(%rax), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0xefd6
movl %r14d, %edx
negl %edx
movq %r12, %rdi
movq %r13, %rsi
movl %r15d, %ecx
callq 0x52d2e
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x50ee6
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x94e0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
notl %r14d
movslq %r14d, %rcx
leaq (%rax,%rcx,4), %rax
addq $0x68, %rax
movl %r15d, (%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
jmp 0x50f1e
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %rbx, %rdi
je 0x50f2e
movq (%rbx), %rsi
incq %rsi
callq 0x94e0
movq %r14, %rdi
callq 0x98b0