LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::GetSenseBallCycle()
int VisualSystem::GetSenseBallCycle() {
  if (mSenseBallCycle == 0) { //用拦截模型来算什么时候可以感知到球
    if (mVisualRequest[0].mValid) {
      if (mVisualRequest[0].PreDistance() <
          ServerParam::instance().visibleDistance()) {
        mSenseBallCycle = 1;
      } else {
        PlayerInterceptInfo int_info;
        VirtualSelf virtual_self(*mpSelfState);

        virtual_self.UpdateIsGoalie(
            false); //否则会用可扑范围代替感知范围计算截球

        int_info.mRes = IR_None;
        int_info.mpPlayer = &virtual_self;

        InterceptInfo::CalcTightInterception(*mpBallState, &int_info);

        mSenseBallCycle = int_info.mMinCycle;
        mSenseBallCycle = Max(mSenseBallCycle, 1);
      }
    } else {
      mSenseBallCycle = 1000;
    }
  }

  return mSenseBallCycle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
cmpl $0x0, 0x11c8(%rax)
jne 0xa8be8
movq -0x230(%rbp), %rdi
addq $0x30, %rdi
movl $0x0, -0xc(%rbp)
leaq -0xc(%rbp), %rsi
callq 0xa8fa0
testb $0x1, 0x10(%rax)
je 0xa8bd5
movq -0x230(%rbp), %rdi
addq $0x30, %rdi
movl $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xa8fa0
movq %rax, %rdi
callq 0xa9760
movsd %xmm0, -0x238(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x8b250
movsd -0x238(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa8aec
movq -0x230(%rbp), %rax
movl $0x1, 0x11c8(%rax)
jmp 0xa8bd3
leaq -0xa0(%rbp), %rdi
callq 0x4ac30
movq -0x230(%rbp), %rax
movq 0x20(%rax), %rsi
leaq -0x218(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0xa9930
movq -0x240(%rbp), %rdi
xorl %esi, %esi
callq 0x7d1a0
jmp 0xa8b26
movq -0x230(%rbp), %rax
movl $0x0, -0x14(%rbp)
leaq -0x218(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq 0x18(%rax), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x1, %edx
callq 0x49c90
jmp 0xa8b56
movq -0x230(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq %rax, %rdi
addq $0x11c8, %rdi           # imm = 0x11C8
movl %ecx, 0x11c8(%rax)
movl $0x1, -0x228(%rbp)
leaq -0x228(%rbp), %rsi
callq 0x329c0
movq %rax, -0x248(%rbp)
jmp 0xa8b8f
movq -0x230(%rbp), %rax
movq -0x248(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x11c8(%rax)
leaq -0x218(%rbp), %rdi
callq 0xa9970
jmp 0xa8bd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0xa9970
jmp 0xa8bfe
jmp 0xa8be6
movq -0x230(%rbp), %rax
movl $0x3e8, 0x11c8(%rax)    # imm = 0x3E8
jmp 0xa8be8
movq -0x230(%rbp), %rax
movl 0x11c8(%rax), %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0xaa60
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::ForceSearchBall()
bool VisualSystem::ForceSearchBall() {
  if (!mpSelfState->IsIdling() && !mVisualRequest[0].mValid) { // force to scan
    mpAgent->GetActionEffector().ResetForScan();

    if (NewSightComeCycle(VW_Wide) == 1) {
      mpAgent->ChangeView(VW_Wide);
    } else if (NewSightComeCycle(VW_Normal) == 1) {
      mpAgent->ChangeView(VW_Normal);
    } else {
      mpAgent->ChangeView(VW_Narrow);
    }

    mpAgent->Turn(sight::ViewAngle(VW_Narrow) - 5.0);

    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x20(%rax), %rdi
callq 0x332f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x15(%rbp)
jne 0xa8c59
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0xa8fa0
movb 0x10(%rax), %al
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xa8c65
jmp 0xa8d0d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x123a0
movq %rax, %rdi
callq 0xf810
movq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0xa9800
cmpl $0x1, %eax
jne 0xa8ca1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x3, %esi
callq 0xa94b0
jmp 0xa8cdc
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0xa9800
cmpl $0x1, %eax
jne 0xa8cc8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x2, %esi
callq 0xa94b0
jmp 0xa8cda
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0xa94b0
jmp 0xa8cdc
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x5be10
movq -0x28(%rbp), %rdi
movsd 0x18c72(%rip), %xmm1    # 0xc1970
subsd %xmm1, %xmm0
callq 0x10430
movb $0x1, -0x1(%rbp)
jmp 0xa8d11
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::SetForceSeePlayer(int)
void VisualSystem::SetForceSeePlayer(Unum i) {
  if (i != 0) {
    mForceToSeeObject[i] = true;
    mHighPriorityPlayerSet.insert(GetVisualRequest(i));

    Logger::instance().GetTextLogger("force_to_see")
        << mpWorldState->CurrentTime() << ": player " << i << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xa8de7
movq -0x30(%rbp), %rdi
addq $0x5f0, %rdi            # imm = 0x5F0
leaq -0xc(%rbp), %rsi
callq 0xa96f0
movq -0x30(%rbp), %rdi
movb $0x1, (%rax)
movq %rdi, %rax
addq $0x608, %rax            # imm = 0x608
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0xa9430
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xa93e0
movq %rax, -0x28(%rbp)
movb %dl, -0x20(%rbp)
callq 0x5add0
movq %rax, %rdi
leaq 0x1c932(%rip), %rsi     # 0xc56ca
callq 0x5b110
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rdi
callq 0x12100
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movq %rax, %rdi
leaq 0x1c917(%rip), %rsi     # 0xc56de
callq 0xa99e0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x2e850
movq %rax, %rdi
movq 0x551ce(%rip), %rsi     # 0xfdfb0
callq 0x1a7c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.h
// Function: VisualSystem::VisualRequest::UpdateEvaluation()
void UpdateEvaluation() {
      mFreq = Max(1.0, mFreq);
      mConf = Max(1.0 - (mCycleDelay / mFreq), 0.0);
      mScore = 1.0 - mConf;
      mScore = Max(mScore, 0.001);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movsd 0x17f74(%rip), %xmm0    # 0xc1010
movsd %xmm0, -0x10(%rbp)
addq $0x18, %rsi
leaq -0x10(%rbp), %rdi
callq 0x12a90
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
cvtsi2sdl 0x14(%rax), %xmm1
divsd 0x18(%rax), %xmm1
movsd 0x17f40(%rip), %xmm0    # 0xc1010
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12a90
movq -0x30(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd 0x17f0d(%rip), %xmm0    # 0xc1010
subsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x28(%rdi)
addq $0x28, %rdi
movsd 0x18fb7(%rip), %xmm0    # 0xc20d0
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x12a90
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::UpdatePredictInfo()
inline void VisualSystem::UpdatePredictInfo() {
  mPreBodyDir = mpAgent->GetSelfBodyDirWithQueuedActions();
  mPreSelfPos = mpAgent->GetSelfPosWithQueuedActions();

  const Unum kickale_player =
      mpAgent->GetInfoState().GetPositionInfo().GetPlayerWithBall();
  if (kickale_player != 0 && kickale_player != mpSelfState->GetUnum()) {
    mPreBallPos = mpBallState->GetPos();
  } else {
    mPreBallPos = mpAgent->GetBallPosWithQueuedActions();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rdi
callq 0xa9580
movq -0x38(%rbp), %rax
movsd %xmm0, 0x648(%rax)
movq 0x8(%rax), %rdi
callq 0xa9ee0
movq -0x38(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x660(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x668(%rax)
movq 0x8(%rax), %rdi
callq 0x2e810
movq %rax, %rdi
callq 0x49590
movq %rax, %rdi
callq 0xa9f20
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xa92a3
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movq 0x20(%rax), %rdi
callq 0x1b470
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
je 0xa92a3
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x650(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x658(%rax)
jmp 0xa92d4
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa9f80
movq -0x38(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x650(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x658(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.h
// Function: PositionInfo::GetClosestOpponentDistToBall()
double GetClosestOpponentDistToBall() {
    return GetClosestOpponentToBall() == 0
               ? HUGE_VALUE
               : mpWorldState->GetOpponent(GetClosestOpponentToBall())
                     .GetPos()
                     .Dist(mpWorldState->GetBall().GetPos());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1d4b0
cmpl $0x0, %eax
jne 0xa930d
movsd 0x18412(%rip), %xmm0    # 0xc1718
movsd %xmm0, -0x20(%rbp)
jmp 0xa936b
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x1d4b0
movq -0x30(%rbp), %rdi
movl %eax, -0xc(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x1d480
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rdi
callq 0x10570
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1d6d0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.h
// Function: sight::SightDelay(ViewWidth)
inline int SightDelay(ViewWidth view_width) {
  switch (view_width) {
  case VW_Narrow:
    return 1;
  case VW_Normal:
    return 2;
  case VW_Wide:
    return 3;
  default:
    Assert(0);
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0xaa018
jmp 0xaa004
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0xaa021
jmp 0xaa00e
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0xaa02a
jmp 0xaa033
movl $0x1, -0x4(%rbp)
jmp 0xaa03a
movl $0x2, -0x4(%rbp)
jmp 0xaa03a
movl $0x3, -0x4(%rbp)
jmp 0xaa03a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldModel.cpp
// Function: WorldModel::WorldModel()
WorldModel::WorldModel() {
  mpHistoryState[0] = new HistoryState;
  mpWorldState[0] = new WorldState(mpHistoryState[0]); //队友的世界状态

  mpHistoryState[1] = new HistoryState;
  mpWorldState[1] =
      new WorldState(mpHistoryState[1]); //供反算时用的，对手的世界状态
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x5312d(%rip), %rcx     # 0xfdd48
movq %rcx, (%rax)
movl $0x14b98, %edi          # imm = 0x14B98
callq 0xa5c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0xaaf10
jmp 0xaac39
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x2128, %edi           # imm = 0x2128
callq 0xa5c0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rsi
callq 0xab310
jmp 0xaac68
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x14b98, %edi          # imm = 0x14B98
callq 0xa5c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0xaaf10
jmp 0xaac8f
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x2128, %edi           # imm = 0x2128
callq 0xa5c0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq 0x20(%rax), %rsi
callq 0xab310
jmp 0xaacbe
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x14b98, %esi          # imm = 0x14B98
callq 0xa5e0
jmp 0xaad3e
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x2128, %esi           # imm = 0x2128
callq 0xa5e0
jmp 0xaad3e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x14b98, %esi          # imm = 0x14B98
callq 0xa5e0
jmp 0xaad3e
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x2128, %esi           # imm = 0x2128
callq 0xa5e0
movq -0x10(%rbp), %rdi
callq 0xaa60
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldModel.cpp
// Function: WorldModel::~WorldModel()
WorldModel::~WorldModel() {
  delete mpWorldState[0];
  delete mpHistoryState[0];

  delete mpWorldState[1];
  delete mpHistoryState[1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x52fcd(%rip), %rcx     # 0xfdd38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xaad8a
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xaadb3
movq -0x20(%rbp), %rdi
callq 0xaaf40
movq -0x20(%rbp), %rdi
movl $0x14b98, %esi          # imm = 0x14B98
callq 0xa5e0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xaadcf
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xaadf8
movq -0x30(%rbp), %rdi
callq 0xaaf40
movq -0x30(%rbp), %rdi
movl $0x14b98, %esi          # imm = 0x14B98
callq 0xa5e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldModel.cpp
// Function: WorldModel::Update(Observer*)
void WorldModel::Update(Observer *observer) {
  //存储一下当前的世界
  mpHistoryState[0]->UpdateHistory(*mpWorldState[0]);
  mpHistoryState[1]->UpdateHistory(*mpWorldState[1]);

  mpWorldState[0]->UpdateFromObserver(observer); //自己方决策使用的世界状态
  mpWorldState[1]->GetReverseFrom(
      mpWorldState[0]); //可供反算对手时使用的世界状态
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xbc450
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0xbc450
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xab640
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xab690
addq $0x20, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldState::GetHistory(int) const
WorldState *WorldState::GetHistory(int i) const {
  if (i == 0) {
    return const_cast<WorldState *>(this);
  } else if (i > HistoryState::HISTORY_SIZE) {
    return 0;
  }

  return mpHistory->GetHistory(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xab577
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xab59d
cmpl $0xa, -0x14(%rbp)
jle 0xab587
movq $0x0, -0x8(%rbp)
jmp 0xab59d
jmp 0xab589
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0xab5b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: HistoryState::GetHistory(int)
WorldState *HistoryState::GetHistory(int num) {
  Assert(num > 0);

  num = num % HISTORY_SIZE;
  num = (mNum + HISTORY_SIZE - num) % HISTORY_SIZE;

  return &mRecord[num];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl 0x14b90(%rdi), %eax
addl $0xa, %eax
subl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xbe620
addq $0x20, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldState::GetReverseFrom(WorldState*)
void WorldState::GetReverseFrom(WorldState *world_state) {
  mCurrentTime = world_state->CurrentTime();
  mPlayMode = world_state->GetPlayMode();
  mIsCycleStopped = world_state->mIsCycleStopped;
  mPlayModeTime = world_state->mPlayModeTime;

  mTeammateGoalieUnum = world_state->mOpponentGoalieUnum;
  mOpponentGoalieUnum = world_state->mTeammateGoalieUnum;

  mTeammateScore = world_state->mOpponentScore;
  mOpponentScore = world_state->mTeammateScore;

  Ball().GetReverseFrom(world_state->Ball());

  for (Unum i = 1; i <= TEAMSIZE; ++i) {
    Opponent(i).GetReverseFrom(world_state->Teammate(i));
    Teammate(i).GetReverseFrom(world_state->Opponent(i));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12100
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x10ed0
movq -0x28(%rbp), %rdi
movl %eax, 0x1c(%rdi)
movq -0x10(%rbp), %rax
movb 0x2120(%rax), %al
andb $0x1, %al
movb %al, 0x2120(%rdi)
movq -0x10(%rbp), %rax
movq 0x24(%rax), %rax
movq %rax, 0x24(%rdi)
movq -0x10(%rbp), %rax
movl 0x2114(%rax), %eax
movl %eax, 0x2110(%rdi)
movq -0x10(%rbp), %rax
movl 0x2110(%rax), %eax
movl %eax, 0x2114(%rdi)
movq -0x10(%rbp), %rax
movl 0x211c(%rax), %eax
movl %eax, 0x2118(%rdi)
movq -0x10(%rbp), %rax
movl 0x2118(%rax), %eax
movl %eax, 0x211c(%rdi)
callq 0x32f60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32f60
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xbc600
movl $0x1, -0x14(%rbp)
cmpl $0xb, -0x14(%rbp)
jg 0xab7b7
movq -0x28(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x5c5b0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x1a9d0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7c3f0
movq -0x28(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x1a9d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x5c5b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x7c3f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xab752
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::AutoDelay(int)
void WorldStateUpdater::AutoDelay(int delay_add) {
  // team均delay一周期
  for (Unum i = 1; i <= TEAMSIZE; i++) {
    mpWorldState->mTeammate[i].AutoUpdate(
        delay_add, PlayerParam::instance().playerConfDecay());
    mpWorldState->mOpponent[i].AutoUpdate(
        delay_add, PlayerParam::instance().playerConfDecay());
  }

  //球delay一周期
  Ball().AutoUpdate(delay_add, PlayerParam::instance().ballConfDecay());

  //特殊处理
  SelfState().UpdateBodyDir(SelfState().GetBodyDir(),
                            SelfState().GetBodyDirDelay(),
                            1.0); //认为自己的身体方向肯定是清楚的
  SelfState().UpdateVel(SelfState().GetVel(), SelfState().GetVelDelay(),
                        1.0); //认为自己的速度肯定是清楚的
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0x10(%rbp)
cmpl $0xb, -0x10(%rbp)
jg 0xadab4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0xa8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x1aa00
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0xbc8b0
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movsd (%rax), %xmm0
callq 0xbe0d0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x10d0, %rdi           # imm = 0x10D0
leaq -0x10(%rbp), %rsi
callq 0x1aa00
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0xbc8b0
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movsd (%rax), %xmm0
callq 0xbe0d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xada1e
movq -0x18(%rbp), %rdi
callq 0xbc760
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x5c(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0xbc890
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %esi
movsd (%rax), %xmm0
callq 0x14340
movq -0x18(%rbp), %rdi
callq 0xbc740
movq -0x18(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0xbc740
movq %rax, %rdi
callq 0x11170
movq -0x18(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
callq 0xbc740
movq %rax, %rdi
callq 0x5c650
movq -0x58(%rbp), %rdi
movsd -0x50(%rbp), %xmm0
movl %eax, %esi
movsd 0x134e1(%rip), %xmm1    # 0xc1010
callq 0x77ef0
movq -0x18(%rbp), %rdi
callq 0xbc740
movq -0x18(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0xbc740
movq %rax, %rdi
callq 0x10a80
movq -0x18(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0xbc740
movq %rax, %rdi
callq 0x28a30
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
movsd 0x13497(%rip), %xmm0    # 0xc1010
callq 0x142a0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::EstimateWorld(bool, int)
void WorldStateUpdater::EstimateWorld(bool is_estimate_to_now, int cycle) {
  /**预估自己的信息*/
  EstimateSelf(is_estimate_to_now, cycle);

  /**预估球的信息*/
  EstimateBall(is_estimate_to_now, cycle);

  /**预估球员的信息*/
  EstimatePlayers();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movb -0x9(%rbp), %al
movl -0x10(%rbp), %edx
andb $0x1, %al
movzbl %al, %esi
callq 0xb9ef0
movq -0x18(%rbp), %rdi
movb -0x9(%rbp), %al
movl -0x10(%rbp), %edx
andb $0x1, %al
movzbl %al, %esi
callq 0xba920
movq -0x18(%rbp), %rdi
callq 0xbb040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::UpdateSightDelay()
void WorldStateUpdater::UpdateSightDelay() {
  mSightDelay = mpObserver->CurrentTime() - mpObserver->LatestSightTime();
  mBallConf = ComputeConf(PlayerParam::instance().ballConfDecay(), mSightDelay);
  mPlayerConf =
      ComputeConf(PlayerParam::instance().playerConfDecay(), mSightDelay);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x11a70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0xbc870
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x9ed10
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
callq 0x798a0
movq %rax, %rdi
callq 0xbc890
movq -0x10(%rbp), %rdi
movsd (%rax), %xmm0
movl 0x28(%rdi), %esi
callq 0xb50e0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x20(%rax)
callq 0x798a0
movq %rax, %rdi
callq 0xbc8b0
movq -0x10(%rbp), %rdi
movsd (%rax), %xmm0
movl 0x28(%rdi), %esi
callq 0xb50e0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::UpdateKnownPlayers()
void WorldStateUpdater::UpdateKnownPlayers() {
  //暂时定队友的位置为最新的时间表示看到

  //更新看到的队友
  for (int i = 1; i <= TEAMSIZE; i++) {
    if (i == mSelfUnum) {
      continue;
    }

    if (mpObserver->Teammate(i).GetDir().time() ==
        mpObserver->LatestSightTime()) {
      UpdateSpecificPlayer(mpObserver->Teammate(i), i, true);
    }
  }

  //更新看到的对手
  for (int i = 1; i <= TEAMSIZE; i++) {
    if (mpObserver->Opponent(i).GetDir().time() ==
        mpObserver->LatestSightTime()) {
      UpdateSpecificPlayer(mpObserver->Opponent(i), i, false);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0xb, -0xc(%rbp)
jg 0xaf83a
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
jne 0xaf7c3
jmp 0xaf82c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xbd1a0
movq %rax, %rdi
callq 0xbd1d0
movq %rax, %rdi
callq 0x28aa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
callq 0xbc870
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x120a0
testb $0x1, %al
jne 0xaf807
jmp 0xaf82a
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xbd1a0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl -0xc(%rbp), %edx
movl $0x1, %ecx
callq 0xb5bc0
jmp 0xaf82c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xaf7ab
movl $0x1, -0x10(%rbp)
cmpl $0xb, -0x10(%rbp)
jg 0xaf8b8
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x10(%rbp), %esi
callq 0xbd1f0
movq %rax, %rdi
callq 0xbd1d0
movq %rax, %rdi
callq 0x28aa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq (%rax), %rdi
callq 0xbc870
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x120a0
testb $0x1, %al
jne 0xaf88b
jmp 0xaf8ab
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x10(%rbp), %esi
callq 0xbd1f0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl -0x10(%rbp), %edx
xorl %ecx, %ecx
callq 0xb5bc0
jmp 0xaf8ad
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xaf841
addq $0x30, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::EstimateToNow()
void WorldStateUpdater::EstimateToNow() {
  if (mSightDelay > 0 && mSightDelay <= HistoryState::HISTORY_SIZE) {
    //保存与sense相关的信息 主要有 mSelfVel mNeckDir
    const Vector &vel = SelfState().GetVel();

    SelfState().UpdateVel(
        mpWorldState->GetHistory(mSightDelay)->mTeammate[mSelfUnum].GetVel());
    int cycle = mSightDelay;
    for (int i = 0; i < cycle; i++) {
      EstimateWorld(true, cycle - i);
    }

    //恢复现场 此时应该看见了 delay可设置为0
    SelfState().UpdateVel(vel);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x28(%rax)
jle 0xb31dd
movq -0x20(%rbp), %rax
cmpl $0xa, 0x28(%rax)
jg 0xb31dd
movq -0x20(%rbp), %rdi
callq 0xbc740
movq %rax, %rdi
callq 0x10a80
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0xbc740
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rdi
movl 0x28(%rax), %esi
callq 0xab550
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0xa8, %rdi
addq $0x14, %rsi
callq 0x1aa00
movq %rax, %rdi
callq 0x10a80
movq -0x28(%rbp), %rdi
movq %rax, %rsi
xorl %edx, %edx
movsd 0xde8f(%rip), %xmm0     # 0xc1010
callq 0x142a0
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb31be
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
subl -0x18(%rbp), %edx
movl $0x1, %esi
callq 0xaee70
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb3197
movq -0x20(%rbp), %rdi
callq 0xbc740
movq %rax, %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
movsd 0xde38(%rip), %xmm0     # 0xc1010
callq 0x142a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::EvaluateConf()
void WorldStateUpdater::EvaluateConf() {
  for (int i = 1; i <= TEAMSIZE; i++) {
    if (i != mSelfUnum) {
      EvaluatePlayer(Teammate(i));
    }

    EvaluatePlayer(Opponent(i));
  }

  //根据delay置球员生死
  int dead_level = 100;
  for (int i = 1; i <= TEAMSIZE; i++) {
    if (i != mSelfUnum && GetTeammate(i).IsAlive()) {
      if (GetTeammate(i).GetPosDelay() > dead_level) {
        Teammate(i).SetIsAlive(false);
      }
    }

    if (GetOpponent(i).IsAlive()) {
      if (GetOpponent(i).GetPosDelay() > dead_level) {
        Opponent(i).SetIsAlive(false);
      }
    }
  }

  // evaluate ball
  EvaluateBall();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0xb, -0xc(%rbp)
jg 0xb42d8
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
je 0xb42b5
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbc780
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xbb390
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xbc7e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xbb390
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb428b
movl $0x64, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0xb, -0x14(%rbp)
jg 0xb43aa
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x14(%rcx), %eax
je 0xb434b
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbd640
movq %rax, %rdi
callq 0x23f20
testb $0x1, %al
jne 0xb4316
jmp 0xb434b
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbd640
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1ddd0
cmpl -0x10(%rbp), %eax
jle 0xb4349
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbc780
movq %rax, %rdi
xorl %esi, %esi
callq 0x288a0
jmp 0xb434b
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbd900
movq %rax, %rdi
callq 0x23f20
testb $0x1, %al
jne 0xb4365
jmp 0xb439a
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbd900
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1ddd0
cmpl -0x10(%rbp), %eax
jle 0xb4398
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbc7e0
movq %rax, %rdi
xorl %esi, %esi
callq 0x288a0
jmp 0xb439a
jmp 0xb439c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb42e6
movq -0x20(%rbp), %rdi
callq 0xbb590
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::ComputeConf(double, int)
double WorldStateUpdater::ComputeConf(double decay, int cycle) {
  if (cycle <= 0) {
    return 1;
  }

  double sum = 1;
  for (int i = 0; i < cycle; i++) {
    sum *= decay;
  }
  return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xb5105
movsd 0xbf12(%rip), %xmm0     # 0xc1010
movsd %xmm0, -0x8(%rbp)
jmp 0xb5145
movsd 0xbf03(%rip), %xmm0     # 0xc1010
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb513b
movsd -0x18(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb5119
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::GetSeenClosestTeammate()
Unum WorldStateUpdater::GetSeenClosestTeammate() {
  Unum num = 0;
  double min = 20000;
  for (int i = 1; i <= TEAMSIZE; i++) {
    if (i != mSelfUnum) {
      if (mpObserver->Teammate(i).GetDist().time() ==
          mpObserver->CurrentTime()) {
        if (mpObserver->Teammate(i).Dist() < min) {
          min = mpObserver->Teammate(i).Dist();
          num = i;
        }
      }
    }
  }

  return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
movsd 0xd775(%rip), %xmm0     # 0xc57a8
movsd %xmm0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
cmpl $0xb, -0x1c(%rbp)
jg 0xb80fd
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x14(%rcx), %eax
je 0xb80ed
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xbd1a0
movq %rax, %rdi
callq 0x28a90
movq %rax, %rdi
callq 0x28aa0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x11a70
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x120a0
testb $0x1, %al
jne 0xb809d
jmp 0xb80eb
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xbd1a0
movq %rax, %rdi
callq 0xbd3a0
movsd (%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb80e9
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xbd1a0
movq %rax, %rdi
callq 0xbd3a0
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xb80eb
jmp 0xb80ed
jmp 0xb80ef
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb803f
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::GetSeenClosestOpponent()
Unum WorldStateUpdater::GetSeenClosestOpponent() {
  Unum num = 0;
  double min = 20000;
  for (int i = 1; i <= TEAMSIZE; i++) {
    if (mpObserver->Opponent(i).GetDist().time() == mpObserver->CurrentTime()) {
      if (mpObserver->Opponent(i).Dist() < min) {
        min = mpObserver->Opponent(i).Dist();
        num = i;
      }
    }
  }

  return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
movsd 0xd675(%rip), %xmm0     # 0xc57a8
movsd %xmm0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
cmpl $0xb, -0x1c(%rbp)
jg 0xb81eb
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xbd1f0
movq %rax, %rdi
callq 0x28a90
movq %rax, %rdi
callq 0x28aa0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x11a70
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x120a0
testb $0x1, %al
jne 0xb818d
jmp 0xb81db
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xbd1f0
movq %rax, %rdi
callq 0xbd3a0
movsd (%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb81d9
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xbd1f0
movq %rax, %rdi
callq 0xbd3a0
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xb81db
jmp 0xb81dd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb813f
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::ComputePlayerMaxDist(PlayerState const&)
double WorldStateUpdater::ComputePlayerMaxDist(const PlayerState &state) {
  //计算最大的速度
  double max_speed = PlayerParam::instance()
                         .HeteroPlayer(state.GetPlayerType())
                         .effectiveSpeedMax();

  return max_speed * state.GetPosDelay();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x798a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a60
movq -0x30(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x29430
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1ddd0
movsd -0x28(%rbp), %xmm0
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::EvaluateBall()
void WorldStateUpdater::EvaluateBall() {
  // if drop ball just forget
  //
  if (mpWorldState->IsBallDropped() && Ball().GetPosDelay() != 0) {
    EvaluateForgetBall(true);
    return;
  }

  if (!mpObserver->IsNewSight()) {
    return;
  }

  if (Ball().GetPosDelay() != 0 && SelfState().GetPosDelay() == 0) {
    if (Ball().GetGuessedTimes() >= 100) {
      EvaluateForgetBall(false);
    } else {
      if (ShouldSee(Ball().GetPos())) {
        Ball().UpdateGuessedTimes(Ball().GetGuessedTimes() + 1);

        const Vector pos = GetNearSidePos(Ball().GetPos());

        Ball().UpdatePos(pos, Ball().GetPosDelay(), Ball().GetPosConf());

        Logger::instance().GetTextLogger("guess")
            << mpWorldState->CurrentTime() << ": guess ball out of view"
            << std::endl;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0xbcf20
testb $0x1, %al
jne 0xbb5b3
jmp 0xbb5e0
movq -0x20(%rbp), %rdi
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1ddd0
cmpl $0x0, %eax
je 0xbb5e0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xbb790
jmp 0xbb780
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x28a50
testb $0x1, %al
jne 0xbb5f5
jmp 0xbb780
movq -0x20(%rbp), %rdi
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1ddd0
cmpl $0x0, %eax
je 0xbb780
movq -0x20(%rbp), %rdi
callq 0xbc740
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1ddd0
cmpl $0x0, %eax
jne 0xbb780
movq -0x20(%rbp), %rdi
callq 0xbc760
movq %rax, %rdi
callq 0xbc9f0
cmpl $0x64, %eax
jl 0xbb657
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xbb790
jmp 0xbb77e
movq -0x20(%rbp), %rdi
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xbb8e0
testb $0x1, %al
jne 0xbb681
jmp 0xbb77c
movq -0x20(%rbp), %rdi
callq 0xbc760
movq -0x20(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0xbc760
movq %rax, %rdi
callq 0xbc9f0
movq -0x40(%rbp), %rdi
movl %eax, %esi
addl $0x1, %esi
callq 0xbc810
movq -0x20(%rbp), %rdi
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x20(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbba40
movq -0x20(%rbp), %rdi
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
callq 0xbc760
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1ddd0
movq -0x20(%rbp), %rdi
movl %eax, -0x2c(%rbp)
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1d930
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %edx
movsd (%rax), %xmm0
leaq -0x18(%rbp), %rsi
callq 0x142f0
callq 0x5add0
movq %rax, %rdi
leaq 0xa28c(%rip), %rsi      # 0xc59c5
callq 0x5b110
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rdi
callq 0x12100
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movq %rax, %rdi
leaq 0xa263(%rip), %rsi      # 0xc59cb
callq 0xbe450
movq %rax, %rdi
movq 0x42839(%rip), %rsi     # 0xfdfb0
callq 0x1a7c0
jmp 0xbb77e
jmp 0xbb780
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::EvaluateForgetBall(bool)
void WorldStateUpdater::EvaluateForgetBall(bool use_memory) {
  if (!use_memory) {
    Ball().UpdatePos(Vector(0, 0), Ball().GetPosDelay(), 0); // as WE2008
    Ball().UpdateVel(Vector(0, 0), Ball().GetPosDelay(), 0); // as WE2008
  }

  Ball().UpdateGuessedTimes(100);

  Logger::instance().GetTextLogger("forget")
      << mpWorldState->CurrentTime() << ": forget ball " << use_memory
      << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
testb $0x1, -0x9(%rbp)
jne 0xbb860
movq -0x58(%rbp), %rdi
callq 0xbc760
movq %rax, -0x68(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11a10
movq -0x58(%rbp), %rdi
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1ddd0
movq -0x68(%rbp), %rdi
movl %eax, %edx
leaq -0x20(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0x142f0
movq -0x58(%rbp), %rdi
callq 0xbc760
movq %rax, -0x60(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x11a10
movq -0x58(%rbp), %rdi
callq 0xbc760
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1ddd0
movq -0x60(%rbp), %rdi
movl %eax, %edx
leaq -0x40(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0x142a0
movq -0x58(%rbp), %rdi
callq 0xbc760
movq %rax, %rdi
movl $0x64, %esi
callq 0xbc810
callq 0x5add0
movq %rax, %rdi
leaq 0xa15f(%rip), %rsi      # 0xc59e4
callq 0x5b110
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rdi
callq 0x12100
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movq %rax, %rdi
leaq 0xa137(%rip), %rsi      # 0xc59eb
callq 0x1a810
movq %rax, %rdi
leaq -0x9(%rbp), %rsi
callq 0xbe4a0
movq %rax, %rdi
movq 0x426e1(%rip), %rsi     # 0xfdfb0
callq 0x1a7c0
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::ShouldSee(Vector const&)
bool WorldStateUpdater::ShouldSee(const Vector &pos) {
  if (!mpObserver->IsNewSight()) {
    return false;
  }

  const ViewWidth view_width = GetSelf().GetViewWidth();
  const AngleDeg view_angle = sight::ViewAngle(view_width);
  const AngleDeg left = GetSelf().GetNeckGlobalDir() - view_angle * 0.5;
  const AngleDeg right = left + view_angle;
  const Vector self_pos = SelfState().GetPos();
  const Vector rel_pos = (pos - self_pos);
  const double dist = rel_pos.Mod();

  return dist < ServerParam::instance().visibleDistance() - 0.1 ||
         IsAngleDegInBetween(left, rel_pos.Dir(), right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%rax), %rdi
callq 0x28a50
testb $0x1, %al
jne 0xbb910
movb $0x0, -0x1(%rbp)
jmp 0xbba2f
movq -0x70(%rbp), %rdi
callq 0xbcea0
movq %rax, %rdi
callq 0x11070
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x5be10
movq -0x70(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
callq 0xbcea0
movq %rax, %rdi
callq 0xa95b0
movq -0x70(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x56b3(%rip), %xmm2     # 0xc1020
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0xbc740
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x110a0
movsd %xmm0, -0x58(%rbp)
movsd %xmm1, -0x50(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x104e0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x8b250
movsd -0x80(%rbp), %xmm1
movsd (%rax), %xmm0
movsd 0x6b1a(%rip), %xmm2     # 0xc2510
subsd %xmm2, %xmm0
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x71(%rbp)
ja 0xbba27
leaq -0x58(%rbp), %rdi
callq 0x10520
movsd %xmm0, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x8ca70
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::EvaluateForgetPlayer(PlayerState&)
void WorldStateUpdater::EvaluateForgetPlayer(PlayerState &player) {
  // i think it will cause trouble with UpdateUnknownPlayer ,it need test.
  player.SetIsAlive(false);
  player.UpdatePos(Vector(0, 0), player.GetPosDelay(), 0);
  player.UpdateVel(Vector(0, 0), player.GetVelDelay(), 0);
  player.UpdateBodyDir(0, player.GetBodyDirDelay(), 0);
  player.UpdateNeckDir(0, player.GetNeckDirDelay(), 0);
  player.UpdateGuessedTimes(100);

  Logger::instance().GetTextLogger("forget")
      << mpWorldState->CurrentTime() << ": forget player " << player.GetUnum()
      << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x288a0
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11a10
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1ddd0
movq -0x90(%rbp), %rdi
movl %eax, %edx
leaq -0x20(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0x142f0
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x11a10
movq -0x10(%rbp), %rdi
callq 0x28a30
movq -0x88(%rbp), %rdi
movl %eax, %edx
leaq -0x40(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0x142a0
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5c650
movq -0x80(%rbp), %rdi
movl %eax, %esi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x77ef0
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5c670
movq -0x78(%rbp), %rdi
movl %eax, %esi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x77f60
movq -0x10(%rbp), %rdi
movl $0x64, %esi
callq 0xbc810
callq 0x5add0
movq %rax, %rdi
leaq 0x9ba5(%rip), %rsi      # 0xc59e4
callq 0x5b110
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rdi
callq 0x12100
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movq %rax, %rdi
leaq 0x9b9c(%rip), %rsi      # 0xc5a0a
callq 0xbe570
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b470
movq -0x60(%rbp), %rdi
movl %eax, -0x54(%rbp)
leaq -0x54(%rbp), %rsi
callq 0x2e850
movq %rax, %rdi
movq 0x42116(%rip), %rsi     # 0xfdfb0
callq 0x1a7c0
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::GetClosestOpponent()
Unum WorldStateUpdater::GetClosestOpponent() {
  double min_dist = 200000;
  int min_index = -1;
  for (int i = 1; i <= TEAMSIZE; i++) {
    if (GetOpponent(i).IsAlive()) {
      if ((GetOpponent(i).GetPos() - SelfState().GetPos()).Mod() < min_dist) {
        min_dist = (GetOpponent(i).GetPos() - SelfState().GetPos()).Mod();
        min_index = i;
      }
    }
  }
  return min_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd 0x985c(%rip), %xmm0     # 0xc5768
movsd %xmm0, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x18(%rbp)
cmpl $0xb, -0x18(%rbp)
jg 0xbc011
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbd900
movq %rax, %rdi
callq 0x23f20
testb $0x1, %al
jne 0xbbf46
jmp 0xbc001
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbd900
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x40(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0xbc740
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x104e0
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xbbfff
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbd900
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0xbc740
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x104e0
movsd %xmm0, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xbc001
jmp 0xbc003
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbbf1f
movl -0x14(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)