LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x60a44
jmp 0x60b64
movq -0x10(%rbp), %rdi
leaq 0x63b6c(%rip), %rsi     # 0xc45bb
callq 0xa710
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x60a74
leaq 0x6202b(%rip), %rdi     # 0xc2a90
callq 0xa4c0
movl $0x1, %edi
callq 0xa740
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0xaba0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movslq (%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x4, %esi
callq 0xaba0
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0xaba0
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0xaba0
movl $0x1, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x60b5b
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
movq 0x8(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x60b4e
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq -0x18(%rbp), %rcx
movl $0x8, %esi
callq 0xaba0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x60af3
jmp 0x60b50
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x60ae1
movq -0x18(%rbp), %rdi
callq 0xa5b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x60c65
jmp 0x60cd8
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x61530
movq -0x28(%rbp), %rdi
callq 0x61550
cmpq $0x0, -0x18(%rbp)
je 0x60cd8
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %eax
movq 0x8(%rdx), %rcx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x60cd6
movq -0x28(%rbp), %rcx
movq 0x28(%rcx), %rax
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x60c89
jmp 0x60cd8
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %eax
movq 0x8(%rdx), %rcx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x60d87
movq -0x20(%rbp), %rcx
movq 0x30(%rcx), %rax
movslq -0x14(%rbp), %rdx
movsd (%rax,%rdx,8), %xmm0
movq 0x28(%rcx), %rax
movl (%rcx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movslq -0x14(%rbp), %rdx
subsd (%rax,%rdx,8), %xmm0
movq 0x30(%rcx), %rax
movslq -0x14(%rbp), %rdx
movsd (%rax,%rdx,8), %xmm2
movq 0x28(%rcx), %rax
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x60cff
movsd -0x10(%rbp), %xmm0
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x60dc2
movsd 0x60a6d(%rip), %xmm0    # 0xc1828
movsd %xmm0, -0x8(%rbp)
jmp 0x60e05
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x61530
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x616d0
movq -0x28(%rbp), %rdi
callq 0x61550
movq -0x28(%rbp), %rdi
callq 0x616f0
movq -0x28(%rbp), %rdi
callq 0x61910
movq -0x28(%rbp), %rdi
callq 0x60ce0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x616bc
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
movq 0x8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x616ac
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rax), %rdx
movl -0xc(%rbp), %esi
subl $0x1, %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movq 0x8(%rcx), %rcx
movl -0xc(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x61667
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
movl -0xc(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x615e3
movq -0x20(%rbp), %rdi
movq 0x28(%rdi), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x61be0
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x61581
jmp 0x616ae
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6156b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x61b6b
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2b3a0
movsd -0x18(%rbp), %xmm1
subsd -0x10(%rbp), %xmm1
movsd 0x60f0b(%rip), %xmm0    # 0xc2a88
ucomisd %xmm1, %xmm0
jbe 0x61ba0
movsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd 0x5f48b(%rip), %xmm1    # 0xc1020
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x61bcb
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0xa520
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
subsd -0x10(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0xb0, %rdi
callq 0xa330
movq -0xa0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
addq $0xd0, %rdi
callq 0xa330
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movl 0x50(%rax), %r8d
leaq 0x60bef(%rip), %rsi     # 0xc2b30
movb $0x0, %al
callq 0xa130
leaq -0x90(%rbp), %rdi
leaq 0x62665(%rip), %rsi     # 0xc45bb
callq 0xa710
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0x61fb3
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x62030
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x62180
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x622f0
movq -0x98(%rbp), %rdi
callq 0xa5b0
jmp 0x62022
jmp 0x61fb5
movq 0x9c034(%rip), %rdi     # 0xfdff0
leaq 0x60b7f(%rip), %rsi     # 0xc2b42
callq 0xa5a0
movq %rax, %rdi
leaq 0x6327f(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x62, %esi
callq 0xaa40
movq %rax, %rdi
leaq 0x61571(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x60b5c(%rip), %rsi     # 0xc2b59
callq 0xa5a0
movq %rax, %rdi
leaq -0x90(%rbp), %rsi
callq 0xa5a0
movq %rax, %rdi
movq 0x9bf95(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x62022
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x62054
jmp 0x62171
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rdx
leaq 0x60b03(%rip), %rsi     # 0xc2b6a
movb $0x0, %al
callq 0xa890
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x20(%rax), %xmm0
leaq 0x60af2(%rip), %rsi     # 0xc2b74
movb $0x1, %al
callq 0xa890
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x30(%rax), %xmm0
leaq 0x60ae0(%rip), %rsi     # 0xc2b7d
movb $0x1, %al
callq 0xa890
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x48(%rbp)
addq $0x10, %rdi
addq $0x8, %rdi
callq 0x13040
movq -0x18(%rbp), %rdi
movl %eax, -0x3c(%rbp)
addq $0x10, %rdi
addq $0x8, %rdi
callq 0x13050
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movl -0x3c(%rbp), %ecx
movl %eax, %r8d
leaq 0x60a98(%rip), %rsi     # 0xc2b86
movb $0x0, %al
callq 0xa890
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x13040
movq -0x18(%rbp), %rdi
movl %eax, -0x24(%rbp)
addq $0x8, %rdi
callq 0x13050
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl %eax, %r8d
leaq 0x60a69(%rip), %rsi     # 0xc2b9f
movb $0x0, %al
callq 0xa890
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0xb0, %rdi
callq 0xa330
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rax
movl 0x54(%rax), %ecx
leaq 0x60a4e(%rip), %rsi     # 0xc2bb8
movb $0x0, %al
callq 0xa890
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x621a4
jmp 0x622e4
movq -0x10(%rbp), %rdi
leaq 0x60ad5(%rip), %rsi     # 0xc2c84
movb $0x0, %al
callq 0xa890
movq -0x10(%rbp), %rdi
leaq 0x60a05(%rip), %rsi     # 0xc2bc6
movb $0x0, %al
callq 0xa890
movq -0x10(%rbp), %rdi
leaq 0x60a1a(%rip), %rsi     # 0xc2bed
movb $0x0, %al
callq 0xa890
movq -0x10(%rbp), %rdi
leaq 0x609e1(%rip), %rsi     # 0xc2bc6
movb $0x0, %al
callq 0xa890
movq -0x30(%rbp), %rax
movq $0x0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq 0xf0(%rax), %rdx
movl 0xf8(%rax), %ecx
movsd 0x100(%rax), %xmm0
leaq 0x609f4(%rip), %rsi     # 0xc2c14
movb $0x1, %al
callq 0xa890
movl $0x1, -0x24(%rbp)
cmpl $0x9, -0x24(%rbp)
jge 0x622d2
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0xf0, %rcx
movslq -0x24(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movslq 0x8(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
addq $0xf0, %rcx
movslq -0x24(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rax, %rcx
addq $0xf0, %rcx
movl -0x24(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
addq $0xf0, %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x18(%rbp), %r8
movsd -0x20(%rbp), %xmm0
leaq 0x6097b(%rip), %rsi     # 0xc2c38
movb $0x1, %al
callq 0xa890
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6222e
movq -0x10(%rbp), %rdi
leaq 0x60981(%rip), %rsi     # 0xc2c5e
movb $0x0, %al
callq 0xa890
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x9, -0x14(%rbp)
jge 0x62800
movq -0x20(%rbp), %rax
addq $0xf0, %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
imulq $0x3e8, (%rax), %rax    # imm = 0x3E8
cmpq -0x10(%rbp), %rax
jl 0x627f3
movq -0x20(%rbp), %rax
addq $0xf0, %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x62800
jmp 0x627f5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x627ab
movl $0x0, -0x18(%rbp)
cmpl $0x9, -0x18(%rbp)
jge 0x62856
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0xf0, %rcx
movslq -0x18(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cvtsi2sdl 0x8(%rcx), %xmm0
cvtsi2sdq 0x28(%rax), %xmm1
divsd %xmm1, %xmm0
addq $0xf0, %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x62807
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x64630
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x62860
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x62750
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x628a0
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x628f0
movq -0x50(%rbp), %rdi
callq 0x62940
movq -0x50(%rbp), %rdi
movq 0x28(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x28(%rdi)
movq -0x18(%rbp), %rsi
callq 0x62790
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x64660
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x64660
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x30(%rbp)
callq 0x64680
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x28(%rbp)
callq 0x646a0
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
jmp 0x62ab9
movq -0x40(%rbp), %rdi
addq $0xf0, %rdi
movq %rdi, -0x58(%rbp)
callq 0x646c0
movq -0x40(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movq %rdi, -0x50(%rbp)
callq 0x646c0
movq -0x40(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movq %rdi, -0x48(%rbp)
callq 0x646c0
movq -0x40(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x646e0
jmp 0x62b07
movq -0x40(%rbp), %rdi
addq $0x168, %rdi            # imm = 0x168
callq 0x646e0
jmp 0x62b19
movq -0x40(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x646e0
jmp 0x62b2b
movq -0x40(%rbp), %rdi
callq 0x64730
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x64730
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x64750
movq -0x40(%rbp), %rax
movl $0x0, 0x80(%rax)
movl $0x0, 0x9c(%rax)
movl $0x0, 0xa0(%rax)
movl $0x0, 0x98(%rax)
movl $0x0, 0xa4(%rax)
movl $0x0, 0xa8(%rax)
movl $0x0, 0xac(%rax)
movl $0x0, 0xb0(%rax)
movl $0x0, 0xb4(%rax)
movl $0x0, 0xc0(%rax)
movl $0x0, 0xb8(%rax)
movl $0x0, 0xbc(%rax)
movl $0x0, 0xc8(%rax)
movl $0x0, 0xcc(%rax)
movl $0x0, 0xc4(%rax)
movl $0x0, 0xd0(%rax)
movl $0x0, 0xd4(%rax)
movl $0x0, 0xd8(%rax)
movl $0x0, 0xdc(%rax)
movl $0x0, 0xe0(%rax)
movl $0x0, 0xec(%rax)
movl $0x0, 0xe4(%rax)
movl $0x0, 0xe8(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x62c73
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x64770
movq -0x50(%rbp), %rdi
callq 0x64770
movq -0x58(%rbp), %rdi
callq 0x64770
movq -0x28(%rbp), %rdi
callq 0x647d0
movq -0x30(%rbp), %rdi
callq 0x647f0
movq -0x38(%rbp), %rdi
callq 0x64850
movq -0x20(%rbp), %rdi
callq 0x64850
movq -0x10(%rbp), %rdi
callq 0xaa60
// File: 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
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
addq $0x30, %rdi
callq 0x648b0
cmpq $0x0, %rax
jbe 0x62d68
movq -0xb8(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x648e0
movq %rax, %rdi
movq -0xb8(%rbp), %rax
movups 0x98(%rax), %xmm0
movups 0xa8(%rax), %xmm1
movups 0xb4(%rax), %xmm2
movups %xmm2, -0x24(%rbp)
movaps %xmm1, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movups 0xc4(%rax), %xmm0
movups 0xd4(%rax), %xmm1
movups 0xe0(%rax), %xmm2
movups %xmm2, -0x54(%rbp)
movaps %xmm1, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movups -0x54(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x4c(%rax)
movaps -0x70(%rbp), %xmm0
movaps -0x60(%rbp), %xmm1
movups %xmm1, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups -0x24(%rbp), %xmm0
movups %xmm0, 0x1c(%rax)
movaps -0x40(%rbp), %xmm0
movaps -0x30(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x64900
jmp 0x62d66
jmp 0x62d68
movq -0xb8(%rbp), %rdi
callq 0x62ed0
jmp 0x62d76
movq -0xb8(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0xd0(%rbp)
callq 0x649c0
movq -0xd0(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x649f0
movq %rax, -0x80(%rbp)
leaq -0xed8(%rip), %rax      # 0x61ed0
movq %rax, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x64a20
movq %rdx, -0xc8(%rbp)
movq %rax, -0xc0(%rbp)
jmp 0x62ddd
movq -0xc8(%rbp), %rax
movq -0xc0(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
callq 0x64950
movq %rdx, -0xe0(%rbp)
movq %rax, -0xd8(%rbp)
jmp 0x62e24
movq -0xb8(%rbp), %rdi
movq -0xe0(%rbp), %rax
movq -0xd8(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movq %rax, -0xa8(%rbp)
addq $0x120, %rdi            # imm = 0x120
callq 0x64770
movq -0xb8(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x64770
movq -0xb8(%rbp), %rdi
addq $0xf0, %rdi
callq 0x64770
movq -0xb8(%rbp), %rdi
addq $0x48, %rdi
callq 0x647d0
movq -0xb8(%rbp), %rdi
addq $0x30, %rdi
callq 0x647f0
movq -0xb8(%rbp), %rdi
addq $0x18, %rdi
callq 0x64850
movq -0xb8(%rbp), %rdi
callq 0x64850
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rdi
callq 0x12860
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x64a70
testb $0x1, (%rax)
je 0x638f8
movq -0x88(%rbp), %rdi
movl $0x0, -0x14(%rbp)
callq 0x64a90
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x6381c
movq -0x88(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x64ac0
movq -0x90(%rbp), %rsi
movq %rax, %rdi
callq 0xa070
cmpl $0x0, %eax
jne 0x6380f
jmp 0x6381c
jmp 0x63811
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x637e1
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x638b5
leaq -0x50(%rbp), %rdi
callq 0x64ae0
callq 0x9e560
movq %rdx, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x63846
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x64b40
jmp 0x6386b
movq -0x90(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa080
jmp 0x6387d
movq -0x88(%rbp), %rdi
movb $0x0, -0x20(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x64b70
jmp 0x63893
leaq -0x50(%rbp), %rdi
callq 0x64be0
jmp 0x638f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x64be0
jmp 0x63901
callq 0x9e560
movq -0x88(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x64ac0
movq %rax, %rdi
addq $0x20, %rdi
leaq -0x80(%rbp), %rsi
callq 0x64b40
movq -0x88(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x64ac0
movb $0x1, 0x30(%rax)
jmp 0x638f8
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xaa60
nopw (%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x64a70
testb $0x1, (%rax)
je 0x63ad2
movq -0x90(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
addq $0x18, %rdi
callq 0x64a90
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x639af
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x64ac0
movq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0xa070
cmpl $0x0, %eax
jne 0x639a2
jmp 0x639af
jmp 0x639a4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x63970
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x63a81
leaq -0x58(%rbp), %rdi
callq 0x64ae0
callq 0x9e560
movq %rdx, -0xb0(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x639d9
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x64b40
jmp 0x639fe
movq -0x98(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xa080
jmp 0x63a10
movq -0x90(%rbp), %rdi
movb $0x0, -0x28(%rbp)
addq $0x18, %rdi
leaq -0x58(%rbp), %rsi
callq 0x64b70
jmp 0x63a2a
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
addq $0x48, %rdi
callq 0x64c00
movq %rax, -0xb8(%rbp)
jmp 0x63a4a
movq -0xa0(%rbp), %rsi
movq -0xb8(%rbp), %rdi
callq 0xa080
jmp 0x63a5f
leaq -0x58(%rbp), %rdi
callq 0x64be0
jmp 0x63ad0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x64be0
jmp 0x63adb
callq 0x9e560
movq -0x90(%rbp), %rdi
movq %rax, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
addq $0x18, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x64ac0
movq %rax, %rdi
addq $0x20, %rdi
leaq -0x88(%rbp), %rsi
callq 0x64b40
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x64ac0
movb $0x1, 0x30(%rax)
jmp 0x63ad2
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x64a70
testb $0x1, (%rax)
je 0x63c83
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x64a90
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x63c81
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0x24(%rbp), %rsi
callq 0x64ac0
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0xa070
cmpl $0x0, %eax
jne 0x63c71
movq -0x40(%rbp), %rdi
callq 0x64a90
movl %eax, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x63c6f
movq -0x40(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x64ac0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0xa070
cmpl $0x0, %eax
jne 0x63c5f
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0x24(%rbp), %rsi
callq 0x64ac0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x64ce0
movq -0x40(%rbp), %rdi
movq %rax, -0x68(%rbp)
movslq -0x2c(%rbp), %rsi
callq 0x64ac0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x64ce0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x68(%rbp), %rax
subq %rcx, %rax
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
movq %rax, -0x60(%rbp)
addq $0x18, %rdi
movslq -0x24(%rbp), %rsi
callq 0x64ac0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x64d00
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x60(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movslq -0x2c(%rbp), %rsi
callq 0x64ac0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x64d00
movq %rax, %rcx
movq -0x58(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x63c8b
jmp 0x63c61
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x63b86
jmp 0x63c71
jmp 0x63c73
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x63b41
jmp 0x63c83
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x64a70
testb $0x1, (%rax)
je 0x64262
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x64260
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xa, %eax
ja 0x6425c
movq -0x20(%rbp), %rax
leaq 0x5e9a7(%rip), %rcx     # 0xc2b04
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movl 0x98(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x98(%rax)
jmp 0x6425e
movq -0x18(%rbp), %rax
movl 0xa0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa0(%rax)
jmp 0x6425e
movq -0x18(%rbp), %rax
movl 0x9c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x9c(%rax)
jmp 0x6425e
movq -0x18(%rbp), %rax
movl 0xa4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa4(%rax)
jmp 0x6425e
movq -0x18(%rbp), %rax
movl 0xa8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa8(%rax)
jmp 0x6425e
movq -0x18(%rbp), %rax
movl 0xac(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xac(%rax)
jmp 0x6425e
movq -0x18(%rbp), %rax
movl 0xb0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb0(%rax)
jmp 0x6425e
movq -0x18(%rbp), %rax
movl 0xb4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb4(%rax)
jmp 0x6425e
movq -0x18(%rbp), %rax
movl 0xb8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb8(%rax)
jmp 0x6425e
movq -0x18(%rbp), %rax
movl 0xbc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xbc(%rax)
jmp 0x6425e
movq -0x18(%rbp), %rax
movl 0xc0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc0(%rax)
jmp 0x6425e
jmp 0x6425e
jmp 0x64260
jmp 0x64262
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x64a70
testb $0x1, (%rax)
je 0x64320
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0xc8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0xcc(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xd0(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0xd4(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0xd8(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0xdc(%rax)
movl 0x20(%rbp), %ecx
movl %ecx, 0xe0(%rax)
movl 0x28(%rbp), %ecx
movl %ecx, 0xe4(%rax)
movl 0x30(%rbp), %ecx
movl %ecx, 0xec(%rax)
movl 0x38(%rbp), %ecx
movl %ecx, 0xe8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x64a70
testb $0x1, (%rax)
je 0x64418
callq 0x9e560
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
addq $0x138, %rdi            # imm = 0x138
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x64b40
movq -0x28(%rbp), %rsi
movq %rsi, %rdi
addq $0x138, %rdi            # imm = 0x138
addq $0x10, %rdi
addq $0x138, %rsi            # imm = 0x138
callq 0x9e930
movq -0x28(%rbp), %rsi
movl %eax, 0x158(%rsi)
movq -0x8(%rbp), %rax
movq %rax, 0x15c(%rsi)
movq %rsi, %rdi
addq $0xf0, %rdi
addq $0x138, %rsi            # imm = 0x138
callq 0x64e70
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x64a70
testb $0x1, (%rax)
je 0x64508
callq 0x9e560
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
addq $0x168, %rdi            # imm = 0x168
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x64b40
movq -0x28(%rbp), %rsi
movq %rsi, %rdi
addq $0x168, %rdi            # imm = 0x168
addq $0x10, %rdi
addq $0x168, %rsi            # imm = 0x168
callq 0x9e930
movq -0x28(%rbp), %rsi
movl %eax, 0x188(%rsi)
movq -0x8(%rbp), %rax
movq %rax, 0x18c(%rsi)
movq %rsi, %rdi
addq $0x108, %rdi            # imm = 0x108
addq $0x168, %rsi            # imm = 0x168
callq 0x64e70
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x64a70
testb $0x1, (%rax)
je 0x645f8
callq 0x9e560
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
addq $0x198, %rdi            # imm = 0x198
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x64b40
movq -0x28(%rbp), %rsi
movq %rsi, %rdi
addq $0x198, %rdi            # imm = 0x198
addq $0x10, %rdi
addq $0x198, %rsi            # imm = 0x198
callq 0x9e930
movq -0x28(%rbp), %rsi
movl %eax, 0x1b8(%rsi)
movq -0x8(%rbp), %rax
movq %rax, 0x1bc(%rsi)
movq %rsi, %rdi
addq $0x120, %rdi            # imm = 0x120
addq $0x198, %rsi            # imm = 0x198
callq 0x64e70
addq $0x30, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::Reset()
void Observer::Reset() {
  // some reset work
  mIsCommandSend = false;
  mIsNewHear = false;
  mIsNewSense = false;
  mIsNewSight = false;
  mIsNewThink = false;
  /*
          mUnknownPlayerCount = 0;

          //current bug info just come from that left side players' info is sent
     before right side players' info mCurrentBugInfo.mLeastNum = 1;
          mCurrentBugInfo.mSide = 'l';*/
  ResetSight();

  mAudioObserver.Reset();

  mIsBallDropped = false;
  mIsPlanned = false;

  mReceiveFullstateMsg = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x0, 0x3384(%rdi)
movb $0x0, 0x3386(%rdi)
movb $0x0, 0x3381(%rdi)
movb $0x0, 0x3382(%rdi)
movb $0x0, 0x3383(%rdi)
callq 0x6b5f0
movq -0x10(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x6e2c0
movq -0x10(%rbp), %rax
movb $0x0, 0x118(%rax)
movb $0x0, 0x3385(%rax)
movb $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl 0x29(%rax), %eax
cmpl $0x3f, %eax
jne 0x68f6d
jmp 0x68f0f
movq 0x950da(%rip), %rdi     # 0xfdff0
leaq 0x59fcb(%rip), %rsi     # 0xc2ee8
callq 0xa5a0
movq %rax, %rdi
leaq 0x5c325(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x54, %esi
callq 0xaa40
movq %rax, %rdi
leaq 0x5a617(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x59fa5(%rip), %rsi     # 0xc2efc
callq 0xa5a0
movq %rax, %rdi
movq 0x9504a(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x68f96
movq -0x18(%rbp), %rdi
movb 0x29(%rdi), %al
subb $0x6c, %al
setne %al
negb %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x68fa0
movq -0x18(%rbp), %rdi
callq 0x6b520
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x58b63(%rip), %rcx     # 0xc40a8
cmpl (%rcx), %eax
jg 0x6b5e1
movq -0x18(%rbp), %rdi
addq $0x1870, %rdi           # imm = 0x1870
leaq -0xc(%rbp), %rsi
callq 0x6e2f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movsbl 0x29(%rax), %esi
callq 0x6e330
movq -0x18(%rbp), %rdi
addq $0x1870, %rdi           # imm = 0x1870
leaq -0xc(%rbp), %rsi
callq 0x6e2f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x6e350
movq -0x18(%rbp), %rdi
addq $0x1fa8, %rdi           # imm = 0x1FA8
leaq -0xc(%rbp), %rsi
callq 0x6e2f0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movsbl 0x2a(%rax), %esi
callq 0x6e330
movq -0x18(%rbp), %rdi
addq $0x1fa8, %rdi           # imm = 0x1FA8
leaq -0xc(%rbp), %rsi
callq 0x6e2f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x6e350
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6b53b
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Observer.cpp
// Function: Observer::ResetSight()
void Observer::ResetSight() {
  mUnknownPlayerCount = 0;
  mBugInfoRanged = 0;
  mLastLeftPlayer = -1;
  mFirstRightPlayer = -1;

  // current bug info just come from that left side players' info is sent before
  // right side players' info
  mCurrentBugInfo.mLeastNum = 1;
  mCurrentBugInfo.mSide = 'l';
  mCurrentBugInfo.mSupSide = 'r';
  mCurrentBugInfo.mSupNum = TEAMSIZE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x31e0(%rax)
movl $0x0, 0x3354(%rax)
movl $0xffffffff, 0x3358(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x335c(%rax) # imm = 0xFFFFFFFF
movl $0x1, 0x3348(%rax)
movb $0x6c, 0x3344(%rax)
movb $0x72, 0x334c(%rax)
movl $0xb, 0x3350(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x548, %rdi            # imm = 0x548
movl -0xc(%rbp), %eax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x6e1a0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
addq $0xc, %rsi
callq 0x6e370
movq -0x58(%rbp), %rdi
addq $0x548, %rdi            # imm = 0x548
movl -0xc(%rbp), %eax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x6e1a0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
addq $0xc, %rsi
callq 0x6e3a0
movq -0x58(%rbp), %rdi
addq $0x548, %rdi            # imm = 0x548
movl -0xc(%rbp), %eax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x6e1a0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
addq $0xc, %rsi
callq 0x6e3d0
movq -0x58(%rbp), %rdi
addq $0x548, %rdi            # imm = 0x548
movl -0xc(%rbp), %eax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x6e1a0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
movsd -0x30(%rbp), %xmm0
addq $0xc, %rsi
callq 0x6e400
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)