LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::SeeBall(double, double, double, double)
void Observer::SeeBall(double dist, double dir, double dist_chg,
                       double dir_chg) {
  mBallObserver.SetDist(dist, mCurrentTime);
  mBallObserver.SetDir(dir, mCurrentTime);
  mBallObserver.SetDistChg(dist_chg, mCurrentTime);
  mBallObserver.SetDirChg(dir_chg, mCurrentTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rdi
addq $0x1830, %rdi           # imm = 0x1830
movsd -0x10(%rbp), %xmm0
addq $0xc, %rsi
callq 0x6e370
movq -0x30(%rbp), %rsi
movq %rsi, %rdi
addq $0x1830, %rdi           # imm = 0x1830
movsd -0x18(%rbp), %xmm0
addq $0xc, %rsi
callq 0x6e3a0
movq -0x30(%rbp), %rsi
movq %rsi, %rdi
addq $0x1830, %rdi           # imm = 0x1830
movsd -0x20(%rbp), %xmm0
addq $0xc, %rsi
callq 0x6e3d0
movq -0x30(%rbp), %rsi
movq %rsi, %rdi
addq $0x1830, %rdi           # imm = 0x1830
movsd -0x28(%rbp), %xmm0
addq $0xc, %rsi
callq 0x6e400
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x16, 0x31e0(%rax)
jge 0x6bab2
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x2840, %rdi           # imm = 0x2840
movslq 0x31e0(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x6e430
movq %rax, %rdi
xorl %esi, %esi
callq 0x6e450
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x2840, %rdi           # imm = 0x2840
movslq 0x31e0(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x6e430
movq -0x40(%rbp), %rsi
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
addq $0xc, %rsi
callq 0x6e370
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x2840, %rdi           # imm = 0x2840
movslq 0x31e0(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x6e430
movq -0x40(%rbp), %rsi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
addq $0xc, %rsi
callq 0x6e3a0
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x31e4, %rdi           # imm = 0x31E4
movslq 0x31e0(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x6e470
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq 0x3344(%rax), %rdx
movq %rdx, (%rcx)
movq 0x334c(%rax), %rdx
movq %rdx, 0x8(%rcx)
movl 0x31e0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x31e0(%rax)
movl 0x3348(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3348(%rax)
cmpl $0xb, 0x3348(%rax)
jle 0x6ba9f
movq -0x40(%rbp), %rax
movb $0x72, 0x3344(%rax)
movl $0x1, 0x3348(%rax)
movq -0x40(%rbp), %rdi
movl $0x3f, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6bac0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x5add0
movq %rax, %rdi
leaq 0x54df0(%rip), %rsi     # 0xc21bf
callq 0x5b110
movq %rax, %rdi
leaq 0x55b61(%rip), %rsi     # 0xc2f3f
callq 0x2e9c0
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x11a70
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movq %rax, %rdi
leaq 0x55b3d(%rip), %rsi     # 0xc2f43
callq 0x1a810
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x2e850
movq %rax, %rdi
movq 0x90b8f(%rip), %rsi     # 0xfdfb0
callq 0x1a7c0
movq -0x28(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movl $0x1, %esi
callq 0x6eb60
movq -0x28(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movq -0x20(%rbp), %rsi
callq 0x6eb80
movq -0x28(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movsd -0x10(%rbp), %xmm0
callq 0x6ebb0
movq -0x28(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movl -0x14(%rbp), %esi
callq 0x6ebd0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x29870
movq -0x18(%rbp), %rdi
callq 0x68d80
movq -0x18(%rbp), %rdi
callq 0x298a0
movb $0x0, -0x9(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x298d0
testb $0x1, %al
jne 0x6d4c2
jmp 0x6d4d2
movq -0x18(%rbp), %rdi
callq 0x6d540
andb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x6d528
callq 0x798a0
movq %rax, %rdi
callq 0x10de0
testb $0x1, (%rax)
jne 0x6d4f6
callq 0x798a0
movq %rax, %rdi
callq 0x12080
testb $0x1, (%rax)
je 0x6d50f
movq -0x18(%rbp), %rdi
callq 0x6d5e0
movq -0x18(%rbp), %rdi
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x6d6e0
jmp 0x6d526
movq -0x18(%rbp), %rdi
callq 0x6d740
movq -0x18(%rbp), %rdi
andb $0x1, %al
movb %al, -0x9(%rbp)
callq 0x6d5e0
jmp 0x6d528
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5c8e0
imull $0x3e8, (%rax), %eax    # imm = 0x3E8
movl %eax, -0x1c(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x6ebf0
movl -0x1c(%rbp), %ecx
movl %eax, %edx
movq -0x18(%rbp), %rax
imull %edx, %ecx
movl %ecx, -0xc(%rbp)
movb $0x1, -0xd(%rbp)
movb 0x3389(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6d5be
movq -0x18(%rbp), %rdi
addq $0x3440, %rdi           # imm = 0x3440
movl -0xc(%rbp), %esi
callq 0x8ea20
andb $0x1, %al
movb %al, -0xe(%rbp)
testb $0x1, -0xe(%rbp)
je 0x6d5bc
movb $0x0, -0xd(%rbp)
jmp 0x6d5be
movq -0x18(%rbp), %rax
movb $0x0, 0x3389(%rax)
movb -0xd(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x10de0
testb $0x1, (%rax)
jne 0x6d618
callq 0x798a0
movq %rax, %rdi
callq 0x12080
testb $0x1, (%rax)
je 0x6d648
callq 0x798a0
movq %rax, %rdi
callq 0x5c8e0
imull $0x3e8, (%rax), %eax    # imm = 0x3E8
movl %eax, -0x1c(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x6ebf0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
imull %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x6d684
callq 0x855e0
movq %rax, %rdi
callq 0x6ec10
movl %eax, -0x20(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x6ec30
movq %rax, %rcx
movl -0x20(%rbp), %eax
addl (%rcx), %eax
movl %eax, -0xc(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x6ebf0
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, -0xd(%rbp)
movb 0x3388(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6d6c0
movq -0x18(%rbp), %rdi
addq $0x33e8, %rdi           # imm = 0x33E8
movl -0xc(%rbp), %esi
callq 0x8ea20
andb $0x1, %al
movb %al, -0xe(%rbp)
testb $0x1, -0xe(%rbp)
je 0x6d6be
movb $0x0, -0xd(%rbp)
jmp 0x6d6c0
movq -0x18(%rbp), %rax
movb $0x0, 0x3388(%rax)
movb -0xd(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x6ec50
movl (%rax), %eax
movl %eax, -0x10(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x6ebf0
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movl -0x10(%rbp), %eax
imull %ecx, %eax
movl %eax, -0xc(%rbp)
addq $0x34f0, %rdi           # imm = 0x34F0
movl -0xc(%rbp), %esi
callq 0x8ea20
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x9(%rbp)
movb 0x3387(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x6d77c
movq -0x18(%rbp), %rax
movb 0x3380(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6d7ec
movq -0x18(%rbp), %rax
addq $0x3390, %rax           # imm = 0x3390
movq %rax, -0x20(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5c8e0
imull $0x3e8, (%rax), %eax    # imm = 0x3E8
movl %eax, -0x24(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x6ebf0
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdi
imull %eax, %esi
callq 0x8ea20
andb $0x1, %al
movb %al, -0xa(%rbp)
testb $0x1, -0xa(%rbp)
je 0x6d7cb
movb $0x0, -0x9(%rbp)
movq -0x18(%rbp), %rax
movb 0x3380(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6d7ea
movq -0x18(%rbp), %rax
movb $0x1, 0x3380(%rax)
jmp 0x6d7ec
movq -0x18(%rbp), %rax
movb $0x0, 0x3387(%rax)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x9(%rbp)
movb 0x3384(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6d87a
movq -0x18(%rbp), %rax
addq $0x3498, %rax           # imm = 0x3498
movq %rax, -0x20(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5c8e0
movq -0x20(%rbp), %rdi
imull $0x3e8, (%rax), %esi    # imm = 0x3E8
callq 0x8ea20
andb $0x1, %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x6d878
movb $0x0, -0x9(%rbp)
jmp 0x6d87a
movq -0x18(%rbp), %rax
movb $0x0, 0x3384(%rax)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x1, 0x3381(%rdi)
movb $0x1, 0x3387(%rdi)
movb $0x0, 0x3388(%rdi)
movb $0x0, 0x3389(%rdi)
callq 0x6b5f0
movq -0x10(%rbp), %rdi
addq $0x3390, %rdi           # imm = 0x3390
callq 0x8eb10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movb $0x1, 0x3383(%rdi)
movb $0x1, 0x3388(%rdi)
movb $0x1, 0x3389(%rdi)
addq $0x3440, %rdi           # imm = 0x3440
callq 0x8eb10
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::SetNewSight()
void Observer::SetNewSight() {
  mIsNewSight = true;
  mSightArrived = true;
  mThinkArrived = false;
  mCondNewSight.Set();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movb $0x1, 0x3382(%rdi)
movb $0x1, 0x3388(%rdi)
movb $0x0, 0x3389(%rdi)
addq $0x33e8, %rdi           # imm = 0x33E8
callq 0x8eb10
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x20(%rbp), %rdi
movq %rdx, %rsi
callq 0x651d0
movq -0x80(%rbp), %rdi
callq 0x119d0
movq %rax, %rdi
callq 0x6ee50
movl (%rax), %eax
movl %eax, -0x74(%rbp)
subl $0x1, %eax
je 0x6daeb
jmp 0x6dad4
movl -0x74(%rbp), %eax
subl $0x2, %eax
je 0x6daf4
jmp 0x6dade
movl -0x74(%rbp), %eax
subl $0x3, %eax
je 0x6db3c
jmp 0x6db80
movb $0x1, -0x1(%rbp)
jmp 0x6dc47
movq -0x80(%rbp), %rdi
callq 0x6ee60
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x6ee90
movl %eax, %esi
shll %esi
leaq -0x40(%rbp), %rdi
callq 0x9e7e0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6dbe4
movq -0x80(%rbp), %rdi
callq 0x6ee60
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x6ee90
imull $0x3, %eax, %esi
leaq -0x60(%rbp), %rdi
callq 0x9e7e0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6dbe4
jmp 0x6db82
movq 0x90467(%rip), %rdi     # 0xfdff0
leaq 0x55358(%rip), %rsi     # 0xc2ee8
callq 0xa5a0
movq %rax, %rdi
leaq 0x576b2(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x354, %esi            # imm = 0x354
callq 0xaa40
movq %rax, %rdi
leaq 0x559a4(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x55388(%rip), %rsi     # 0xc2f52
callq 0xa5a0
movq %rax, %rdi
movq 0x903d7(%rip), %rsi     # 0xfdfb0
callq 0xa630
movb $0x1, -0x1(%rbp)
jmp 0x6dc47
movq -0x80(%rbp), %rdi
callq 0x6eeb0
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9e930
movl %eax, -0x84(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x6ec10
movl %eax, -0x88(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x6ec30
movl -0x88(%rbp), %ecx
movq %rax, %rdx
movl -0x84(%rbp), %eax
addl (%rdx), %ecx
cmpl %ecx, %eax
jge 0x6dc43
movb $0x1, -0x1(%rbp)
jmp 0x6dc47
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.h
// Function: SenseObserver::SenseObserver()
SenseObserver() {
    mViewWidth = VW_None;

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

    mSpeed = 0.0;
    mSpeedDir = 0.0;
    mNeckDir = 0.0;

    mKickCount = 0;
    mDashCount = 0;
    mTurnCount = 0;
    mSayCount = 0;
    mTurnNeckCount = 0;
    mCatchCount = 0;
    mMoveCount = 0;
    mChangeViewCount = 0;

    mArmMovableBan = 0;
    mArmExpires = 0;
    mArmTargetDir = 0.0;
    mArmTargetDist = 0.0;
    mArmCount = 0;

    mFocusSide = '?';
    mFocusUnum = 0;
    mFocusCount = 0;

    mTackleExpires = 0;
    mTackleCount = 0;

    mCardType = CR_None;
    mFoulChargedCycle = 0;
    ClearCollisionState();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x94, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
callq 0x855e0
movq %rax, %rdi
callq 0x32930
movq %rax, %rcx
movq -0x10(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
callq 0x855e0
movq %rax, %rdi
callq 0x6ef30
movq %rax, %rcx
movq -0x10(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
callq 0x855e0
movq %rax, %rdi
callq 0x6ef50
movq -0x10(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rdi)
movl $0x0, 0x38(%rdi)
movl $0x0, 0x3c(%rdi)
movl $0x0, 0x40(%rdi)
movl $0x0, 0x44(%rdi)
movl $0x0, 0x48(%rdi)
movl $0x0, 0x4c(%rdi)
movl $0x0, 0x50(%rdi)
movl $0x0, 0x54(%rdi)
movl $0x0, 0x58(%rdi)
movl $0x0, 0x5c(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rdi)
movl $0x0, 0x70(%rdi)
movb $0x3f, 0x74(%rdi)
movl $0x0, 0x78(%rdi)
movl $0x0, 0x7c(%rdi)
movl $0x0, 0x80(%rdi)
movl $0x0, 0x84(%rdi)
movl $0x0, 0x88(%rdi)
movl $0x0, 0x8c(%rdi)
callq 0x6ef70
addq $0x10, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.h
// Function: AudioObserver::AudioObserver()
AudioObserver() {
    mIsOurCoachSayValid = false;
    mIsTeammateSayValid = false;
    mHearDir = 0.0;
    mHearUnum = 0;
    mHearInfoType = HearInfo_Null;
    mTeammateCount = mOpponentCount = 0;
    for (int i = 1; i <= TEAMSIZE; ++i) {
      mOpponentType[i] = -1;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3fed0
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0xa820
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
callq 0x6efa0
jmp 0x6de21
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
callq 0x6efc0
jmp 0x6de33
movq -0x20(%rbp), %rdi
addq $0xa0, %rdi
callq 0x6efc0
jmp 0x6de45
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
callq 0x6f010
jmp 0x6de57
movq -0x20(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
callq 0x6f010
jmp 0x6de69
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movb $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rax)
movl $0x0, 0x80(%rax)
movl $0x0, 0x380(%rax)
movl $0x0, 0x37c(%rax)
movl $0x0, 0x378(%rax)
movl $0x1, -0x18(%rbp)
cmpl $0xb, -0x18(%rbp)
jg 0x6defd
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
leaq -0x18(%rbp), %rsi
callq 0x6f060
movq %rax, -0x38(%rbp)
jmp 0x6dec8
movq -0x38(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6deab
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa370
movq -0x30(%rbp), %rdi
callq 0x40100
jmp 0x6df03
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.h
// Function: ServerBugInfo::ServerBugInfo()
ServerBugInfo() {
    mSide = 'l';   // server send left player as default
    mLeastNum = 1; // the default least num is 1;
    mSupSide = 'r';
    mSupNum = TEAMSIZE; // THE DEFUALT
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x6c, (%rax)
movl $0x1, 0x4(%rax)
movb $0x72, 0x8(%rax)
movl $0xb, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.h
// Function: MarkerObserver::Initialize(MarkerType, Vector const&, bool)
void Initialize(MarkerType type, const Vector &global_pos, bool rotate) {
    SetGlobalPosition(rotate ? -global_pos
                             : global_pos); /* If on the right side of the
                                               field, flip all coords */
    SetType(type);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, -0x19(%rbp)
je 0x6e1fd
movq -0x18(%rbp), %rdi
callq 0x6f560
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
jmp 0x6e210
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6f530
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6f5c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.h
// Function: LineObserver::Initialize(SideLineType, Vector const&, bool)
void Initialize(SideLineType type, const Vector &global_pos, bool rotate) {
    SetGlobalPosition(rotate ? -global_pos
                             : global_pos); /* If on the right side of the
                                               field, flip all coords */
    SetType(type);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, -0x19(%rbp)
je 0x6e28d
movq -0x18(%rbp), %rdi
callq 0x6f560
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
jmp 0x6e2a0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6f530
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6f5e0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6fa78
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x70af0
movq -0x50(%rbp), %rdi
movl %eax, -0x24(%rbp)
addq $0x8, %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x70b70
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x70b90
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
callq 0x70bf0
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x70bc0
testb $0x1, %al
jne 0x6fa34
jmp 0x6fa76
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0x70c60
movq %rax, %rdi
callq 0xa240
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x70c20
testb $0x1, %al
jne 0x6fa63
jmp 0x6fa69
movb $0x1, -0x1(%rbp)
jmp 0x6fa7c
jmp 0x6fa6b
movq -0x20(%rbp), %rdi
callq 0x70c90
jmp 0x6fa0c
jmp 0x6fa78
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x200, -0x1c(%rbp)     # imm = 0x200
jge 0x70276
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x70b70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x71110
movq %rax, %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rdi
callq 0x71110
movq %rax, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmoval %ecx, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0x70b90
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x70bf0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x70bc0
testb $0x1, %al
jne 0x7023a
jmp 0x70266
leaq -0x38(%rbp), %rdi
callq 0x70c60
movq %rax, %rdi
callq 0xa240
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x6ff40
leaq -0x38(%rbp), %rdi
callq 0x70c90
jmp 0x7021a
jmp 0x70268
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x701ad
movq -0x10(%rbp), %rdi
leaq 0x52d90(%rip), %rsi     # 0xc3011
callq 0xa5a0
movq %rax, %rdi
cvtsi2ssl -0x18(%rbp), %xmm0
cvtsi2ssl -0x14(%rbp), %xmm1
divss %xmm1, %xmm0
callq 0xa400
movq %rax, %rdi
movq 0x8dd0a(%rip), %rsi     # 0xfdfb0
callq 0xa630
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x238(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0xa660
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0xaa20
movb %al, -0x229(%rbp)
jmp 0x70343
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x7034f
jmp 0x703a8
movq -0x238(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x70180
jmp 0x70364
leaq -0x218(%rbp), %rdi
callq 0xa880
jmp 0x70372
movb $0x1, -0x1(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x70470
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0xa8c0
jmp 0x7048a
movq 0x8dc41(%rip), %rdi     # 0xfdff0
leaq 0x52bde(%rip), %rsi     # 0xc2f94
callq 0xa5a0
movq %rax, -0x240(%rbp)
jmp 0x703c4
movq -0x240(%rbp), %rdi
leaq 0x54e7f(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, -0x248(%rbp)
jmp 0x703e0
movq -0x248(%rbp), %rdi
movl $0xb2, %esi
callq 0xaa40
movq %rax, -0x250(%rbp)
jmp 0x703fa
movq -0x250(%rbp), %rdi
leaq 0x52c19(%rip), %rsi     # 0xc3021
callq 0xa5a0
movq %rax, -0x258(%rbp)
jmp 0x70416
movq -0x258(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa5a0
movq %rax, -0x260(%rbp)
jmp 0x7042f
movq -0x260(%rbp), %rdi
leaq 0x52bf8(%rip), %rsi     # 0xc3035
callq 0xa5a0
movq %rax, -0x268(%rbp)
jmp 0x7044b
movq -0x268(%rbp), %rdi
movq 0x8db57(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x70460
jmp 0x70462
movb $0x0, -0x1(%rbp)
movl $0x1, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0xa8c0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x29(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x70537
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x70520
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x70507
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x70507
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x7050f
leaq -0x29(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6fa90
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x704bf
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x706b8
jmp 0x70578
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x28, %ecx
movb %al, -0x231(%rbp)
je 0x7059f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x231(%rbp)
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0x705ab
jmp 0x705b9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x70578
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x705db
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x705c1
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x224(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x224(%rbp), %rdx
shlq $0x0, %rdx
callq 0xa2f0
movslq -0x224(%rbp), %rax
movb $0x0, -0x120(%rbp,%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x7063c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x70622
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x224(%rbp)
leaq -0x220(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x224(%rbp), %rdx
shlq $0x0, %rdx
callq 0xa2f0
movq -0x230(%rbp), %rdi
movslq -0x224(%rbp), %rax
movb $0x0, -0x220(%rbp,%rax)
leaq -0x120(%rbp), %rsi
leaq -0x220(%rbp), %rdx
callq 0x6fa90
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0x706ab
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x70691
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x70566
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.h
// Function: ParamEngine::hash(char const*)
int hash(const char *str) {
    if (str != 0) {
      unsigned h = str[0];
      for (int i = 1; str[i] != 0; ++i) {
        h = (h << 5) - h + str[i];
      }
      return h % HASH_SIZE; // remainder
    } else {
      return -1;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x70b57
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x70b4a
movl -0x1c(%rbp), %eax
shll $0x5, %eax
subl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x70b14
movl -0x1c(%rbp), %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, -0x4(%rbp)
jmp 0x70b5e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.h
// Function: bool ParamEngine::SetParam<int>(char const*, int)
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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x70dc7
leaq -0x28(%rbp), %rdi
callq 0x70cb0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x6f9a0
andb $0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x70d5d
leaq -0x28(%rbp), %rdi
callq 0x70c60
movl 0x28(%rax), %eax
decl %eax
subl $0x3, %eax
ja 0x70d51
jmp 0x70d37
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x70c60
movl -0x3c(%rbp), %ecx
movq 0x20(%rax), %rax
movl %ecx, (%rax)
jmp 0x70d57
movb $0x0, -0x1(%rbp)
jmp 0x70dcb
movb $0x1, -0x1(%rbp)
jmp 0x70dcb
movq 0x8d28c(%rip), %rdi     # 0xfdff0
leaq 0x522cc(%rip), %rsi     # 0xc3037
callq 0xa5a0
movq %rax, %rdi
leaq 0x544d7(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x97, %esi
callq 0xaa40
movq %rax, %rdi
leaq 0x52266(%rip), %rsi     # 0xc2ffc
callq 0xa5a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xa5a0
movq %rax, %rdi
leaq 0x52284(%rip), %rsi     # 0xc3035
callq 0xa5a0
movq %rax, %rdi
movq 0x8d1f0(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x70dc7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x71580
callq 0x9e170
movq %rax, %rdi
leaq 0x35c3b8(%rip), %rsi    # 0x3cd8a0
callq 0x9e450
cmpl $0x0, %eax
jle 0x7156f
callq 0x63700
movq %rax, %rdi
callq 0x64330
callq 0x33ef0
movq %rax, %rdi
leaq 0x35c392(%rip), %rsi    # 0x3cd8a0
movl $0x1, %edx
callq 0x34320
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x29870
movq -0x18(%rbp), %rdi
leaq 0x35c370(%rip), %rsi    # 0x3cd8a0
callq 0x71640
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x298a0
callq 0x63700
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rdi
callq 0x11a70
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x64380
jmp 0x714d9
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x20, %rdi
callq 0x8ebb0
movq -0x10(%rbp), %rdi
movb $0x0, 0x4c(%rdi)
addq $0x20, %rdi
callq 0x8ebe0
movq -0x10(%rbp), %rdi
callq 0x71a70
callq 0x9e170
movq %rax, %rdi
leaq 0x35c2da(%rip), %rsi    # 0x3cd8a0
callq 0x9e450
movq -0x10(%rbp), %rdi
leaq 0x35c2ca(%rip), %rsi    # 0x3cd8a0
callq 0x71fb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x715b7
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x8ebb0
movq -0x10(%rbp), %rdi
movb $0x1, 0x4c(%rdi)
addq $0x20, %rdi
callq 0x8ebe0
callq 0x33ef0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x33f80
callq 0x33ef0
movq %rax, %rdi
leaq 0x35c27d(%rip), %rsi    # 0x3cd8a0
movl $0x1, %edx
callq 0x34320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x6(%rax), %eax
cmpl $0x72, %eax
jne 0x73ae5
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x72230
leaq -0x18(%rbp), %rdi
callq 0x77cc0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x73a9a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x73a80
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rsi
movslq -0x24(%rbp), %rdx
shlq $0x0, %rdx
leaq 0x35fdf5(%rip), %rdi    # 0x3d38b0
callq 0xa2f0
movq -0x30(%rbp), %rdi
movslq -0x24(%rbp), %rcx
leaq 0x35fde1(%rip), %rax    # 0x3d38b0
movb $0x0, (%rax,%rcx)
leaq 0x35fdd6(%rip), %rsi    # 0x3d38b0
callq 0x77840
movb $0x1, -0x1(%rbp)
jmp 0x73ae9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x5add0
movq %rax, %rdi
movq -0x10(%rbp), %rdx
movl $0x7, %esi
callq 0x5b370
movq -0x10(%rbp), %rax
addq $0xd, %rax
movq %rax, -0x10(%rbp)
callq 0x798a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x70540
callq 0x798a0
movq %rax, %rdi
callq 0x79b10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x5add0
movq %rax, %rdi
movq -0x10(%rbp), %rdx
movl $0x6, %esi
callq 0x5b370
movq -0x10(%rbp), %rax
addq $0xd, %rax
movq %rax, -0x10(%rbp)
callq 0x855e0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x70540
callq 0x855e0
movq %rax, %rdi
callq 0x85bc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x77bf0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x74c03
movq -0x10(%rbp), %rdi
callq 0x78240
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x782e0
jmp 0x74c13
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x78320
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x5add0
movq %rax, %rdi
movq -0x10(%rbp), %rdx
movl $0xa, %esi
callq 0x5b370
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0xa0d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x74c68
jmp 0x74c76
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x74c4e
jmp 0x74c78
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0xa0d0
cmpl $0x0, %eax
je 0x74c97
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x74c78
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0xa0d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x74cb9
jmp 0x74cc7
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x74c9f
movq -0x18(%rbp), %rdi
callq 0x78240
movl %eax, -0x24(%rbp)
callq 0x798a0
movq %rax, %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x7af40
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5bd50
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x74d0d
movb $0x1, 0x35ab93(%rip)    # 0x3cf8a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x42, %eax
je 0x75f92
jmp 0x75f61
movl -0x14(%rbp), %eax
subl $0x50, %eax
je 0x75f7f
jmp 0x75f6b
movl -0x14(%rbp), %eax
subl $0x62, %eax
je 0x75f92
jmp 0x75f75
movl -0x14(%rbp), %eax
subl $0x70, %eax
jne 0x75fa5
jmp 0x75f7f
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
callq 0x767c0
jmp 0x75fba
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
callq 0x76890
jmp 0x75fba
jmp 0x75fa7
movq -0x30(%rbp), %rdi
callq 0x783d0
movq -0x30(%rbp), %rax
movl $0x5, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)