LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::Save(char const*)
void Net::Save(const char *fname) {
  if (mUnits == 0)
    return;
  FILE *fp;
  if ((fp = fopen(fname, "w")) == 0) {
    perror("BPN::Save(char *fname)");
    exit(1);
  }
#ifdef BINARY
  fwrite(&mLayers, sizeof(mLayers), 1, fp);
  fwrite(mUnits, sizeof(*mUnits), mLayers, fp);
  fwrite(&mEta, sizeof(mEta), 1, fp);
  fwrite(&mAlpha, sizeof(mAlpha), 1, fp);
  for (int i = 1; i < mLayers; ++i) {
    for (int j = 0; j < mUnits[i]; ++j) {
      fwrite(mWeight[i][j], sizeof(*mWeight[i][j]), mUnits[i - 1] + 1, fp);
    }
  }
#else
  fprintf(fp, "#mLayers\n%d\n#mUnits\n", mLayers);
  for (int i = 0; i < mLayers; ++i) {
    fprintf(fp, "%d ", mUnits[i]);
  }
  fprintf(fp, "\n#mEta\n%lf\n#mAlpha\n%lf\n#mWeight\n", mEta, mAlpha);
  for (int i = 1; i < mLayers; ++i) {
    fprintf(fp, "#Layer %d\n", i);
    for (int j = 0; j < mUnits[i]; ++j) {
      for (int k = 0; k < mUnits[i - 1] + 1; ++k) {
        fprintf(fp, "%lf ", mWeight[i][j][k]);
      }
      fprintf(fp, "\n");
    }
    fprintf(fp, "\n");
  }
#endif
  fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x2e98a
movq %rdi, %rbx
leaq 0x2bb82(%rip), %rax     # 0x5a44b
movq %rsi, %rdi
movq %rax, %rsi
callq 0x95a0
testq %rax, %rax
je 0x2e999
movq %rax, %r14
pushq $0x4
popq %r12
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x9990
movq 0x8(%rbx), %rdi
movslq (%rbx), %rdx
movq %r12, %rsi
movq %r14, %rcx
callq 0x9990
leaq 0x38(%rbx), %rdi
pushq $0x8
popq %r12
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x9990
leaq 0x40(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x9990
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x2e974
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movslq (%rax,%r15,4), %rcx
cmpq %rcx, %r13
jge 0x2e96f
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movq (%rcx,%r13,8), %rdi
movslq -0x4(%rax,%r15,4), %rdx
incq %rdx
movq %r12, %rsi
movq %r14, %rcx
callq 0x9990
incq %r13
jmp 0x2e93e
incq %r15
jmp 0x2e933
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x94c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a158(%rip), %rdi     # 0x58af8
callq 0x9410
pushq $0x1
popq %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::Run(double*, double*)
void Net::Run(real *input, real *output) {
  if (mUnits == 0)
    return;
  SetInput(input);
  FeedForward();
  if (output != 0) {
    for (int i = 0; i < mUnits[mLayers - 1]; ++i) {
      output[i] = mOutput[mLayers - 1][i];
    }
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2ea66
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
movq %rsi, (%rax)
callq 0x2eff0
testq %rbx, %rbx
je 0x2ea62
movslq (%r14), %rax
movq 0x8(%r14), %rdx
movq 0x28(%r14), %rcx
movl -0x4(%rdx,%rax,4), %edx
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
cmpq %rsi, %rdx
je 0x2ea62
movq -0x8(%rcx,%rax,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rbx,%rsi,8)
incq %rsi
jmp 0x2ea49
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::Error()
real Net::Error() {
  real error = 0.0;
  for (int i = 0; i < mUnits[mLayers - 1]; ++i) {
    error += (mDesire[i] - mOutput[mLayers - 1][i]) *
             (mDesire[i] - mOutput[mLayers - 1][i]);
  }
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq 0x28(%rdi), %rcx
movl -0x4(%rdx,%rax,4), %edx
movq 0x30(%rdi), %rsi
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
xorpd %xmm0, %xmm0
cmpq %rdi, %rdx
je 0x2eaac
movsd (%rsi,%rdi,8), %xmm1
movq -0x8(%rcx,%rax,8), %r8
subsd (%r8,%rdi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdi
jmp 0x2ea8a
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::Train(double*, double*)
real Net::Train(real *input, real *desire) {
  if (mUnits == 0)
    return -1.0;
  SetInput(input);
  SetDesire(desire);
  FeedForward();
  BackProp();
  UpdateWeight();

  return Error();
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2eaec
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq %rsi, (%rax)
movq %rdx, 0x30(%rdi)
callq 0x2eff0
movq %rbx, %rdi
callq 0x2f0a0
movq %rbx, %rdi
callq 0x2f1c6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2ea68
movsd 0x2857c(%rip), %xmm0    # 0x57070
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::FeedForward()
inline void Net::FeedForward() {
  for (int i = 1; i < mLayers; ++i) {
    for (int j = 0; j < mUnits[i]; ++j) {
      mOutput[i][j] = mWeight[i][j][mUnits[i - 1]]; // bias
      for (int k = 0; k < mUnits[i - 1]; ++k) {
        mOutput[i][j] += mOutput[i - 1][k] * mWeight[i][j][k];
      }
      mOutput[i][j] = sigmoid(mOutput[i][j]);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x2f094
xorl %r15d, %r15d
movq 0x8(%rbx), %rdx
movslq (%rdx,%r14,4), %rax
cmpq %rax, %r15
jge 0x2f08c
movq 0x10(%rbx), %rcx
movq 0x28(%rbx), %rax
movq (%rcx,%r14,8), %rcx
movq (%rcx,%r15,8), %rcx
movslq -0x4(%rdx,%r14,4), %rdi
movsd (%rcx,%rdi,8), %xmm0
movq (%rax,%r14,8), %rdx
movsd %xmm0, (%rdx,%r15,8)
testl %edi, %edi
movl $0x0, %esi
cmovgl %edi, %esi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x2f071
movq -0x8(%rax,%r14,8), %r8
movsd (%r8,%rdi,8), %xmm1
mulsd (%rcx,%rdi,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%r15,8)
incq %rdi
jmp 0x2f04d
movq %rbx, %rdi
callq 0x2f35a
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x2f010
incq %r14
jmp 0x2f001
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::BackProp()
inline void Net::BackProp() {
  for (int i = 0; i < mUnits[mLayers - 1]; ++i) {
    mDelta[mLayers - 1][i] = (mDesire[i] - mOutput[mLayers - 1][i]) *
                             mOutput[mLayers - 1][i] *
                             (1.0 - mOutput[mLayers - 1][i]);
  }

  for (int i = mLayers - 2; i >= 1; --i) {
    for (int j = 0; j < mUnits[i]; ++j) {
      mDelta[i][j] = 0.0;
      for (int k = 0; k < mUnits[i + 1]; ++k) {
        mDelta[i][j] += mDelta[i + 1][k] * mWeight[i + 1][k][j];
      }
      mDelta[i][j] *= mOutput[i][j] * (1.0 - mOutput[i][j]);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
movq 0x20(%rdi), %rdx
movslq (%rdi), %rcx
movl -0x4(%rax,%rcx,4), %esi
movq 0x30(%rdi), %r8
movq 0x28(%rdi), %r9
xorl %r10d, %r10d
testl %esi, %esi
cmovlel %r10d, %esi
movsd 0x27f73(%rip), %xmm0    # 0x57048
cmpq %r10, %rsi
je 0x2f10f
movsd (%r8,%r10,8), %xmm1
movq -0x8(%r9,%rcx,8), %r11
movsd (%r11,%r10,8), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
mulsd %xmm1, %xmm3
movq -0x8(%rdx,%rcx,8), %r11
movsd %xmm3, (%r11,%r10,8)
incq %r10
jmp 0x2f0d5
addl $-0x2, %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x2f1ba
movl %ecx, %esi
movl (%rax,%rsi,4), %r8d
movq 0x20(%rdi), %r9
movq 0x28(%rdi), %r10
movq %rcx, -0x30(%rbp)
leal 0x1(%rcx), %r11d
testl %r8d, %r8d
cmovlel %edx, %r8d
xorl %ebx, %ebx
cmpq %r8, %rbx
je 0x2f1af
movq (%r9,%rsi,8), %r14
andq $0x0, (%r14,%rbx,8)
movl (%rax,%r11,4), %r15d
movq 0x10(%rdi), %r12
testl %r15d, %r15d
cmovlel %edx, %r15d
xorpd %xmm1, %xmm1
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x2f18a
movq (%r9,%r11,8), %rcx
movsd (%rcx,%r13,8), %xmm2
movq (%r12,%r11,8), %rcx
movq (%rcx,%r13,8), %rcx
mulsd (%rcx,%rbx,8), %xmm2
addsd %xmm2, %xmm1
movsd %xmm1, (%r14,%rbx,8)
incq %r13
jmp 0x2f15f
movq (%r10,%rsi,8), %r15
movsd (%r15,%rbx,8), %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
mulsd %xmm2, %xmm3
mulsd %xmm3, %xmm1
movsd %xmm1, (%r14,%rbx,8)
incq %rbx
jmp 0x2f13b
movq -0x30(%rbp), %rcx
decl %ecx
jmp 0x2f114
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/Net.cpp
// Function: Net::UpdateWeight()
inline void Net::UpdateWeight() {
  for (int i = 1; i < mLayers; ++i) {
    for (int j = 0; j < mUnits[i]; ++j) {
      for (int k = 0; k < mUnits[i - 1]; ++k) {
        mDeltaWeight[i][j][k] = mEta * mDelta[i][j] * mOutput[i - 1][k] +
                                mAlpha * mDeltaWeight[i][j][k];
        mWeight[i][j][k] += mDeltaWeight[i][j][k];
      }
      mDeltaWeight[i][j][mUnits[i - 1]] =
          mEta * mDelta[i][j] + mAlpha * mDeltaWeight[i][j][mUnits[i - 1]];
      mWeight[i][j][mUnits[i - 1]] += mDeltaWeight[i][j][mUnits[i - 1]];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
movabsq $0x1, %rdx
cmpq -0x38(%rbp), %rdx
jge 0x2f2f8
movq -0x30(%rbp), %rax
movl (%rax,%rdx,4), %r8d
movq 0x20(%rdi), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rdi), %r11
testl %r8d, %r8d
movl $0x0, %eax
cmovlel %eax, %r8d
xorl %ebx, %ebx
cmpq %r8, %rbx
je 0x2f2f0
movq -0x30(%rbp), %rax
movslq -0x4(%rax,%rdx,4), %r14
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
movq 0x10(%rdi), %r13
movq 0x18(%rdi), %rsi
testl %r14d, %r14d
movl $0x0, %eax
cmovgl %r14d, %eax
xorl %ecx, %ecx
movsd 0x38(%rdi), %xmm0
cmpq %rcx, %rax
je 0x2f2a6
movq (%r15,%rdx,8), %r9
mulsd (%r9,%rbx,8), %xmm0
movq -0x8(%r12,%rdx,8), %r9
movsd 0x40(%rdi), %xmm1
movq (%rsi,%rdx,8), %r10
movq (%r10,%rbx,8), %r10
mulsd (%r10,%rcx,8), %xmm1
mulsd (%r9,%rcx,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%r10,%rcx,8)
movq (%r13,%rdx,8), %r9
movq (%r9,%rbx,8), %r9
addsd (%r9,%rcx,8), %xmm0
movsd %xmm0, (%r9,%rcx,8)
incq %rcx
jmp 0x2f250
movq -0x48(%rbp), %rax
movq (%rax,%rdx,8), %rax
movsd 0x40(%rdi), %xmm1
movq (%r11,%rdx,8), %rcx
movq (%rcx,%rbx,8), %rcx
mulsd (%rcx,%r14,8), %xmm1
mulsd (%rax,%rbx,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%r14,8)
movq -0x40(%rbp), %rax
movq (%rax,%rdx,8), %rax
movq (%rax,%rbx,8), %rax
addsd (%rax,%r14,8), %xmm0
movsd %xmm0, (%rax,%r14,8)
incq %rbx
jmp 0x2f220
incq %rdx
jmp 0x2f1ec
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.h
// Function: drand(double, double)
inline double drand(double low, double high) {
  if (low > high)
    std::swap(low, high);
  if (high - low < 1.0e-10)
    return (low + high) * 0.5;
  return low + drand48() * (high - low);
}

// Assembly:
movapd %xmm1, %xmm3
minsd %xmm0, %xmm3
movapd %xmm0, %xmm4
maxsd %xmm1, %xmm4
subsd %xmm3, %xmm4
movsd 0x297d1(%rip), %xmm2    # 0x58af0
ucomisd %xmm4, %xmm2
jbe 0x2f332
addsd %xmm1, %xmm0
mulsd 0x28517(%rip), %xmm0    # 0x57848
retq
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm3, -0x10(%rbp)
movsd %xmm4, -0x8(%rbp)
callq 0x9450
mulsd -0x8(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: StatisticUnit::StatisticUnit()
StatisticUnit::StatisticUnit() {
  //初始化CU
  CU.count = 0;
  CU.average = 0;
  CU.quadrature = 0;
  CU.variance = 0;
  CU.MaxDelay.val = 0;
  CU.MaxDelay.ValTime = Time(-3, 0);
  CU.MinDelay.val = 111111110;
  CU.MinDelay.ValTime = Time(-3, 0);

  BeginName = "";
  EndName = "";
  int threshold = 20;
  MissBegin = 0;
  for (int i = 0; i < 9; i++) {
    Interval[i].threshold = threshold;
    Interval[i].count = 0;
    Interval[i].probility = 0;
    threshold += 10;
  }

  CMDSend.Dashs = 0;
  CMDSend.Turns = 0;
  CMDSend.Kicks = 0;
  CMDSend.Says = 0;
  CMDSend.TurnNecks = 0;
  CMDSend.Catchs = 0;
  CMDSend.Moves = 0;
  CMDSend.ChangeViews = 0;
  CMDSend.Tackles = 0;
  CMDSend.Pointtos = 0;
  CMDSend.Attentiontos = 0;

  CMDExecute.Dashs = 0;
  CMDExecute.Turns = 0;
  CMDExecute.Kicks = 0;
  CMDExecute.Says = 0;
  CMDExecute.TurnNecks = 0;
  CMDExecute.Catchs = 0;
  CMDExecute.Moves = 0;
  CMDExecute.ChangeViews = 0;
  CMDExecute.Tackles = 0;
  CMDExecute.Pointtos = 0;
  CMDExecute.Attentiontos = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc0(%rdi), %rax
movq %rax, 0xb0(%rdi)
andq $0x0, 0xb8(%rdi)
leaq 0xb0(%rdi), %r14
xorl %eax, %eax
movb %al, 0xc0(%rdi)
leaq 0xe0(%rdi), %rcx
movq %rcx, 0xd0(%rdi)
andq $0x0, 0xd8(%rdi)
movb %al, 0xe0(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0xd0(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
movq %rax, 0x18(%rdi)
movq $0x69f6bc6, (%rdi)      # imm = 0x69F6BC6
movq %rax, 0x8(%rdi)
leaq 0x2935c(%rip), %rsi     # 0x58760
movq %r14, %rdi
callq 0x9970
leaq 0x2934d(%rip), %rsi     # 0x58760
movq %r15, %rdi
callq 0x9970
andl $0x0, 0x54(%rbx)
leaq 0x100(%rbx), %rax
pushq $0x14
popq %rcx
cmpq $0x6e, %rcx
je 0x2f445
movq %rcx, -0x10(%rax)
andl $0x0, -0x8(%rax)
andq $0x0, (%rax)
addq $0xa, %rcx
addq $0x18, %rax
jmp 0x2f429
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x58(%rbx)
andq $0x0, 0xa8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x9240
movq %r14, %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: StatisticUnit::Flush()
void StatisticUnit::Flush() {
  char fileName[128];
  sprintf(fileName, "Test/%s-%s-%d.txt", BeginName.data(), EndName.data(),
          MyID);
  FILE *fp = fopen(fileName, "w");
  if (fp != 0) {
    PrintStatic(fp);
    OutPutInterVal(fp);
    PrintCommond(fp);
    fclose(fp);
  } else {
    PRINT_ERROR("open file error " << fileName);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq 0xb0(%rdi), %rdx
movq 0xd0(%rdi), %rcx
movl 0x50(%rdi), %r8d
leaq 0x296b4(%rip), %rsi     # 0x58b98
leaq -0x90(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x9100
leaq 0x2af4f(%rip), %rsi     # 0x5a44b
movq %r14, %rdi
callq 0x95a0
testq %rax, %rax
je 0x2f540
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2f5ae
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f662
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f76e
movq %r14, %rdi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x94c0
movq 0x47aa9(%rip), %rdi     # 0x76ff0
leaq 0x2965c(%rip), %rsi     # 0x58baa
callq 0x94b0
leaq 0x2bc18(%rip), %rsi     # 0x5b172
movq %rax, %rdi
callq 0x94b0
pushq $0x62
popq %rsi
movq %rax, %rdi
callq 0x9890
leaq 0x29eab(%rip), %rsi     # 0x5941f
movq %rax, %rdi
callq 0x94b0
leaq 0x2963e(%rip), %rsi     # 0x58bc1
movq %rax, %rdi
callq 0x94b0
leaq -0x90(%rbp), %rsi
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
callq 0x99e8
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: StatisticUnit::PrintStatic(_IO_FILE*)
void StatisticUnit::PrintStatic(FILE *fp) {
  if (fp == 0) {
    return;
  }

  fprintf(fp, "Num: %ld\n", CU.count);
  fprintf(fp, "Ave: %f\n", CU.average);
  fprintf(fp, "Var: %f\n", CU.variance);
  fprintf(fp, "Max: %ld --cycle(%d,%d)\n", CU.MaxDelay.val,
          CU.MaxDelay.ValTime.T(), CU.MaxDelay.ValTime.S());
  fprintf(fp, "Min: %ld --cycle(%d,%d)\n", CU.MinDelay.val,
          CU.MinDelay.ValTime.T(), CU.MinDelay.ValTime.S());
  fprintf(fp, "Miss %s : %d\n", BeginName.data(), MissBegin);
}

// Assembly:
testq %rsi, %rsi
je 0x2f660
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdx
leaq 0x29603(%rip), %rsi     # 0x58bd2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96f0
movsd 0x20(%r14), %xmm0
leaq 0x295f6(%rip), %rsi     # 0x58bdc
movq %rbx, %rdi
movb $0x1, %al
callq 0x96f0
movsd 0x30(%r14), %xmm0
leaq 0x295e8(%rip), %rsi     # 0x58be5
movq %rbx, %rdi
movb $0x1, %al
callq 0x96f0
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %r8d
leaq 0x295d4(%rip), %rsi     # 0x58bee
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96f0
movq (%r14), %rdx
movl 0x8(%r14), %ecx
movl 0xc(%r14), %r8d
leaq 0x295d1(%rip), %rsi     # 0x58c07
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96f0
movq 0xb0(%r14), %rdx
movl 0x54(%r14), %ecx
leaq 0x295ce(%rip), %rsi     # 0x58c20
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x96f0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: StatisticUnit::OutPutInterVal(_IO_FILE*)
void StatisticUnit::OutPutInterVal(FILE *fp) {
  if (fp == 0) {
    return;
  }

  fprintf(fp, "\n\n");
  fprintf(fp, "\t+------------+----------+----------+\n");
  fprintf(fp, "\t|interval(ms)|count     |probility |\n");
  fprintf(fp, "\t+------------+----------+----------+\n");
  long count = 0;
  double probility = 0;
  fprintf(fp, "\t| <=%3ld      |%4d      | %1.6f |\n", Interval[0].threshold,
          Interval[0].count, Interval[0].probility);
  for (int i = 1; i < 9; i++) {
    count = Interval[i].count;
    probility = Interval[i].probility;
    fprintf(fp, "\t| %3ld~%3ld    |%4ld      | %1.6f |\n",
            Interval[i - 1].threshold, Interval[i].threshold, count, probility);
  }
  fprintf(fp, "\t+------------+----------+----------+\n\n\n");
}

// Assembly:
testq %rsi, %rsi
je 0x2f76d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x29666(%rip), %rdi     # 0x58cec
pushq $0x2
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rbx, %rcx
callq 0x9990
leaq 0x2958f(%rip), %r12     # 0x58c2e
pushq $0x26
popq %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x9990
leaq 0x2959a(%rip), %rdi     # 0x58c55
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x9990
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x9990
movq 0xf0(%r14), %rdx
movl 0xf8(%r14), %ecx
movsd 0x100(%r14), %xmm0
leaq 0x29584(%rip), %rsi     # 0x58c7c
movq %rbx, %rdi
movb $0x1, %al
callq 0x96f0
xorl %r12d, %r12d
leaq 0x29594(%rip), %r15     # 0x58ca0
cmpq $0xc0, %r12
je 0x2f74a
movslq 0x110(%r14,%r12), %r8
movsd 0x118(%r14,%r12), %xmm0
movq 0xf0(%r14,%r12), %rdx
movq 0x108(%r14,%r12), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x96f0
addq $0x18, %r12
jmp 0x2f70c
leaq 0x29575(%rip), %rdi     # 0x58cc6
pushq $0x28
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9990
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: StatisticUnit::InterValStacistic(long)
void StatisticUnit::InterValStacistic(long val) {
  for (int i = 0; i < 9; i++) {
    if (Interval[i].threshold * 1000 >= val) {
      Interval[i].count++;
      break;
    }
  }
  for (int i = 0; i < 9; i++) {
    Interval[i].probility = ((double)Interval[i].count) / (double)CU.count;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x18(%rax), %rcx
cmpq $0xf0, %rcx
je 0x2fa3e
imulq $0x3e8, 0xf0(%rdi,%rax), %rdx # imm = 0x3E8
movq %rcx, %rax
cmpq %rsi, %rdx
jl 0x2fa16
incl 0xe0(%rdi,%rcx)
cvtsi2sdq 0x28(%rdi), %xmm0
xorl %eax, %eax
cmpq $0xd8, %rax
je 0x2fa6a
cvtsi2sdl 0xf8(%rdi,%rax), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x100(%rdi,%rax)
addq $0x18, %rax
jmp 0x2fa46
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: StatisticUnit::SetStatistic(long, Time)
void StatisticUnit::SetStatistic(long val, Time current) {
  TIMEDATA td;
  td.val = val;
  td.ValTime = current;
  SetMaxVal(td);
  SetMinVal(td);
  SetAverage(val);
  Setquadrature(val);
  SetVariance();
  CU.count++;
  InterValStacistic(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x10(%rdi)
jge 0x2fb19
movq %rbx, 0x10(%r14)
movq %rdx, 0x18(%r14)
cmpq %rbx, (%r14)
jle 0x2fb25
movq %rbx, (%r14)
movq %rdx, 0x8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2faae
movsd 0x20(%r14), %xmm0
movsd 0x38(%r14), %xmm1
mulsd %xmm0, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x30(%r14)
incq 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2fa10
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: NetworkTest::NetworkTest()
NetworkTest::NetworkTest() {
  BeginTimelist.clear();
  EndTimelist.clear();
  StatUnit.clear();
  mUnum = 0;

  CMDSend.Dashs = 0;
  CMDSend.Turns = 0;
  CMDSend.Kicks = 0;
  CMDSend.Says = 0;
  CMDSend.TurnNecks = 0;
  CMDSend.Catchs = 0;
  CMDSend.Moves = 0;
  CMDSend.ChangeViews = 0;
  CMDSend.Tackles = 0;
  CMDSend.Pointtos = 0;
  CMDSend.Attentiontos = 0;

  CMDExecute.Dashs = 0;
  CMDExecute.Turns = 0;
  CMDExecute.Kicks = 0;
  CMDExecute.Says = 0;
  CMDExecute.TurnNecks = 0;
  CMDExecute.Catchs = 0;
  CMDExecute.Moves = 0;
  CMDExecute.ChangeViews = 0;
  CMDExecute.Tackles = 0;
  CMDExecute.Pointtos = 0;
  CMDExecute.Attentiontos = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x50(%rdi), %rax
andl $0x0, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
movq %rax, 0x60(%rdi)
movq %rax, 0x68(%rdi)
andq $0x0, 0x70(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x30(%rdi), %r15
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
movq %rax, 0x78(%rdi)
movups %xmm0, 0xf0(%rdi)
movups %xmm0, 0x100(%rdi)
movups %xmm0, 0x110(%rdi)
movups %xmm0, 0x120(%rdi)
movups %xmm0, 0x130(%rdi)
andq $0x0, 0x150(%rdi)
movups %xmm0, 0x140(%rdi)
movq %rax, 0x15c(%rdi)
movups %xmm0, 0x178(%rdi)
movups %xmm0, 0x168(%rdi)
movq %rax, 0x18c(%rdi)
movups %xmm0, 0x1a8(%rdi)
movups %xmm0, 0x198(%rdi)
movq %rax, 0x1bc(%rdi)
callq 0x30b8c
movq %r14, %rdi
callq 0x30b8c
movq %r15, %rdi
callq 0x30b9a
andl $0x0, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0xa8(%rbx)
movups %xmm0, 0xb8(%rbx)
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xd8(%rbx)
andq $0x0, 0xe8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: NetworkTest::~NetworkTest()
NetworkTest::~NetworkTest() {
  if (StatUnit.size() > 0) {
    StatUnit[0].setCMDData(CMDSend, CMDExecute);
  }
  // BeginTimelist.clear();
  // EndTimelist.clear();
  // StatUnit.clear();

  WriteRealTimeRecord(); // record RealTime information
  std::for_each(StatUnit.begin(), StatUnit.end(),
                std::mem_fun_ref(&StatisticUnit::Flush));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x2fcf7
movups 0xc4(%rbx), %xmm0
movups 0xd4(%rbx), %xmm1
movups 0xe0(%rbx), %xmm2
movups %xmm2, -0x24(%rbp)
movaps %xmm1, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movups 0x98(%rbx), %xmm0
movups 0xa8(%rbx), %xmm1
movq 0xb8(%rbx), %rcx
movl 0xc0(%rbx), %edx
movl %edx, 0x80(%rax)
movq %rcx, 0x78(%rax)
movups %xmm1, 0x68(%rax)
movups %xmm0, 0x58(%rax)
movaps -0x40(%rbp), %xmm0
movaps -0x30(%rbp), %xmm1
movups %xmm0, 0x84(%rax)
movups %xmm1, 0x94(%rax)
movups -0x24(%rbp), %xmm0
movups %xmm0, 0xa0(%rax)
movq %rbx, %rdi
callq 0x2fd70
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
leaq -0x854(%rip), %rdx      # 0x2f4ba
xorl %ecx, %ecx
callq 0x30bff
leaq 0x30(%rbx), %r14
leaq 0x120(%rbx), %rdi
callq 0x30ed8
leaq 0x108(%rbx), %rdi
callq 0x30ed8
leaq 0xf0(%rbx), %rdi
callq 0x30ed8
leaq 0x48(%rbx), %rdi
callq 0x30d62
movq %r14, %rdi
callq 0x30ba8
leaq 0x18(%rbx), %rdi
callq 0x30bd4
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x30bd4
movq %rax, %rdi
callq 0x10599
nop
// File: /workspace/github_cpp_makefile_star2_O2/wrighteagle2d[P]wrighteaglebase/Debug/../src/NetworkTest.cpp
// Function: NetworkTest::Begin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void NetworkTest::Begin(const std::string BeginName) {
  if (PlayerParam::instance().NetworkTest()) {
    int i = 0, size = BeginTimelist.size();
    for (; i < size; i++) {
      if (!BeginTimelist[i].Name.compare(BeginName)) {
        break;
      }
    }
    if (i == size) {
      TIMEUNIT Bg;
      Bg.RT = GetRealTime();
      Bg.Name = BeginName;
      Bg.IsRecord = false;
      BeginTimelist.push_back(Bg);
    } else {
      BeginTimelist[i].RT = GetRealTime();
      BeginTimelist[i].IsRecord = true;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x38d94
cmpb $0x1, 0x5c49(%rax)
jne 0x302cc
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x38
popq %rcx
cqto
idivq %rcx
xorl %r13d, %r13d
testl %eax, %eax
movl $0x0, %r15d
movq %rax, -0x30(%rbp)
cmovgl %eax, %r15d
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x3025d
movq (%rbx), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x9070
testl %eax, %eax
je 0x3025a
incq %r12
addq $0x38, %r13
jmp 0x3023a
movl %r12d, %r15d
cmpl -0x30(%rbp), %r15d
jne 0x302ae
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
callq 0x47448
leaq -0x68(%rbp), %rdi
movq %rax, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %r14, %rsi
callq 0x92b0
leaq -0x68(%rbp), %rsi
movb $0x0, 0x30(%rsi)
movq %rbx, %rdi
callq 0x30c4a
leaq -0x68(%rbp), %rdi
callq 0x9240
jmp 0x302cc
callq 0x47448
movl %r15d, %ecx
movq (%rbx), %rsi
imulq $0x38, %rcx, %rcx
movq %rax, 0x20(%rsi,%rcx)
movq %rdx, 0x28(%rsi,%rcx)
movb $0x1, 0x30(%rsi,%rcx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x302dd
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38d94
cmpb $0x1, 0x5c49(%rax)
jne 0x303ff
movq %rbx, -0x30(%rbp)
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
movq %r15, -0x38(%rbp)
leaq 0x18(%r15), %r12
pushq $0x38
popq %rcx
cqto
idivq %rcx
xorl %r15d, %r15d
testl %eax, %eax
movl $0x0, %r13d
movq %rax, -0x40(%rbp)
cmovgl %eax, %r13d
xorl %ebx, %ebx
cmpq %rbx, %r13
je 0x30373
movq (%r12), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x9070
testl %eax, %eax
je 0x30370
incq %rbx
addq $0x38, %r15
jmp 0x3034f
movl %ebx, %r13d
cmpl -0x40(%rbp), %r13d
jne 0x303e0
leaq -0x68(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
callq 0x47448
leaq -0x78(%rbp), %rdi
movq %rax, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %r14, %rsi
callq 0x92b0
leaq -0x78(%rbp), %rsi
movb $0x0, 0x30(%rsi)
movq %r12, %rdi
callq 0x30c4a
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
movq %r14, %rsi
callq 0x30c86
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x92b0
leaq -0x78(%rbp), %rdi
callq 0x9240
jmp 0x303ff
callq 0x47448
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 0x30410
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x9240
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %r12
movq %rdi, %r14
callq 0x38d94
xorl %ecx, %ecx
cmpb $0x1, 0x5c49(%rax)
jne 0x304d8
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
pushq $0x38
popq %rsi
cqto
idivq %rsi
testl %eax, %eax
cmovlel %ecx, %eax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
je 0x304d8
movq %rax, -0x40(%rbp)
imulq $0x38, %rax, %r13
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq -0x38(%rbp), %rsi
callq 0x9070
testl %eax, %eax
je 0x30499
movq -0x40(%rbp), %rax
incq %rax
jmp 0x3046e
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
pushq $0x38
popq %rcx
idivq %rcx
movq %rax, %r15
testl %r15d, %r15d
movl $0x0, %eax
cmovlel %eax, %r15d
pushq $0x28
popq %rbx
subl $0x1, %r15d
jb 0x30490
movq (%r14), %rdi
addq %r13, %rdi
movq %r12, %rsi
callq 0x9070
testl %eax, %eax
je 0x304dc
addq $0x38, %rbx
jmp 0x304ba
xorl %eax, %eax
jmp 0x304fd
movq (%r14), %rsi
movq 0x18(%r14), %rcx
movq 0x20(%rcx,%r13), %rdx
subq -0x8(%rsi,%rbx), %rdx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
addq 0x28(%rcx,%r13), %rax
subq (%rsi,%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38d94
cmpb $0x1, 0x5c49(%rax)
jne 0x308df
movl (%r14), %eax
decl %eax
cmpl $0xa, %eax
ja 0x308df
leaq 0x282ec(%rip), %rcx     # 0x58b6c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl 0xa0(%rbx)
jmp 0x308df
incl 0xbc(%rbx)
jmp 0x308df
incl 0xb0(%rbx)
jmp 0x308df
incl 0xa8(%rbx)
jmp 0x308df
incl 0xa4(%rbx)
jmp 0x308df
incl 0xb8(%rbx)
jmp 0x308df
incl 0x9c(%rbx)
jmp 0x308df
incl 0x98(%rbx)
jmp 0x308df
incl 0xc0(%rbx)
jmp 0x308df
incl 0xb4(%rbx)
jmp 0x308df
incl 0xac(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38d94
cmpb $0x1, 0x5c49(%rax)
jne 0x30972
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_O2/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 0x38d94
cmpb $0x1, 0x5c49(%rax)
jne 0x30a24
callq 0x47448
leaq 0x138(%rbx), %r15
leaq 0x148(%rbx), %rdi
movq %rax, 0x148(%rbx)
movq %rdx, 0x150(%rbx)
movq %r15, %rsi
callq 0x475fc
movl %eax, 0x158(%rbx)
movq %r14, 0x15c(%rbx)
addq $0xf0, %rbx
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30d2e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38d94
cmpb $0x1, 0x5c49(%rax)
jne 0x30ad2
callq 0x47448
leaq 0x168(%rbx), %r15
leaq 0x178(%rbx), %rdi
movq %rax, 0x178(%rbx)
movq %rdx, 0x180(%rbx)
movq %r15, %rsi
callq 0x475fc
movl %eax, 0x188(%rbx)
movq %r14, 0x18c(%rbx)
addq $0x108, %rbx            # imm = 0x108
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30d2e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38d94
cmpb $0x1, 0x5c49(%rax)
jne 0x30b80
callq 0x47448
leaq 0x198(%rbx), %r15
leaq 0x1a8(%rbx), %rdi
movq %rax, 0x1a8(%rbx)
movq %rdx, 0x1b0(%rbx)
movq %r15, %rsi
callq 0x475fc
movl %eax, 0x1b8(%rbx)
movq %r14, 0x1bc(%rbx)
addq $0x120, %rbx            # imm = 0x120
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30d2e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x31e90
movq 0x451b2(%rip), %rdi     # 0x76ff0
leaq 0x2712b(%rip), %rsi     # 0x58f70
callq 0x94b0
leaq 0x29321(%rip), %rsi     # 0x5b172
movq %rax, %rdi
callq 0x94b0
pushq $0x54
popq %rsi
movq %rax, %rdi
callq 0x9890
leaq 0x275b4(%rip), %rsi     # 0x5941f
movq %rax, %rdi
callq 0x94b0
leaq 0x2710a(%rip), %rsi     # 0x58f84
movq %rax, %rdi
callq 0x94b0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x99e8
movq %rdi, %rbx
xorl %esi, %esi
cmpb $0x6c, %al
setne %sil
callq 0x31eae
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x32734
// File: /workspace/github_cpp_makefile_star2_O2/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 0x277f9(%rip), %rax     # 0x59f38
movslq (%rax), %rax
movb 0x29(%rdi), %cl
movb 0x2a(%rdi), %dl
addq $0x1fec, %rdi           # imm = 0x1FEC
movabsq $0x1, %rsi
cmpq %rax, %rsi
jg 0x3277b
movb %cl, -0x73c(%rdi)
movl %esi, -0x738(%rdi)
movb %dl, -0x4(%rdi)
movl %esi, (%rdi)
incq %rsi
addq $0xa8, %rdi
jmp 0x32759
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x32971
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 0x32961
movb $0x72, 0x3344(%rdi)
movl $0x1, 0x3348(%rdi)
movl $0x3f, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
popq %rbp
jmp 0x32974
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x32d2e
imulq $0x70, %rax, %rcx
movb $0x1, 0x2880(%rdi,%rcx)
movb %sil, 0x2881(%rdi,%rcx)
movsd %xmm0, 0x2840(%rdi,%rcx)
movq 0xc(%rdi), %r10
movq %r10, 0x2848(%rdi,%rcx)
movsd %xmm1, 0x2850(%rdi,%rcx)
movq 0xc(%rdi), %r10
movq %r10, 0x2858(%rdi,%rcx)
movb %dl, 0x2884(%rdi,%rcx)
movq %r10, 0x2888(%rdi,%rcx)
movb %r8b, 0x2890(%rdi,%rcx)
movq %r10, 0x2894(%rdi,%rcx)
movl %r9d, 0x28a8(%rdi,%rcx)
shlq $0x4, %rax
movups 0x3344(%rdi), %xmm0
movups %xmm0, 0x31e4(%rdi,%rax)
incl 0x31e0(%rdi)
movl 0x3348(%rdi), %r9d
leal 0x1(%r9), %eax
movl %eax, 0x3348(%rdi)
movb 0x28(%rdi), %cl
movb 0x29(%rdi), %dl
movl $0x72, %r8d
movl $0x6c, %eax
movzbl %sil, %esi
cmpl $0xa, %r9d
jg 0x32d02
leaq 0x3344(%rdi), %r9
cmpb $0x6c, %sil
movl %eax, %r10d
cmovel %r8d, %r10d
cmpb %dl, %cl
cmovel %esi, %r10d
cmpb (%r9), %r10b
je 0x32d13
movb $0x72, 0x3344(%rdi)
movl $0x1, 0x3348(%rdi)
cmpb $0x6c, %sil
cmovel %r8d, %eax
cmpb %dl, %cl
cmovel %esi, %eax
movsbl %al, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
popq %rbp
jmp 0x32974
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x18, %rsp
movq %rdx, %r14
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
leaq -0x24(%rbp), %r15
movl %esi, (%r15)
callq 0x2ca2e
leaq 0x25096(%rip), %rsi     # 0x581fb
movq %rax, %rdi
callq 0x2cc3e
leaq 0x25e53(%rip), %rsi     # 0x58fc7
movq %rax, %rdi
callq 0x1a606
leaq 0xc(%rbx), %rsi
movq %rax, %rdi
callq 0x10e94
leaq 0x25e3c(%rip), %rsi     # 0x58fcb
movq %rax, %rdi
callq 0x10f8a
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a512
movq 0x43e07(%rip), %rsi     # 0x76fb0
movq %rax, %rdi
callq 0x10f5c
movb $0x1, 0x1e0(%rbx)
leaq 0x1e8(%rbx), %rdi
movq %r14, %rsi
callq 0x92b0
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x238(%rbx)
movl (%r15), %eax
movl %eax, 0x240(%rbx)
addq $0x18, %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::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 0x4206e
movq %rbx, %rdi
callq 0x31d2e
movq %r14, %rdi
callq 0x4208a
callq 0x3db2c
cmpb $0x1, 0x32c9(%rax)
jne 0x3322b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x33278
callq 0x38d94
cmpb $0x0, 0x31a5(%rax)
jne 0x33247
callq 0x38d94
cmpb $0x1, 0x31a6(%rax)
jne 0x3325c
movq %rbx, %rdi
callq 0x332ca
movl %eax, %r14d
movq %rbx, %rdi
callq 0x33360
jmp 0x3326f
movq %rbx, %rdi
callq 0x3339c
movl %eax, %r14d
movq %rbx, %rdi
callq 0x332ca
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38d94
movl 0x5c54(%rax), %r14d
callq 0x3db2c
movq %rax, %rcx
movb $0x1, %al
cmpb $0x0, 0x3389(%rbx)
jne 0x332be
imull 0x329c(%rcx), %r14d
imull $0x3e8, %r14d, %esi     # imm = 0x3E8
leaq 0x3440(%rbx), %rdi
callq 0x41f78
xorb $0x1, %al
movb $0x0, 0x3389(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x38d94
cmpb $0x0, 0x31a5(%rax)
jne 0x332f0
callq 0x38d94
cmpb $0x1, 0x31a6(%rax)
jne 0x33312
callq 0x38d94
movl 0x5c54(%rax), %r14d
callq 0x3db2c
imull 0x329c(%rax), %r14d
imull $0x3e8, %r14d, %r14d    # imm = 0x3E8
jmp 0x33337
callq 0x3db2c
movl 0x3380(%rax), %r14d
callq 0x38d94
addl 0x5c4c(%rax), %r14d
callq 0x3db2c
imull 0x329c(%rax), %r14d
movb $0x1, %al
cmpb $0x0, 0x3388(%rbx)
jne 0x33353
leaq 0x33e8(%rbx), %rdi
movl %r14d, %esi
callq 0x41f78
xorb $0x1, %al
movb $0x0, 0x3388(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop