LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.h
// Function: void ParamEngine::AddParam<int>(char const*, int*, int)
void AddParam(const char *name, T *address, T value) {
    if (address) {
      // assign default value
      *address = value;

      // allocate Param struct
      Param param(name, static_cast<void *>(address), ParamTypes<T>::TYPE);

      if (param.type == V_NONE) {
        std::cerr << __FILE__ << ":" << __LINE__ << ": param type error \""
                  << name << "\"" << std::endl;
        return;
      }
      // put into list
      int id = hash(name);
      if (id > -1) {
        this->mParamLists[id].push_back(param);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
testq %rdx, %rdx
je 0x39d83
movq %rsi, %rbx
movq %rdi, %r14
movl %ecx, (%rdx)
leaq -0x48(%rbp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
callq 0x3a13a
cmpl $0x0, 0x28(%r15)
je 0x39d1c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34666
testl %eax, %eax
js 0x39d7a
movl %eax, %eax
imulq $0x18, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0x8, %rdi
leaq -0x48(%rbp), %rsi
callq 0x3a168
jmp 0x39d7a
movq 0x3d2cd(%rip), %rdi     # 0x76ff0
leaq 0x1f391(%rip), %rsi     # 0x590bb
callq 0x94b0
leaq 0x2143c(%rip), %rsi     # 0x5b172
movq %rax, %rdi
callq 0x94b0
pushq $0x7a
popq %rsi
movq %rax, %rdi
callq 0x9890
leaq 0x1ff93(%rip), %rsi     # 0x59ce3
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x94b0
leaq 0x211f9(%rip), %rsi     # 0x5af63
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
callq 0x99e8
leaq -0x48(%rbp), %rdi
callq 0x9240
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39d90
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::PlayerState()
PlayerState::PlayerState()
    : MobileState(ServerParam::instance().playerDecay(),
                  PlayerParam::instance().HeteroPlayer(0).effectiveSpeedMax()) {
  mBallCatchable = false;
  mCatchBan = 0;
  mCollideWithBall = false;
  mCollideWithPlayer = false;
  mCollideWithPost = false;
  mIsAlive = false;
  mIsGoalie = false;
  mIsSensed = false;
  mIsKicked = false;
  mIsPointing = false;
  mKickRate = 0.0;
  mIsKickable = false;
  mMaxTurnAngle = 0.0;
  mPlayerType = 0;

  mStamina = ServerParam::instance().staminaMax();
  mEffort = ServerParam::instance().effortInit();
  mCapacity = ServerParam::instance().staminaCapacity();
  mRecovery = ServerParam::instance().recoverInit();

  mTackleBan = 0;
  mUnderDangerousTackleCondition = false;

  mFoulChargedCycle = 0;

  mUnum = 0;

  mViewWidth = VW_Normal;
  mIsTired = false;
  mMinStamina = PlayerParam::instance().MinStamina();

  mCardType = CR_None;
  mIsBodyDirMayChanged = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3db2c
movsd 0x3020(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x38d94
movq 0x5c38(%rax), %rax
movsd 0x3098(%rax), %xmm1
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x33a4c
leaq 0x3bb4c(%rip), %rax     # 0x75e28
movq %rax, (%rbx)
andq $0x0, 0x98(%rbx)
movl $0x270f, %eax           # imm = 0x270F
movl %eax, 0xa0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%rbx)
movl %eax, 0xb8(%rbx)
andq $0x0, 0xc0(%rbx)
movups %xmm0, 0xd0(%rbx)
andq $0x0, 0xe0(%rbx)
movl %eax, 0xe8(%rbx)
andq $0x0, 0xf0(%rbx)
movb $0x3f, 0xf8(%rbx)
movabsq $0x270f00000000, %rax   # imm = 0x270F00000000
movq %rax, 0xfc(%rbx)
movups %xmm0, 0x140(%rbx)
xorl %eax, %eax
movb %al, 0x138(%rbx)
andl $0x0, 0xcc(%rbx)
andw $0x0, 0x120(%rbx)
movb %al, 0x122(%rbx)
andw $0x0, 0x175(%rbx)
andq $0x0, 0x130(%rbx)
movb %al, 0x128(%rbx)
andq $0x0, 0x158(%rbx)
andl $0x0, 0x114(%rbx)
andl $0x0, 0x10f(%rbx)
andq $0x0, 0x108(%rbx)
callq 0x3db2c
movsd 0x3048(%rax), %xmm0
movsd %xmm0, 0x78(%rbx)
callq 0x3db2c
movsd 0x3078(%rax), %xmm0
movsd %xmm0, 0x80(%rbx)
callq 0x3db2c
movsd 0x3390(%rax), %xmm0
movsd %xmm0, 0x88(%rbx)
callq 0x3db2c
movsd 0x3058(%rax), %xmm0
movsd %xmm0, 0x90(%rbx)
andl $0x0, 0xc8(%rbx)
xorl %eax, %eax
movb %al, 0x150(%rbx)
andl $0x0, 0x124(%rbx)
movq $0x2, 0x118(%rbx)
movb %al, 0x160(%rbx)
callq 0x38d94
movsd 0x5c60(%rax), %xmm0
movsd %xmm0, 0x168(%rbx)
andl $0x0, 0x170(%rbx)
movb $0x1, 0x174(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xd716
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::IsKickable(BallState const&, double const&) const
bool PlayerState::IsKickable(const BallState &ball_state,
                             const double &buffer) const {
  if (ball_state.GetPosConf() < FLOAT_EPS || GetPosConf() < FLOAT_EPS)
    return false;
  double dis2self = GetPos().Dist(ball_state.GetPos());
  return (dis2self <= GetKickableArea() - buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
movsd 0x1cbdd(%rip), %xmm0    # 0x57040
ucomisd 0x20(%rsi), %xmm0
ja 0x3a4a2
movq %rdi, %r14
ucomisd 0x20(%rdi), %xmm0
ja 0x3a4a2
movq %rdx, %rbx
addq $0x8, %rsi
leaq 0x8(%r14), %rdi
callq 0x2198a
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movsd (%rax), %xmm0
subsd (%rbx), %xmm0
ucomisd -0x18(%rbp), %xmm0
setae %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetPredictedPosWithDash(int, double, double) const
Vector PlayerState::GetPredictedPosWithDash(int steps, double dash_power,
                                            AngleDeg dash_dir) const {
  Simulator::Player self(*this);
  int dash_dir_idx = Dasher::GetDashDirIdx(dash_dir);

  for (int i = 0; i < steps; ++i) {
    self.Dash(dash_power, dash_dir_idx);
  }

  return self.mPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movsd %xmm0, -0x28(%rbp)
movl %esi, %r15d
leaq -0x30(%rbp), %rax
movsd %xmm1, (%rax)
movups 0x8(%rdi), %xmm0
leaq -0x70(%rbp), %rbx
movaps %xmm0, (%rbx)
movups 0x30(%rdi), %xmm0
movaps %xmm0, 0x10(%rbx)
movsd 0xb0(%rdi), %xmm0
movsd %xmm0, 0x20(%rbx)
cvttsd2si 0x78(%rdi), %ecx
movl %ecx, 0x28(%rbx)
movsd 0x80(%rdi), %xmm0
movsd %xmm0, 0x30(%rbx)
movl 0x114(%rdi), %ecx
movl %ecx, 0x38(%rbx)
movq %rax, %rdi
callq 0x1cb50
movl %eax, %r14d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovgl %r15d, %r12d
subl $0x1, %r12d
jb 0x3a814
movq %rbx, %rdi
movsd -0x28(%rbp), %xmm0
movl %r14d, %esi
callq 0x3f4da
jmp 0x3a7fc
movsd -0x70(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetPredictedVelWithDash(int, double, double) const
Vector PlayerState::GetPredictedVelWithDash(int steps, double dash_power,
                                            AngleDeg dash_dir) const {
  Simulator::Player self(*this);
  int dash_dir_idx = Dasher::GetDashDirIdx(dash_dir);

  for (int i = 0; i < steps; ++i) {
    self.Dash(dash_power, dash_dir_idx);
  }

  return self.mVel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movsd %xmm0, -0x28(%rbp)
movl %esi, %r15d
leaq -0x30(%rbp), %rax
movsd %xmm1, (%rax)
movups 0x8(%rdi), %xmm0
leaq -0x70(%rbp), %rbx
movaps %xmm0, (%rbx)
movups 0x30(%rdi), %xmm0
movaps %xmm0, 0x10(%rbx)
movsd 0xb0(%rdi), %xmm0
movsd %xmm0, 0x20(%rbx)
cvttsd2si 0x78(%rdi), %ecx
movl %ecx, 0x28(%rbx)
movsd 0x80(%rdi), %xmm0
movsd %xmm0, 0x30(%rbx)
movl 0x114(%rdi), %ecx
movl %ecx, 0x38(%rbx)
movq %rax, %rdi
callq 0x1cb50
movl %eax, %r14d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovgl %r15d, %r12d
subl $0x1, %r12d
jb 0x3a8b6
movq %rbx, %rdi
movsd -0x28(%rbp), %xmm0
movl %r14d, %esi
callq 0x3f4da
jmp 0x3a89e
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::CorrectDashPowerForStamina(double) const
double PlayerState::CorrectDashPowerForStamina(double dash_power) const {
  double stamina = GetStamina();

  if (IsOutOfStamina()) {
    return dash_power; //已经没有容量了，不需要在控制了
  }

  double new_power;

  if (dash_power >= 0) {
    new_power = Min(dash_power, stamina - PlayerParam::instance().MinStamina());
    if (new_power < 0)
      new_power = 0;
  } else {
    new_power = Min(-dash_power,
                    (stamina - PlayerParam::instance().MinStamina()) / 2.0);
    if (new_power < 0)
      new_power = 0;

    new_power = -new_power;
  }

  return new_power;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movaps %xmm0, -0x10(%rbp)
movsd 0x78(%rdi), %xmm0
movaps %xmm0, -0x20(%rbp)
callq 0xcfba
testb %al, %al
je 0x3a8f6
movapd -0x10(%rbp), %xmm0
jmp 0x3a985
xorpd %xmm1, %xmm1
movapd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x3a960
xorpd 0x1c713(%rip), %xmm0    # 0x57020
movapd %xmm0, -0x10(%rbp)
callq 0x38d94
movapd -0x20(%rbp), %xmm1
subsd 0x5c60(%rax), %xmm1
mulsd 0x1cf1c(%rip), %xmm1    # 0x57848
minsd -0x10(%rbp), %xmm1
movapd 0x1c6e7(%rip), %xmm0    # 0x57020
xorpd %xmm1, %xmm0
cmpltsd %xmm0, %xmm1
movapd %xmm0, %xmm2
movsd 0x1e5f2(%rip), %xmm0    # 0x58f40
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x3a985
callq 0x38d94
movapd -0x20(%rbp), %xmm0
subsd 0x5c60(%rax), %xmm0
minsd -0x10(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3a985
xorpd %xmm0, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetRandAngle(double const&, double const&, BallState const&) const
AngleDeg PlayerState::GetRandAngle(const double &power, const double &vel,
                                   const BallState &bs) const {

  double dir_diff = fabs((bs.GetPos() - GetPos()).Dir() - GetBodyDir());
  Vector tmp = bs.GetPos() - GetPos();
  double dist_ball =
      (tmp.Mod() - GetPlayerSize() - -ServerParam::instance().ballSize());

  double pos_rate =
      0.5 + 0.25 * (dir_diff / 180 + dist_ball / GetKickableMargin());
  // [0.5, 1.0]
  double speed_rate =
      0.5 + 0.5 * (bs.GetVel().Mod() / (ServerParam::instance().ballSpeedMax() *
                                        ServerParam::instance().ballDecay()));
  // [0, 2*kick_rand]
  double max_rand = GetKickRand() *
                    (power / ServerParam::instance().maxPower()) *
                    (pos_rate + speed_rate);

  return Rad2Deg(max_rand / vel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
movsd 0x8(%rcx), %xmm0
movsd 0x10(%rcx), %xmm1
subsd 0x8(%rdi), %xmm0
subsd 0x10(%rdi), %xmm1
movq %rsi, %r15
leaq -0x58(%rbp), %rdi
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
callq 0xcd30
subsd 0xb0(%r14), %xmm0
andpd 0x1c622(%rip), %xmm0    # 0x57010
movapd %xmm0, -0x40(%rbp)
movsd 0x8(%r12), %xmm0
movsd 0x10(%r12), %xmm1
subsd 0x8(%r14), %xmm0
subsd 0x10(%r14), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq %r14, %rdi
callq 0x2abf4
movsd -0x28(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x3db2c
movsd -0x28(%rbp), %xmm0
addsd 0x30d8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movapd -0x40(%rbp), %xmm0
divsd 0x1c60c(%rip), %xmm0    # 0x57068
movapd %xmm0, -0x40(%rbp)
movq %r14, %rdi
callq 0x2abc0
movsd -0x28(%rbp), %xmm0
divsd (%rax), %xmm0
addsd -0x40(%rbp), %xmm0
mulsd 0x1c5f9(%rip), %xmm0    # 0x57078
addsd 0x1cdc1(%rip), %xmm0    # 0x57848
movsd %xmm0, -0x28(%rbp)
movsd 0x30(%r12), %xmm0
movsd 0x38(%r12), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x3db2c
movsd 0x30f8(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
callq 0x3db2c
movsd -0x48(%rbp), %xmm1
mulsd 0x30e0(%rax), %xmm1
movsd -0x40(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd 0x1cd64(%rip), %xmm1    # 0x57848
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq %r14, %rdi
callq 0x3adba
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd (%r15), %xmm0
movsd %xmm0, -0x48(%rbp)
callq 0x3db2c
movsd -0x48(%rbp), %xmm0
divsd 0x3130(%rax), %xmm0
mulsd -0x28(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
divsd (%rbx), %xmm0
mulsd 0x1c52f(%rip), %xmm0    # 0x57068
divsd 0x1c567(%rip), %xmm0    # 0x570a8
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetControlBallProb(Vector const&) const
double PlayerState::GetControlBallProb(const Vector &ball_pos) const {
  const double dist = GetPos().Dist(ball_pos);

  if (dist < GetKickableArea()) {
    return 1.0; //已经可踢了
  }

  if (IsGoalie()) {
    return Max(GetCatchProb(dist),
               ::GetTackleProb(ball_pos, GetPos(), GetBodyDir(), false));
  } else {
    return ::GetTackleProb(ball_pos, GetPos(), GetBodyDir(), false);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x2198a
movsd %xmm0, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movsd (%rax), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x3ab95
movsd 0x1c4b5(%rip), %xmm0    # 0x57048
jmp 0x3abee
cmpb $0x1, 0x175(%rbx)
jne 0x3abd2
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x3abfa
movsd %xmm0, -0x28(%rbp)
addq $0xb0, %rbx
leaq -0x1a(%rbp), %rcx
movb $0x0, (%rcx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3aded
maxsd -0x28(%rbp), %xmm0
jmp 0x3abee
addq $0xb0, %rbx
leaq -0x19(%rbp), %rcx
movb $0x0, (%rcx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3aded
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetCatchProb(double const&) const
double PlayerState::GetCatchProb(const double &dist) const {
  if (dist < GetMinCatchArea()) {
    return ServerParam::instance().catchProb();
  } else {
    double min_length = ServerParam::instance().catchAreaLength() *
                        (2.0 - GetCatchAreaLStretch());
    double max_length =
        ServerParam::instance().catchAreaLength() * GetCatchAreaLStretch();
    if (max_length < min_length + FLOAT_EPS)
      return 0.0;
    double delt =
        Sqrt(dist * dist - ServerParam::instance().catchAreaWidth() *
                               ServerParam::instance().catchAreaWidth() / 4);
    if (delt > max_length)
      return 0.0;
    double dx = delt - min_length;
    return MinMax(0.0,
                  ServerParam::instance().catchProb() -
                      ServerParam::instance().catchProb() * dx /
                          (max_length - min_length),
                  ServerParam::instance().catchProb());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rsi), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x3ae4c
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x3db2c
movsd -0x28(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x3ac40
movsd 0x31c0(%rax), %xmm1
jmp 0x3ad80
movsd 0x31b0(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
callq 0x3ae80
movsd 0x1cafb(%rip), %xmm0    # 0x57758
subsd (%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x3db2c
movsd 0x31b0(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
callq 0x3ae80
movsd -0x18(%rbp), %xmm2
mulsd (%rax), %xmm2
movsd 0x1c3aa(%rip), %xmm0    # 0x57040
addsd -0x28(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm0
ja 0x3ad80
movsd %xmm2, -0x18(%rbp)
movsd (%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x3db2c
movsd 0x31b8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x3db2c
movsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd 0x31b8(%rax), %xmm1
mulsd 0x1f020(%rip), %xmm1    # 0x59d08
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3ad00
sqrtsd %xmm0, %xmm0
jmp 0x3ad09
callq 0x93e0
xorpd %xmm1, %xmm1
movsd -0x18(%rbp), %xmm2
ucomisd %xmm2, %xmm0
ja 0x3ad80
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x3db2c
movsd 0x31c0(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x3db2c
movsd -0x30(%rbp), %xmm0
mulsd 0x31c0(%rax), %xmm0
movsd -0x18(%rbp), %xmm1
subsd -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
movapd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x3db2c
xorpd %xmm0, %xmm0
movsd -0x20(%rbp), %xmm2
maxsd %xmm0, %xmm2
movsd 0x31c0(%rax), %xmm1
minsd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.h
// Function: GetTackleProb(Vector const&, bool)
inline double GetTackleProb(const Vector &ball_2_player, const bool foul) {
  double tackle_dist =
      (ball_2_player.X() > 0.06 /*this is buffer*/ ? ServerParam::instance()
                                                         .tackleDist()
                                                   : ServerParam::instance()
                                                         .tackleBackDist());

  if (fabs(tackle_dist) < FLOAT_EPS) {
    return 0.0;
  } else {
    double dx = fabs(ball_2_player.X()) / tackle_dist;
    double dy = fabs(ball_2_player.Y()) / ServerParam::instance().tackleWidth();

    if (dx > 1.0 || dy > 1.0 ||
        ball_2_player.Mod() > ServerParam::instance().maxTackleArea()) {
      return 0.0;
    }

    double exponent = (foul) ? ServerParam::instance().foulExponent()
                             : ServerParam::instance().tackleExponent();
    // tackle failure probability
    double prob = pow(dx, exponent) + pow(dy, exponent);
    prob = MinMax(0.0, prob, 1.0);
    return 1.0 - prob;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movsd (%rdi), %xmm0
xorl %r15d, %r15d
ucomisd 0x1d8d6(%rip), %xmm0    # 0x587a8
movl %esi, %ebx
setbe %r15b
callq 0x3db2c
shll $0x4, %r15d
movsd 0x32f8(%r15,%rax), %xmm0
movapd 0x1c11d(%rip), %xmm1    # 0x57010
andpd %xmm0, %xmm1
xorpd %xmm3, %xmm3
movsd 0x1c13d(%rip), %xmm2    # 0x57040
ucomisd %xmm1, %xmm2
ja 0x3b00b
movsd (%r14), %xmm2
movsd 0x8(%r14), %xmm1
movapd %xmm1, -0x40(%rbp)
andpd 0x1c0eb(%rip), %xmm2    # 0x57010
divsd %xmm0, %xmm2
movapd %xmm2, -0x30(%rbp)
callq 0x3db2c
movapd -0x30(%rbp), %xmm0
ucomisd 0x1c108(%rip), %xmm0    # 0x57048
ja 0x3b007
movapd -0x40(%rbp), %xmm0
andpd 0x1c0bd(%rip), %xmm0    # 0x57010
divsd 0x3310(%rax), %xmm0
ucomisd 0x1c0e5(%rip), %xmm0    # 0x57048
ja 0x3b007
movapd %xmm0, -0x40(%rbp)
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x3db2c
movsd -0x20(%rbp), %xmm0
ucomisd 0x3300(%rax), %xmm0
xorpd %xmm3, %xmm3
ja 0x3b00b
callq 0x3db2c
leaq 0x3318(%rax), %rcx
addq $0x33e0, %rax           # imm = 0x33E0
testb %bl, %bl
cmoveq %rcx, %rax
movsd (%rax), %xmm1
movsd %xmm1, -0x20(%rbp)
movaps -0x30(%rbp), %xmm0
callq 0x98a0
movsd %xmm0, -0x30(%rbp)
movapd -0x40(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x98a0
addsd -0x30(%rbp), %xmm0
xorpd %xmm1, %xmm1
maxsd %xmm1, %xmm0
movsd 0x1c04f(%rip), %xmm3    # 0x57048
movapd %xmm3, %xmm1
minsd %xmm0, %xmm1
subsd %xmm1, %xmm3
jmp 0x3b00b
xorpd %xmm3, %xmm3
movapd %xmm3, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Plotter.cpp
// Function: Plotter::Init()
void Plotter::Init() {
#ifndef WIN32
  mIsDisplayOk = getenv("DISPLAY") != 0;

  if (PlayerParam::instance().UsePlotter()) {
    mpGnupolot = popen("gnuplot", "w");
  }

  if (mpGnupolot) {
    if (mIsDisplayOk) {
      GnuplotExecute("set terminal x11");
    }
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1ecc6(%rip), %rdi     # 0x59d10
callq 0x95e0
testq %rax, %rax
setne 0x8(%rbx)
callq 0x38d94
cmpb $0x0, 0x5c46(%rax)
je 0x3b07d
leaq 0x1ecad(%rip), %rdi     # 0x59d18
leaq 0x1f3d9(%rip), %rsi     # 0x5a44b
callq 0x91d0
movq %rax, 0x10(%rbx)
jmp 0x3b081
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x3b0a3
cmpb $0x1, 0x8(%rbx)
jne 0x3b0a3
leaq 0x1ec8d(%rip), %rsi     # 0x59d20
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3b18e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Plotter.cpp
// Function: Plotter::GnuplotExecute(char const*, ...)
void Plotter::GnuplotExecute(const char *cmd, ...) {
#ifndef WIN32
  if (!mpGnupolot)
    return;

  va_list ap;
  char local_cmd[GP_CMD_SIZE];

  va_start(ap, cmd);
  vsprintf(local_cmd, cmd, ap);
  va_end(ap);

  strcat(local_cmd, "\n");

  fputs(local_cmd, mpGnupolot);
  fflush(mpGnupolot);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x8d0, %rsp            # imm = 0x8D0
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x3b1d0
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
cmpq $0x0, 0x10(%rdi)
je 0x3b249
movq %rdi, %rbx
movabsq $0x3000000010, %rax     # imm = 0x3000000010
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
leaq -0xe0(%rbp), %rax
movq %rax, 0x10(%rdx)
leaq -0x8e0(%rbp), %r14
movq %r14, %rdi
callq 0x9250
movq %r14, %rdi
callq 0x9210
movw $0xa, -0x8e0(%rbp,%rax)
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x9540
movq 0x10(%rbx), %rdi
callq 0x9590
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::UpdateRoutine()
void PositionInfo::UpdateRoutine() {
  UpdateDistMatrix();
  UpdateOffsideLine();
  UpdateOppGoalInfo();

  /** 每个周期clear一次 */
  mPlayer2BallList.clear();
  mTeammate2BallList.clear();
  mOpponent2BallList.clear();

  for (int i = 0; i < 1 + 2 * TEAMSIZE; ++i) {
    mPlayer2PlayerList[i].clear();
    mTeammate2PlayerList[i].clear();
    mOpponent2PlayerList[i].clear();
  }

  mXSortTeammateList.clear();
  mXSortOpponentList.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3b4c6
movq %rbx, %rdi
callq 0x3b716
movq %rbx, %rdi
callq 0x3b97e
movq 0x10d8(%rbx), %rax
cmpq %rax, 0x10e0(%rbx)
je 0x3b417
movq %rax, 0x10e0(%rbx)
movq 0x10f0(%rbx), %rax
cmpq %rax, 0x10f8(%rbx)
je 0x3b42e
movq %rax, 0x10f8(%rbx)
movq 0x1108(%rbx), %rax
cmpq %rax, 0x1110(%rbx)
je 0x3b445
movq %rax, 0x1110(%rbx)
movq $-0x228, %rax           # imm = 0xFDD8
testq %rax, %rax
je 0x3b4a5
movq 0x1348(%rbx,%rax), %rcx
cmpq %rcx, 0x1350(%rbx,%rax)
je 0x3b46b
movq %rcx, 0x1350(%rbx,%rax)
movq 0x1570(%rbx,%rax), %rcx
cmpq %rcx, 0x1578(%rbx,%rax)
je 0x3b485
movq %rcx, 0x1578(%rbx,%rax)
movq 0x1798(%rbx,%rax), %rcx
cmpq %rcx, 0x17a0(%rbx,%rax)
je 0x3b49f
movq %rcx, 0x17a0(%rbx,%rax)
addq $0x18, %rax
jmp 0x3b44c
leaq 0x10a8(%rbx), %rdi
callq 0x3c86c
addq $0x10c0, %rbx           # imm = 0x10C0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3c86c
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::UpdateOppGoalInfo()
void PositionInfo::UpdateOppGoalInfo() {
  mOppGoal2Ball = Vector(ServerParam::instance().PITCH_LENGTH / 2.0, 0.0) -
                  mpWorldState->GetBall().GetPos();
  mOppLeftPost2Ball = ServerParam::instance().oppLeftGoalPost() -
                      mpWorldState->GetBall().GetPos();
  mOppRightPost2Ball = ServerParam::instance().oppRightGoalPost() -
                       mpWorldState->GetBall().GetPos();
  mOppGoal2BallAngle = mOppGoal2Ball.Dir();
  mOppLeftPost2BallAngle = mOppLeftPost2Ball.Dir();
  mOppRightPost2BallAngle = mOppRightPost2Ball.Dir();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x3db2c
leaq 0x1e530(%rip), %rax     # 0x59ec8
movsd (%rax), %xmm0
mulsd 0x1bea4(%rip), %xmm0    # 0x57848
movq 0x10(%rbx), %rax
subsd 0x38(%rax), %xmm0
xorpd %xmm1, %xmm1
subsd 0x40(%rax), %xmm1
leaq 0x18a8(%rbx), %r14
movsd %xmm0, 0x18a8(%rbx)
movsd %xmm1, 0x18b0(%rbx)
callq 0x3db2c
movq 0x10(%rbx), %rcx
movsd 0x3930(%rax), %xmm0
movsd 0x3938(%rax), %xmm1
subsd 0x38(%rcx), %xmm0
subsd 0x40(%rcx), %xmm1
leaq 0x18b8(%rbx), %r15
movsd %xmm0, 0x18b8(%rbx)
movsd %xmm1, 0x18c0(%rbx)
callq 0x3db2c
movq 0x10(%rbx), %rcx
movsd 0x3940(%rax), %xmm0
movsd 0x3948(%rax), %xmm1
subsd 0x38(%rcx), %xmm0
subsd 0x40(%rcx), %xmm1
leaq 0x18c8(%rbx), %r12
movsd %xmm0, 0x18c8(%rbx)
movsd %xmm1, 0x18d0(%rbx)
movq %r14, %rdi
callq 0xcd30
movsd %xmm0, 0x18d8(%rbx)
movq %r15, %rdi
callq 0xcd30
movsd %xmm0, 0x18e0(%rbx)
movq %r12, %rdi
callq 0xcd30
movsd %xmm0, 0x18e8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetXSortTeammate[abi:cxx11]()
const list<KeyPlayerInfo> &PositionInfo::GetXSortTeammate() {
  if (mXSortTeammateList.empty()) {
    KeyPlayerInfo kp;
    for (int i = 1; i <= TEAMSIZE; i++) {
      if (mpWorldState->GetTeammate(i).IsAlive() == true &&
          mpWorldState->GetTeammate(i).GetPosConf() > FLOAT_EPS) {
        kp.mUnum = i;
        kp.mValue = mpWorldState->GetTeammate(i).GetPos().X();
        mXSortTeammateList.push_back(kp);
      }
    }
    mXSortTeammateList.sort();
  }
  return mXSortTeammateList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10a8(%rdi), %rbx
cmpq %rbx, 0x10a8(%rdi)
jne 0x3bb6e
movq %rdi, %r14
leaq -0x38(%rbp), %r15
andl $0x0, (%r15)
andq $0x0, 0x8(%r15)
pushq $0x1
popq %r12
xorl %r13d, %r13d
movsd 0x1b534(%rip), %xmm1    # 0x57040
cmpq $0x1028, %r13           # imm = 0x1028
je 0x3bb66
movq 0x10(%r14), %rax
cmpb $0x1, 0x1ba(%rax,%r13)
jne 0x3bb5a
movsd 0xc8(%rax,%r13), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3bb5a
movl %r12d, -0x38(%rbp)
movsd 0xb0(%rax,%r13), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c88e
movsd 0x1b4e6(%rip), %xmm1    # 0x57040
addq $0x178, %r13            # imm = 0x178
incl %r12d
jmp 0x3bb0c
movq %rbx, %rdi
callq 0x3c89e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetXSortOpponent[abi:cxx11]()
const list<KeyPlayerInfo> &PositionInfo::GetXSortOpponent() {
  if (mXSortOpponentList.empty()) {
    KeyPlayerInfo kp;
    for (int i = 1; i <= TEAMSIZE; i++) {
      if (mpWorldState->GetOpponent(i).IsAlive() == true &&
          mpWorldState->GetOpponent(i).GetPosConf() > FLOAT_EPS) {
        kp.mUnum = i;
        kp.mValue = mpWorldState->GetOpponent(i).GetPos().X();
        mXSortOpponentList.push_back(kp);
      }
    }
    mXSortOpponentList.sort();
  }
  return mXSortOpponentList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10c0(%rdi), %rbx
cmpq %rbx, 0x10c0(%rdi)
jne 0x3bc26
movq %rdi, %r14
leaq -0x38(%rbp), %r15
andl $0x0, (%r15)
andq $0x0, 0x8(%r15)
pushq $0x1
popq %r12
xorl %r13d, %r13d
movsd 0x1b47c(%rip), %xmm1    # 0x57040
cmpq $0x1028, %r13           # imm = 0x1028
je 0x3bc1e
movq 0x10(%r14), %rax
cmpb $0x1, 0x11e2(%rax,%r13)
jne 0x3bc12
movsd 0x10f0(%rax,%r13), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3bc12
movl %r12d, -0x38(%rbp)
movsd 0x10d8(%rax,%r13), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c88e
movsd 0x1b42e(%rip), %xmm1    # 0x57040
addq $0x178, %r13            # imm = 0x178
incl %r12d
jmp 0x3bbc4
movq %rbx, %rdi
callq 0x3c89e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetClosePlayerToPoint(Vector const&, int const&) const
vector<Unum>
PositionInfo::GetClosePlayerToPoint(const Vector &bp,
                                    const Unum &exclude_unum) const {
  vector<pair<Unum, double>> tmp;

  for (vector<PlayerState *>::const_iterator it =
           mpWorldState->GetPlayerList().begin();
       it != mpWorldState->GetPlayerList().end(); ++it) {
    if ((*it)->IsAlive() && (*it)->GetPosConf() > FLOAT_EPS &&
        (*it)->GetUnum() != exclude_unum) { // 算距离自己的球员时把自己排除掉
      tmp.push_back(
          pair<Unum, double>((*it)->GetUnum(), (*it)->GetPos().Dist2(bp)));
    }
  }

  sort(tmp.begin(), tmp.end(), PlayerDistCompare());

  vector<Unum> ret;
  for (vector<pair<Unum, double>>::iterator it = tmp.begin(); it != tmp.end();
       ++it) {
    ret.push_back(it->first);
  }

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorpd %xmm0, %xmm0
leaq -0x40(%rbp), %rax
movapd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x10(%rsi), %rax
movq 0x20f8(%rax), %r13
movsd 0x1afdb(%rip), %xmm1    # 0x57040
cmpq 0x2100(%rax), %r13
je 0x3c0da
movq (%r13), %rdx
cmpb $0x1, 0x112(%rdx)
jne 0x3c0d4
movsd 0x20(%rdx), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3c0d4
movl 0x11c(%rdx), %ecx
cmpl (%r14), %ecx
je 0x3c0d4
movsd 0x8(%rdx), %xmm0
subsd (%r15), %xmm0
movsd 0x10(%rdx), %xmm1
subsd 0x8(%r15), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movl %ecx, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x18440
movq 0x10(%r12), %rax
movsd 0x1af6c(%rip), %xmm1    # 0x57040
addq $0x8, %r13
jmp 0x3c065
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3d304
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq -0x40(%rbp), %r14
cmpq -0x38(%rbp), %r14
je 0x3c10f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ca5e
addq $0x10, %r14
jmp 0x3c0f8
leaq -0x40(%rbp), %rdi
callq 0x18402
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c12c
movq %rax, %r14
jmp 0x3c13c
movq %rax, %r14
movq %rbx, %rdi
callq 0x13008
leaq -0x40(%rbp), %rdi
callq 0x18402
movq %r14, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetCloseTeammateToBall()
const vector<Unum> &PositionInfo::GetCloseTeammateToBall() {
  if (mTeammate2BallList.empty()) {
    const vector<Unum> &player2ball = GetClosePlayerToBall();
    for (vector<Unum>::const_iterator it = player2ball.begin();
         it != player2ball.end(); ++it) {
      if ((*it) > 0) {
        mTeammate2BallList.push_back(*it);
      }
    }
  }
  return mTeammate2BallList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x10f0(%rdi), %rbx
movq 0x10f0(%rdi), %rax
cmpq 0x10f8(%rdi), %rax
je 0x3c1dd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3c14e
movq %rax, %r14
movq (%rax), %r15
cmpq 0x8(%r14), %r15
je 0x3c1cf
cmpl $0x0, (%r15)
jle 0x3c1ff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ca5e
addq $0x4, %r15
jmp 0x3c1e8
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetCloseOpponentToBall()
const vector<Unum> &PositionInfo::GetCloseOpponentToBall() {
  if (mOpponent2BallList.empty()) {
    const vector<Unum> &player2ball = GetClosePlayerToBall();
    for (vector<Unum>::const_iterator it = player2ball.begin();
         it != player2ball.end(); ++it) {
      if ((*it) < 0) {
        mOpponent2BallList.push_back(-(*it));
      }
    }
  }
  return mOpponent2BallList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x1108(%rdi), %rbx
movq 0x1108(%rdi), %rax
cmpq 0x1110(%rdi), %rax
je 0x3c23c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3c14e
movq %rax, %r14
movq (%rax), %r12
leaq -0x24(%rbp), %r15
cmpq 0x8(%r14), %r12
je 0x3c22c
movl (%r12), %eax
testl %eax, %eax
jns 0x3c269
negl %eax
movl %eax, -0x24(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3da22
addq $0x4, %r12
jmp 0x3c24b
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetCloseOpponentToPoint(Vector const&)
vector<Unum> PositionInfo::GetCloseOpponentToPoint(const Vector &bp) {
  vector<Unum> opp2point;
  const vector<Unum> &player2ball = GetClosePlayerToPoint(bp);
  for (vector<Unum>::const_iterator it = player2ball.begin();
       it != player2ball.end(); ++it) {
    if ((*it) < 0) {
      opp2point.push_back(-(*it));
    }
  }

  return opp2point;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x1c(%rbp), %rcx
andl $0x0, (%rcx)
leaq -0x38(%rbp), %rdi
callq 0x3c024
movq -0x38(%rbp), %r15
leaq -0x1c(%rbp), %r14
cmpq -0x30(%rbp), %r15
je 0x3c2c6
movl (%r15), %eax
testl %eax, %eax
jns 0x3c2c0
negl %eax
movl %eax, -0x1c(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3da22
addq $0x4, %r15
jmp 0x3c2a3
leaq -0x38(%rbp), %rdi
callq 0x13008
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3c2ee
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x13008
movq %rbx, %rdi
callq 0x13008
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetClosePlayerToPlayer(int)
const vector<Unum> &PositionInfo::GetClosePlayerToPlayer(Unum i) {
  int index = Unum2Index(i);
  if (mPlayer2PlayerList[index].empty()) {
    mPlayer2PlayerList[index] =
        GetClosePlayerToPoint(mpWorldState->GetPlayer(i).GetPos(), i);
  }
  return mPlayer2PlayerList[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, -0x14(%rbp)
pushq $0xb
popq %rcx
subl %esi, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
leaq (%rdi,%rcx), %rbx
addq $0x1120, %rbx           # imm = 0x1120
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x3c391
movq %rdi, %rax
movq 0x10(%rdi), %rcx
testl %esi, %esi
jle 0x3c351
decl %esi
imulq $0x178, %rsi, %rdx      # imm = 0x178
addq %rcx, %rdx
addq $0xa8, %rdx
jmp 0x3c367
notl %esi
movslq %esi, %rdx
imulq $0x178, %rdx, %rdx      # imm = 0x178
addq %rcx, %rdx
addq $0x10d0, %rdx           # imm = 0x10D0
addq $0x8, %rdx
leaq -0x30(%rbp), %r14
leaq -0x14(%rbp), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3c024
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d9b6
movq %r14, %rdi
callq 0x13008
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetCloseTeammateToPlayer(int)
const vector<Unum> &PositionInfo::GetCloseTeammateToPlayer(Unum i) {
  int index = Unum2Index(i);
  if (mTeammate2PlayerList[index].empty()) {
    const vector<Unum> &player2player = GetClosePlayerToPlayer(i);
    for (vector<Unum>::const_iterator it = player2player.begin();
         it != player2player.end(); ++it) {
      if ((*it) > 0) {
        mTeammate2PlayerList[index].push_back(*it);
      }
    }
  }
  return mTeammate2PlayerList[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $0xb
popq %rax
subl %esi, %eax
testl %esi, %esi
cmovgl %esi, %eax
cltq
imulq $0x18, %rax, %rax
leaq (%rdi,%rax), %rbx
addq $0x1348, %rbx           # imm = 0x1348
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x3c3da
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3c2fe
movq %rax, %r14
movq (%rax), %r15
cmpq 0x8(%r14), %r15
je 0x3c3cc
cmpl $0x0, (%r15)
jle 0x3c3fc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ca5e
addq $0x4, %r15
jmp 0x3c3e5
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetCloseOpponentToPlayer(int)
const vector<Unum> &PositionInfo::GetCloseOpponentToPlayer(Unum i) {
  int index = Unum2Index(i);
  if (mOpponent2PlayerList[index].empty()) {
    const vector<Unum> &player2player = GetClosePlayerToPlayer(i);
    for (vector<Unum>::const_iterator it = player2player.begin();
         it != player2player.end(); ++it) {
      if ((*it) < 0) {
        mOpponent2PlayerList[index].push_back(-(*it));
      }
    }
  }
  return mOpponent2PlayerList[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
pushq $0xb
popq %rax
subl %esi, %eax
testl %esi, %esi
cmovgl %esi, %eax
cltq
imulq $0x18, %rax, %rax
leaq (%rdi,%rax), %rbx
addq $0x1570, %rbx           # imm = 0x1570
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x3c445
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3c2fe
movq %rax, %r14
movq (%rax), %r12
leaq -0x24(%rbp), %r15
cmpq 0x8(%r14), %r12
je 0x3c435
movl (%r12), %eax
testl %eax, %eax
jns 0x3c472
negl %eax
movl %eax, -0x24(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3da22
addq $0x4, %r12
jmp 0x3c454
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetPlayerWithBallList()
const vector<Unum> &PositionInfo::GetPlayerWithBallList() {
  if (mPlayerWithBallList_UpdateTime != mpWorldState->CurrentTime()) {
    mPlayerWithBallList.clear();
    if (GetClosePlayerToBall().size() > 0) {
      for (unsigned int i = 0; i < GetClosePlayerToBall().size(); ++i) {
        Unum unum = GetClosePlayerToBall()[i];
        if (mpWorldState->GetPlayer(unum).IsKickable()) {
          mPlayerWithBallList.push_back(unum);
        }
      }
    }
    mPlayerWithBallList_UpdateTime = mpWorldState->CurrentTime();
  }
  return mPlayerWithBallList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movl 0x17f4(%rdi), %ecx
cmpl 0x14(%rax), %ecx
jne 0x3c4a8
movl 0x10(%rax), %eax
cmpl %eax, 0x17f0(%rbx)
je 0x3c568
movq 0x17d8(%rbx), %rax
cmpq %rax, 0x17e0(%rbx)
je 0x3c4bf
movq %rax, 0x17e0(%rbx)
movq %rbx, %rdi
callq 0x3c14e
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x3c559
leaq 0x17d8(%rbx), %r14
xorl %r12d, %r12d
leaq -0x24(%rbp), %r15
movl %r12d, %r12d
movq %rbx, %rdi
callq 0x3c14e
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x3c559
movq %rbx, %rdi
callq 0x3c14e
movq (%rax), %rax
movl (%rax,%r12,4), %ecx
movl %ecx, -0x24(%rbp)
movq 0x10(%rbx), %rax
testl %ecx, %ecx
jle 0x3c52b
decl %ecx
imulq $0x178, %rcx, %rcx      # imm = 0x178
addq %rcx, %rax
addq $0xa8, %rax
jmp 0x3c540
notl %ecx
movslq %ecx, %rcx
imulq $0x178, %rcx, %rcx      # imm = 0x178
addq %rcx, %rax
addq $0x10d0, %rax           # imm = 0x10D0
cmpb $0x1, 0x128(%rax)
jne 0x3c554
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ca5e
incl %r12d
jmp 0x3c4e2
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x17f0(%rbx)
addq $0x17d8, %rbx           # imm = 0x17D8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetPlayerWithBall(double)
Unum PositionInfo::GetPlayerWithBall(const double buffer) {
  Unum tm_with_ball = GetTeammateWithBall(buffer);
  Unum opp_with_ball = GetOpponentWithBall(buffer);

  if (tm_with_ball > 0)
    return tm_with_ball;
  return -opp_with_ball;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
callq 0x3c5ba
movl %eax, %r14d
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x3c67a
negl %eax
testl %r14d, %r14d
cmovgl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetTeammateWithBall(double)
Unum PositionInfo::GetTeammateWithBall(const double buffer) {
  if (mpWorldState->GetBall().GetPosConf() < FLOAT_EPS) {
    return 0;
  }

  for (unsigned int i = 0; i < GetCloseTeammateToBall().size(); ++i) {
    Unum tm = GetCloseTeammateToBall()[i];
    if (mpWorldState->GetTeammate(tm).IsKickable(mpWorldState->GetBall(),
                                                 buffer)) {
      return tm;
    }
    if (GetBallDistToTeammate(tm) > 2.0)
      break; //（因为list是按距离顺序排好的，剩下的就不用了）
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, -0x30(%rbp)
movq 0x10(%rdi), %rcx
xorl %eax, %eax
movsd 0x1aa65(%rip), %xmm0    # 0x57040
ucomisd 0x50(%rcx), %xmm0
ja 0x3c66a
movq %rdi, %r14
leaq -0x30(%rbp), %r15
pushq $0xb
popq %r12
xorl %r13d, %r13d
movl %r13d, %r13d
movq %r14, %rdi
callq 0x3c1ae
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x3c664
movq %r14, %rdi
callq 0x3c1ae
movq (%rax), %rax
movslq (%rax,%r13,4), %rbx
movq 0x10(%r14), %rsi
imulq $0x178, %rbx, %rax      # imm = 0x178
leaq (%rax,%rsi), %rdi
addq $-0xd0, %rdi
addq $0x30, %rsi
movq %r15, %rdx
callq 0x3a44e
testb %al, %al
jne 0x3c668
movl %r12d, %eax
subl %ebx, %eax
testl %ebx, %ebx
cmovgl %ebx, %eax
cltq
movsd 0x20(%r14,%rax,8), %xmm0
incl %r13d
ucomisd 0x1b0f6(%rip), %xmm0    # 0x57758
jbe 0x3c5f4
xorl %eax, %eax
jmp 0x3c66a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetOpponentWithBall(double)
Unum PositionInfo::GetOpponentWithBall(const double buffer) {
  if (mpWorldState->GetBall().GetPosConf() < FLOAT_EPS) {
    return 0;
  }

  for (unsigned int i = 0; i < GetCloseOpponentToBall().size(); ++i) {
    Unum opp = GetCloseOpponentToBall()[i];
    if (mpWorldState->GetOpponent(opp).IsKickable(mpWorldState->GetBall(),
                                                  buffer)) {
      return opp;
    }
    if (GetBallDistToOpponent(opp) > 2.0)
      break;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, -0x30(%rbp)
movq 0x10(%rdi), %rax
xorl %ebx, %ebx
movsd 0x1a9a5(%rip), %xmm0    # 0x57040
ucomisd 0x50(%rax), %xmm0
ja 0x3c72d
movq %rdi, %r14
xorl %ebx, %ebx
leaq -0x30(%rbp), %r15
xorl %r12d, %r12d
movl %r12d, %r12d
movq %r14, %rdi
callq 0x3c206
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x3c72d
movq %r14, %rdi
callq 0x3c206
movq (%rax), %rax
movslq (%rax,%r12,4), %r13
movq 0x10(%r14), %rsi
imulq $0x178, %r13, %rax      # imm = 0x178
leaq (%rax,%rsi), %rdi
addq $0xf58, %rdi            # imm = 0xF58
addq $0x30, %rsi
movq %r15, %rdx
callq 0x3a44e
testb %al, %al
jne 0x3c72a
movl %r13d, %eax
negl %eax
leal 0xb(%r13), %ecx
testl %r13d, %r13d
cmovsl %eax, %ecx
movslq %ecx, %rax
movsd 0x20(%r14,%rax,8), %xmm0
incl %r12d
ucomisd 0x1b032(%rip), %xmm0    # 0x57758
jbe 0x3c6b2
jmp 0x3c72d
movl %r13d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/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 %ebx, %ebx
movsd 0x1a8ea(%rip), %xmm0    # 0x57040
ucomisd 0x50(%rax), %xmm0
ja 0x3c7b2
movq %rdi, %r14
callq 0x3c478
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x3c7b2
xorl %ebx, %ebx
xorl %eax, %eax
movl %eax, %r15d
movq %r14, %rdi
callq 0x3c478
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x3c7b2
movq %r14, %rdi
callq 0x3c478
movq (%rax), %rcx
leal 0x1(%r15), %eax
cmpl $0x0, (%rcx,%r15,4)
jle 0x3c772
movq %r14, %rdi
callq 0x3c478
movq (%rax), %rax
movl (%rax,%r15,4), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %ebx, %ebx
movsd 0x1a868(%rip), %xmm0    # 0x57040
ucomisd 0x50(%rax), %xmm0
ja 0x3c836
movq %rdi, %r14
callq 0x3c478
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x3c836
xorl %ebx, %ebx
xorl %eax, %eax
movl %eax, %r15d
movq %r14, %rdi
callq 0x3c478
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x3c836
movq %r14, %rdi
callq 0x3c478
movq (%rax), %rcx
leal 0x1(%r15), %eax
cmpl $0x0, (%rcx,%r15,4)
jns 0x3c7f4
movq %r14, %rdi
callq 0x3c478
movq (%rax), %rax
xorl %ebx, %ebx
subl (%rax,%r15,4), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x34298
movq 0x33f0(%r15), %rsi
movq %r15, %rdi
callq 0x343fa
movq %r15, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x34298
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3dc5a
nop