LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: NetworkTest::End(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void NetworkTest::End(const std::string BeginName, const std::string EndName) {
  if (PlayerParam::instance().NetworkTest()) {
    int i = 0, size = EndTimelist.size();
    for (; i < size; i++) {
      if (EndTimelist[i].Name.compare(EndName) == 0) {
        break;
      }
    }

    if (i == size) {
      TIMEUNIT End;
      End.RT = GetRealTime();
      End.Name = EndName;
      End.IsRecord = false;
      EndTimelist.push_back(End);
      EndtoBegin[EndName] = BeginName;
    } else {
      EndTimelist[i].RT = GetRealTime();
      EndTimelist[i].IsRecord = true;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x450ba
cmpb $0x1, 0x5c49(%rax)
jne 0x399e8
leaq 0x18(%r15), %r12
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rcx
testl %ecx, %ecx
jle 0x3993c
movq %r15, -0x38(%rbp)
movq %rbx, -0x40(%rbp)
movq %rcx, -0x30(%rbp)
movl %ecx, %ebx
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%r12), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x9080
testl %eax, %eax
je 0x39941
incq %r13
addq $0x38, %r15
cmpq %r13, %rbx
jne 0x3990c
movq -0x30(%rbp), %rcx
movl %ecx, %r13d
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r15
jmp 0x3994d
xorl %r13d, %r13d
jmp 0x3994d
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r15
movq -0x30(%rbp), %rcx
cmpl %ecx, %r13d
jne 0x399c9
leaq -0x68(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
callq 0x55bd8
leaq -0x78(%rbp), %rdi
movq %rax, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %r14, %rsi
callq 0x92a0
leaq -0x78(%rbp), %rsi
movb $0x0, 0x30(%rsi)
movq %r12, %rdi
callq 0x3a52a
addq $0x48, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3a596
movq %rax, %rdi
movq %rbx, %rsi
callq 0x92a0
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x399e8
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x399e8
callq 0x55bd8
movl %r13d, %ecx
movq (%r12), %rsi
imulq $0x38, %rcx, %rcx
movq %rax, 0x20(%rsi,%rcx)
movq %rdx, 0x28(%rsi,%rcx)
movb $0x1, 0x30(%rsi,%rcx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x399f9
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x39a11
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: NetworkTest::getInterval(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
long NetworkTest::getInterval(const std::string BeginName,
                              const std::string EndName) {
  if (PlayerParam::instance().NetworkTest()) {
    int i, Size = EndTimelist.size();
    for (i = 0; i < Size; i++) {
      if (!EndTimelist[i].Name.compare(EndName)) {
        int j, BSize = BeginTimelist.size();
        for (j = 0; j < BSize; j++) {
          if (!BeginTimelist[i].Name.compare(BeginName)) {
            long UseTime =
                (EndTimelist[i].RT.GetSec() - BeginTimelist[j].RT.GetSec()) *
                    1000000 +
                EndTimelist[i].RT.GetUsec() - BeginTimelist[j].RT.GetUsec();
            return UseTime;
          }
        }
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, -0x50(%rbp)
movq %rdi, %r15
callq 0x450ba
cmpb $0x1, 0x5c49(%rax)
jne 0x39b62
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %r14 # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %r14
testl %r14d, %r14d
setg -0x29(%rbp)
jle 0x39b58
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq %rbx, -0x38(%rbp)
movq %r14, -0x40(%rbp)
imulq $0x38, %r12, %r13
movq 0x18(%r15), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x9080
testl %eax, %eax
jne 0x39b46
movq 0x8(%r15), %rax
subq (%r15), %rax
shrq $0x3, %rax
imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7
movq %rax, -0x48(%rbp)
testl %eax, %eax
setg %dil
jle 0x39b41
movl %edi, -0x30(%rbp)
movq (%r15), %rdi
addq %r13, %rdi
movq -0x50(%rbp), %rsi
callq 0x9080
testl %eax, %eax
je 0x39b05
movq -0x48(%rbp), %rax
leal -0x1(%rax), %ebx
xorl %r14d, %r14d
cmpl %r14d, %ebx
je 0x39b37
movq (%r15), %rdi
addq %r13, %rdi
movq -0x50(%rbp), %rsi
callq 0x9080
incq %r14
testl %eax, %eax
jne 0x39adc
cmpl -0x48(%rbp), %r14d
setl %dil
movq -0x38(%rbp), %rbx
jmp 0x39b0b
xorl %r14d, %r14d
movl -0x30(%rbp), %edi
movq (%r15), %rax
movq 0x18(%r15), %rcx
movq 0x20(%rcx,%r13), %rdx
imulq $0x38, %r14, %rsi
subq 0x20(%rax,%rsi), %rdx
imulq $0xf4240, %rdx, %rdx    # imm = 0xF4240
addq 0x28(%rcx,%r13), %rdx
subq 0x28(%rax,%rsi), %rdx
movq %rdx, -0x58(%rbp)
jmp 0x39b3d
xorl %edi, %edi
movq -0x38(%rbp), %rbx
movq -0x40(%rbp), %r14
testb %dil, %dil
jne 0x39b58
incq %r12
cmpq %r14, %r12
setb -0x29(%rbp)
jne 0x39a80
jmp 0x39b58
testb $0x1, -0x29(%rbp)
movq -0x58(%rbp), %rax
jne 0x39b64
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: NetworkTest::SetCommandSendCount(CommandInfo const&)
void NetworkTest::SetCommandSendCount(const CommandInfo &cmd) {
  if (PlayerParam::instance().NetworkTest()) {
    if (cmd.mType != CT_None) {
      switch (cmd.mType) {
      case CT_Kick:
        ++CMDSend.Kicks;
        break;
      case CT_Turn:
        ++CMDSend.Turns;
        break;
      case CT_Dash:
        ++CMDSend.Dashs;
        break;
      case CT_Say:
        ++CMDSend.Says;
        break;
      case CT_TurnNeck:
        ++CMDSend.TurnNecks;
        break;
      case CT_Catch:
        ++CMDSend.Catchs;
        break;
      case CT_Move:
        ++CMDSend.Moves;
        break;
      case CT_ChangeView:
        ++CMDSend.ChangeViews;
        break;
      case CT_Pointto:
        ++CMDSend.Pointtos;
        break;
      case CT_Attentionto:
        ++CMDSend.Attentiontos;
        break;
      case CT_Tackle:
        ++CMDSend.Tackles;
        break;
      default:
        break;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x450ba
cmpb $0x1, 0x5c49(%rax)
jne 0x3a12f
movl (%r14), %eax
decl %eax
cmpl $0xa, %eax
ja 0x3a12f
leaq 0x32ae0(%rip), %rcx     # 0x6cbb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl 0xa0(%rbx)
jmp 0x3a12f
incl 0xbc(%rbx)
jmp 0x3a12f
incl 0xb0(%rbx)
jmp 0x3a12f
incl 0xa8(%rbx)
jmp 0x3a12f
incl 0xa4(%rbx)
jmp 0x3a12f
incl 0xb8(%rbx)
jmp 0x3a12f
incl 0x9c(%rbx)
jmp 0x3a12f
incl 0x98(%rbx)
jmp 0x3a12f
incl 0xc0(%rbx)
jmp 0x3a12f
incl 0xb4(%rbx)
jmp 0x3a12f
incl 0xac(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: NetworkTest::SetCommandExecuteCount(int, int, int, int, int, int, int, int, int, int, int)
void NetworkTest::SetCommandExecuteCount(int d, int k, int tu, int s, int tn,
                                         int c, int m, int cv, int pt, int tk,
                                         int fc) {
  if (PlayerParam::instance().NetworkTest()) {
    CMDExecute.Dashs = d;
    CMDExecute.Kicks = k;
    CMDExecute.Turns = tu;
    CMDExecute.Says = s;
    CMDExecute.TurnNecks = tn;
    CMDExecute.Catchs = c;
    CMDExecute.Moves = m;
    CMDExecute.ChangeViews = cv;
    CMDExecute.Pointtos = pt;
    CMDExecute.Tackles = tk;
    CMDExecute.Attentiontos = fc;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x2c(%rbp)
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x450ba
cmpb $0x1, 0x5c49(%rax)
jne 0x3a1c2
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %ecx
movl 0x28(%rbp), %edx
movl 0x20(%rbp), %esi
movl 0x18(%rbp), %edi
movl 0x10(%rbp), %r8d
movl %r14d, 0xc8(%rbx)
movl %r13d, 0xc4(%rbx)
movl %r12d, 0xcc(%rbx)
movl %r15d, 0xd0(%rbx)
movl -0x2c(%rbp), %r9d
movl %r9d, 0xd4(%rbx)
movl %r8d, 0xd8(%rbx)
movl %edi, 0xdc(%rbx)
movl %esi, 0xe0(%rbx)
movl %edx, 0xe4(%rbx)
movl %ecx, 0xec(%rbx)
movl %eax, 0xe8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: NetworkTest::AddParserEnd(Time)
void NetworkTest::AddParserEnd(Time current_time) {
  if (PlayerParam::instance().NetworkTest()) {
    mParserRecord.mEndTime = GetRealTime();
    mParserRecord.mCostTime = mParserRecord.mEndTime - mParserRecord.mBeginTime;
    mParserRecord.mTime = current_time;
    mParserList.push_back(mParserRecord);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x450ba
cmpb $0x1, 0x5c49(%rax)
jne 0x3a289
callq 0x55bd8
leaq 0x138(%rbx), %r15
leaq 0x148(%rbx), %rdi
movq %rax, 0x148(%rbx)
movq %rdx, 0x150(%rbx)
movq %r15, %rsi
callq 0x55de4
movl %eax, 0x158(%rbx)
movq %r14, 0x15c(%rbx)
movq 0xf8(%rbx), %rsi
cmpq 0x100(%rbx), %rsi
je 0x3a294
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, 0xf8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0xf0, %rbx
movq %rbx, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b1b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: NetworkTest::AddDecisionEnd(Time)
void NetworkTest::AddDecisionEnd(Time current_time) {
  if (PlayerParam::instance().NetworkTest()) {
    mDecisionRecord.mEndTime = GetRealTime();
    mDecisionRecord.mCostTime =
        mDecisionRecord.mEndTime - mDecisionRecord.mBeginTime;
    mDecisionRecord.mTime = current_time;
    mDecisionList.push_back(mDecisionRecord);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x450ba
cmpb $0x1, 0x5c49(%rax)
jne 0x3a367
callq 0x55bd8
leaq 0x168(%rbx), %r15
leaq 0x178(%rbx), %rdi
movq %rax, 0x178(%rbx)
movq %rdx, 0x180(%rbx)
movq %r15, %rsi
callq 0x55de4
movl %eax, 0x188(%rbx)
movq %r14, 0x18c(%rbx)
movq 0x110(%rbx), %rsi
cmpq 0x118(%rbx), %rsi
je 0x3a372
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, 0x110(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x108, %rbx            # imm = 0x108
movq %rbx, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b1b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: NetworkTest::AddCommandSendEnd(Time)
void NetworkTest::AddCommandSendEnd(Time current_time) {
  if (PlayerParam::instance().NetworkTest()) {
    mCommandSendRecord.mEndTime = GetRealTime();
    mCommandSendRecord.mCostTime =
        mCommandSendRecord.mEndTime - mCommandSendRecord.mBeginTime;
    mCommandSendRecord.mTime = current_time;
    mCommandSendList.push_back(mCommandSendRecord);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x450ba
cmpb $0x1, 0x5c49(%rax)
jne 0x3a445
callq 0x55bd8
leaq 0x198(%rbx), %r15
leaq 0x1a8(%rbx), %rdi
movq %rax, 0x1a8(%rbx)
movq %rdx, 0x1b0(%rbx)
movq %r15, %rsi
callq 0x55de4
movl %eax, 0x1b8(%rbx)
movq %r14, 0x1bc(%rbx)
movq 0x128(%rbx), %rsi
cmpq 0x130(%rbx), %rsi
je 0x3a450
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, 0x128(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x120, %rbx            # imm = 0x120
movq %rbx, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b1b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::Initialize()
void Observer::Initialize() {
  if (mOurSide == '?') {
    PRINT_ERROR("my side unknown, can not initialize");
    return;
  }

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

  InitializeFlags(rotate);
  InitializePlayers();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb 0x29(%rdi), %al
cmpb $0x3f, %al
jne 0x3baa9
movq 0x4b5d4(%rip), %rbx     # 0x86ff0
leaq 0x3159d(%rip), %rsi     # 0x6cfc0
movl $0x13, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x3378b(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x54, %esi
callq 0x9880
movq %rax, %rbx
leaq 0x31a24(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x31565(%rip), %rsi     # 0x6cfd4
movl $0x23, %edx
movq %rbx, %rdi
callq 0x9560
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9330
movq %rdi, %rbx
xorl %esi, %esi
cmpb $0x6c, %al
setne %sil
callq 0x3bb02
leaq 0x324c8(%rip), %rax     # 0x6df88
movl (%rax), %eax
testl %eax, %eax
jle 0x3bafb
movb 0x29(%rbx), %cl
movb 0x2a(%rbx), %dl
incq %rax
addq $0x1fec, %rbx           # imm = 0x1FEC
movl $0x1, %esi
movb %cl, -0x73c(%rbx)
movl %esi, -0x738(%rbx)
movb %dl, -0x4(%rbx)
movl %esi, (%rbx)
incq %rsi
addq $0xa8, %rbx
cmpq %rsi, %rax
jne 0x3badb
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::InitializePlayers()
void Observer::InitializePlayers() {
  for (int i = 1; i <= ServerParam::TEAM_SIZE; ++i) {
    mTeammateObservers[i].SetSide(mOurSide);
    mTeammateObservers[i].SetUnum(i);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x31bef(%rip), %rax     # 0x6df88
movl (%rax), %eax
testl %eax, %eax
jle 0x3c3d4
movb 0x29(%rdi), %cl
movb 0x2a(%rdi), %dl
incq %rax
addq $0x1fec, %rdi           # imm = 0x1FEC
movl $0x1, %esi
movb %cl, -0x73c(%rdi)
movl %esi, -0x738(%rdi)
movb %dl, -0x4(%rdi)
movl %esi, (%rdi)
incq %rsi
addq $0xa8, %rdi
cmpq %rsi, %rax
jne 0x3c3b4
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::SeeMarker(MarkerType, double, double, double, double)
void Observer::SeeMarker(MarkerType marker, double dist, double dir,
                         double dist_chg, double dir_chg) {
  mMarkerObservers[marker].SetDist(dist, mCurrentTime);
  mMarkerObservers[marker].SetDir(dir, mCurrentTime);
  mMarkerObservers[marker].SetDistChg(dist_chg, mCurrentTime);
  mMarkerObservers[marker].SetDirChg(dir_chg, mCurrentTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
imulq $0x58, %rax, %rax
movsd %xmm0, 0x548(%rdi,%rax)
movq 0xc(%rdi), %rcx
movq %rcx, 0x550(%rdi,%rax)
movsd %xmm1, 0x558(%rdi,%rax)
movq %rcx, 0x560(%rdi,%rax)
movsd %xmm2, 0x568(%rdi,%rax)
movq %rcx, 0x570(%rdi,%rax)
movsd %xmm3, 0x578(%rdi,%rax)
movq %rcx, 0x580(%rdi,%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movsd %xmm0, 0x1830(%rdi)
movq 0xc(%rdi), %rax
movq %rax, 0x1838(%rdi)
movsd %xmm1, 0x1840(%rdi)
movq %rax, 0x1848(%rdi)
movsd %xmm2, 0x1850(%rdi)
movq %rax, 0x1858(%rdi)
movsd %xmm3, 0x1860(%rdi)
movq %rax, 0x1868(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::SeePlayer(double, double)
void Observer::SeePlayer(double dist, double dir) {
  if (mUnknownPlayerCount < MAX_UNKNOWN_PLAYES) {
    mUnknownPlayers[mUnknownPlayerCount].SetIsKnownSide(false);
    mUnknownPlayers[mUnknownPlayerCount].SetDist(dist, mCurrentTime);
    mUnknownPlayers[mUnknownPlayerCount].SetDir(dir, mCurrentTime);
    mUnknownPlayersBugInfo[mUnknownPlayerCount] = mCurrentBugInfo;
    mUnknownPlayerCount += 1;

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movsd %xmm0, -0x30(%rbp)
movq %rdi, %r14
callq 0x35b4a
leaq 0x2f3ca(%rip), %rsi     # 0x6c23b
movq %rax, %rdi
callq 0x35d5e
leaq 0x30197(%rip), %rsi     # 0x6d017
movq %rax, %rdi
callq 0x1f454
movq %rax, %r12
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x3ceac
leaq 0xc(%r14), %rsi
movq %r12, %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0xea74
leaq 0x30168(%rip), %rsi     # 0x6d01b
movq %r12, %rdi
callq 0x136bc
movq %rax, %r12
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x3cedb
leaq 0x210(%r12), %rdi
movl %ebx, %esi
callq 0x9880
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x3cf1f
movq %r12, %r13
addq $0x210, %r13            # imm = 0x210
movq 0x210(%r12), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r13, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movb $0x1, 0x1e0(%r14)
leaq 0x1e8(%r14), %rdi
movq %r15, %rsi
callq 0x92a0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x238(%r14)
movl %ebx, 0x240(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::WaitForNewInfo()
bool Observer::WaitForNewInfo() {
  Lock();
  Reset();
  UnLock();

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

  return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3548(%rdi), %r14
movq %r14, %rdi
callq 0x4f686
xorl %eax, %eax
movl %eax, 0x31e0(%rbx)
movl %eax, 0x3381(%rbx)
movq $-0x1, 0x3358(%rbx)
movl $0x1, 0x3348(%rbx)
movb $0x6c, 0x3344(%rbx)
movb $0x72, 0x334c(%rbx)
movq $0xb, 0x3350(%rbx)
movq $0x0, 0x538(%rbx)
movl %eax, 0x540(%rbx)
movb %al, 0x118(%rbx)
movw $0x0, 0x3385(%rbx)
movb %al, 0x8(%rbx)
movq %r14, %rdi
callq 0x4f6a2
callq 0x4a75c
cmpb $0x1, 0x32c9(%rax)
jne 0x3cff4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3d040
callq 0x450ba
cmpb $0x0, 0x31a5(%rax)
jne 0x3d010
callq 0x450ba
cmpb $0x1, 0x31a6(%rax)
jne 0x3d025
movq %rbx, %rdi
callq 0x3d092
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3d128
jmp 0x3d038
movq %rbx, %rdi
callq 0x3d164
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3d092
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::WaitForNewThink()
bool Observer::WaitForNewThink() {
  int max_time = PlayerParam::instance().WaitTimeOut() * 1000 *
                 ServerParam::instance().slowDownFactor();

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x450ba
cmpb $0x0, 0x31a5(%rax)
jne 0x3d0b8
callq 0x450ba
cmpb $0x1, 0x31a6(%rax)
jne 0x3d0da
callq 0x450ba
movl 0x5c54(%rax), %r14d
callq 0x4a75c
imull 0x329c(%rax), %r14d
imull $0x3e8, %r14d, %r14d    # imm = 0x3E8
jmp 0x3d0ff
callq 0x4a75c
movl 0x3380(%rax), %r14d
callq 0x450ba
addl 0x5c4c(%rax), %r14d
callq 0x4a75c
imull 0x329c(%rax), %r14d
movb $0x1, %al
cmpb $0x0, 0x3388(%rbx)
jne 0x3d11b
leaq 0x33e8(%rbx), %rdi
movl %r14d, %esi
callq 0x4f590
xorb $0x1, %al
movb $0x0, 0x3388(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x450ba
movl 0x5c50(%rax), %r14d
callq 0x4a75c
imull 0x329c(%rax), %r14d
addq $0x34f0, %rbx           # imm = 0x34F0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4f590
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d185
movb $0x1, %al
cmpb $0x0, 0x3380(%rbx)
jne 0x3d1c6
leaq 0x3390(%rbx), %r14
callq 0x450ba
movl 0x5c54(%rax), %r15d
callq 0x4a75c
imull 0x329c(%rax), %r15d
imull $0x3e8, %r15d, %esi     # imm = 0x3E8
movq %r14, %rdi
callq 0x4f590
xorb $0x1, %al
cmpb $0x0, 0x3380(%rbx)
jne 0x3d1c6
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_O1/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 0x3d20d
leaq 0x3498(%rbx), %r14
callq 0x450ba
imull $0x3e8, 0x5c54(%rax), %esi # imm = 0x3E8
movq %r14, %rdi
callq 0x4f590
xorb $0x1, %al
movb $0x0, 0x3384(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::SetNewSense()
void Observer::SetNewSense() {
  mIsNewSense = true;
  mSenseArrived = true;
  mSightArrived =
      false; // sight不可能比sense更早到，在这里暂时修正一下，rcssserver-13.0出来后再改
  mThinkArrived = false;
  ResetSight();
  mCondNewSense.Set();
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, 0x3383(%rdi)
movw $0x101, 0x3388(%rdi)    # imm = 0x101
addq $0x3440, %rdi           # imm = 0x3440
popq %rbp
jmp 0x4f638
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f638
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d4e6
movq %rdi, %r14
cmpl $0x3, %eax
je 0x3d3ee
cmpl $0x2, %eax
jne 0x3d458
movups 0x3370(%r14), %xmm0
leaq -0x30(%rbp), %rbx
movups %xmm0, (%rbx)
callq 0x4a75c
movl 0x3284(%rax), %esi
addl %esi, %esi
jmp 0x3d40b
movups 0x3370(%r14), %xmm0
leaq -0x30(%rbp), %rbx
movups %xmm0, (%rbx)
callq 0x4a75c
movl 0x3284(%rax), %eax
leal (%rax,%rax,2), %esi
movq %rbx, %rdi
callq 0x55d5c
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movups 0x3360(%r14), %xmm0
leaq -0x30(%rbp), %rsi
movups %xmm0, (%rsi)
leaq -0x20(%rbp), %rdi
callq 0x55de4
movl %eax, %ebx
callq 0x4a75c
movl 0x3380(%rax), %r14d
callq 0x450ba
addl 0x5c4c(%rax), %r14d
cmpl %r14d, %ebx
setl %bl
jmp 0x3d4e6
movq 0x49b91(%rip), %r14     # 0x86ff0
leaq 0x2fb5a(%rip), %rsi     # 0x6cfc0
movl $0x13, %edx
movq %r14, %rdi
callq 0x9560
leaq 0x31d48(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %r14, %rdi
callq 0x9560
movq %r14, %rdi
movl $0x354, %esi            # imm = 0x354
callq 0x9880
movq %rax, %r14
leaq 0x2ffe1(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x2fb78(%rip), %rsi     # 0x6d02a
movl $0x10, %edx
movq %r14, %rdi
callq 0x9560
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pxor %xmm0, %xmm0
movdqu %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
movdqu %xmm0, 0x88(%rdi)
movl $0xffffffff, 0x98(%rdi) # imm = 0xFFFFFFFF
movdqu %xmm0, 0x9c(%rdi)
movl $0x0, 0xac(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0xb0(%rdi)
movl $0xd4, %ecx
movdqu %xmm0, -0x1c(%rdi,%rcx)
movl $0xffffffff, -0xc(%rdi,%rcx) # imm = 0xFFFFFFFF
movq %rax, -0x4(%rdi,%rcx)
addq $0x20, %rcx
cmpq $0x234, %rcx            # imm = 0x234
jne 0x3d5cc
movl $0x234, %eax            # imm = 0x234
pxor %xmm0, %xmm0
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movdqu %xmm0, -0x1c(%rdi,%rax)
movl $0xffffffff, -0xc(%rdi,%rax) # imm = 0xFFFFFFFF
movq %rcx, -0x4(%rdi,%rax)
addq $0x20, %rax
cmpq $0x394, %rax            # imm = 0x394
jne 0x3d5fa
xorl %eax, %eax
movb %al, (%rdi)
movb %al, 0x20(%rdi)
movq %rax, 0x78(%rdi)
movl %eax, 0x80(%rdi)
movl %eax, 0x380(%rdi)
movq %rax, 0x378(%rdi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x48(%rdi)
movdqu %xmm0, 0x58(%rdi)
movdqu %xmm0, 0x64(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
testq %rsi, %rsi
je 0x3d905
movq %rdx, %rbx
movq %rsi, %r14
movsbl (%rsi), %esi
movb 0x1(%r14), %dl
testb %dl, %dl
je 0x3d8ca
leaq 0x2(%r14), %rax
movsbl %dl, %edx
movl %esi, %ecx
shll $0x5, %ecx
subl %esi, %ecx
addl %edx, %ecx
movb (%rax), %dl
incq %rax
movl %ecx, %esi
testb %dl, %dl
jne 0x3d8b1
jmp 0x3d8cc
movl %esi, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
leaq (%rcx,%rcx,2), %rax
leaq (%rdi,%rax,8), %r15
addq $0x8, %r15
movq %r15, %r12
movq (%r12), %r12
movq %r12, (%rbx)
cmpq %r15, %r12
je 0x3d905
movq 0x10(%r12), %rsi
movq %r14, %rdi
callq 0x9670
testl %eax, %eax
jne 0x3d8e1
movb $0x1, %al
cmpq %r15, %r12
jne 0x3d907
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3de14
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
leaq -0x30(%rbp), %rdx
movq $0x0, (%rdx)
callq 0x3d88c
movl %eax, %ebx
testb %al, %al
je 0x3dd5d
movq -0x30(%rbp), %r15
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
movq %r14, %rdi
callq 0x9560
leaq 0x2f3ab(%rip), %rsi     # 0x6d0cc
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
movl 0x38(%r15), %eax
decl %eax
cmpl $0x3, %eax
ja 0x3de81
leaq 0x2f314(%rip), %rcx     # 0x6d058
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x30(%r15), %rax
movl (%rax), %esi
movq %r14, %rdi
callq 0x9880
jmp 0x3ddda
movq 0x4928c(%rip), %r14     # 0x86ff0
leaq 0x2f2fd(%rip), %rsi     # 0x6d068
movl $0x16, %edx
movq %r14, %rdi
callq 0x9560
leaq 0x31443(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %r14, %rdi
callq 0x9560
movq %r14, %rdi
movl $0x8e, %esi
callq 0x9880
movq %rax, %r14
leaq 0x2f32d(%rip), %rsi     # 0x6d0d0
movl $0x14, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
callq 0x9200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9560
leaq 0x2f33c(%rip), %rsi     # 0x6d109
movl $0x1, %edx
movq %r14, %rdi
callq 0x9560
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movb $0x1, %al
testb %bl, %bl
leaq 0x10(%rsp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jne 0x3de16
xorl %eax, %eax
retq
movb $0x22, %r12b
leaq -0x21(%rbp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x9560
movq 0x30(%r15), %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq %rax, %rdi
callq 0x9560
leaq -0x22(%rbp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
jmp 0x3ddd5
movq 0x30(%r15), %rax
cmpb $0x1, (%rax)
jne 0x3de88
leaq 0x31485(%rip), %rsi     # 0x6f2e7
movl $0x2, %edx
jmp 0x3ddd2
movq 0x30(%r15), %rax
movsd (%rax), %xmm0
movq %r14, %rdi
callq 0x97d0
jmp 0x3ddda
xorl %eax, %eax
jmp 0x3de03
leaq 0x31445(%rip), %rsi     # 0x6f2d4
movl $0x3, %edx
jmp 0x3ddd2
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.cpp
// Function: ParamEngine::DumpParam(std::ostream&)
void ParamEngine::DumpParam(std::ostream &os) {
  int sum = 0;
  int count = 0;
  for (int i = 0; i < HASH_SIZE; ++i) {
    ParamList &param_list = mParamLists[i];
    sum += param_list.size();
    count += param_list.size() > 0 ? 1 : 0;
    ParamPtr it = param_list.begin();
    for (; it != param_list.end(); ++it) {
      // os << "# " << i << std::endl;
      PrintParam(it->name.c_str(), os);
    }
  }
  os << "#hash hit rate " << float(count) / sum << std::endl;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x218(%rbp), %r15
movq %r15, %rdi
movl $0x10, %edx
callq 0x9520
movq (%r15), %rax
movq -0x18(%rax), %rax
movl -0x1f8(%rbp,%rax), %r15d
testl %r15d, %r15d
je 0x3e05d
movq 0x49001(%rip), %rdi     # 0x86ff0
leaq 0x2f072(%rip), %rsi     # 0x6d068
movl $0x16, %edx
callq 0x9560
movq 0x48fe9(%rip), %rdi     # 0x86ff0
leaq 0x311b4(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
callq 0x9560
movq 0x48fd1(%rip), %rdi     # 0x86ff0
movl $0xb2, %esi
callq 0x9880
movq %rax, %rbx
leaq 0x2f0c2(%rip), %rsi     # 0x6d0f5
movl $0x15, %edx
movq %rax, %rdi
callq 0x9560
testq %r14, %r14
je 0x3e07a
movq %r14, %rdi
callq 0x9200
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x3e093
leaq -0x218(%rbp), %rsi
movq %rbx, %rdi
callq 0x3deac
leaq -0x218(%rbp), %rdi
callq 0x96c0
jmp 0x3e0ce
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x9860
leaq 0x2f06f(%rip), %rsi     # 0x6d109
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
testl %r15d, %r15d
sete %bl
movq 0x48ed5(%rip), %rax     # 0x86fb0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x210(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x218(%rbp,%rcx)
callq 0x9400
leaq -0x120(%rbp), %rdi
callq 0x91c0
movl %ebx, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x9700
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.cpp
// Function: ParamEngine::ParseFromCmdLine(int, char**)
void ParamEngine::ParseFromCmdLine(int argc, char **argv) {
  char *name;
  char *buffer;
  char dummy = '\0';

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movb $0x0, -0x21(%rbp)
testl %esi, %esi
jle 0x3e18f
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
incl %r14d
addq $0x8, %rbx
leaq -0x21(%rbp), %r12
movq -0x8(%rbx), %rsi
cmpb $0x2d, (%rsi)
jne 0x3e182
cmpl $0x2, %r14d
je 0x3e174
movq (%rbx), %rdx
cmpb $0x2d, (%rdx)
jne 0x3e177
movq %r12, %rdx
incq %rsi
movq %r15, %rdi
callq 0x3d910
decl %r14d
addq $0x8, %rbx
cmpl $0x1, %r14d
jg 0x3e15d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.cpp
// Function: ParamEngine::ParseFromServerMsg(char const*)
void ParamEngine::ParseFromServerMsg(const char *line) {
  const char *p = line;
  const char *q;
  char name[256];
  char buffer[256];
  int n;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, -0x30(%rbp)
cmpb $0x0, (%rsi)
je 0x3e283
movq %rsi, %r13
movabsq $0x100000000, %r14      # imm = 0x100000000
movzbl (%r13), %eax
orl $0x8, %eax
cmpl $0x28, %eax
jne 0x3e1dc
incq %r13
jmp 0x3e1ca
leaq -0x1(%r13), %rax
movabsq $-0x100000000, %rbx     # imm = 0xFFFFFFFF00000000
movq %r13, %r15
movq %rax, %r12
addq %r14, %rbx
cmpb $0x20, (%r15)
leaq 0x1(%r15), %r15
leaq 0x1(%rax), %rax
jne 0x3e1ed
sarq $0x20, %rbx
leaq -0x130(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x9270
movb $0x0, -0x130(%rbp,%rbx)
movabsq $-0x200000000, %rbx     # imm = 0xFFFFFFFE00000000
movq %r12, %r13
incq %r12
addq %r14, %rbx
cmpb $0x29, 0x1(%r13)
jne 0x3e229
sarq $0x20, %rbx
leaq -0x230(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x9270
movb $0x0, -0x230(%rbp,%rbx)
movq -0x30(%rbp), %rdi
leaq -0x130(%rbp), %rsi
movq %r12, %rdx
callq 0x3d910
cmpb $0x29, 0x1(%r13)
leaq 0x1(%r13), %r13
je 0x3e26d
cmpb $0x0, (%r13)
jne 0x3e1ca
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_O1/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:
testq %rsi, %rsi
je 0x3e8ab
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
leaq -0x20(%rbp), %rdx
movq $0x0, (%rdx)
callq 0x3d88c
movl %eax, %ebx
testb %al, %al
je 0x3e7f4
movq -0x20(%rbp), %rax
movl 0x38(%rax), %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0x3e89a
movq 0x30(%rax), %rdi
movq %r15, %rsi
callq 0x92a0
movb $0x1, %al
jmp 0x3e89c
movq 0x487f5(%rip), %r15     # 0x86ff0
leaq 0x2e909(%rip), %rsi     # 0x6d10b
movl $0x14, %edx
movq %r15, %rdi
callq 0x9560
leaq 0x309ac(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %r15, %rdi
callq 0x9560
movq %r15, %rdi
movl $0x97, %esi
callq 0x9880
movq %rax, %r15
leaq 0x2e896(%rip), %rsi     # 0x6d0d0
movl $0x14, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
callq 0x9200
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9560
leaq 0x2e8a5(%rip), %rsi     # 0x6d109
movl $0x1, %edx
movq %r15, %rdi
callq 0x9560
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r15, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
jmp 0x3e89c
xorl %eax, %eax
testb %bl, %bl
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jne 0x3e8ad
xorl %eax, %eax
andb $0x1, %al
retq