LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38d94
movl 0x5c50(%rax), %r14d
callq 0x3db2c
imull 0x329c(%rax), %r14d
addq $0x34f0, %rbx           # imm = 0x34F0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x41f78
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x333bd
movb $0x1, %al
cmpb $0x0, 0x3380(%rbx)
jne 0x333fe
leaq 0x3390(%rbx), %r14
callq 0x38d94
movl 0x5c54(%rax), %r15d
callq 0x3db2c
imull 0x329c(%rax), %r15d
imull $0x3e8, %r15d, %esi     # imm = 0x3E8
movq %r14, %rdi
callq 0x41f78
xorb $0x1, %al
cmpb $0x0, 0x3380(%rbx)
jne 0x333fe
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_O2/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 0x33445
leaq 0x3498(%rbx), %r14
callq 0x38d94
imull $0x3e8, 0x5c54(%rax), %esi # imm = 0x3E8
movq %r14, %rdi
callq 0x41f78
xorb $0x1, %al
movb $0x0, 0x3384(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x3381(%rdi)
movw $0x1, 0x3387(%rdi)
movb $0x0, 0x3389(%rdi)
callq 0x3277e
addq $0x3390, %rbx           # imm = 0x3390
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x42020
// File: /workspace/github_cpp_makefile_star2_O2/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
movb $0x1, 0x3382(%rdi)
movw $0x1, 0x3388(%rdi)
addq $0x33e8, %rdi           # imm = 0x33E8
popq %rbp
jmp 0x42020
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3367a
movq %rdi, %r14
cmpl $0x3, %eax
je 0x335c0
cmpl $0x2, %eax
jne 0x33625
movups 0x3370(%r14), %xmm0
leaq -0x30(%rbp), %rbx
movups %xmm0, (%rbx)
callq 0x3db2c
movl 0x3284(%rax), %esi
addl %esi, %esi
jmp 0x335db
movups 0x3370(%r14), %xmm0
leaq -0x30(%rbp), %rbx
movups %xmm0, (%rbx)
callq 0x3db2c
imull $0x3, 0x3284(%rax), %esi
movq %rbx, %rdi
callq 0x4759a
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movups 0x3360(%r14), %xmm0
leaq -0x30(%rbp), %rsi
movups %xmm0, (%rsi)
leaq -0x20(%rbp), %rdi
callq 0x475fc
movl %eax, %ebx
callq 0x3db2c
movl 0x3380(%rax), %r14d
callq 0x38d94
addl 0x5c4c(%rax), %r14d
cmpl %r14d, %ebx
setl %bl
jmp 0x3367a
movq 0x439c4(%rip), %rdi     # 0x76ff0
leaq 0x2593d(%rip), %rsi     # 0x58f70
callq 0x94b0
leaq 0x27b33(%rip), %rsi     # 0x5b172
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movl $0x354, %esi            # imm = 0x354
callq 0x9890
leaq 0x25dc4(%rip), %rsi     # 0x5941f
movq %rax, %rdi
callq 0x94b0
leaq 0x25970(%rip), %rsi     # 0x58fda
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
callq 0x99e8
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
andq $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
movups %xmm0, 0x88(%rdi)
orl $-0x1, 0x98(%rdi)
leaq 0x28(%rdi), %r15
andl $0x0, 0xac(%rdi)
movups %xmm0, 0x9c(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0xb0(%rdi)
addq $0xb8, %rdi
callq 0x33960
leaq 0x218(%rbx), %rdi
callq 0x33960
xorl %eax, %eax
movb %al, (%rbx)
movb %al, 0x20(%rbx)
andq $0x0, 0x78(%rbx)
andl $0x0, 0x80(%rbx)
andl $0x0, 0x380(%rbx)
andq $0x0, 0x378(%rbx)
cmpq $0xb, %rax
je 0x337aa
orl $-0x1, 0x48(%rbx,%rax,4)
incq %rax
jmp 0x3379a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x9240
movq %r14, %rdi
callq 0x21b20
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x33c74
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x34666
cltq
imulq $0x18, %rax, %rax
leaq (%r15,%rax), %r12
addq $0x8, %r12
movq %r12, %r13
movq (%r13), %r13
movq %r13, (%rbx)
cmpq %r12, %r13
setne %r15b
je 0x33c77
movq 0x10(%r13), %rsi
movq %r14, %rdi
callq 0x9690
testl %eax, %eax
jne 0x33c52
jmp 0x33c77
xorl %r15d, %r15d
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_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.cpp
// Function: ParamEngine::PrintParam(char const*, std::ostream&)
bool ParamEngine::PrintParam(const char *name, std::ostream &os) {
  if (name != 0) {
    ParamPtr it;
    bool found = GetParam(name, it);
    if (found == true) {
      os << it->name << " = ";
      switch (it->type) {
      case V_INT:
        os << *static_cast<int *>(it->ptr);
        break;
      case V_DOUBLE:
        os << *static_cast<double *>(it->ptr);
        break;
      case V_STRING:
        os << '\"' << *static_cast<std::string *>(it->ptr) << '\"';
        break;
      case V_ONOFF:
        if (*static_cast<bool *>(it->ptr) == true) {
          os << "on";
        } else {
          os << "off";
        }
        break;
      default:
        return false;
      }
      os << std::endl;
      return true;
    } else {
      std::cerr << __FILE__ << ":" << __LINE__ << ": unknown argument \'"
                << name << "\'" << std::endl;
    }
  }
  return false;
}

// Assembly:
testq %rsi, %rsi
je 0x33fe1
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x20(%rbp), %rdx
andq $0x0, (%rdx)
callq 0x33c20
testb %al, %al
je 0x33fe4
movq -0x20(%rbp), %r15
leaq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x9430
leaq 0x250d5(%rip), %rsi     # 0x5907c
movq %rax, %rdi
callq 0x94b0
movl 0x38(%r15), %eax
decl %eax
cmpl $0x3, %eax
ja 0x34044
leaq 0x25043(%rip), %rcx     # 0x59008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x30(%r15), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x9890
jmp 0x340a3
xorl %eax, %eax
retq
movq 0x43005(%rip), %rdi     # 0x76ff0
leaq 0x25026(%rip), %rsi     # 0x59018
callq 0x94b0
leaq 0x27174(%rip), %rsi     # 0x5b172
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movl $0x8e, %esi
callq 0x9890
leaq 0x25066(%rip), %rsi     # 0x59080
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x94b0
leaq 0x25085(%rip), %rsi     # 0x590b9
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
callq 0x99e8
xorl %eax, %eax
jmp 0x340ad
pushq $0x22
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x9570
movq 0x30(%r15), %rsi
movq %rax, %rdi
callq 0x9430
movq %rax, %rdi
movl %r14d, %esi
callq 0x9570
jmp 0x340a3
movq 0x30(%r15), %rax
cmpb $0x1, (%rax)
jne 0x34094
leaq 0x27217(%rip), %rsi     # 0x5b297
jmp 0x3409b
movq 0x30(%r15), %rax
movsd (%rax), %xmm0
movq %rbx, %rdi
callq 0x97e0
jmp 0x340a3
leaq 0x271e9(%rip), %rsi     # 0x5b284
movq %rbx, %rdi
callq 0x94b0
movq %rbx, %rdi
callq 0x99e8
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq $0x200, %rax            # imm = 0x200
je 0x34158
movl %r13d, -0x2c(%rbp)
movl %r15d, -0x30(%rbp)
movq %rax, -0x48(%rbp)
imulq $0x18, %rax, %rax
movq -0x38(%rbp), %rcx
leaq (%rcx,%rax), %r13
movq 0x10(%rcx,%rax), %rcx
xorl %r12d, %r12d
movq %rcx, -0x40(%rbp)
testq %rcx, %rcx
setne %r12b
movq %r13, %r15
movq (%r15), %r15
cmpq %r13, %r15
je 0x34140
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x33f6a
jmp 0x34127
movl -0x2c(%rbp), %r13d
addl -0x40(%rbp), %r13d
movl -0x30(%rbp), %r15d
addl %r12d, %r15d
movq -0x48(%rbp), %rax
incq %rax
jmp 0x340f1
leaq 0x24f36(%rip), %rsi     # 0x59095
movq %rbx, %rdi
callq 0x94b0
cvtsi2ss %r15d, %xmm0
cvtsi2ss %r13d, %xmm1
divss %xmm1, %xmm0
movq %rax, %rdi
callq 0x9380
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x99e8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
leaq -0x218(%rbp), %r15
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x9520
movq (%r15), %rax
movq -0x18(%rax), %rax
movl -0x1f8(%rbp,%rax), %r15d
testl %r15d, %r15d
je 0x34244
movq 0x42e07(%rip), %rdi     # 0x76ff0
leaq 0x24e28(%rip), %rsi     # 0x59018
callq 0x94b0
leaq 0x26f76(%rip), %rsi     # 0x5b172
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movl $0xb2, %esi
callq 0x9890
leaq 0x24e8d(%rip), %rsi     # 0x590a5
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x94b0
leaq 0x24e87(%rip), %rsi     # 0x590b9
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
callq 0x99e8
jmp 0x3425f
leaq -0x218(%rbp), %rsi
movq %r14, %rdi
callq 0x340ca
leaq -0x218(%rbp), %rdi
callq 0x96e0
testl %r15d, %r15d
sete %bl
leaq -0x218(%rbp), %rdi
callq 0x9720
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 0x9720
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
leaq -0x21(%rbp), %r12
movb $0x0, (%r12)
addq $0x8, %rbx
testl %r14d, %r14d
jle 0x342ec
movq -0x8(%rbx), %rsi
cmpb $0x2d, (%rsi)
jne 0x342e7
cmpl $0x1, %r14d
je 0x342d9
movq (%rbx), %rdx
cmpb $0x2d, (%rdx)
jne 0x342dc
movq %r12, %rdx
incq %rsi
movq %r15, %rdi
callq 0x33c8a
decl %r14d
jmp 0x342b9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/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 %rsi, %r12
movq %rdi, -0x30(%rbp)
movabsq $0x100000000, %r14      # imm = 0x100000000
movb (%rsi), %al
testb %al, %al
je 0x343e7
leaq 0x1(%r12), %rcx
leaq -0x1(%r12), %r15
movq %rcx, %r13
movzbl %al, %edx
orl $0x8, %edx
cmpl $0x28, %edx
jne 0x34354
movb 0x1(%r12), %al
incq %r12
incq %r13
incq %rcx
incq %r15
jmp 0x34336
xorl %ebx, %ebx
cmpb $0x20, %al
je 0x34369
movb (%r13), %al
incq %r13
addq %r14, %rbx
incq %r15
jmp 0x34356
sarq $0x20, %rbx
leaq -0x130(%rbp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x9290
movb $0x0, -0x130(%rbp,%rbx)
movabsq $-0x200000000, %rbx     # imm = 0xFFFFFFFE00000000
movq %r15, %r12
incq %r15
addq %r14, %rbx
cmpb $0x29, 0x1(%r12)
jne 0x34391
sarq $0x20, %rbx
leaq -0x230(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x9290
movb $0x0, -0x230(%rbp,%rbx)
movq -0x30(%rbp), %rdi
leaq -0x130(%rbp), %rsi
movq %r15, %rdx
callq 0x33c8a
movb 0x1(%r12), %al
incq %r12
cmpb $0x29, %al
je 0x343d6
jmp 0x34321
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/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:
testq %rsi, %rsi
je 0x3468a
pushq %rbp
movq %rsp, %rbp
movsbl (%rsi), %eax
incq %rsi
movsbl (%rsi), %ecx
testl %ecx, %ecx
je 0x34683
imull $0x1f, %eax, %eax
addl %ecx, %eax
jmp 0x34672
andl $0x1ff, %eax            # imm = 0x1FF
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3489e
movq %rdx, %r14
movq %rsi, %rbx
leaq -0x18(%rbp), %rdx
andq $0x0, (%rdx)
callq 0x33c20
testb %al, %al
je 0x3483e
movq -0x18(%rbp), %rax
movl 0x38(%rax), %ecx
decl %ecx
cmpl $0x4, %ecx
setb %bl
jae 0x348a0
movq 0x30(%rax), %rdi
movq %r14, %rsi
callq 0x92b0
jmp 0x348a0
movq 0x427ab(%rip), %rdi     # 0x76ff0
leaq 0x2486f(%rip), %rsi     # 0x590bb
callq 0x94b0
leaq 0x2691a(%rip), %rsi     # 0x5b172
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movl $0x97, %esi
callq 0x9890
leaq 0x2480c(%rip), %rsi     # 0x59080
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x94b0
leaq 0x2482b(%rip), %rsi     # 0x590b9
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
callq 0x99e8
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4208d(%rip), %rax     # 0x76a00
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x42058
andl $0x0, 0x58(%r15)
andq $0x0, 0x51(%r15)
movq %r14, 0x10(%r15)
andl $0x0, 0x18(%r15)
andq $0x0, 0x48(%r15)
movb $0x0, 0x50(%r15)
callq 0x47724
callq 0x38d94
cmpb $0x1, 0x31a5(%rax)
jne 0x349d3
callq 0x471ac
movq %rax, %r14
callq 0x3db2c
movq 0x31e8(%rax), %r15
callq 0x3db2c
addq $0x320c, %rax           # imm = 0x320C
jmp 0x34a21
callq 0x38d94
cmpb $0x1, 0x31a6(%rax)
jne 0x34a02
callq 0x471ac
movq %rax, %r14
callq 0x3db2c
movq 0x31e8(%rax), %r15
callq 0x3db2c
addq $0x3208, %rax           # imm = 0x3208
jmp 0x34a21
callq 0x471ac
movq %rax, %r14
callq 0x3db2c
movq 0x31e8(%rax), %r15
callq 0x3db2c
addq $0x31e0, %rax           # imm = 0x31E0
movl (%rax), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x471e8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x42064
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
callq 0x34b16
leaq 0x311ca2(%rip), %r14    # 0x346740
pushq $0x1
popq %r15
movl $0x3548, %r12d          # imm = 0x3548
callq 0x471ac
movq %rax, %rdi
movq %r14, %rsi
callq 0x47396
testl %eax, %eax
jle 0x34aa8
callq 0x3018a
movq %rax, %rdi
callq 0x30982
callq 0x1d7c4
movq %rax, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x1da72
movq 0x10(%rbx), %rdi
addq %r12, %rdi
callq 0x4206e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34bac
movq 0x10(%rbx), %rdi
addq %r12, %rdi
callq 0x4208a
callq 0x3018a
movq 0x10(%rbx), %rcx
movq 0xc(%rcx), %rsi
movq %rax, %rdi
callq 0x309b4
jmp 0x34aa8
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4206e
movb $0x0, 0x4c(%rbx)
movq %r14, %rdi
callq 0x4208a
callq 0x34e86
leaq 0x311bf9(%rip), %r15    # 0x346740
callq 0x471ac
movq %rax, %rdi
movq %r15, %rsi
callq 0x47396
movq %rbx, %rdi
movq %r15, %rsi
callq 0x350ca
testb %al, %al
je 0x34b47
movq %r14, %rdi
callq 0x4206e
movb $0x1, 0x4c(%rbx)
movq %r14, %rdi
callq 0x4208a
callq 0x1d7c4
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x1d83e
callq 0x1d7c4
leaq 0x311ba9(%rip), %rsi    # 0x346740
pushq $0x1
popq %rdx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1da72
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, -0x28(%rbp)
movb 0x6(%rsi), %r12b
cmpb $0x72, %r12b
jne 0x36013
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdx
callq 0x35252
movq %r15, %rdi
callq 0x38145
movabsq $-0x100000000, %r14     # imm = 0xFFFFFFFF00000000
movq (%r15), %rsi
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rsi, %rcx
addq %rax, %r14
cmpb $0x29, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x35fe1
sarq $0x20, %r14
leaq 0x316758(%rip), %r15    # 0x34c750
movq %r15, %rdi
movq %r14, %rdx
callq 0x9290
movb $0x0, (%r14,%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x38064
cmpb $0x72, %r12b
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/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 0x2ca2e
pushq $0x7
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2cd5a
addq $0xd, %rbx
callq 0x38d94
movq %rax, %rdi
movq %rbx, %rsi
callq 0x342fa
callq 0x38d94
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x38fe8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ca2e
pushq $0x6
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2cd5a
addq $0xd, %rbx
callq 0x3db2c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x342fa
callq 0x3db2c
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3dc5a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %rsi, (%r15)
movq %r15, %rdi
callq 0x38103
movl %eax, %r14d
movq (%r15), %rdi
cmpb $0x29, (%rdi)
jne 0x3693d
movq 0x10(%rbx), %rax
movslq %r14d, %rcx
incl 0x90(%rax,%rcx,4)
jmp 0x3694d
callq 0x383d1
movq 0x10(%rbx), %rcx
movslq %r14d, %rdx
movl %eax, 0x38(%rcx,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %rbx
callq 0x2ca2e
pushq $0xa
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2cd5a
addq $-0x3, %rbx
movsbl 0x3(%rbx), %edi
callq 0x90b0
incq %rbx
testl %eax, %eax
je 0x36979
movsbl 0x2(%rbx), %edi
callq 0x90b0
incq %rbx
testl %eax, %eax
jne 0x36989
leaq 0x1(%rbx), %r14
movsbl 0x1(%rbx), %edi
incq %rbx
callq 0x90b0
testl %eax, %eax
je 0x3699d
movq %rbx, %rdi
callq 0x383d1
movl %eax, %ebx
callq 0x38d94
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x39c6e
callq 0x38d94
movl 0x3008(%rax), %eax
decl %eax
cmpl %eax, %ebx
jl 0x369e1
movb $0x1, 0x311d5f(%rip)    # 0x348740
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x42, %eax
je 0x37248
cmpl $0x70, %eax
je 0x3723e
cmpl $0x62, %eax
je 0x37248
cmpl $0x50, %eax
jne 0x37264
movq %rbx, %rdi
callq 0x376fe
jmp 0x37281
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
andq $0x0, 0x10(%rbx)
movabsq $0x3800000001, %rax     # imm = 0x3800000001
jmp 0x3727e
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
andq $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_O2/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 $0x42, %eax
je 0x374ad
cmpl $0x46, %eax
je 0x374c9
cmpl $0x47, %eax
je 0x37499
cmpl $0x50, %eax
je 0x374a3
cmpl $0x62, %eax
je 0x374ad
cmpl $0x66, %eax
je 0x374c9
cmpl $0x70, %eax
je 0x374a3
cmpl $0x6c, %eax
je 0x374d3
cmpl $0x67, %eax
jne 0x374dd
movq %rbx, %rdi
callq 0x377a4
jmp 0x374fa
movq %rbx, %rdi
callq 0x37d72
jmp 0x374fa
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
andq $0x0, 0x10(%rbx)
movabsq $0x3800000001, %rax     # imm = 0x3800000001
jmp 0x374f7
movq %rbx, %rdi
callq 0x37800
jmp 0x374fa
movq %rbx, %rdi
callq 0x37d24
jmp 0x374fa
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
andq $0x0, 0x10(%rbx)
movabsq $0x3800000005, %rax     # imm = 0x3800000005
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x5, 0x8(%rdi)
movabsq $0x3800000004, %rax     # imm = 0x3800000004
movq %rax, (%rdi)
leaq 0x2(%rdx), %rax
leaq -0x28(%rbp), %r15
movq %rax, (%r15)
movb 0x2(%rdx), %r12b
movb %r12b, 0xc(%rdi)
movq %r15, %rdi
callq 0x38103
movl %eax, 0x10(%rbx)
movq (%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r15)
cmpb $0x67, 0x1(%rcx)
jne 0x37762
movq 0x10(%r14), %rcx
cmpb 0x28(%rcx), %r12b
je 0x37762
movl %eax, 0x30(%rcx)
leaq -0x28(%rbp), %rdi
callq 0x38103
movl %eax, 0x14(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseBall(char*)
Parser::ObjType Parser::ParseBall(char *msg) {
  (void)msg;
  ObjType result;
  result.type = OBJ_Ball;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl $0x5, 0x8(%rdi)
movb $0x3f, 0xc(%rdi)
andq $0x0, 0x10(%rdi)
movabsq $0x3800000001, %rcx     # imm = 0x3800000001
movq %rcx, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movzbl (%rdx), %ecx
cmpl $0x47, %ecx
je 0x377f2
cmpl $0x67, %ecx
jne 0x377fe
movl $0x2, (%rax)
movzbl 0x2(%rdx), %ecx
cmpl $0x6c, %ecx
je 0x377fa
cmpl $0x72, %ecx
jne 0x377fe
movl $0x1, 0x4(%rax)
jmp 0x377fe
movl $0x3, (%rax)
jmp 0x377fe
andl $0x0, 0x4(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movabsq $0x3800000000, %rcx     # imm = 0x3800000000
movq %rcx, (%rdi)
movb 0x2(%rdx), %cl
addb $-0x62, %cl
rorb %cl
cmpb $0x9, %cl
ja 0x37d6f
movzbl %cl, %ecx
movl $0x321, %edx            # imm = 0x321
btl %ecx, %edx
jae 0x37d6f
leaq 0x21587(%rip), %rdx     # 0x592f0
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38075
cmpl $0x72, %eax
jne 0x3807b
popq %rbp
jmp 0x38082
popq %rbp
jmp 0x36ce0
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseCard(char*)
void Parser::ParseCard(char *msg) {
  CardType card_type;
  switch (msg[0]) {
  case 'y':
    card_type = CR_Yellow;
    break;
  case 'r':
    card_type = CR_Red;
    break;
  default:
    card_type = CR_None;
    break;
  }
  Unum player;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, -0x28(%rbp)
movb (%rsi), %r14b
cmpb $0x64, 0x7(%rsi)
movq 0x10(%rdi), %rax
movb 0x28(%rax), %r15b
jne 0x380af
movb 0x9(%rsi), %r12b
jmp 0x380b3
movb 0xc(%rsi), %r12b
leaq -0x28(%rbp), %rdi
callq 0x38103
decl %eax
movq 0x10(%rbx), %rcx
cltq
cmpb %r15b, %r12b
jne 0x380d5
leaq (%rcx,%rax,4), %rax
addq $0xc0, %rax
jmp 0x380df
leaq (%rcx,%rax,4), %rax
addq $0xec, %rax
xorl %ecx, %ecx
cmpb $0x72, %r14b
sete %cl
addl %ecx, %ecx
cmpb $0x79, %r14b
pushq $0x1
popq %rdx
cmovnel %ecx, %edx
movl %edx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.h
// Function: parser::get_int(char**)
inline int get_int(char **str_ptr) {
  while (!isdigit(**str_ptr) && **str_ptr != '-' && **str_ptr != '+' &&
         **str_ptr != '.' && **str_ptr)
    (*str_ptr)++;
  return static_cast<int>(strtol(*str_ptr, str_ptr, 10));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rsi
movq (%rdi), %rdi
movabsq $0x680000000001, %rax   # imm = 0x680000000001
movb (%rdi), %cl
movsbl %cl, %edx
addl $-0x30, %edx
cmpl $0xa, %edx
jb 0x3813a
cmpb $0x2e, %cl
ja 0x38132
movzbl %cl, %ecx
btq %rcx, %rax
jb 0x3813a
incq %rdi
movq %rdi, (%rsi)
jmp 0x38117
movl $0xa, %edx
popq %rbp
jmp 0x96a0
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.h
// Function: parser::get_double(char**)
inline double get_double(char **str_ptr) {
  while (!isdigit(**str_ptr) && **str_ptr != '-' && **str_ptr != '+' &&
         **str_ptr != '.' && **str_ptr)
    (*str_ptr)++;
  return strtod(*str_ptr, str_ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rsi
movq (%rdi), %rdi
movabsq $0x680000000001, %rax   # imm = 0x680000000001
movb (%rdi), %cl
movsbl %cl, %edx
addl $-0x30, %edx
cmpl $0xa, %edx
jb 0x381e6
cmpb $0x2e, %cl
ja 0x381de
movzbl %cl, %ecx
btq %rcx, %rax
jb 0x381e6
incq %rdi
movq %rdi, (%rsi)
jmp 0x381c3
popq %rbp
jmp 0x93c0
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.h
// Function: PlayerState::SetIsAlive(bool)
inline void PlayerState::SetIsAlive(bool alive) {
  mIsAlive = alive;

  if (!mIsAlive) {
    UpdatePos(GetPos(), GetPosDelay(), 0.0);
    UpdateVel(GetVel(), GetVelDelay(), 0.0);

    mNeckDir.mConf = 0.0;
    mBodyDir.mConf = 0.0;
  }
}

// Assembly:
movb %sil, 0x112(%rdi)
testl %esi, %esi
jne 0x38237
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movl 0x18(%rdi), %edx
xorps %xmm0, %xmm0
callq 0xde1c
leaq 0x30(%rbx), %rsi
movl 0x40(%rbx), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0xdde8
andq $0x0, 0xa8(%rbx)
andq $0x0, 0xc0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.h
// Function: PlayerState::UpdatePlayerType(int)
inline void PlayerState::UpdatePlayerType(int type) {
  if (mPlayerType != type) {
    mPlayerType = type;

    SetDecay(PlayerParam::instance().HeteroPlayer(mPlayerType).playerDecay());
    SetEffectiveSpeedMax(
        PlayerParam::instance().HeteroPlayer(mPlayerType).effectiveSpeedMax());
  }
}

// Assembly:
cmpl %esi, 0x114(%rdi)
je 0x382a5
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x114(%rdi)
callq 0x38d94
movq 0x5c38(%rax), %rax
movslq 0x114(%rbx), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd 0x3020(%rax,%rcx), %xmm0
movsd %xmm0, 0x58(%rbx)
callq 0x38d94
movq 0x5c38(%rax), %rax
movslq 0x114(%rbx), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd 0x3098(%rax,%rcx), %xmm0
movsd %xmm0, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.h
// Function: PlayerState::UpdateArmPoint(double, int, double, double, int, int)
inline void PlayerState::UpdateArmPoint(AngleDeg dir, int delay, double conf,
                                        double dist, int move_ban,
                                        int expire_ban) {
  ArmPoint arm;
  arm.mTargetDir = GetNormalizeAngleDeg(dir);
  arm.mTargetDist = dist;
  arm.mMovableBan = move_ban;
  arm.mExpireBan = expire_ban;

  mArmPoint.mValue = arm;
  mArmPoint.mCycleDelay = delay;
  mArmPoint.mConf = conf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movl %edx, %r14d
movsd %xmm2, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movl %esi, %r15d
movq %rdi, %r12
movabsq $-0x3f99800000000000, %rax # imm = 0xC066800000000000
leaq -0x38(%rbp), %rdi
movq %rax, (%rdi)
callq 0xd305
movl %r14d, 0xd0(%r12)
movl %ebx, 0xd4(%r12)
movsd -0x28(%rbp), %xmm1
movsd %xmm1, 0xd8(%r12)
movsd %xmm0, 0xe0(%r12)
movl %r15d, 0xe8(%r12)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0xf0(%r12)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Player.cpp
// Function: Player::SendOptionToServer()
void Player::SendOptionToServer() {
  while (!mpParser->IsClangOk()) {
    mpAgent->CheckCommands(mpObserver);
    mpAgent->Clang(7, 8);
    mpObserver->SetCommandSend();
    WaitFor(200);
  }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x7
popq %r14
pushq $0x8
popq %r15
movq 0x20(%rbx), %rdi
callq 0x387c6
testb %al, %al
jne 0x38613
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdi
callq 0x17f12
movq 0x18(%rbx), %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x387ee
movq 0x8(%rbx), %rdi
callq 0x334d0
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x96b0
jmp 0x385bd
callq 0x38838
movq 0x8(%rbx), %rdi
callq 0x334d0
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x96b0
movq 0x20(%rbx), %rdi
callq 0x38810
movl %eax, %r14d
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdi
callq 0x17f12
movq 0x18(%rbx), %rdi
testb %r14b, %r14b
je 0x385fb
pushq $0x3
popq %rdx
xorl %esi, %esi
callq 0x3884a
movq 0x8(%rbx), %rdi
callq 0x334d0
movl $0x30d40, %edi          # imm = 0x30D40
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x96b0
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Player.cpp
// Function: Player::Run()
void Player::Run() {
  // TIMETEST("Run");

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

  mpObserver->Lock();

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

  mpObserver->UnLock();

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

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

  last_time = time;

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

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

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

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

  mpAgent->SetHistoryActiveBehaviors();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb 0x3160f4(%rip), %al     # 0x34e760
testb %al, %al
je 0x38794
movl $0x3548, %r14d          # imm = 0x3548
movq 0x8(%rbx), %rdi
addq %r14, %rdi
callq 0x4206e
leaq 0x459e3(%rip), %rdi     # 0x7e070
callq 0x214fa
callq 0x18f98
movq %rax, %rdi
callq 0x193b0
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdi
callq 0x17f12
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
callq 0x4c538
addq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x4208a
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
movslq 0x316084(%rip), %rcx    # 0x34e758
testq %rcx, %rcx
js 0x38718
leal 0x1(%rcx), %edi
movl 0x10(%rax), %edx
movl 0x14(%rax), %esi
xorl %edx, %edi
orl %esi, %edi
je 0x38718
movl 0x31606d(%rip), %r8d    # 0x34e75c
leal 0x1(%r8), %edi
movl %esi, %r9d
xorl %edi, %r9d
movl %edx, %r10d
xorl %ecx, %r10d
orl %r9d, %r10d
je 0x38718
xorl %r8d, %esi
xorl %ecx, %edx
orl %esi, %edx
jne 0x38718
shlq $0x20, %rdi
orq %rcx, %rdi
movq %rdi, 0x10(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x316035(%rip)    # 0x34e758
leaq 0x45946(%rip), %rdi     # 0x7e070
callq 0x21582
callq 0x49230
movq %rax, %rdi
callq 0x4933e
movq 0x18(%rbx), %rsi
movq 0x30(%rbx), %rdi
callq 0x1ce78
callq 0x49230
movq %rax, %rdi
callq 0x494d2
callq 0x18f98
movq %rax, %rdi
callq 0x19d18
callq 0x3db2c
cmpb $0x1, 0x32c9(%rax)
jne 0x3877a
movq 0x18(%rbx), %rdi
callq 0x183f0
movq 0x18(%rbx), %rdi
callq 0xdaae
callq 0x2ca2e
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2cdf0
leaq 0x315fc5(%rip), %rdi    # 0x34e760
callq 0x9900
testl %eax, %eax
je 0x38674
movl $0xffffff9c, %eax       # imm = 0xFFFFFF9C
movq %rax, 0x315fa4(%rip)    # 0x34e758
leaq 0x315fa5(%rip), %rdi    # 0x34e760
callq 0x9310
jmp 0x38674
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.h
// Function: Parser::IsSyncOk()
bool IsSyncOk() {
    bool ret;
    mOkMutex.Lock();
    ret = mSynchOk;
    mOkMutex.UnLock();
    return ret;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x4206e
movb 0x4e(%rbx), %bl
movq %r14, %rdi
callq 0x4208a
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq