LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogRectangular(Rectangular const&, SightLogger::Color)
void Logger::LogRectangular(const Rectangular &rect, SightLogger::Color color) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();

    pSightLogger->AddLine(rect.TopLeftCorner(), rect.TopRightCorner(), color);
    pSightLogger->AddLine(rect.TopLeftCorner(), rect.BottomLeftCorner(), color);
    pSightLogger->AddLine(rect.BottomLeftCorner(), rect.BottomRightCorner(),
                          color);
    pSightLogger->AddLine(rect.BottomRightCorner(), rect.TopRightCorner(),
                          color);

    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x43dce
cmpb $0x1, 0x5c44(%rax)
jne 0x35568
movq %r15, %rdi
callq 0x34e20
movq %rax, %r12
leaq 0x228(%rax), %rdi
movq %rdi, -0x30(%rbp)
callq 0x4e01a
movq 0x258(%r12), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r12)
movsd (%r14), %xmm0
movsd 0x10(%r14), %xmm1
leaq -0x50(%rbp), %r13
movsd %xmm0, (%r13)
movsd %xmm1, 0x8(%r13)
movsd 0x8(%r14), %xmm0
leaq -0x40(%rbp), %r15
movsd %xmm0, (%r15)
movsd %xmm1, 0x8(%r15)
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x35c12
movsd (%r14), %xmm0
movsd 0x10(%r14), %xmm1
movsd %xmm0, (%r13)
movsd %xmm1, 0x8(%r13)
movsd 0x18(%r14), %xmm1
movsd %xmm0, (%r15)
movsd %xmm1, 0x8(%r15)
leaq -0x50(%rbp), %r15
leaq -0x40(%rbp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl %ebx, %ecx
callq 0x35c12
movsd (%r14), %xmm0
movsd 0x18(%r14), %xmm1
movsd %xmm0, (%r15)
movsd %xmm1, 0x8(%r15)
movsd 0x8(%r14), %xmm0
movsd %xmm0, (%r13)
movsd %xmm1, 0x8(%r13)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movl %ebx, %ecx
callq 0x35c12
movsd 0x8(%r14), %xmm0
movsd 0x18(%r14), %xmm1
movsd %xmm0, (%r15)
movsd %xmm1, 0x8(%r15)
movsd 0x10(%r14), %xmm1
movsd %xmm0, (%r13)
movsd %xmm1, 0x8(%r13)
leaq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %r12, %rdi
movl %ebx, %ecx
callq 0x35c12
movq -0x30(%rbp), %rdi
callq 0x4e036
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogDribble(Vector const&, Vector const&, char const*, bool)
void Logger::LogDribble(const Vector &start, const Vector &target,
                        const char *comment, bool is_execute) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();

    pSightLogger->AddPoint(target, comment, SightLogger::Blue);
    if (is_execute) {
      pSightLogger->AddLine(start, target, SightLogger::Blue);
    }

    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r15d
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
callq 0x43dce
cmpb $0x1, 0x5c44(%rax)
jne 0x35615
movq %r13, -0x30(%rbp)
movq %r14, %rdi
callq 0x34e20
movq %rax, %r14
leaq 0x228(%rax), %r13
movq %r13, %rdi
callq 0x4e01a
movq 0x258(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r14)
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x35ad0
testb %r15b, %r15b
je 0x355ff
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x35c12
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e036
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogPass(bool, Vector const&, Vector const&, char const*, bool)
void Logger::LogPass(const bool reverse, const Vector &start,
                     const Vector &target, const char *comment,
                     bool is_execute) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();

    pSightLogger->AddPoint(reverse ? target.Rotate(180.0) : target, comment,
                           SightLogger::Red);
    if (is_execute) {
      pSightLogger->AddLine(reverse ? start.Rotate(180.0) : start,
                            reverse ? target.Rotate(180.0) : target,
                            SightLogger::Red);
    }

    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %r13d
movq %r8, %r12
movq %rcx, %r14
movq %rdx, -0x48(%rbp)
movl %esi, %ebx
movq %rdi, %r15
callq 0x43dce
cmpb $0x1, 0x5c44(%rax)
jne 0x35742
movq %r15, %rdi
callq 0x34e20
movq %rax, %r15
leaq 0x228(%rax), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4e01a
movq 0x258(%r15), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r15)
testb %bl, %bl
je 0x356f7
movabsq $0x4066800000000000, %rbx # imm = 0x4066800000000000
leaq -0x60(%rbp), %rsi
movq %rbx, (%rsi)
movq %r14, %rdi
callq 0x3268c
leaq -0x40(%rbp), %rsi
movsd %xmm0, (%rsi)
movsd %xmm1, 0x8(%rsi)
movq %r15, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x35ad0
testb %r13b, %r13b
je 0x35739
leaq -0x78(%rbp), %rsi
movq %rbx, (%rsi)
movq -0x48(%rbp), %rdi
callq 0x3268c
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
leaq -0x70(%rbp), %rsi
movq %rbx, (%rsi)
movq %r14, %rdi
callq 0x3268c
movsd %xmm0, -0x60(%rbp)
movsd %xmm1, -0x58(%rbp)
jmp 0x35727
movups (%r14), %xmm0
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
movq %r15, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x35ad0
testb %r13b, %r13b
je 0x35739
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
movups (%r14), %xmm0
movaps %xmm0, -0x60(%rbp)
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x35c12
movq -0x68(%rbp), %rdi
callq 0x4e036
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::Construct(int, int*)
void Net::Construct(int layers, int *units) {
  if (layers == 0)
    return;
  mLayers = layers;
  mUnits = new int[mLayers];
  if (units != 0) {
    for (int i = 0; i < mLayers; ++i) {
      mUnits[i] = units[i];
    }
  }

  Memaloc();
  SetDefaultValue();
}

// Assembly:
testl %esi, %esi
je 0x36730
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, (%rdi)
movl %esi, %r15d
shlq $0x2, %r15
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %r15, %rdi
setle %r12b
callq 0x9050
movq %rax, 0x8(%rbx)
testq %r14, %r14
sete %cl
orb %r12b, %cl
jne 0x366ed
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x93e0
movq %rbx, %rdi
callq 0x369a6
movabsq $0x3fe6666666666666, %rax # imm = 0x3FE6666666666666
movq %rax, 0x38(%rbx)
movq $0x0, 0x40(%rbx)
movabsq $0x3f847ae147ae147b, %rax # imm = 0x3F847AE147AE147B
movq %rax, 0x48(%rbx)
movl $0x3e8, 0x50(%rbx)      # imm = 0x3E8
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x36b82
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::Construct(char const*)
void Net::Construct(const char *fname) {
  FILE *fp;
  if ((fp = fopen(fname, "r")) == 0) {
    perror("BPN::Construct(char *fname)");
    exit(1);
  }
#ifdef BINARY
  if (fread(&mLayers, sizeof(mLayers), 1, fp) < 1) {
    Assert(0);
  }
  mUnits = new int[mLayers];
  if (fread(mUnits, sizeof(*mUnits), mLayers, fp) < 1) {
    Assert(0);
  }
  if (fread(&mEta, sizeof(mEta), 1, fp) < 1) {
    Assert(0);
  }
  if (fread(&mAlpha, sizeof(mAlpha), 1, fp) < 1) {
    Assert(0);
  }
  Memaloc();
  InitWeight();

  for (int i = 1; i < mLayers; ++i) {
    for (int j = 0; j < mUnits[i]; ++j) {
      if (fread(mWeight[i][j], sizeof(*mWeight[i][j]), mUnits[i - 1] + 1, fp) <
          1) {
        Assert(0);
      }
    }
  }
#else
  fscanf(fp, "#mLayers\n%d\n#mUnits\n", &mLayers);
  mUnits = new int[mLayers];
  for (int i = 0; i < mLayers; ++i) {
    fscanf(fp, "%d ", &mUnits[i]);
  }
  fscanf(fp, "\n#mEta\n%lf\n#mAlpha\n%lf\n#mWeight\n", &mEta, &mAlpha);
  int tmp;
  Memaloc();
  InitWeight();

  for (int i = 1; i < mLayers; ++i) {
    fscanf(fp, "#Layer %d\n", &tmp);
    for (int j = 0; j < mUnits[i]; ++j) {
      for (int k = 0; k < mUnits[i - 1] + 1; ++k) {
        fscanf(fp, "%lf ", &mWeight[i][j][k]);
      }
      fscanf(fp, "\n");
    }
    fscanf(fp, "\n");
  }
#endif
  fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x36e02(%rip), %rsi     # 0x6d560
movq %rax, %rdi
callq 0x95a0
testq %rax, %rax
je 0x36861
movq %rax, %r14
movl $0x1, %r12d
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x9720
movslq (%rbx), %r15
leaq (,%r15,4), %rax
testq %r15, %r15
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x9050
movq %rax, 0x8(%rbx)
movl $0x4, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x9720
leaq 0x38(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x9720
leaq 0x40(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x9720
movq %rbx, %rdi
callq 0x369a6
movq %rbx, %rdi
callq 0x36b82
movl (%rbx), %ecx
cmpl $0x2, %ecx
jl 0x36851
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax,%r12,4)
jle 0x36846
xorl %r15d, %r15d
movq 0x10(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movq (%rcx,%r15,8), %rdi
movslq -0x4(%rax,%r12,4), %rdx
incq %rdx
movl $0x8, %esi
movq %r14, %rcx
callq 0x9720
incq %r15
movq 0x8(%rbx), %rax
movslq (%rax,%r12,4), %rcx
cmpq %rcx, %r15
jl 0x36813
movl (%rbx), %ecx
incq %r12
movslq %ecx, %rdx
cmpq %rdx, %r12
jl 0x36809
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x94b0
callq 0x9ea5
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::Destroy()
void Net::Destroy() {
  if (mUnits == 0)
    return;
  for (int i = 1; i < mLayers; ++i) {
    for (int j = 0; j < mUnits[i]; ++j) {
      delete[] mWeight[i][j];
      delete[] mDeltaWeight[i][j];
    }
    delete[] mWeight[i];
    delete[] mDeltaWeight[i];
  }
  delete[] mWeight;
  delete[] mDeltaWeight;

  for (int i = 1; i < mLayers; ++i) {
    delete[] mOutput[i];
    delete[] mDelta[i];
  }
  delete[] mOutput;
  delete[] mDelta;

  delete[] mUnits;
  if (mLogName != 0)
    delete[] mLogName;
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x369a4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, (%rdi)
jl 0x3690c
movl $0x1, %r14d
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
jle 0x368dd
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x368b7
callq 0x9630
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x368cd
callq 0x9630
incq %r15
movq 0x8(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %r15
jl 0x368a1
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x368ef
callq 0x9630
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x36901
callq 0x9630
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x36893
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3691a
callq 0x9630
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x36928
callq 0x9630
cmpl $0x2, (%rbx)
jl 0x36962
movl $0x1, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x36945
callq 0x9630
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x36957
callq 0x9630
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x36933
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x36970
callq 0x9630
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3697e
callq 0x9630
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3698c
callq 0x9630
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jne 0x9630
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::Memaloc()
void Net::Memaloc() {
  mWeight = new real **[mLayers];
  mDeltaWeight = new real **[mLayers];
  for (int i = 1; i < mLayers; ++i) {
    mWeight[i] = new real *[mUnits[i]];
    mDeltaWeight[i] = new real *[mUnits[i]];
    for (int j = 0; j < mUnits[i]; ++j) {
      mWeight[i][j] = new real[mUnits[i - 1] + 1];      // one bias
      mDeltaWeight[i][j] = new real[mUnits[i - 1] + 1]; // one bias
    }
  }

  mOutput = new real *[mLayers];
  mDelta = new real *[mLayers];
  for (int i = 1; i < mLayers; ++i) {
    mOutput[i] = new real[mUnits[i]];
    mDelta[i] = new real[mUnits[i]];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdi), %r15
leaq (,%r15,8), %r14
testq %r15, %r15
movq $-0x1, %r12
cmovsq %r12, %r14
movq %r14, %rdi
callq 0x9050
movq %rax, 0x10(%rbx)
movq %r14, -0x30(%rbp)
movq %r14, %rdi
callq 0x9050
movq %rax, 0x18(%rbx)
cmpq $0x2, %r15
jl 0x36abd
movq 0x8(%rbx), %rax
movl $0x1, %r13d
movslq (%rax,%r13,4), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
cmovsq %r12, %rdi
callq 0x9050
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x8(%rbx), %rax
movslq (%rax,%r13,4), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
cmovsq %r12, %rdi
callq 0x9050
movq 0x18(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax,%r13,4)
jle 0x36ab1
xorl %r14d, %r14d
movslq -0x4(%rax,%r13,4), %rax
cmpq %r12, %rax
leaq 0x8(,%rax,8), %rdi
cmovlq %r12, %rdi
callq 0x9050
movq 0x10(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r14,8)
movq 0x8(%rbx), %rax
movslq -0x4(%rax,%r13,4), %rax
cmpq $-0x1, %rax
leaq 0x8(,%rax,8), %rdi
cmovlq %r12, %rdi
callq 0x9050
movq 0x18(%rbx), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
movq 0x8(%rbx), %rax
movslq (%rax,%r13,4), %rcx
cmpq %rcx, %r14
jl 0x36a52
incq %r13
cmpq %r15, %r13
jne 0x36a00
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x9050
movq %rax, 0x28(%rbx)
movq %r14, %rdi
callq 0x9050
movq %rax, 0x20(%rbx)
cmpl $0x2, %r15d
jl 0x36b3c
movl $0x1, %r14d
movq $-0x1, %r12
movq 0x8(%rbx), %rax
movslq (%rax,%r14,4), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
cmovsq %r12, %rdi
callq 0x9050
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq 0x8(%rbx), %rax
movslq (%rax,%r14,4), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
cmovsq %r12, %rdi
callq 0x9050
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq %r14, %r15
jne 0x36aec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::InitWeight()
void Net::InitWeight() {
  for (int i = 1; i < mLayers; ++i) {
    for (int j = 0; j < mUnits[i]; ++j) {
      for (int k = 0; k < mUnits[i - 1] + 1; ++k) {
        mWeight[i][j][k] = small_rand();
        mDeltaWeight[i][j][k] = 0.0;
      }
    }
  }
}

// Assembly:
movl (%rdi), %ecx
cmpl $0x2, %ecx
jl 0x36c2d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl $0x1, %r14d
cmpl $0x0, (%rax,%r14,4)
jle 0x36c1a
xorl %r15d, %r15d
cmpl $0x0, -0x4(%rax,%r14,4)
js 0x36c0c
movq $-0x1, %r12
callq 0x9430
movsd 0x324cd(%rip), %xmm1    # 0x69098
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, 0x8(%rax,%r12,8)
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rax
movq $0x0, 0x8(%rax,%r12,8)
movq 0x8(%rbx), %rax
movslq -0x4(%rax,%r14,4), %rcx
incq %r12
cmpq %rcx, %r12
jl 0x36bbe
incq %r15
movslq (%rax,%r14,4), %rcx
cmpq %rcx, %r15
jl 0x36baf
movl (%rbx), %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0x36ba5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
cmpq $0x0, 0x8(%rdi)
je 0x36d23
movq %rdi, %rbx
leaq 0x3581d(%rip), %rax     # 0x6c46b
movq %rsi, %rdi
movq %rax, %rsi
callq 0x95a0
testq %rax, %rax
je 0x36d2c
movq %rax, %r14
movl $0x1, %r15d
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x99a0
movq 0x8(%rbx), %rdi
movslq (%rbx), %rdx
movl $0x4, %esi
movq %r14, %rcx
callq 0x99a0
leaq 0x38(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x99a0
leaq 0x40(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x99a0
movl (%rbx), %ecx
cmpl $0x2, %ecx
jl 0x36d13
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0x36d08
xorl %r12d, %r12d
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movq (%rcx,%r12,8), %rdi
movslq -0x4(%rax,%r15,4), %rdx
incq %rdx
movl $0x8, %esi
movq %r14, %rcx
callq 0x99a0
incq %r12
movq 0x8(%rbx), %rax
movslq (%rax,%r15,4), %rcx
cmpq %rcx, %r12
jl 0x36cd5
movl (%rbx), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0x36ccb
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x94b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x9ebd
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x36eae
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
movq %rsi, (%rax)
movl (%rdi), %ecx
cmpl $0x2, %ecx
jl 0x36e71
movq 0x8(%r14), %rax
movl $0x1, %r15d
cmpl $0x0, (%rax,%r15,4)
jle 0x36e62
movq 0x28(%r14), %rdx
movq (%rdx,%r15,8), %rcx
xorl %r12d, %r12d
movq 0x10(%r14), %rsi
movq (%rsi,%r15,8), %rsi
movq (%rsi,%r12,8), %rsi
movslq -0x4(%rax,%r15,4), %rax
movsd (%rsi,%rax,8), %xmm0
movsd %xmm0, (%rcx,%r12,8)
testq %rax, %rax
jle 0x36e24
movq -0x8(%rdx,%r15,8), %rdx
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm1
mulsd (%rsi,%rdi,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%r12,8)
incq %rdi
cmpq %rdi, %rax
jne 0x36e08
xorpd 0x321f4(%rip), %xmm0    # 0x69020
callq 0x98d0
movsd 0x3221f(%rip), %xmm1    # 0x69058
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movq 0x28(%r14), %rdx
movq (%rdx,%r15,8), %rcx
movsd %xmm1, (%rcx,%r12,8)
incq %r12
movq 0x8(%r14), %rax
movslq (%rax,%r15,4), %rsi
cmpq %rsi, %r12
jl 0x36de0
movl (%r14), %ecx
incq %r15
movslq %ecx, %rdx
cmpq %rdx, %r15
jl 0x36dca
testq %rbx, %rbx
je 0x36ea6
movq 0x8(%r14), %rax
movslq %ecx, %rcx
movslq -0x4(%rax,%rcx,4), %rax
testq %rax, %rax
jle 0x36ea6
decq %rcx
movq 0x28(%r14), %rdx
movq (%rdx,%rcx,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rbx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x36e94
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8(%rdi), %rax
movslq (%rdi), %rdx
movslq -0x4(%rax,%rdx,4), %rax
testq %rax, %rax
jle 0x36ef4
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rcx
movq -0x8(%rsi,%rdx,8), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
subsd (%rdx,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x36ed8
jmp 0x36ef8
xorpd %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb0(%rdi), %r14
leaq 0xc0(%rdi), %r15
movq %r15, 0xb0(%rdi)
xorl %eax, %eax
movq %rax, 0xb8(%rdi)
movb %al, 0xc0(%rdi)
leaq 0xd0(%rdi), %r12
leaq 0xe0(%rdi), %r13
movq %r13, 0xd0(%rdi)
movq %rax, 0xd8(%rdi)
movb %al, 0xe0(%rdi)
movq %rax, 0x10(%rdi)
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 0x32fa3(%rip), %rcx     # 0x6a790
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x9780
movq 0xd8(%rbx), %rdx
leaq 0x32f86(%rip), %rcx     # 0x6a790
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x9780
movl $0x0, 0x54(%rbx)
leaq 0x100(%rbx), %rax
movl $0x14, %ecx
movq %rcx, -0x10(%rax)
movl $0x0, -0x8(%rax)
movq $0x0, (%rax)
addq $0xa, %rcx
addq $0x18, %rax
cmpq $0x6e, %rcx
jne 0x3782a
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x58(%rbx)
movq $0x0, 0xa8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x37899
movq (%r13), %rsi
incq %rsi
callq 0x94e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x9f1d
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x332a4(%rip), %rsi     # 0x6abcc
leaq -0x90(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x9110
leaq 0x34b2b(%rip), %rsi     # 0x6c46b
movq %r14, %rdi
callq 0x95a0
testq %rax, %rax
je 0x37984
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x37a34
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37ae8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37bf6
movq %r14, %rdi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x94b0
movq 0x4c665(%rip), %rbx     # 0x83ff0
leaq 0x3324c(%rip), %rsi     # 0x6abde
movl $0x16, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x357ec(%rip), %rsi     # 0x6d192
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x62, %esi
callq 0x9880
movq %rax, %rbx
leaq 0x33a8d(%rip), %rsi     # 0x6b457
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x33217(%rip), %rsi     # 0x6abf5
movl $0x10, %edx
movq %rbx, %rdi
callq 0x9560
movq %r14, %rdi
callq 0x9200
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9560
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x37ae6
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdx
leaq 0x331b1(%rip), %rsi     # 0x6ac06
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96d0
movsd 0x20(%r14), %xmm0
leaq 0x331a4(%rip), %rsi     # 0x6ac10
movq %rbx, %rdi
movb $0x1, %al
callq 0x96d0
movsd 0x30(%r14), %xmm0
leaq 0x33196(%rip), %rsi     # 0x6ac19
movq %rbx, %rdi
movb $0x1, %al
callq 0x96d0
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %r8d
leaq 0x33182(%rip), %rsi     # 0x6ac22
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96d0
movq (%r14), %rdx
movl 0x8(%r14), %ecx
movl 0xc(%r14), %r8d
leaq 0x3317f(%rip), %rsi     # 0x6ac3b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96d0
movq 0xb0(%r14), %rdx
movl 0x54(%r14), %ecx
leaq 0x3317c(%rip), %rsi     # 0x6ac54
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x96d0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x37bf4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x33217(%rip), %rdi     # 0x6ad20
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x99a0
leaq 0x33140(%rip), %r15     # 0x6ac62
movl $0x26, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x99a0
leaq 0x3314b(%rip), %rdi     # 0x6ac89
movl $0x26, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x99a0
movl $0x26, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x99a0
movq 0xf0(%r14), %rdx
movl 0xf8(%r14), %ecx
movsd 0x100(%r14), %xmm0
leaq 0x3312d(%rip), %rsi     # 0x6acb0
movq %rbx, %rdi
movb $0x1, %al
callq 0x96d0
xorl %r12d, %r12d
leaq 0x3313d(%rip), %r15     # 0x6acd4
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 0x96d0
addq $0x18, %r12
cmpq $0xc0, %r12
jne 0x37b97
leaq 0x33120(%rip), %rdi     # 0x6acfa
movl $0x28, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x99a0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
imulq $0x3e8, 0xf0(%rdi,%rax), %rcx # imm = 0x3E8
cmpq %rsi, %rcx
jge 0x37f01
addq $0x18, %rax
cmpq $0xd8, %rax
jne 0x37ee2
jmp 0x37f08
incl 0xf8(%rdi,%rax)
cvtsi2sdq 0x28(%rdi), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
cvtsi2sdl 0xf8(%rdi,%rax), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x100(%rdi,%rax)
addq $0x18, %rax
cmpq $0xd8, %rax
jne 0x37f10
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpq %rsi, 0x10(%rdi)
jge 0x37fe4
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
cmpq %rsi, (%rdi)
jle 0x37ff0
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq 0x28(%rdi), %rax
cvtsi2sd %rax, %xmm0
cvtsi2sd %rsi, %xmm1
movsd 0x20(%rdi), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
incq %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm2
movq %rsi, %rcx
imulq %rsi, %rcx
cvtsi2sd %rcx, %xmm3
movsd %xmm2, 0x20(%rdi)
mulsd 0x38(%rdi), %xmm0
addsd %xmm3, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rdi)
mulsd %xmm2, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, 0x30(%rdi)
movq %rax, 0x28(%rdi)
popq %rbp
jmp 0x37edc
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x50(%rdi), %rax
movl $0x0, 0x50(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x58(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
movq %rax, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movq %rcx, 0x70(%rdi)
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)
movups %xmm0, 0x140(%rdi)
movq %rcx, 0x150(%rdi)
movq %rax, 0x15c(%rdi)
movups %xmm0, 0x168(%rdi)
movups %xmm0, 0x178(%rdi)
movq %rax, 0x18c(%rdi)
movups %xmm0, 0x198(%rdi)
movups %xmm0, 0x1a8(%rdi)
movq %rax, 0x1bc(%rdi)
xorl %esi, %esi
callq 0x397bc
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x397bc
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %r12
cmpq %r15, %r12
je 0x3813f
movq %r15, %r14
movq %r14, %rdi
callq 0x378ac
addq $0x1c8, %r14            # imm = 0x1C8
cmpq %r12, %r14
jne 0x38127
movq %r15, 0x38(%rbx)
movl $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)
movq $0x0, 0xe8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
cmpq %rax, 0x38(%rdi)
je 0x3820d
movups 0xc4(%rbx), %xmm0
movups 0xd4(%rbx), %xmm1
movups 0xe0(%rbx), %xmm2
movups %xmm2, -0x34(%rbp)
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%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 -0x50(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
movups %xmm0, 0x84(%rax)
movups %xmm1, 0x94(%rax)
movups -0x34(%rbp), %xmm0
movups %xmm0, 0xa0(%rax)
movq %rbx, %rdi
callq 0x382be
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %r15
cmpq %r15, %r14
je 0x38233
movq %r14, %rdi
callq 0x378fe
addq $0x1c8, %r14            # imm = 0x1C8
jmp 0x3821d
movq 0x120(%rbx), %rdi
testq %rdi, %rdi
je 0x3824e
movq 0x130(%rbx), %rsi
subq %rdi, %rsi
callq 0x94e0
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x38269
movq 0x118(%rbx), %rsi
subq %rdi, %rsi
callq 0x94e0
leaq 0x30(%rbx), %r14
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x38288
movq 0x100(%rbx), %rsi
subq %rdi, %rsi
callq 0x94e0
leaq 0x48(%rbx), %rdi
callq 0x3970c
movq %r14, %rdi
callq 0x3951c
leaq 0x18(%rbx), %rdi
callq 0x39576
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x39576
jmp 0x382b6
movq %rax, %rdi
callq 0x12c1b
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43dce
cmpb $0x1, 0x5c49(%rax)
jne 0x389a0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %r13 # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %r13
testl %r13d, %r13d
jle 0x38918
movq %r13, -0x30(%rbp)
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x9080
testl %eax, %eax
je 0x3891d
incq %r12
addq $0x38, %r15
cmpq %r12, %r13
jne 0x388f8
jmp 0x38926
xorl %r12d, %r12d
jmp 0x38921
movq -0x30(%rbp), %r13
cmpl %r13d, %r12d
jne 0x38982
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
callq 0x543e4
leaq -0x68(%rbp), %rdi
movq %rax, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %r14, %rsi
callq 0x92a0
leaq -0x68(%rbp), %rsi
movb $0x0, 0x30(%rsi)
movq %rbx, %rdi
callq 0x395e4
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x389a0
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x389a0
callq 0x543e4
movl %r12d, %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 0x389b1
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x389c9
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43dce
cmpb $0x1, 0x5c49(%rax)
jne 0x38afe
movq %rbx, -0x38(%rbp)
leaq 0x18(%r15), %r12
movq 0x20(%r15), %rax
movq %r15, -0x40(%rbp)
subq 0x18(%r15), %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %r13 # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %r13
testl %r13d, %r13d
jle 0x38a5a
movq %r13, -0x30(%rbp)
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
xorl %ebx, %ebx
movq (%r12), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x9080
testl %eax, %eax
je 0x38a5e
incq %rbx
addq $0x38, %r15
cmpq %rbx, %r13
jne 0x38a39
jmp 0x38a67
xorl %ebx, %ebx
jmp 0x38a62
movq -0x30(%rbp), %r13
cmpl %r13d, %ebx
jne 0x38ae0
leaq -0x68(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
callq 0x543e4
leaq -0x78(%rbp), %rdi
movq %rax, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %r14, %rsi
callq 0x92a0
leaq -0x78(%rbp), %rsi
movb $0x0, 0x30(%rsi)
movq %r12, %rdi
callq 0x395e4
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
movq %r14, %rsi
callq 0x39650
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x92a0
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x38afe
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x38afe
callq 0x543e4
movl %ebx, %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 0x38b0f
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x38b27
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x40(%rbp)
movq %rdi, %rbx
callq 0x43dce
cmpb $0x1, 0x5c49(%rax)
jne 0x38bea
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rcx
testl %ecx, %ecx
jle 0x38bea
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movq %rcx, -0x30(%rbp)
imulq $0x38, %r14, %r12
movq 0x18(%rbx), %rdi
addq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0x9080
testl %eax, %eax
je 0x38baf
incq %r14
movq -0x30(%rbp), %rcx
cmpq %rcx, %r14
jne 0x38b89
jmp 0x38bea
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xb6db6db7, %eax, %r15d # imm = 0xB6DB6DB7
testl %r15d, %r15d
jle 0x38ba1
movl $0x28, %r13d
movq (%rbx), %rdi
addq %r12, %rdi
movq -0x40(%rbp), %rsi
callq 0x9080
testl %eax, %eax
je 0x38bee
addq $0x38, %r13
decl %r15d
jne 0x38bcc
jmp 0x38ba1
xorl %eax, %eax
jmp 0x38c0f
movq (%rbx), %rsi
movq 0x18(%rbx), %rcx
movq 0x20(%rcx,%r12), %rdx
subq -0x8(%rsi,%r13), %rdx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
addq 0x28(%rcx,%r12), %rax
subq (%rsi,%r13), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43dce
cmpb $0x1, 0x5c49(%rax)
jne 0x391df
movl (%r14), %eax
decl %eax
cmpl $0xa, %eax
ja 0x391df
leaq 0x31a20(%rip), %rcx     # 0x6aba0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl 0xa0(%rbx)
jmp 0x391df
incl 0xbc(%rbx)
jmp 0x391df
incl 0xb0(%rbx)
jmp 0x391df
incl 0xa8(%rbx)
jmp 0x391df
incl 0xa4(%rbx)
jmp 0x391df
incl 0xb8(%rbx)
jmp 0x391df
incl 0x9c(%rbx)
jmp 0x391df
incl 0x98(%rbx)
jmp 0x391df
incl 0xc0(%rbx)
jmp 0x391df
incl 0xb4(%rbx)
jmp 0x391df
incl 0xac(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43dce
cmpb $0x1, 0x5c49(%rax)
jne 0x39339
callq 0x543e4
leaq 0x138(%rbx), %r15
leaq 0x148(%rbx), %rdi
movq %rax, 0x148(%rbx)
movq %rdx, 0x150(%rbx)
movq %r15, %rsi
callq 0x545ce
movl %eax, 0x158(%rbx)
movq %r14, 0x15c(%rbx)
movq 0xf8(%rbx), %rsi
cmpq 0x100(%rbx), %rsi
je 0x39344
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, 0xf8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0xf0, %rbx
movq %rbx, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a248
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43dce
cmpb $0x1, 0x5c49(%rax)
jne 0x39417
callq 0x543e4
leaq 0x168(%rbx), %r15
leaq 0x178(%rbx), %rdi
movq %rax, 0x178(%rbx)
movq %rdx, 0x180(%rbx)
movq %r15, %rsi
callq 0x545ce
movl %eax, 0x188(%rbx)
movq %r14, 0x18c(%rbx)
movq 0x110(%rbx), %rsi
cmpq 0x118(%rbx), %rsi
je 0x39422
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, 0x110(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x108, %rbx            # imm = 0x108
movq %rbx, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a248
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43dce
cmpb $0x1, 0x5c49(%rax)
jne 0x394f5
callq 0x543e4
leaq 0x198(%rbx), %r15
leaq 0x1a8(%rbx), %rdi
movq %rax, 0x1a8(%rbx)
movq %rdx, 0x1b0(%rbx)
movq %r15, %rsi
callq 0x545ce
movl %eax, 0x1b8(%rbx)
movq %r14, 0x1bc(%rbx)
movq 0x128(%rbx), %rsi
cmpq 0x130(%rbx), %rsi
je 0x39500
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x30, 0x128(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x120, %rbx            # imm = 0x120
movq %rbx, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a248