LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseCard(char*)
void Parser::ParseCard(char *msg) {
  CardType card_type;
  switch (msg[0]) {
  case 'y':
    card_type = CR_Yellow;
    break;
  case 'r':
    card_type = CR_Red;
    break;
  default:
    card_type = CR_None;
    break;
  }
  Unum player;

  if (msg[7] == 'd') {
    if (msg[9] == mpObserver->OurInitSide()) {
      player = parser::get_int(&msg);
      mpObserver->SetTeammateCardType(player, card_type);
    } else {
      player = parser::get_int(&msg);
      mpObserver->SetOpponentCardType(player, card_type);
    }
  } else {
    if (msg[12] == mpObserver->OurInitSide()) {
      player = parser::get_int(&msg);
      mpObserver->SetTeammateCardType(player, card_type);
    } else {
      player = parser::get_int(&msg);
      mpObserver->SetOpponentCardType(player, card_type);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, -0x20(%rbp)
movb (%rsi), %cl
movsbl %cl, %edx
addl $-0x30, %edx
cmpb $0x64, 0x7(%rsi)
movq 0x10(%rdi), %rsi
movb 0x28(%rsi), %sil
jne 0x43345
cmpb %sil, 0x9(%rax)
jne 0x43393
movl $0xc0, %r14d
cmpl $0xa, %edx
jb 0x4340d
movabsq $0x680000000001, %rdx   # imm = 0x680000000001
movl %ecx, %esi
cmpb $0x2e, %sil
ja 0x4332d
movzbl %sil, %esi
btq %rsi, %rdx
jb 0x43409
movb 0x1(%rax), %sil
incq %rax
movsbl %sil, %edi
addl $-0x30, %edi
cmpl $0xa, %edi
jae 0x43319
jmp 0x43409
cmpb %sil, 0xc(%rax)
jne 0x433cf
movl $0xc0, %r14d
cmpl $0xa, %edx
jb 0x4340d
movabsq $0x680000000001, %rdx   # imm = 0x680000000001
movl %ecx, %esi
cmpb $0x2e, %sil
ja 0x4337e
movzbl %sil, %esi
btq %rsi, %rdx
jb 0x43409
movb 0x1(%rax), %sil
incq %rax
movsbl %sil, %edi
addl $-0x30, %edi
cmpl $0xa, %edi
jae 0x4336a
jmp 0x43409
movl $0xec, %r14d
cmpl $0xa, %edx
jb 0x4340d
movabsq $0x680000000001, %rdx   # imm = 0x680000000001
movl %ecx, %esi
cmpb $0x2e, %sil
ja 0x433ba
movzbl %sil, %esi
btq %rsi, %rdx
jb 0x43409
movb 0x1(%rax), %sil
incq %rax
movsbl %sil, %edi
addl $-0x30, %edi
cmpl $0xa, %edi
jae 0x433aa
jmp 0x43409
movl $0xec, %r14d
cmpl $0xa, %edx
jb 0x4340d
movabsq $0x680000000001, %rdx   # imm = 0x680000000001
movl %ecx, %esi
cmpb $0x2e, %sil
ja 0x433f6
movzbl %sil, %esi
btq %rsi, %rdx
jb 0x43409
movb 0x1(%rax), %sil
incq %rax
movsbl %sil, %edi
addl $-0x30, %edi
cmpl $0xa, %edi
jae 0x433e6
movq %rax, -0x20(%rbp)
xorl %edx, %edx
cmpb $0x72, %cl
sete %dl
addl %edx, %edx
cmpb $0x79, %cl
movl $0x1, %r15d
cmovnel %edx, %r15d
leaq -0x20(%rbp), %rsi
movq %rax, %rdi
movl $0xa, %edx
callq 0x9680
addq 0x10(%rbx), %r14
shlq $0x20, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
sarq $0x1e, %rcx
movl %r15d, (%rcx,%r14)
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/Player.cpp
// Function: Player::SendOptionToServer()
void Player::SendOptionToServer() {
  while (!mpParser->IsClangOk()) {
    mpAgent->CheckCommands(mpObserver);
    mpAgent->Clang(7, 8);
    mpObserver->SetCommandSend();
    WaitFor(200);
  }

  while (!mpParser->IsSyncOk()) {
    mpAgent->CheckCommands(mpObserver);
    mpAgent->SynchSee();
    mpObserver->SetCommandSend();
    WaitFor(200);
  }

  mpAgent->CheckCommands(mpObserver);
  mpAgent->EarOff(false);
  mpObserver->SetCommandSend();
  WaitFor(200);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r15
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x4e01a
movb 0x4d(%r15), %r15b
movq %r14, %rdi
callq 0x4e036
testb %r15b, %r15b
jne 0x435f7
movq 0x8(%rbx), %r14
movq 0x18(%rbx), %rdi
movb 0x3382(%r14), %al
movb %al, 0x28(%rdi)
movq 0x1838(%r14), %rax
movq %rax, 0x2c(%rdi)
callq 0xee28
movq %rax, %rdi
movq %r14, %rsi
callq 0xd632
movq 0x18(%rbx), %rdi
callq 0xee28
movq %rax, %rdi
movl $0x7, %esi
movl $0x8, %edx
callq 0xc88a
movq 0x8(%rbx), %rdi
callq 0x3c2e6
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x9690
movq 0x20(%rbx), %r15
jmp 0x43579
movq 0x20(%rbx), %r15
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x4e01a
movb 0x4e(%r15), %r15b
movq %r14, %rdi
callq 0x4e036
testb %r15b, %r15b
jne 0x4368b
movq 0x8(%rbx), %r14
movq 0x18(%rbx), %rdi
movb 0x3382(%r14), %al
movb %al, 0x28(%rdi)
movq 0x1838(%r14), %rax
movq %rax, 0x2c(%rdi)
callq 0xee28
movq %rax, %rdi
movq %r14, %rsi
callq 0xd632
movq 0x18(%rbx), %rdi
callq 0xee28
movq %rax, %rdi
callq 0xc97a
movq 0x8(%rbx), %rdi
callq 0x3c2e6
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x9690
movq 0x20(%rbx), %r15
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x4e01a
movb 0x4e(%r15), %r15b
movq %r14, %rdi
callq 0x4e036
cmpb $0x1, %r15b
jne 0x43618
movq 0x8(%rbx), %r14
movq 0x18(%rbx), %rdi
movb 0x3382(%r14), %al
movb %al, 0x28(%rdi)
movq 0x1838(%r14), %rax
movq %rax, 0x2c(%rdi)
callq 0xee28
movq %rax, %rdi
movq %r14, %rsi
callq 0xd632
movq 0x18(%rbx), %rdi
callq 0xee28
movq %rax, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0xc920
movq 0x8(%rbx), %rdi
callq 0x3c2e6
movl $0x30d40, %edi          # imm = 0x30D40
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9690
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Player.cpp
// Function: Player::Run()
void Player::Run() {
  // TIMETEST("Run");

  static Time last_time = Time(-100, 0);

  mpObserver->Lock();

  /** 下面几个更新顺序不能变 */
  Formation::instance.SetTeammateFormations();
  CommunicateSystem::instance().Update(); //在这里解析hear信息，必须首先更新
  mpAgent->CheckCommands(mpObserver);
  mpWorldModel->Update(mpObserver);

  mpObserver->UnLock();

  const Time &time = mpAgent->GetWorldState().CurrentTime();

  if (last_time.T() >= 0) {
    if (time != Time(last_time.T() + 1, 0) &&
        time != Time(last_time.T(), last_time.S() + 1)) {
      if (time == last_time) {
        mpAgent->World().SetCurrentTime(
            Time(last_time.T(), last_time.S() + 1)); //否则决策数据更新会出问题
      }
    }
  }

  last_time = time;

  Formation::instance
      .UpdateOpponentRole(); // TODO:
                             // 暂时放在这里，教练未发来对手阵型信息时自己先计算

  VisualSystem::instance().ResetVisualRequest();
  mpDecisionTree->Decision(*mpAgent);

  VisualSystem::instance().Decision();
  CommunicateSystem::instance().Decision();

  if (ServerParam::instance().synchMode()) {
    mpAgent->Done();
  }

  mpAgent->SetHistoryActiveBehaviors();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x31805f(%rip), %al     # 0x35b760
testb %al, %al
je 0x43857
movl $0x3548, %r14d          # imm = 0x3548
movq 0x8(%rbx), %rdi
addq %r14, %rdi
callq 0x4e01a
leaq 0x4794e(%rip), %rdi     # 0x8b070
callq 0x27402
callq 0x1d004
movq %rax, %rdi
callq 0x1d538
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 0x18(%rbx), %rax
movq 0x18(%rax), %rax
movslq 0x317fcf(%rip), %rcx    # 0x35b758
testq %rcx, %rcx
js 0x437cd
leal 0x1(%rcx), %edi
movl 0x10(%rax), %edx
movl 0x14(%rax), %esi
xorl %edx, %edi
orl %esi, %edi
je 0x437cd
movl 0x317fb8(%rip), %r8d    # 0x35b75c
leal 0x1(%r8), %edi
movl %esi, %r9d
xorl %edi, %r9d
movl %edx, %r10d
xorl %ecx, %r10d
orl %r9d, %r10d
je 0x437cd
xorl %r8d, %esi
xorl %ecx, %edx
orl %esi, %edx
jne 0x437cd
shlq $0x20, %rdi
orq %rcx, %rdi
movq %rdi, 0x10(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x317f80(%rip)    # 0x35b758
leaq 0x47891(%rip), %rdi     # 0x8b070
callq 0x27486
callq 0x565ee
movq %rax, %rdi
callq 0x566a2
movq 0x18(%rbx), %rsi
movq 0x30(%rbx), %rdi
callq 0x222ac
callq 0x565ee
movq %rax, %rdi
callq 0x56846
callq 0x1d004
movq %rax, %rdi
callq 0x1e28a
callq 0x49360
cmpb $0x1, 0x32c9(%rax)
jne 0x43837
movq 0x18(%rbx), %rdi
callq 0xee28
movq %rax, %rdi
callq 0xc838
movq 0x18(%rbx), %rdi
callq 0xf204
callq 0x34c60
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35042
callq 0xa044
jmp 0x43709
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x40, %rsp
testq %rdx, %rdx
je 0x450b4
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, (%rdx)
leaq -0x58(%rbp), %r12
leaq -0x21(%rbp), %rdx
movq %r12, %rdi
callq 0x241d4
movq %r15, 0x20(%r12)
movl $0x1, 0x28(%r12)
testq %r14, %r14
je 0x4509b
movsbl (%r14), %eax
movb 0x1(%r14), %dl
testb %dl, %dl
je 0x4506c
addq $0x2, %r14
movsbl %dl, %edx
movl %eax, %ecx
shll $0x5, %ecx
subl %eax, %ecx
addl %edx, %ecx
movb (%r14), %dl
incq %r14
movl %ecx, %eax
testb %dl, %dl
jne 0x45052
jmp 0x4506e
movl %eax, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
leaq (%rcx,%rcx,2), %rax
leaq (%rbx,%rax,8), %rbx
addq $0x8, %rbx
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x45472
movq %rax, %rdi
movq %rbx, %rsi
callq 0x90b0
incq 0x10(%rbx)
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x450b4
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x94e0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x450dd
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x49360
movsd 0x3020(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x43dce
movq 0x5c38(%rax), %rax
movsd 0x3098(%rax), %xmm1
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x3c766
leaq 0x3d94c(%rip), %rax     # 0x82e68
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x98(%rbx)
movl $0x270f, %ecx           # imm = 0x270F
movl %ecx, 0xa0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%rbx)
movl %ecx, 0xb8(%rbx)
movq %rax, 0xc0(%rbx)
movups %xmm0, 0xd0(%rbx)
movq %rax, 0xe0(%rbx)
movl %ecx, 0xe8(%rbx)
movq %rax, 0xf0(%rbx)
movb $0x3f, 0xf8(%rbx)
movabsq $0x270f00000000, %rcx   # imm = 0x270F00000000
movq %rcx, 0xfc(%rbx)
movups %xmm0, 0x140(%rbx)
movb %al, 0x138(%rbx)
movl %eax, 0xcc(%rbx)
movw %ax, 0x120(%rbx)
movb %al, 0x122(%rbx)
movw %ax, 0x175(%rbx)
movq %rax, 0x130(%rbx)
movb %al, 0x128(%rbx)
movq %rax, 0x158(%rbx)
movl %eax, 0x114(%rbx)
movl %eax, 0x10f(%rbx)
movq %rax, 0x108(%rbx)
callq 0x49360
movsd 0x3048(%rax), %xmm0
movsd %xmm0, 0x78(%rbx)
callq 0x49360
movsd 0x3078(%rax), %xmm0
movsd %xmm0, 0x80(%rbx)
callq 0x49360
movsd 0x3390(%rax), %xmm0
movsd %xmm0, 0x88(%rbx)
callq 0x49360
movsd 0x3058(%rax), %xmm0
movsd %xmm0, 0x90(%rbx)
xorl %eax, %eax
movl %eax, 0xc8(%rbx)
movb %al, 0x150(%rbx)
movl %eax, 0x124(%rbx)
movq $0x2, 0x118(%rbx)
movb %al, 0x160(%rbx)
callq 0x43dce
movsd 0x5c60(%rax), %xmm0
movsd %xmm0, 0x168(%rbx)
movl $0x0, 0x170(%rbx)
movb $0x1, 0x174(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x3cd56(%rip), %rax     # 0x823d0
movq %rax, (%rbx)
movq 0x68(%rbx), %rdi
movl $0x670, %esi            # imm = 0x670
callq 0x94e0
movq %r14, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
xorl %eax, %eax
movsd 0x239a2(%rip), %xmm0    # 0x69040
ucomisd 0x20(%rsi), %xmm0
ja 0x456fa
ucomisd 0x20(%rdi), %xmm0
ja 0x456fa
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movsd 0x8(%rdi), %xmm0
subsd 0x8(%rsi), %xmm0
movsd 0x10(%rdi), %xmm1
subsd 0x10(%rsi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movsd (%rax), %xmm0
subsd (%rbx), %xmm0
ucomisd -0x10(%rbp), %xmm0
setae %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x58, %rsp
movsd %xmm0, -0x20(%rbp)
movl %esi, %ebx
leaq -0x68(%rbp), %rax
movsd %xmm1, (%rax)
movups 0x8(%rdi), %xmm0
movaps %xmm0, -0x60(%rbp)
movups 0x30(%rdi), %xmm0
movaps %xmm0, -0x50(%rbp)
movsd 0xb0(%rdi), %xmm0
movsd %xmm0, -0x40(%rbp)
cvttsd2si 0x78(%rdi), %ecx
movl %ecx, -0x38(%rbp)
movsd 0x80(%rdi), %xmm0
movsd %xmm0, -0x30(%rbp)
movl 0x114(%rdi), %ecx
movl %ecx, -0x28(%rbp)
movq %rax, %rdi
callq 0x22022
testl %ebx, %ebx
jle 0x45cda
movl %eax, %r14d
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movsd -0x20(%rbp), %xmm0
movl %r14d, %esi
callq 0x4ad88
decl %ebx
jne 0x45cc6
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x58, %rsp
movsd %xmm0, -0x20(%rbp)
movl %esi, %ebx
leaq -0x68(%rbp), %rax
movsd %xmm1, (%rax)
movups 0x8(%rdi), %xmm0
movaps %xmm0, -0x60(%rbp)
movups 0x30(%rdi), %xmm0
movaps %xmm0, -0x50(%rbp)
movsd 0xb0(%rdi), %xmm0
movsd %xmm0, -0x40(%rbp)
cvttsd2si 0x78(%rdi), %ecx
movl %ecx, -0x38(%rbp)
movsd 0x80(%rdi), %xmm0
movsd %xmm0, -0x30(%rbp)
movl 0x114(%rdi), %ecx
movl %ecx, -0x28(%rbp)
movq %rax, %rdi
callq 0x22022
testl %ebx, %ebx
jle 0x45d6e
movl %eax, %r14d
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movsd -0x20(%rbp), %xmm0
movl %r14d, %esi
callq 0x4ad88
decl %ebx
jne 0x45d5a
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x30, %rsp
movaps %xmm0, -0x10(%rbp)
movsd 0x78(%rdi), %xmm0
movsd 0x88(%rdi), %xmm1
movapd %xmm0, -0x30(%rbp)
addsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
callq 0x43dce
movsd 0x5c60(%rax), %xmm0
addsd 0x23280(%rip), %xmm0    # 0x69040
ucomisd -0x18(%rbp), %xmm0
jbe 0x45dd1
movapd -0x10(%rbp), %xmm0
jmp 0x45e60
xorpd %xmm1, %xmm1
movapd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x45e3b
xorpd 0x23238(%rip), %xmm0    # 0x69020
movapd %xmm0, -0x10(%rbp)
callq 0x43dce
movapd -0x30(%rbp), %xmm1
subsd 0x5c60(%rax), %xmm1
mulsd 0x23a71(%rip), %xmm1    # 0x69878
minsd -0x10(%rbp), %xmm1
movapd 0x2320c(%rip), %xmm0    # 0x69020
xorpd %xmm1, %xmm0
cmpltsd %xmm0, %xmm1
movapd %xmm0, %xmm2
movsd 0x25157(%rip), %xmm0    # 0x6af80
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x45e60
callq 0x43dce
movapd -0x30(%rbp), %xmm0
subsd 0x5c60(%rax), %xmm0
minsd -0x10(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x45e60
xorpd %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %rbx
movsd 0x8(%rdi), %xmm0
movsd 0x10(%rdi), %xmm1
subsd (%rsi), %xmm0
subsd 0x8(%rsi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movsd (%rax), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x46175
movsd 0x22ee5(%rip), %xmm0    # 0x69058
jmp 0x461d2
leaq 0x8(%rbx), %r15
cmpb $0x1, 0x175(%rbx)
jne 0x461b6
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x461de
movsd %xmm0, -0x28(%rbp)
addq $0xb0, %rbx
leaq -0x1a(%rbp), %rcx
movb $0x0, (%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x463b9
maxsd -0x28(%rbp), %xmm0
jmp 0x461d2
addq $0xb0, %rbx
leaq -0x19(%rbp), %rcx
movb $0x0, (%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x463b9
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/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 0x43dce
movq 0x5c38(%rax), %rax
movslq 0x114(%r14), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd 0x3088(%rax,%rcx), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x49360
movsd -0x28(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x4623e
movsd 0x31c0(%rax), %xmm1
jmp 0x463ac
movsd 0x31b0(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x43dce
movq 0x5c38(%rax), %rax
movslq 0x114(%r14), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd 0x23513(%rip), %xmm0    # 0x69780
subsd 0x3070(%rax,%rcx), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x49360
movsd 0x31b0(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x43dce
movq 0x5c38(%rax), %rax
movslq 0x114(%r14), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd -0x18(%rbp), %xmm2
mulsd 0x3070(%rax,%rcx), %xmm2
movsd 0x22d7e(%rip), %xmm0    # 0x69040
addsd -0x28(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm0
ja 0x463ac
movsd %xmm2, -0x18(%rbp)
movsd (%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x49360
movsd 0x31b8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x49360
movsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd 0x31b8(%rax), %xmm1
mulsd 0x25a14(%rip), %xmm1    # 0x6bd28
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4632c
sqrtsd %xmm0, %xmm0
jmp 0x46335
callq 0x93c0
xorpd %xmm1, %xmm1
movsd -0x18(%rbp), %xmm2
ucomisd %xmm2, %xmm0
ja 0x463ac
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x49360
movsd 0x31c0(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x49360
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 0x49360
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2576a(%rip), %rdi     # 0x6bd30
callq 0x95e0
testq %rax, %rax
setne 0x8(%rbx)
callq 0x43dce
cmpb $0x0, 0x5c46(%rax)
je 0x465f9
leaq 0x25751(%rip), %rdi     # 0x6bd38
leaq 0x25e7d(%rip), %rsi     # 0x6c46b
callq 0x91b0
movq %rax, 0x10(%rbx)
jmp 0x465fd
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x4661f
cmpb $0x1, 0x8(%rbx)
jne 0x4661f
leaq 0x25731(%rip), %rsi     # 0x6bd40
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x46722
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x46a56
movq %rbx, %rdi
callq 0x46cfe
movq %rbx, %rdi
callq 0x46f6e
movq 0x10d8(%rbx), %rax
cmpq %rax, 0x10e0(%rbx)
je 0x469ab
movq %rax, 0x10e0(%rbx)
movq 0x10f0(%rbx), %rax
cmpq %rax, 0x10f8(%rbx)
je 0x469c2
movq %rax, 0x10f8(%rbx)
movq 0x1108(%rbx), %rax
cmpq %rax, 0x1110(%rbx)
je 0x469d9
movq %rax, 0x1110(%rbx)
movq $-0x228, %rax           # imm = 0xFDD8
movq 0x1348(%rbx,%rax), %rcx
cmpq %rcx, 0x1350(%rbx,%rax)
je 0x469fa
movq %rcx, 0x1350(%rbx,%rax)
movq 0x1570(%rbx,%rax), %rcx
cmpq %rcx, 0x1578(%rbx,%rax)
je 0x46a14
movq %rcx, 0x1578(%rbx,%rax)
movq 0x1798(%rbx,%rax), %rcx
cmpq %rcx, 0x17a0(%rbx,%rax)
je 0x46a2e
movq %rcx, 0x17a0(%rbx,%rax)
addq $0x18, %rax
jne 0x469e0
leaq 0x10a8(%rbx), %rdi
callq 0x4829e
addq $0x10c0, %rbx           # imm = 0x10C0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4829e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x49360
leaq 0x24f60(%rip), %rax     # 0x6bee8
movsd (%rax), %xmm0
mulsd 0x228e4(%rip), %xmm0    # 0x69878
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 0x49360
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 0x49360
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 0xe702
movsd %xmm0, 0x18d8(%rbx)
movq %r15, %rdi
callq 0xe702
movsd %xmm0, 0x18e0(%rbx)
movq %r12, %rdi
callq 0xe702
movsd %xmm0, 0x18e8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x10a8(%rdi), %rbx
cmpq %rbx, 0x10a8(%rdi)
jne 0x4716e
movq %rdi, %r14
movl $0x1, %r15d
xorl %r12d, %r12d
movsd 0x21f4d(%rip), %xmm1    # 0x69040
movq 0x10(%r14), %rax
cmpb $0x1, 0x1ba(%rax,%r12)
jne 0x47153
movsd 0xc8(%rax,%r12), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x47153
movsd 0xb0(%rax,%r12), %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x20, %edi
callq 0x94c0
movl %r15d, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x90b0
movsd 0x21ef4(%rip), %xmm1    # 0x69040
incq 0x10b8(%r14)
addq $0x178, %r12            # imm = 0x178
incl %r15d
cmpq $0x1028, %r12           # imm = 0x1028
jne 0x470f3
movq %rbx, %rdi
callq 0x482da
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x10c0(%rdi), %rbx
cmpq %rbx, 0x10c0(%rdi)
jne 0x47230
movq %rdi, %r14
movl $0x1, %r15d
xorl %r12d, %r12d
movsd 0x21e8b(%rip), %xmm1    # 0x69040
movq 0x10(%r14), %rax
cmpb $0x1, 0x11e2(%rax,%r12)
jne 0x47215
movsd 0x10f0(%rax,%r12), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x47215
movsd 0x10d8(%rax,%r12), %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x20, %edi
callq 0x94c0
movl %r15d, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x90b0
movsd 0x21e32(%rip), %xmm1    # 0x69040
incq 0x10d0(%r14)
addq $0x178, %r12            # imm = 0x178
incl %r15d
cmpq $0x1028, %r12           # imm = 0x1028
jne 0x471b5
movq %rbx, %rdi
callq 0x482da
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq 0x10(%rsi), %rax
movq 0x20f8(%rax), %r13
cmpq 0x2100(%rax), %r13
je 0x4792b
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq (%r13), %rdx
cmpb $0x1, 0x112(%rdx)
jne 0x47878
movsd 0x20(%rdx), %xmm0
ucomisd 0x2182a(%rip), %xmm0    # 0x69040
jbe 0x47878
movl 0x11c(%rdx), %ecx
cmpl (%r14), %ecx
je 0x47878
movsd 0x8(%rdx), %xmm0
movsd 0x10(%rdx), %xmm1
subsd (%r15), %xmm0
subsd 0x8(%r15), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movl %ecx, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x47866
movupd -0x50(%rbp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, -0x38(%rbp)
jmp 0x47873
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x1c5f0
movq 0x10(%r12), %rax
addq $0x8, %r13
cmpq 0x2100(%rax), %r13
jne 0x477fc
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %r15
cmpq %r15, %r14
je 0x478cb
movq %r15, %rax
subq %r14, %rax
sarq $0x4, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x48c6e
movq %r14, %rdi
movq %r15, %rsi
callq 0x48d79
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %r15
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
cmpq %r15, %r14
je 0x47915
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x478f9
movl (%r14), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x47908
movq %rbx, %rdi
movq %r14, %rdx
callq 0x49144
movq -0x38(%rbp), %r15
addq $0x10, %r14
cmpq %r15, %r14
jne 0x478e0
movq -0x40(%rbp), %r14
testq %r14, %r14
je 0x47937
movq -0x30(%rbp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x94e0
jmp 0x47937
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4794b
movq %rax, %r14
jmp 0x47967
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x47967
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x94e0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4797c
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x94e0
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
leaq 0x10f0(%rdi), %rbx
movq 0x10f0(%rdi), %rax
cmpq 0x10f8(%rdi), %rax
jne 0x47ab4
movq %rdi, %r14
callq 0x47984
movq (%rax), %r12
cmpq 0x8(%rax), %r12
je 0x47ab4
movq %rax, %r15
movl (%r12), %eax
testl %eax, %eax
jle 0x47aaa
movq 0x10f8(%r14), %rsi
cmpq 0x1100(%r14), %rsi
je 0x47a9f
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10f8(%r14)
jmp 0x47aaa
movq %rbx, %rdi
movq %r12, %rdx
callq 0x49144
addq $0x4, %r12
cmpq 0x8(%r15), %r12
jne 0x47a78
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1108(%rdi), %rbx
movq 0x1108(%rdi), %rax
cmpq 0x1110(%rdi), %rax
jne 0x47b44
movq %rdi, %r14
callq 0x47984
movq %rax, %r15
movq (%rax), %r13
movq 0x8(%rax), %rax
cmpq %rax, %r13
je 0x47b44
leaq -0x2c(%rbp), %r12
movl (%r13), %ecx
testl %ecx, %ecx
jns 0x47b3b
negl %ecx
movl %ecx, -0x2c(%rbp)
movq 0x1110(%r14), %rsi
cmpq 0x1118(%r14), %rsi
je 0x47b2c
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x1110(%r14)
jmp 0x47b37
movq %rbx, %rdi
movq %r12, %rdx
callq 0x49284
movq 0x8(%r15), %rax
addq $0x4, %r13
cmpq %rax, %r13
jne 0x47b00
movq %rbx, %rax
addq $0x8, %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/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)
movq $0x0, 0x10(%rdi)
leaq -0x1c(%rbp), %rcx
movl $0x0, (%rcx)
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x477b6
movq (%r15), %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x47bd8
leaq -0x1c(%rbp), %r15
movl (%r14), %ecx
testl %ecx, %ecx
jns 0x47bcb
negl %ecx
movl %ecx, -0x1c(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x47bbc
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x47bcb
movq %rbx, %rdi
movq %r15, %rdx
callq 0x49284
movq -0x30(%rbp), %rax
addq $0x4, %r14
cmpq %rax, %r14
jne 0x47b9a
movq -0x38(%rbp), %r14
testq %r14, %r14
je 0x47bec
movq -0x28(%rbp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x94e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x47c12
movq -0x28(%rbp), %rsi
subq %rdi, %rsi
callq 0x94e0
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0xa17e
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl $0xb, %ecx
subl %esi, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdi,%rcx,8), %rbx
addq $0x1120, %rbx           # imm = 0x1120
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x47c67
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rax
movq 0x10(%rdi), %rcx
testl %esi, %esi
jle 0x47c87
decl %esi
imulq $0x178, %rsi, %rdx      # imm = 0x178
addq %rcx, %rdx
addq $0xa8, %rdx
jmp 0x47c9d
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 0x477b6
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x47c5b
subq %rdi, %rsi
callq 0x94e0
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x47c5b
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x94e0
jmp 0x47c5b
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0xb, %eax
subl %esi, %eax
testl %esi, %esi
cmovgl %esi, %eax
cltq
leaq (%rax,%rax,2), %rax
leaq (%rdi,%rax,8), %rbx
addq $0x1348, %rbx           # imm = 0x1348
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x47d83
callq 0x47c26
movq (%rax), %r15
cmpq 0x8(%rax), %r15
je 0x47d83
movq %rax, %r14
movl (%r15), %eax
testl %eax, %eax
jle 0x47d79
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x47d6e
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x47d79
movq %rbx, %rdi
movq %r15, %rdx
callq 0x49144
addq $0x4, %r15
cmpq 0x8(%r14), %r15
jne 0x47d51
movq %rbx, %rax
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::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
movl $0xb, %eax
subl %esi, %eax
testl %esi, %esi
cmovgl %esi, %eax
cltq
leaq (%rax,%rax,2), %rax
leaq (%rdi,%rax,8), %rbx
addq $0x1570, %rbx           # imm = 0x1570
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x47e1a
callq 0x47c26
movq %rax, %r14
movq (%rax), %r12
movq 0x8(%rax), %rax
cmpq %rax, %r12
je 0x47e1a
leaq -0x24(%rbp), %r15
movl (%r12), %ecx
testl %ecx, %ecx
jns 0x47e11
negl %ecx
movl %ecx, -0x24(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x47e02
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x47e0d
movq %rbx, %rdi
movq %r15, %rdx
callq 0x49284
movq 0x8(%r14), %rax
addq $0x4, %r12
cmpq %rax, %r12
jne 0x47ddf
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movl 0x17f4(%rdi), %ecx
cmpl 0x14(%rax), %ecx
jne 0x47e59
movl 0x10(%rax), %eax
cmpl %eax, 0x17f0(%rbx)
je 0x47f5a
movq 0x17d8(%rbx), %rax
cmpq %rax, 0x17e0(%rbx)
je 0x47e70
movq %rax, 0x17e0(%rbx)
movq %rbx, %rdi
callq 0x47984
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x47f4b
movq %rbx, %rdi
callq 0x47984
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x47f4b
leaq 0x17d8(%rbx), %r14
movl $0x1, %r12d
xorl %r13d, %r13d
leaq -0x2c(%rbp), %r15
movq %rbx, %rdi
callq 0x47984
movq (%rax), %rax
movl (%rax,%r13,4), %eax
movl %eax, -0x2c(%rbp)
movq 0x10(%rbx), %rcx
testl %eax, %eax
jle 0x47ede
leal -0x1(%rax), %edx
imulq $0x178, %rdx, %rdx      # imm = 0x178
addq %rdx, %rcx
addq $0xa8, %rcx
jmp 0x47ef6
movl %eax, %edx
notl %edx
movslq %edx, %rdx
imulq $0x178, %rdx, %rdx      # imm = 0x178
addq %rdx, %rcx
addq $0x10d0, %rcx           # imm = 0x10D0
cmpb $0x1, 0x128(%rcx)
jne 0x47f29
movq 0x17e0(%rbx), %rsi
cmpq 0x17e8(%rbx), %rsi
je 0x47f1e
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x17e0(%rbx)
jmp 0x47f29
movq %r14, %rdi
movq %r15, %rdx
callq 0x49144
movl %r12d, %r13d
movq %rbx, %rdi
callq 0x47984
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
incl %r12d
cmpq %r13, %rcx
ja 0x47eae
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x17f0(%rbx)
addq $0x17d8, %rbx           # imm = 0x17D8
movq %rbx, %rax
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/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 0x47fae
movl %eax, %r14d
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x48086
negl %eax
testl %r14d, %r14d
cmovgl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
xorl %r14d, %r14d
movsd 0x21070(%rip), %xmm0    # 0x69040
ucomisd 0x50(%rax), %xmm0
ja 0x48074
movq %rdi, %rbx
callq 0x47a42
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x48074
movl $0x1, %r12d
xorl %r13d, %r13d
leaq -0x30(%rbp), %r15
movq %rbx, %rdi
callq 0x47a42
movq (%rax), %rax
movslq (%rax,%r13,4), %r14
movq 0x10(%rbx), %rsi
imulq $0x178, %r14, %rax      # imm = 0x178
leaq (%rax,%rsi), %rdi
addq $-0xd0, %rdi
addq $0x30, %rsi
movq %r15, %rdx
callq 0x45694
testb %al, %al
jne 0x48074
movl $0xb, %eax
subl %r14d, %eax
testl %r14d, %r14d
cmovgl %r14d, %eax
cltq
movsd 0x20(%rbx,%rax,8), %xmm0
xorl %r14d, %r14d
ucomisd 0x2172c(%rip), %xmm0    # 0x69780
ja 0x48074
movl %r12d, %r13d
movq %rbx, %rdi
callq 0x47a42
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
incl %r12d
cmpq %r13, %rcx
ja 0x47ffd
movl %r14d, %eax
addq $0x8, %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/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 %r14d, %r14d
movsd 0x20f98(%rip), %xmm0    # 0x69040
ucomisd 0x50(%rax), %xmm0
ja 0x4814d
movq %rdi, %rbx
callq 0x47ac0
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x4814d
movl $0x1, %r12d
xorl %r13d, %r13d
leaq -0x30(%rbp), %r15
movq %rbx, %rdi
callq 0x47ac0
movq (%rax), %rax
movslq (%rax,%r13,4), %r14
movq 0x10(%rbx), %rsi
imulq $0x178, %r14, %rax      # imm = 0x178
leaq (%rax,%rsi), %rdi
addq $0xf58, %rdi            # imm = 0xF58
addq $0x30, %rsi
movq %r15, %rdx
callq 0x45694
testb %al, %al
jne 0x4814d
movl %r14d, %eax
negl %eax
leal 0xb(%r14), %ecx
testl %r14d, %r14d
cmovsl %eax, %ecx
movslq %ecx, %rax
movsd 0x20(%rbx,%rax,8), %xmm0
xorl %r14d, %r14d
ucomisd 0x21653(%rip), %xmm0    # 0x69780
ja 0x4814d
movl %r12d, %r13d
movq %rbx, %rdi
callq 0x47ac0
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x2, %rcx
incl %r12d
cmpq %r13, %rcx
ja 0x480d5
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop