LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::Initialize()
void Observer::Initialize() {
  if (mOurSide == '?') {
    PRINT_ERROR("my side unknown, can not initialize");
    return;
  }

  /* if true, multiply all coords by -1 inside initialize */
  bool rotate = (mOurSide == 'l') ? false : true;

  InitializeFlags(rotate);
  InitializePlayers();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb 0x29(%rdi), %al
cmpb $0x3f, %al
jne 0x3aac5
movq 0x495b8(%rip), %rbx     # 0x83ff0
leaq 0x30571(%rip), %rsi     # 0x6afb0
movl $0x13, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x3273f(%rip), %rsi     # 0x6d192
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x54, %esi
callq 0x9880
movq %rax, %rbx
leaq 0x309e0(%rip), %rsi     # 0x6b457
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x30539(%rip), %rsi     # 0x6afc4
movl $0x23, %edx
movq %rbx, %rdi
callq 0x9560
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9330
movq %rdi, %rbx
xorl %esi, %esi
cmpb $0x6c, %al
setne %sil
callq 0x3ab1e
leaq 0x3147c(%rip), %rax     # 0x6bf58
movl (%rax), %eax
testl %eax, %eax
jle 0x3ab17
movb 0x29(%rbx), %cl
movb 0x2a(%rbx), %dl
incq %rax
addq $0x1fec, %rbx           # imm = 0x1FEC
movl $0x1, %esi
movb %cl, -0x73c(%rbx)
movl %esi, -0x738(%rbx)
movb %dl, -0x4(%rbx)
movl %esi, (%rbx)
incq %rsi
addq $0xa8, %rbx
cmpq %rsi, %rax
jne 0x3aaf7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::InitializePlayers()
void Observer::InitializePlayers() {
  for (int i = 1; i <= ServerParam::TEAM_SIZE; ++i) {
    mTeammateObservers[i].SetSide(mOurSide);
    mTeammateObservers[i].SetUnum(i);

    mOpponentObservers[i].SetSide(mOppSide);
    mOpponentObservers[i].SetUnum(i);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x30ba3(%rip), %rax     # 0x6bf58
movl (%rax), %eax
testl %eax, %eax
jle 0x3b3f0
movb 0x29(%rdi), %cl
movb 0x2a(%rdi), %dl
incq %rax
addq $0x1fec, %rdi           # imm = 0x1FEC
movl $0x1, %esi
movb %cl, -0x73c(%rdi)
movl %esi, -0x738(%rdi)
movb %dl, -0x4(%rdi)
movl %esi, (%rdi)
incq %rsi
addq $0xa8, %rdi
cmpq %rsi, %rax
jne 0x3b3d0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::SeePlayer(double, double)
void Observer::SeePlayer(double dist, double dir) {
  if (mUnknownPlayerCount < MAX_UNKNOWN_PLAYES) {
    mUnknownPlayers[mUnknownPlayerCount].SetIsKnownSide(false);
    mUnknownPlayers[mUnknownPlayerCount].SetDist(dist, mCurrentTime);
    mUnknownPlayers[mUnknownPlayerCount].SetDir(dir, mCurrentTime);
    mUnknownPlayersBugInfo[mUnknownPlayerCount] = mCurrentBugInfo;
    mUnknownPlayerCount += 1;

    mCurrentBugInfo.mLeastNum++;
    if (mCurrentBugInfo.mLeastNum > TEAMSIZE) {
      mCurrentBugInfo.mSide = 'r';
      mCurrentBugInfo.mLeastNum = 1;
    }
    AdjustUnum('?', -1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x31e0(%rdi), %rax
cmpq $0x15, %rax
jg 0x3b5e7
imulq $0x70, %rax, %rcx
movb $0x0, 0x2880(%rdi,%rcx)
movsd %xmm0, 0x2840(%rdi,%rcx)
movq 0xc(%rdi), %rdx
movq %rdx, 0x2848(%rdi,%rcx)
movsd %xmm1, 0x2850(%rdi,%rcx)
movq 0xc(%rdi), %rdx
movq %rdx, 0x2858(%rdi,%rcx)
shlq $0x4, %rax
movups 0x3344(%rdi), %xmm0
movups %xmm0, 0x31e4(%rdi,%rax)
incl 0x31e0(%rdi)
movl 0x3348(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x3348(%rdi)
cmpl $0xb, %eax
jl 0x3b5d7
movb $0x72, 0x3344(%rdi)
movl $0x1, 0x3348(%rdi)
movl $0x3f, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
popq %rbp
jmp 0x3b5ea
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::SeePlayer(char, double, double, bool, bool, bool, CardType)
void Observer::SeePlayer(char side, double dist, double dir, bool is_tackling,
                         bool is_kicked, bool is_lying, CardType card_type) {
  if (mUnknownPlayerCount < MAX_UNKNOWN_PLAYES) {
    mUnknownPlayers[mUnknownPlayerCount].SetIsKnownSide(true);
    mUnknownPlayers[mUnknownPlayerCount].SetSide(side);
    mUnknownPlayers[mUnknownPlayerCount].SetDist(dist, mCurrentTime);
    mUnknownPlayers[mUnknownPlayerCount].SetDir(dir, mCurrentTime);
    mUnknownPlayers[mUnknownPlayerCount].SetIsTcakling(is_tackling,
                                                       mCurrentTime);
    mUnknownPlayers[mUnknownPlayerCount].SetIsKicked(is_kicked, mCurrentTime);
    mUnknownPlayers[mUnknownPlayerCount].SetIsLying(is_lying, mCurrentTime);
    mUnknownPlayers[mUnknownPlayerCount].SetCardType(card_type);
    mUnknownPlayersBugInfo[mUnknownPlayerCount] = mCurrentBugInfo;
    mUnknownPlayerCount += 1;

    mCurrentBugInfo.mLeastNum++;
    if (mCurrentBugInfo.mLeastNum > TEAMSIZE ||
        (OurInitSide() == OurSide() ? side : (side == 'l' ? 'r' : 'l')) !=
            mCurrentBugInfo.mSide) {
      mCurrentBugInfo.mSide = 'r';
      mCurrentBugInfo.mLeastNum = 1;
    }

    AdjustUnum(OurInitSide() == OurSide() ? side : (side == 'l' ? 'r' : 'l'),
               -1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x31e0(%rdi), %rax
cmpq $0x15, %rax
jg 0x3ba6d
imulq $0x70, %rax, %rcx
movb $0x1, 0x2880(%rdi,%rcx)
movb %sil, 0x2881(%rdi,%rcx)
movsd %xmm0, 0x2840(%rdi,%rcx)
movq 0xc(%rdi), %r10
movq %r10, 0x2848(%rdi,%rcx)
movsd %xmm1, 0x2850(%rdi,%rcx)
movq 0xc(%rdi), %r10
movq %r10, 0x2858(%rdi,%rcx)
movb %dl, 0x2884(%rdi,%rcx)
movq %r10, 0x2888(%rdi,%rcx)
movb %r8b, 0x2890(%rdi,%rcx)
movq %r10, 0x2894(%rdi,%rcx)
movl %r9d, 0x28a8(%rdi,%rcx)
shlq $0x4, %rax
movups 0x3344(%rdi), %xmm0
movups %xmm0, 0x31e4(%rdi,%rax)
incl 0x31e0(%rdi)
movl 0x3348(%rdi), %r8d
leal 0x1(%r8), %eax
movl %eax, 0x3348(%rdi)
movb 0x28(%rdi), %al
movb 0x29(%rdi), %dl
movzbl %sil, %ecx
cmpl $0xa, %r8d
jg 0x3ba35
leaq 0x3344(%rdi), %rsi
cmpb $0x6c, %cl
movl $0x72, %r8d
movl $0x6c, %r9d
cmovel %r8d, %r9d
cmpb %dl, %al
cmovel %ecx, %r9d
cmpb (%rsi), %r9b
je 0x3ba46
movb $0x72, 0x3344(%rdi)
movl $0x1, 0x3348(%rdi)
cmpb $0x6c, %cl
movl $0x72, %esi
movl $0x6c, %r8d
cmovel %esi, %r8d
cmpb %dl, %al
cmovel %ecx, %r8d
movsbl %r8b, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
popq %rbp
jmp 0x3b5ea
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::HearTeammateSay(double, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Observer::HearTeammateSay(AngleDeg hear_dir, Unum hear_unum,
                               const std::string &hear_content) {
  Logger::instance().GetTextLogger("freeform")
      << "\n#\n"
      << CurrentTime() << " hear from tm " << hear_unum << std::endl;

  mAudioObserver.SetTeammateSayValid(true);
  mAudioObserver.SetTeammateSayConent(hear_content);
  mAudioObserver.SetHearDir(hear_dir);
  mAudioObserver.SetHearUnum(hear_unum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movsd %xmm0, -0x30(%rbp)
movq %rdi, %r14
callq 0x34c60
leaq 0x2e39a(%rip), %rsi     # 0x6a23b
movq %rax, %rdi
callq 0x34e74
leaq 0x2f157(%rip), %rsi     # 0x6b007
movq %rax, %rdi
callq 0x1efb6
movq %rax, %r12
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x3bedc
leaq 0xc(%r14), %rsi
movq %r12, %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0xe974
leaq 0x2f128(%rip), %rsi     # 0x6b00b
movq %r12, %rdi
callq 0x13582
movq %rax, %r12
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x3bf0b
leaq 0x210(%r12), %rdi
movl %ebx, %esi
callq 0x9880
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x3bf4f
movq %r12, %r13
addq $0x210, %r13            # imm = 0x210
movq 0x210(%r12), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r13, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movb $0x1, 0x1e0(%r14)
leaq 0x1e8(%r14), %rdi
movq %r15, %rsi
callq 0x92a0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x238(%r14)
movl %ebx, 0x240(%r14)
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/Observer.cpp
// Function: Observer::WaitForNewInfo()
bool Observer::WaitForNewInfo() {
  Lock();
  Reset();
  UnLock();

  bool flag = false;
  if (ServerParam::instance().synchMode()) {
    flag = WaitForNewThink();
  } else {
    if (PlayerParam::instance().isCoach() ||
        PlayerParam::instance().isTrainer()) {
      flag = WaitForNewSight(); // see_global 信息
      WaitForCoachNewHear();
    } else {
      flag =
          WaitForNewSense(); //首先等到sense信息，然后在花40毫秒等一下hear和sight
      WaitForNewSight();
    }
  }

  return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3548(%rdi), %r14
movq %r14, %rdi
callq 0x4e01a
xorl %eax, %eax
movl %eax, 0x31e0(%rbx)
movl %eax, 0x3381(%rbx)
movq $-0x1, 0x3358(%rbx)
movl $0x1, 0x3348(%rbx)
movb $0x6c, 0x3344(%rbx)
movb $0x72, 0x334c(%rbx)
movq $0xb, 0x3350(%rbx)
movq $0x0, 0x538(%rbx)
movl %eax, 0x540(%rbx)
movb %al, 0x118(%rbx)
movw $0x0, 0x3385(%rbx)
movb %al, 0x8(%rbx)
movq %r14, %rdi
callq 0x4e036
callq 0x49360
cmpb $0x1, 0x32c9(%rax)
jne 0x3c024
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3c070
callq 0x43dce
cmpb $0x0, 0x31a5(%rax)
jne 0x3c040
callq 0x43dce
cmpb $0x1, 0x31a6(%rax)
jne 0x3c055
movq %rbx, %rdi
callq 0x3c0c2
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3c158
jmp 0x3c068
movq %rbx, %rdi
callq 0x3c194
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3c0c2
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::WaitForNewThink()
bool Observer::WaitForNewThink() {
  int max_time = PlayerParam::instance().WaitTimeOut() * 1000 *
                 ServerParam::instance().slowDownFactor();

  bool ret = true;
  if (mThinkArrived == false) {
    bool timeout = mCondNewThink.Wait(max_time);
    if (timeout) {
      ret = false;
    }
  }
  mThinkArrived = false;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x43dce
movl 0x5c54(%rax), %r14d
callq 0x49360
movq %rax, %rcx
movb $0x1, %al
cmpb $0x0, 0x3389(%rbx)
jne 0x3c0b6
imull 0x329c(%rcx), %r14d
imull $0x3e8, %r14d, %esi     # imm = 0x3E8
leaq 0x3440(%rbx), %rdi
callq 0x4df24
xorb $0x1, %al
movb $0x0, 0x3389(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::WaitForNewSight()
bool Observer::WaitForNewSight() {
  int max_time;

  if (PlayerParam::instance().isCoach() ||
      PlayerParam::instance().isTrainer()) {
    max_time = PlayerParam::instance().WaitTimeOut() * 1000 *
               ServerParam::instance().slowDownFactor();
  } else {
    // TODO:
    // rcssserver13.2.0开始，所有信息均在周期一开始就发，这里暂时不判断是否有视觉，所有周期均等WaitSightBuffer
    if (true /** WillBeNewSight() */) {
      max_time = ServerParam::instance().synchSeeOffset() +
                 PlayerParam::instance().WaitSightBuffer();
    } else {
      max_time = PlayerParam::instance()
                     .WaitHearBuffer(); // though there will be no sight msg,
                                        // take 10ms to wait for the hear msg
    }
    max_time *= ServerParam::instance().slowDownFactor();
  }

  bool ret = true;
  if (mSightArrived == false) {
    bool timeout = mCondNewSight.Wait(max_time);
    if (timeout) {
      ret = false;
    }
  }
  mSightArrived = false;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x43dce
cmpb $0x0, 0x31a5(%rax)
jne 0x3c0e8
callq 0x43dce
cmpb $0x1, 0x31a6(%rax)
jne 0x3c10a
callq 0x43dce
movl 0x5c54(%rax), %r14d
callq 0x49360
imull 0x329c(%rax), %r14d
imull $0x3e8, %r14d, %r14d    # imm = 0x3E8
jmp 0x3c12f
callq 0x49360
movl 0x3380(%rax), %r14d
callq 0x43dce
addl 0x5c4c(%rax), %r14d
callq 0x49360
imull 0x329c(%rax), %r14d
movb $0x1, %al
cmpb $0x0, 0x3388(%rbx)
jne 0x3c14b
leaq 0x33e8(%rbx), %rdi
movl %r14d, %esi
callq 0x4df24
xorb $0x1, %al
movb $0x0, 0x3388(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::WaitForCoachNewHear()
bool Observer::WaitForCoachNewHear() {
  int max_time = PlayerParam::instance().WaitHearBuffer() *
                 ServerParam::instance().slowDownFactor();
  mCondCoachNewHear.Wait(
      max_time); // 注意：coach的hear信息每周期有很多，这里只wait，不set
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x43dce
movl 0x5c50(%rax), %r14d
callq 0x49360
imull 0x329c(%rax), %r14d
addq $0x34f0, %rbx           # imm = 0x34F0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4df24
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::WaitForNewSense()
bool Observer::WaitForNewSense() {
  bool ret = true;
  if (mSenseArrived == false || mIsBeginDecision == false) {
    bool timeout =
        mCondNewSense.Wait(PlayerParam::instance().WaitTimeOut() * 1000 *
                           ServerParam::instance().slowDownFactor());
    if (timeout) {
      ret = false;
    }

    if (mIsBeginDecision == false) {
      mIsBeginDecision =
          true; // set to true after the first wait and will be never changed
    }
  }
  mSenseArrived = false; // reset the indication of new visual information
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x3387(%rdi)
je 0x3c1b5
movb $0x1, %al
cmpb $0x0, 0x3380(%rbx)
jne 0x3c1f6
leaq 0x3390(%rbx), %r14
callq 0x43dce
movl 0x5c54(%rax), %r15d
callq 0x49360
imull 0x329c(%rax), %r15d
imull $0x3e8, %r15d, %esi     # imm = 0x3E8
movq %r14, %rdi
callq 0x4df24
xorb $0x1, %al
cmpb $0x0, 0x3380(%rbx)
jne 0x3c1f6
movb $0x1, 0x3380(%rbx)
movb $0x0, 0x3387(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::WaitForCommandSend()
bool Observer::WaitForCommandSend() {
  bool flag = true;
  if (mIsCommandSend == false) {
    bool is_timeout =
        mCondCommandSend.Wait(PlayerParam::instance().WaitTimeOut() * 1000);
    if (is_timeout == true) {
      flag = false;
    }
  }

  mIsCommandSend = false;
  return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %al
cmpb $0x0, 0x3384(%rdi)
jne 0x3c23d
leaq 0x3498(%rbx), %r14
callq 0x43dce
imull $0x3e8, 0x5c54(%rax), %esi # imm = 0x3E8
movq %r14, %rdi
callq 0x4df24
xorb $0x1, %al
movb $0x0, 0x3384(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::SetNewSense()
void Observer::SetNewSense() {
  mIsNewSense = true;
  mSenseArrived = true;
  mSightArrived =
      false; // sight不可能比sense更早到，在这里暂时修正一下，rcssserver-13.0出来后再改
  mThinkArrived = false;
  ResetSight();
  mCondNewSense.Set();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, 0x3381(%rdi)
movw $0x1, 0x3387(%rdi)
movb $0x0, 0x3389(%rdi)
movl $0x0, 0x31e0(%rdi)
movl $0x1, 0x3348(%rdi)
movb $0x6c, 0x3344(%rdi)
movb $0x72, 0x334c(%rdi)
movaps 0x2ece2(%rip), %xmm0    # 0x6af70
movups %xmm0, 0x3350(%rdi)
addq $0x3390, %rdi           # imm = 0x3390
popq %rbp
jmp 0x4dfcc
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::SetNewThink()
void Observer::SetNewThink() {
  mIsNewThink = true;
  mSightArrived = true;
  mThinkArrived = true;
  mCondNewThink.Set();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, 0x3383(%rdi)
movw $0x101, 0x3388(%rdi)    # imm = 0x101
addq $0x3440, %rdi           # imm = 0x3440
popq %rbp
jmp 0x4dfcc
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::WillBeNewSight()
bool Observer::WillBeNewSight() {
  RealTime next_sight_time;
  switch (Sense().GetViewWidth()) {
  case VW_Narrow:
    return true;
  case VW_Normal:
    next_sight_time =
        GetLastSightRealTime() + 2 * ServerParam::instance().simStep();
    break;
  case VW_Wide:
    next_sight_time =
        GetLastSightRealTime() + 3 * ServerParam::instance().simStep();
    break;
  default:
    PRINT_ERROR("view width error");
    return true; /** bug is here, wait anyway */
  }

  if (next_sight_time - GetLastCycleBeginRealTime() <
      ServerParam::instance().synchSeeOffset() +
          PlayerParam::instance().WaitSightBuffer()) {
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movl 0x120(%rdi), %eax
movb $0x1, %bl
cmpl $0x1, %eax
je 0x3c516
movq %rdi, %r14
cmpl $0x3, %eax
je 0x3c41e
cmpl $0x2, %eax
jne 0x3c488
movups 0x3370(%r14), %xmm0
leaq -0x30(%rbp), %rbx
movups %xmm0, (%rbx)
callq 0x49360
movl 0x3284(%rax), %esi
addl %esi, %esi
jmp 0x3c43b
movups 0x3370(%r14), %xmm0
leaq -0x30(%rbp), %rbx
movups %xmm0, (%rbx)
callq 0x49360
movl 0x3284(%rax), %eax
leal (%rax,%rax,2), %esi
movq %rbx, %rdi
callq 0x5454e
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movups 0x3360(%r14), %xmm0
leaq -0x30(%rbp), %rsi
movups %xmm0, (%rsi)
leaq -0x20(%rbp), %rdi
callq 0x545ce
movl %eax, %ebx
callq 0x49360
movl 0x3380(%rax), %r14d
callq 0x43dce
addl 0x5c4c(%rax), %r14d
cmpl %r14d, %ebx
setl %bl
jmp 0x3c516
movq 0x47b61(%rip), %r14     # 0x83ff0
leaq 0x2eb1a(%rip), %rsi     # 0x6afb0
movl $0x13, %edx
movq %r14, %rdi
callq 0x9560
leaq 0x30ce8(%rip), %rsi     # 0x6d192
movl $0x1, %edx
movq %r14, %rdi
callq 0x9560
movq %r14, %rdi
movl $0x354, %esi            # imm = 0x354
callq 0x9880
movq %rax, %r14
leaq 0x2ef89(%rip), %rsi     # 0x6b457
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x2eb38(%rip), %rsi     # 0x6b01a
movl $0x10, %edx
movq %r14, %rdi
callq 0x9560
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.cpp
// Function: ParamEngine::GetParam(char const*, std::_List_iterator<Param>&)
bool ParamEngine::GetParam(const char *name, ParamEngine::ParamPtr &it) {
  if (name != 0) {
    int id = hash(name);
    ParamList &param_list = mParamLists[id];
    it = param_list.begin();
    for (; it != param_list.end(); ++it) {
      if (str_equal(name, it->name.c_str())) {
        return true;
      }
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x3c919
movq %rdx, %rbx
movq %rsi, %r14
movsbl (%rsi), %edx
movb 0x1(%rsi), %sil
testb %sil, %sil
je 0x3c91e
leaq 0x2(%r14), %rax
movsbl %sil, %esi
movl %edx, %ecx
shll $0x5, %ecx
subl %edx, %ecx
addl %esi, %ecx
movb (%rax), %sil
incq %rax
movl %ecx, %edx
testb %sil, %sil
jne 0x3c8fd
jmp 0x3c920
xorl %r15d, %r15d
jmp 0x3c955
movl %edx, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
leaq (%rcx,%rcx,2), %rax
leaq (%rdi,%rax,8), %r12
addq $0x8, %r12
movq %r12, %r13
movq (%r13), %r13
movq %r13, (%rbx)
cmpq %r12, %r13
setne %r15b
je 0x3c955
movq 0x10(%r13), %rsi
movq %r14, %rdi
callq 0x9670
testl %eax, %eax
jne 0x3c935
movl %r15d, %eax
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/ParamEngine.cpp
// Function: ParamEngine::DumpParam(std::ostream&)
void ParamEngine::DumpParam(std::ostream &os) {
  int sum = 0;
  int count = 0;
  for (int i = 0; i < HASH_SIZE; ++i) {
    ParamList &param_list = mParamLists[i];
    sum += param_list.size();
    count += param_list.size() > 0 ? 1 : 0;
    ParamPtr it = param_list.begin();
    for (; it != param_list.end(); ++it) {
      // os << "# " << i << std::endl;
      PrintParam(it->name.c_str(), os);
    }
  }
  os << "#hash hit rate " << float(count) / sum << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
xorl %r13d, %r13d
xorl %r15d, %r15d
movl $0x0, -0x2c(%rbp)
movl %r15d, -0x30(%rbp)
leaq (,%r13,2), %rax
addq %r13, %rax
movq -0x38(%rbp), %rcx
leaq (%rcx,%rax,8), %r12
movq (%r12), %r15
movq 0x10(%r12), %rcx
movq %rcx, -0x40(%rbp)
cmpq $0x1, %rcx
sbbl $-0x1, -0x2c(%rbp)
cmpq %r12, %r15
je 0x3cf81
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3cd1a
movq (%r15), %r15
jmp 0x3cf68
movl -0x30(%rbp), %r15d
addl -0x40(%rbp), %r15d
incq %r13
cmpq $0x200, %r13            # imm = 0x200
jne 0x3cf3c
leaq 0x2e139(%rip), %rsi     # 0x6b0d5
movl $0xf, %edx
movq %rbx, %rdi
callq 0x9560
cvtsi2ssl -0x2c(%rbp), %xmm0
cvtsi2ss %r15d, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x97d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9330
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.cpp
// Function: ParamEngine::SaveToConfigFile(char const*)
bool ParamEngine::SaveToConfigFile(const char *file_name) {
  std::ofstream config_file(file_name);
  if (config_file.good()) {
    DumpParam(config_file);
    config_file.close();
    return true;
  } else {
    std::cerr << __FILE__ << ":" << __LINE__ << ": can not open file \'"
              << file_name << "\'" << std::endl;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x218(%rbp), %r15
movq %r15, %rdi
movl $0x10, %edx
callq 0x9520
movq (%r15), %rax
movq -0x18(%rax), %rax
movl -0x1f8(%rbp,%rax), %r15d
testl %r15d, %r15d
je 0x3d0c1
movq 0x46f9d(%rip), %rdi     # 0x83ff0
leaq 0x2dffe(%rip), %rsi     # 0x6b058
movl $0x16, %edx
callq 0x9560
movq 0x46f85(%rip), %rdi     # 0x83ff0
leaq 0x30120(%rip), %rsi     # 0x6d192
movl $0x1, %edx
callq 0x9560
movq 0x46f6d(%rip), %rdi     # 0x83ff0
movl $0xb2, %esi
callq 0x9880
movq %rax, %rbx
leaq 0x2e04e(%rip), %rsi     # 0x6b0e5
movl $0x15, %edx
movq %rax, %rdi
callq 0x9560
testq %r14, %r14
je 0x3d0de
movq %r14, %rdi
callq 0x9200
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x3d0f7
leaq -0x218(%rbp), %rsi
movq %rbx, %rdi
callq 0x3cf10
leaq -0x218(%rbp), %rdi
callq 0x96c0
jmp 0x3d132
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x9860
leaq 0x2dffb(%rip), %rsi     # 0x6b0f9
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
testl %r15d, %r15d
sete %bl
movq 0x46e71(%rip), %rax     # 0x83fb0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x210(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x218(%rbp,%rcx)
callq 0x9400
leaq -0x120(%rbp), %rdi
callq 0x91c0
movl %ebx, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x9700
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.cpp
// Function: ParamEngine::ParseFromCmdLine(int, char**)
void ParamEngine::ParseFromCmdLine(int argc, char **argv) {
  char *name;
  char *buffer;
  char dummy = '\0';

  while (argc > 0) {
    if (**argv == '-') {
      name = *argv + 1;
      if (argc > 1 && **(argv + 1) != '-') {
        buffer = *(argv + 1);
      } else {
        buffer = &dummy;
      }
      SetParamFromString(name, buffer);
    }
    --argc;
    ++argv;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movb $0x0, -0x21(%rbp)
testl %esi, %esi
jle 0x3d1f3
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
incl %r14d
addq $0x8, %rbx
leaq -0x21(%rbp), %r12
movq -0x8(%rbx), %rsi
cmpb $0x2d, (%rsi)
jne 0x3d1e6
cmpl $0x2, %r14d
je 0x3d1d8
movq (%rbx), %rdx
cmpb $0x2d, (%rdx)
jne 0x3d1db
movq %r12, %rdx
incq %rsi
movq %r15, %rdi
callq 0x3c968
decl %r14d
addq $0x8, %rbx
cmpl $0x1, %r14d
jg 0x3d1c1
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/ParamEngine.cpp
// Function: ParamEngine::ParseFromServerMsg(char const*)
void ParamEngine::ParseFromServerMsg(const char *line) {
  const char *p = line;
  const char *q;
  char name[256];
  char buffer[256];
  int n;

  while (*p != '\0') {
    while (*p == '(' || *p == ' ')
      p++;
    q = p;
    while (*q != ' ')
      q++;
    n = q - p;
    strncpy(name, p, n * sizeof(char));
    name[n] = '\0';
    p = q + 1;
    while (*q != ')')
      q++;
    n = q - p;
    strncpy(buffer, p, n * sizeof(char));
    buffer[n] = '\0';
    SetParamFromString(name, buffer);
    while (*q == ')')
      q++;
    p = q;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, -0x30(%rbp)
movb (%rsi), %al
testb %al, %al
je 0x3d2e2
movq %rsi, %rbx
movabsq $0x100000000, %r12      # imm = 0x100000000
movzbl %al, %eax
orl $0x8, %eax
cmpl $0x28, %eax
jne 0x3d242
movb 0x1(%rbx), %al
incq %rbx
jmp 0x3d22f
leaq 0x1(%rbx), %r13
movq %rbx, %rax
xorl %r15d, %r15d
movq %rax, %r14
addq %r12, %r15
cmpb $0x20, (%r13)
leaq 0x1(%r13), %r13
leaq 0x1(%rax), %rax
jne 0x3d24c
sarq $0x20, %r15
leaq -0x130(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9270
movb $0x0, -0x130(%rbp,%r15)
movabsq $-0x200000000, %r15     # imm = 0xFFFFFFFE00000000
movq %r14, %rbx
incq %r14
addq %r12, %r15
cmpb $0x29, 0x1(%rbx)
jne 0x3d28a
sarq $0x20, %r15
leaq -0x230(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x9270
movb $0x0, -0x230(%rbp,%r15)
movq -0x30(%rbp), %rdi
leaq -0x130(%rbp), %rsi
movq %r14, %rdx
callq 0x3c968
movzbl 0x1(%rbx), %eax
incq %rbx
cmpl $0x29, %eax
je 0x3d2ce
testl %eax, %eax
jne 0x3d22f
addq $0x208, %rsp            # imm = 0x208
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/ParamEngine.h
// Function: bool ParamEngine::SetParam<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool SetParam(const char *name, T value) {
    if (name != 0) {
      ParamPtr it;
      bool found = GetParam(name, it);
      if (found == true) {
        switch (it->type) {
        case V_INT:
        case V_DOUBLE:
        case V_STRING:
        case V_ONOFF:
          *static_cast<T *>(it->ptr) = value;
          break;
        default:
          return false;
        }
        return true;
      } else {
        std::cerr << __FILE__ << ":" << __LINE__ << ": unknown argument \'"
                  << name << "\'" << std::endl;
      }
    }
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x3d8b8
movq %rdx, %r14
movq %rsi, %rbx
leaq -0x18(%rbp), %rdx
movq $0x0, (%rdx)
callq 0x3c8d4
testb %al, %al
je 0x3d814
movq -0x18(%rbp), %rax
movl 0x38(%rax), %ecx
decl %ecx
cmpl $0x4, %ecx
setb %bl
jae 0x3d8ba
movq 0x30(%rax), %rdi
movq %r14, %rsi
callq 0x92a0
jmp 0x3d8ba
movq 0x467d5(%rip), %r14     # 0x83ff0
leaq 0x2d8d9(%rip), %rsi     # 0x6b0fb
movl $0x14, %edx
movq %r14, %rdi
callq 0x9560
leaq 0x2f95c(%rip), %rsi     # 0x6d192
movl $0x1, %edx
movq %r14, %rdi
callq 0x9560
movq %r14, %rdi
movl $0x97, %esi
callq 0x9880
movq %rax, %r14
leaq 0x2d866(%rip), %rsi     # 0x6b0c0
movl $0x14, %edx
movq %rax, %rdi
callq 0x9560
movq %rbx, %rdi
callq 0x9200
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x9560
leaq 0x2d875(%rip), %rsi     # 0x6b0f9
movl $0x1, %edx
movq %r14, %rdi
callq 0x9560
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::Parser(Observer*)
Parser::Parser(Observer *p_observer) {
  mpObserver = p_observer;

  mConnectServerOk = false;
  mHalfTime = 0;
  mClangOk = false;
  mSynchOk = false;
  mEyeOnOk = false;
  mEarOnOk = false;

  mLastServerPlayMode = SPM_Null;

  ServerPlayModeMap::instance();

  if (PlayerParam::instance().isCoach()) {
    UDPSocket::instance().Initial(ServerParam::instance().serverHost().c_str(),
                                  ServerParam::instance().onlineCoachPort());
  } else if (PlayerParam::instance().isTrainer()) {
    UDPSocket::instance().Initial(ServerParam::instance().serverHost().c_str(),
                                  ServerParam::instance().offlineCoachPort());
  } else {
    UDPSocket::instance().Initial(ServerParam::instance().serverHost().c_str(),
                                  ServerParam::instance().playerPort());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x46015(%rip), %rax     # 0x839f0
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x4e004
xorl %eax, %eax
movl %eax, 0x58(%r15)
movq %rax, 0x51(%r15)
movq %r14, 0x10(%r15)
movl %eax, 0x18(%r15)
movq %rax, 0x48(%r15)
movb $0x0, 0x50(%r15)
callq 0x546f6
callq 0x43dce
cmpb $0x1, 0x31a5(%rax)
jne 0x3da39
callq 0x54038
movq %rax, %r14
callq 0x49360
movq 0x31e8(%rax), %r15
callq 0x49360
addq $0x320c, %rax           # imm = 0x320C
jmp 0x3da87
callq 0x43dce
cmpb $0x1, 0x31a6(%rax)
jne 0x3da68
callq 0x54038
movq %rax, %r14
callq 0x49360
movq 0x31e8(%rax), %r15
callq 0x49360
addq $0x3208, %rax           # imm = 0x3208
jmp 0x3da87
callq 0x54038
movq %rax, %r14
callq 0x49360
movq 0x31e8(%rax), %r15
callq 0x49360
addq $0x31e0, %rax           # imm = 0x31E0
movl (%rax), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x54056
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4e010
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::StartRoutine()
void Parser::StartRoutine() {
  ConnectToServer();

  while (true) {
    if (UDPSocket::instance().Receive(mBuf) > 0) {
      NetworkTest::instance().AddParserBegin();

      DynamicDebug::instance().AddMessage(mBuf,
                                          MT_Parse); // 动态调试记录Parser信息

      mpObserver->Lock(); // parse时禁止WorldState更新
      Parse(mBuf);
      mpObserver->UnLock();

      NetworkTest::instance().AddParserEnd(mpObserver->CurrentTime());
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3db8a
leaq 0x315c2d(%rip), %r14    # 0x353740
movl $0x3548, %r15d          # imm = 0x3548
callq 0x54038
movq %rax, %rdi
movq %r14, %rsi
callq 0x542da
testl %eax, %eax
jle 0x3db19
callq 0x38882
movq %rax, %rdi
callq 0x39282
callq 0x22cde
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x23068
movq 0x10(%rbx), %rdi
addq %r15, %rdi
callq 0x4e01a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3dc22
movq 0x10(%rbx), %rdi
addq %r15, %rdi
callq 0x4e036
callq 0x38882
movq 0x10(%rbx), %rcx
movq 0xc(%rcx), %rsi
movq %rax, %rdi
callq 0x392b4
jmp 0x3db19
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ConnectToServer()
void Parser::ConnectToServer() {
  mOkMutex.Lock();
  mConnectServerOk = false;
  mOkMutex.UnLock();

  SendInitialLizeMsg();
  do {
    UDPSocket::instance().Receive(mBuf);
  } while (!ParseInitializeMsg(mBuf));

  mOkMutex.Lock();
  mConnectServerOk = true;
  mOkMutex.UnLock();

  DynamicDebug::instance().Initial(
      mpObserver); // 动态调试的初始化，知道自己是哪边了才能初始化，位置不能动
  DynamicDebug::instance().AddMessage(mBuf, MT_Parse); // 动态调试记录Parse信息

  // Logger::instance().GetTextLogger("msg-text") << mBuf << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x4e01a
movb $0x0, 0x4c(%rbx)
movq %r14, %rdi
callq 0x4e036
callq 0x3df76
leaq 0x315b85(%rip), %r15    # 0x353740
callq 0x54038
movq %rax, %rdi
movq %r15, %rsi
callq 0x542da
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3e28a
testb %al, %al
je 0x3dbbb
movq %r14, %rdi
callq 0x4e01a
movb $0x1, 0x4c(%rbx)
movq %r14, %rdi
callq 0x4e036
callq 0x22cde
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x22d58
callq 0x22cde
leaq 0x315b35(%rip), %rsi    # 0x353740
movq %rax, %rdi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x23068
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseForTrainer(char*)
bool Parser::ParseForTrainer(char *msg) {
  char *end;
  int n;
  static char buffer[MAX_MESSAGE];

  if (msg[6] == 'r') // 跳过括号和hear，referee
  {
    ParseTime(msg, &msg, true);
    parser::get_word(&msg);
    end = msg;
    while (*end != ')')
      end++;
    n = end - msg;
    strncpy(buffer, msg, n * sizeof(char));
    buffer[n] = '\0';

    ParseRefereeMsg(buffer);
    return true;
  } else
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movb 0x6(%rsi), %r13b
cmpb $0x72, %r13b
jne 0x3fe7b
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdx
movl $0x1, %ecx
callq 0x3e426
movq (%r14), %r14
movsbl (%r14), %r15d
movl %r15d, %edi
callq 0x97c0
testl %r15d, %r15d
je 0x3fe2f
testl %eax, %eax
jne 0x3fe2f
movsbl 0x1(%r14), %r15d
incq %r14
movl %r15d, %edi
callq 0x97c0
testl %r15d, %r15d
je 0x3fe2b
testl %eax, %eax
je 0x3fe12
movq %r14, -0x30(%rbp)
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %r14, %rcx
addq %rax, %r15
cmpb $0x29, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x3fe46
sarq $0x20, %r15
leaq 0x3198f3(%rip), %r12    # 0x359750
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9270
movb $0x0, (%r15,%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x432ac
cmpb $0x72, %r13b
sete %al
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/Parser.cpp
// Function: Parser::ParsePlayerParam(char*)
void Parser::ParsePlayerParam(char *msg) {
  Logger::instance().InitSightLogger(PlayerParam_Msg, msg);

  msg += 13; // 去掉"(player_param"
  PlayerParam::instance().ParseFromServerMsg(msg);
  PlayerParam::instance().MaintainConsistency();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x34c60
movq %rax, %rdi
movl $0x7, %esi
movq %rbx, %rdx
callq 0x34fac
addq $0xd, %rbx
callq 0x43dce
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3d200
callq 0x43dce
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x440c8
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseServerParam(char*)
void Parser::ParseServerParam(char *msg) {
  Logger::instance().InitSightLogger(ServerParam_Msg, msg);

  msg += 13; // 去掉"(server_param"
  ServerParam::instance().ParseFromServerMsg(msg);
  ServerParam::instance().MaintainConsistency();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x34c60
movq %rax, %rdi
movl $0x6, %esi
movq %rbx, %rdx
callq 0x34fac
addq $0xd, %rbx
callq 0x49360
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3d200
callq 0x49360
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x494ca
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseChangePlayerType(char*)
void Parser::ParseChangePlayerType(char *msg) {
  int player = parser::get_int(&msg);
  if (*msg != ')') {
    int type = parser::get_int(msg);
    mpObserver->SetTeammateType(player, type);
  } else {
    mpObserver->AddOpponentTypeChangedCount(player);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, -0x28(%rbp)
movb (%rsi), %al
movsbl %al, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jb 0x41059
movabsq $0x680000000001, %rcx   # imm = 0x680000000001
cmpb $0x2e, %al
ja 0x41044
movzbl %al, %eax
btq %rax, %rcx
jb 0x41055
movb 0x1(%rsi), %al
incq %rsi
movsbl %al, %edx
addl $-0x30, %edx
cmpl $0xa, %edx
jae 0x41037
movq %rsi, -0x28(%rbp)
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
leaq -0x28(%rbp), %r15
movq %rsi, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x9680
movq %rax, %r14
movq (%r15), %rdi
movb (%rdi), %al
cmpb $0x29, %al
jne 0x4109c
movq 0x10(%rbx), %rax
shlq $0x20, %r14
addq %r12, %r14
sarq $0x1e, %r14
incl 0x94(%rax,%r14)
jmp 0x410c7
movsbl %al, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jae 0x410d4
xorl %esi, %esi
movl $0xa, %edx
callq 0x9680
movq 0x10(%rbx), %rcx
shlq $0x20, %r14
addq %r12, %r14
sarq $0x1e, %r14
movl %eax, 0x3c(%rcx,%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x680000000001, %rcx   # imm = 0x680000000001
cmpb $0x2e, %al
ja 0x410eb
movzbl %al, %eax
btq %rax, %rcx
jb 0x410a7
movb 0x1(%rdi), %al
incq %rdi
movsbl %al, %edx
addl $-0x30, %edx
cmpl $0xa, %edx
jae 0x410de
jmp 0x410a7
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParsePlayerType(char*)
void Parser::ParsePlayerType(char *msg) {
  Logger::instance().InitSightLogger(PlayerType_Msg, msg);

  char *p = msg;
  while (!isspace(*p))
    p++;
  while (isspace(*p))
    p++;
  char *line = p;
  while (!isspace(*p))
    p++;
  int type = parser::get_int(p);
  PlayerParam::instance().AddPlayerType(type, line);

  if (type >= PlayerParam::instance().playerTypes() - 1) {
    mIsPlayerTypesReady = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
callq 0x34c60
movq %rax, %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq 0x34fac
addq $-0x3, %rbx
movsbl 0x3(%rbx), %edi
callq 0x90c0
incq %rbx
testl %eax, %eax
je 0x41125
movsbl 0x2(%rbx), %edi
callq 0x90c0
incq %rbx
testl %eax, %eax
jne 0x41135
leaq 0x1(%rbx), %r14
movb 0x1(%rbx), %r12b
incq %rbx
movsbl %r12b, %r15d
movl %r15d, %edi
callq 0x90c0
testl %eax, %eax
je 0x41149
addl $-0x30, %r15d
cmpl $0xa, %r15d
jae 0x411af
movq %rbx, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x9680
movq %rax, %rbx
callq 0x43dce
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x44fc2
callq 0x43dce
movl 0x3008(%rax), %eax
decl %eax
cmpl %ebx, %eax
jg 0x411a6
movb $0x1, 0x31459a(%rip)    # 0x355740
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x680000000001, %rax   # imm = 0x680000000001
cmpb $0x2e, %r12b
ja 0x411c9
movzbl %r12b, %ecx
btq %rcx, %rax
jb 0x4116a
movb 0x1(%rbx), %r12b
incq %rbx
movsbl %r12b, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jae 0x411b9
jmp 0x4116a
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseObjType_Fullstate(char*)
Parser::ObjType Parser::ParseObjType_Fullstate(char *msg) {
  switch (*msg) {
  case 'p':
  case 'P':
    return ParsePlayer_Fullstate(msg);
  case 'b':
  case 'B':
    return ParseBall(msg);
  default:
    PARSE_ERROR("unknown object");
    break;
  }

  ObjType result;
  result.type = OBJ_None;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rdx), %eax
cmpl $0x61, %eax
jg 0x41d54
cmpl $0x42, %eax
je 0x41d68
cmpl $0x50, %eax
je 0x41d5e
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
movabsq $0x3800000005, %rax     # imm = 0x3800000005
jmp 0x41d85
cmpl $0x62, %eax
je 0x41d68
cmpl $0x70, %eax
jne 0x41d35
movq %rbx, %rdi
callq 0x426b6
jmp 0x41d88
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
movabsq $0x3800000001, %rax     # imm = 0x3800000001
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseObjType(char*)
Parser::ObjType Parser::ParseObjType(char *msg) {
  switch (*msg) {
  case 'g':
  case 'G':
    return ParseGoal(msg);
  case 'f':
  case 'F':
    return ParseMarker(msg);
  case 'l':
    return ParseLine(msg);
  case 'p':
  case 'P':
    return ParsePlayer(msg);
  case 'b':
  case 'B':
    return ParseBall(msg);
  default:
    PARSE_ERROR("unknown object");
    break;
  }

  ObjType result;
  result.type = OBJ_None;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rdx), %eax
cmpl $0x61, %eax
jle 0x4226d
cmpl $0x66, %eax
jle 0x42292
cmpl $0x70, %eax
je 0x42288
cmpl $0x6c, %eax
je 0x422cf
cmpl $0x67, %eax
je 0x422c5
jmp 0x422d9
cmpl $0x46, %eax
jg 0x4227e
cmpl $0x42, %eax
je 0x422a6
cmpl $0x46, %eax
je 0x4229c
jmp 0x422d9
cmpl $0x47, %eax
je 0x422c5
cmpl $0x50, %eax
jne 0x422d9
movq %rbx, %rdi
callq 0x42dc6
jmp 0x422f9
cmpl $0x62, %eax
je 0x422a6
cmpl $0x66, %eax
jne 0x422d9
movq %rbx, %rdi
callq 0x42846
jmp 0x422f9
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
movabsq $0x3800000001, %rax     # imm = 0x3800000001
jmp 0x422f6
movq %rbx, %rdi
callq 0x427e4
jmp 0x422f9
movq %rbx, %rdi
callq 0x42d76
jmp 0x422f9
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
movabsq $0x3800000005, %rax     # imm = 0x3800000005
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParsePlayer_Fullstate(char*)
Parser::ObjType Parser::ParsePlayer_Fullstate(char *msg) {
  //((p l 1 g 8) -47.5 0 0 0 -66.8915 -80 (stamina 8000 0.829636 1 130600))
  //((p r 11 14) 0.385 -7.01275e-12 -1.15337e-23 -8.33192e-24 46.129 0 (stamina
  //8000 0.933173 1 124249)))

  ObjType result;

  result.type = OBJ_Player;
  msg += 2; // 'p '
  result.side = *msg;
  result.num = parser::get_int(&msg);
  msg += 1;

  if (*msg == 'g') {
    if (result.side != mpObserver->OurInitSide()) {
      mpObserver->SeeOppGoalie(result.num);
    }
  }

  result.player_type = parser::get_int(&msg);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x5, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x3800000004, %rax     # imm = 0x3800000004
movq %rax, (%rdi)
leaq 0x2(%rdx), %rdi
movq %rdi, -0x30(%rbp)
movb 0x2(%rdx), %r13b
movb %r13b, 0xc(%rbx)
movsbl %r13b, %eax
addl $-0x30, %eax
movabsq $0x680000000001, %r12   # imm = 0x680000000001
cmpl $0xa, %eax
jb 0x42731
movl %r13d, %eax
cmpb $0x2e, %al
ja 0x4271c
movzbl %al, %eax
btq %rax, %r12
jb 0x4272d
movb 0x1(%rdi), %al
incq %rdi
movsbl %al, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jae 0x4270f
movq %rdi, -0x30(%rbp)
leaq -0x30(%rbp), %r15
movq %r15, %rsi
movl $0xa, %edx
callq 0x9680
movl %eax, 0x10(%rbx)
movq (%r15), %rcx
leaq 0x1(%rcx), %rdi
movq %rdi, (%r15)
movb 0x1(%rcx), %cl
cmpb $0x67, %cl
jne 0x42768
movq 0x10(%r14), %rdx
movb $0x67, %cl
cmpb 0x28(%rdx), %r13b
je 0x42773
movl %eax, 0x30(%rdx)
movb (%rdi), %cl
movsbl %cl, %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x42796
cmpb $0x2e, %cl
ja 0x42781
movzbl %cl, %eax
btq %rax, %r12
jb 0x42792
movb 0x1(%rdi), %cl
incq %rdi
movsbl %cl, %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0x42773
movq %rdi, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x9680
movl %eax, 0x14(%rbx)
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/Parser.cpp
// Function: Parser::ParseGoal(char*)
Parser::ObjType Parser::ParseGoal(char *msg) {
  ObjType result;
  if (*msg == 'g') { // goal
    result.type = OBJ_Marker;
    msg += 2; // 'g '
    if (*msg == 'r') {
      result.marker = Goal_R;
    } else if (*msg == 'l') {
      result.marker = Goal_L;
    } else {
      PARSE_ERROR("goal ?");
    }
  } else if (*msg == 'G') { // goal behind
    result.type = OBJ_Marker_Behind;
    // result.marker = _pMem->ClosestGoal(); TODO: how to process?
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movabsq $0x3800000005, %rcx     # imm = 0x3800000005
movq %rcx, (%rdi)
movl $0x5, 0x8(%rdi)
movb $0x3f, 0xc(%rdi)
movq $0x0, 0x10(%rdi)
movzbl (%rdx), %ecx
cmpl $0x47, %ecx
je 0x42835
cmpl $0x67, %ecx
jne 0x42844
movl $0x2, (%rax)
movzbl 0x2(%rdx), %ecx
cmpl $0x6c, %ecx
je 0x4283d
cmpl $0x72, %ecx
jne 0x42844
movl $0x1, 0x4(%rax)
jmp 0x42844
movl $0x3, (%rax)
jmp 0x42844
movl $0x0, 0x4(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseLine(char*)
Parser::ObjType Parser::ParseLine(char *msg) {
  ObjType result;
  result.type = OBJ_Line;
  msg += 2; // 'l'
  if (*msg == 'r') {
    result.line = SL_Right;
  } else if (*msg == 'l') {
    result.line = SL_Left;
  } else if (*msg == 't') {
    result.line = SL_Top;
  } else if (*msg == 'b') {
    result.line = SL_Bottom;
  } else {
    PARSE_ERROR("line ?");
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl $0x5, 0x8(%rdi)
movb $0x3f, 0xc(%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x3800000000, %rcx     # imm = 0x3800000000
movq %rcx, (%rdi)
movb 0x2(%rdx), %cl
addb $-0x62, %cl
rorb %cl
cmpb $0x9, %cl
ja 0x42dc4
movzbl %cl, %ecx
movl $0x321, %edx            # imm = 0x321
btl %ecx, %edx
jae 0x42dc4
leaq 0x28572(%rip), %rdx     # 0x6b330
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseRefereeMsg(char*)
void Parser::ParseRefereeMsg(char *msg) {
  if (msg[0] == 'y' || msg[0] == 'r')
    ParseCard(msg);
  else
    ParsePlayMode(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl (%rsi), %eax
cmpl $0x79, %eax
je 0x432bd
cmpl $0x72, %eax
jne 0x432c3
popq %rbp
jmp 0x432ca
popq %rbp
jmp 0x4166c
nop