LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::InitSightLogger(ServerMsgType, char const*)
void Logger::InitSightLogger(ServerMsgType msg_type, const char *msg) {
  if (PlayerParam::instance().SaveSightLog()) {
    switch (msg_type) {
    case ServerParam_Msg:
      GetSightLogger()->SetServerParamMsg(msg);
      break;
    case PlayerParam_Msg:
      GetSightLogger()->SetPlayerParamMsg(msg);
      break;
    case PlayerType_Msg:
      GetSightLogger()->SetPlayerTypeMsg(msg);
      break;
    default:
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
callq 0x450ba
cmpb $0x1, 0x5c43(%rax)
jne 0x35ee6
cmpl $0xa, %r15d
je 0x35f0e
cmpl $0x7, %r15d
je 0x35ef1
cmpl $0x6, %r15d
jne 0x35ee6
movq %r14, %rdi
callq 0x35d0a
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x34248
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x35d0a
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3429a
movq %r14, %rdi
callq 0x35d0a
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x342ec
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogPoint(Vector const&, SightLogger::Color, char const*)
void Logger::LogPoint(const Vector &target, SightLogger::Color color,
                      const char *comment) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();
    pSightLogger->AddPoint(target, comment, color);
    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
callq 0x450ba
cmpb $0x1, 0x5c44(%rax)
jne 0x35fdb
movq %r12, %rdi
callq 0x35d0a
movq %rax, %r12
leaq 0x228(%rax), %r13
movq %r13, %rdi
callq 0x4f686
movq 0x258(%r12), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x369c6
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f6a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogGoToPoint(Vector const&, Vector const&, char const*)
void Logger::LogGoToPoint(const Vector &start, const Vector &target,
                          const char *comment) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();
    pSightLogger->AddPoint(target, comment, SightLogger::Red);
    pSightLogger->AddCircle(target, 0.2, SightLogger::Red);
    pSightLogger->AddLine(start, target, SightLogger::Red);
    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x450ba
cmpb $0x1, 0x5c44(%rax)
jne 0x36084
movq %r15, %rdi
callq 0x35d0a
movq %rax, %r13
leaq 0x228(%rax), %r15
movq %r15, %rdi
callq 0x4f686
movq 0x258(%r13), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r13)
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x369c6
movabsq $0x3fc999999999999a, %rax # imm = 0x3FC999999999999A
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
movq %r13, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x36aa2
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x36b08
movq %r15, %rdi
callq 0x4f6a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogShoot(Vector const&, Vector const&, char const*)
void Logger::LogShoot(const Vector &start, const Vector &target,
                      const char *comment) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();
    pSightLogger->AddPoint(target, comment, SightLogger::Purple);
    pSightLogger->AddLine(start, target, SightLogger::Purple);
    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x450ba
cmpb $0x1, 0x5c44(%rax)
jne 0x36126
movq %r12, %rdi
callq 0x35d0a
movq %rax, %r12
leaq 0x228(%rax), %r13
movq %r13, %rdi
callq 0x4f686
movq 0x258(%r12), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r12)
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl $0x6, %ecx
callq 0x369c6
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x6, %ecx
callq 0x36b08
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f6a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogIntercept(Vector const&, char const*)
void Logger::LogIntercept(const Vector &interpt, const char *comment) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();
    pSightLogger->AddPoint(interpt, comment, SightLogger::Cyan);
    pSightLogger->AddCircle(interpt, 0.1, SightLogger::Cyan);
    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x450ba
cmpb $0x1, 0x5c44(%rax)
jne 0x361c4
movq %r15, %rdi
callq 0x35d0a
movq %rax, %r15
leaq 0x228(%rax), %r12
movq %r12, %rdi
callq 0x4f686
movq 0x258(%r15), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r15)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x5, %ecx
callq 0x369c6
movabsq $0x3fb999999999999a, %rax # imm = 0x3FB999999999999A
leaq -0x28(%rbp), %rdx
movq %rax, (%rdx)
movq %r15, %rdi
movq %rbx, %rsi
movl $0x5, %ecx
callq 0x36aa2
movq %r12, %rdi
callq 0x4f6a2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogLine(Vector const&, Vector const&, SightLogger::Color, char const*)
void Logger::LogLine(const Vector &begin, const Vector &end,
                     SightLogger::Color color, const char *comment) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();
    pSightLogger->AddPoint(end, comment, color);
    pSightLogger->AddLine(begin, end, color);
    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
callq 0x450ba
cmpb $0x1, 0x5c44(%rax)
jne 0x36263
movq %r13, %rdi
callq 0x35d0a
movq %rax, %r13
movq %r15, -0x30(%rbp)
leaq 0x228(%rax), %r15
movq %r15, %rdi
callq 0x4f686
movq 0x258(%r13), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r13)
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x369c6
movq %r13, %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x36b08
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f6a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogCircle(Vector const&, double const&, SightLogger::Color)
void Logger::LogCircle(const Vector &o, const double &r,
                       SightLogger::Color color) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();
    pSightLogger->AddCircle(o, r, color);
    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x450ba
cmpb $0x1, 0x5c44(%rax)
jne 0x362ed
movq %r12, %rdi
callq 0x35d0a
movq %rax, %r12
leaq 0x228(%rax), %r13
movq %r13, %rdi
callq 0x4f686
movq 0x258(%r12), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x36aa2
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f6a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/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 0x450ba
cmpb $0x1, 0x5c44(%rax)
jne 0x36452
movq %r15, %rdi
callq 0x35d0a
movq %rax, %r12
leaq 0x228(%rax), %rdi
movq %rdi, -0x30(%rbp)
callq 0x4f686
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 0x36b08
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 0x36b08
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 0x36b08
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 0x36b08
movq -0x30(%rbp), %rdi
callq 0x4f6a2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/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 0x450ba
cmpb $0x1, 0x5c44(%rax)
jne 0x364ff
movq %r13, -0x30(%rbp)
movq %r14, %rdi
callq 0x35d0a
movq %rax, %r14
leaq 0x228(%rax), %r13
movq %r13, %rdi
callq 0x4f686
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 0x369c6
testb %r15b, %r15b
je 0x364e9
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x36b08
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f6a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/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, %ebx
movq %r8, %r13
movq %rcx, %r14
movq %rdx, -0x48(%rbp)
movl %esi, %r12d
movq %rdi, %r15
callq 0x450ba
cmpb $0x1, 0x5c44(%rax)
jne 0x3663b
movq %r15, %rdi
callq 0x35d0a
movq %rax, %r15
leaq 0x228(%rax), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4f686
movq 0x258(%r15), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r15)
movabsq $0x4066800000000000, %rax # imm = 0x4066800000000000
testb %r12b, %r12b
je 0x3659b
leaq -0x60(%rbp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x33428
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
jmp 0x365a3
movups (%r14), %xmm0
movaps %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x369c6
testb %bl, %bl
je 0x36632
testb %r12b, %r12b
je 0x365e3
leaq -0x78(%rbp), %rsi
movabsq $0x4066800000000000, %rax # imm = 0x4066800000000000
movq %rax, (%rsi)
movq -0x48(%rbp), %rdi
callq 0x33428
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
jmp 0x365ee
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
testb %r12b, %r12b
je 0x36618
leaq -0x70(%rbp), %rsi
movabsq $0x4066800000000000, %rax # imm = 0x4066800000000000
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x33428
movsd %xmm0, -0x60(%rbp)
movsd %xmm1, -0x58(%rbp)
jmp 0x36620
movups (%r14), %xmm0
movaps %xmm0, -0x60(%rbp)
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x36b08
movq -0x68(%rbp), %rdi
callq 0x4f6a2
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.h
// Function: SightLogger::PointShape::PointShape(Vector const&, SightLogger::Color, char const*)
PointShape(const Vector &point, Color color, const char *cmt = 0)
        : ItemShape(color) {
      x = point.X();
      y = point.Y();
      if (cmt) {
        comment.assign(cmt);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, (%rdi)
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movsd (%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
testq %rcx, %rcx
je 0x36c02
movq %rcx, %r14
movq %rdi, %rbx
addq $0x18, %rbx
movq %rcx, %rdi
callq 0x9200
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x9780
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x36c23
movq (%r15), %rsi
incq %rsi
callq 0x94e0
movq %r14, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37629
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, (%rdi)
movslq %esi, %rax
shlq $0x2, %rax
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x9050
movq %rax, 0x8(%rbx)
testq %r14, %r14
je 0x375ea
cmpl $0x0, (%rbx)
jle 0x375ea
movl (%rbx), %ecx
cmpl $0x2, %ecx
movl $0x1, %edx
cmovgel %ecx, %edx
shlq $0x2, %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x93e0
movq %rbx, %rdi
callq 0x3789a
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 %r14
popq %rbp
jmp 0x37a76
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37f3a(%rip), %rsi     # 0x6f590
movq %rax, %rdi
callq 0x95a0
testq %rax, %rax
je 0x37755
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 0x3789a
movq %rbx, %rdi
callq 0x37a76
cmpl $0x2, (%rbx)
jl 0x37745
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax,%r12,4)
jle 0x3773a
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 0x37709
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x376fb
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x94b0
callq 0x9ed1
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37898
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, (%rdi)
jl 0x37800
movl $0x1, %r14d
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
jle 0x377d1
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x377ab
callq 0x9630
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x377c1
callq 0x9630
incq %r15
movq 0x8(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %r15
jl 0x37795
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x377e3
callq 0x9630
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x377f5
callq 0x9630
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x37787
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3780e
callq 0x9630
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3781c
callq 0x9630
cmpl $0x2, (%rbx)
jl 0x37856
movl $0x1, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x37839
callq 0x9630
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x3784b
callq 0x9630
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x37827
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x37864
callq 0x9630
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x37872
callq 0x9630
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x37880
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_O1/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 0x379b1
movl $0x1, %r13d
movq 0x8(%rbx), %rax
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 0x379a5
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 0x37946
incq %r13
cmpq %r15, %r13
jne 0x378f0
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 0x37a30
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 0x379e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::SetDefaultValue()
void Net::SetDefaultValue() {
  SetLearningRate(0.7);
  SetAlpha(0.0);
  SetDesiredError(0.01);
  SetMaxEpochs(1000);
  InitWeight();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movabsq $0x3fe6666666666666, %rax # imm = 0x3FE6666666666666
movq %rax, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movabsq $0x3f847ae147ae147b, %rax # imm = 0x3F847AE147AE147B
movq %rax, 0x48(%rdi)
movl $0x3e8, 0x50(%rdi)      # imm = 0x3E8
popq %rbp
jmp 0x37a76
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x2, (%rdi)
jl 0x37b29
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %r14d
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
jle 0x37b12
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
cmpl $0x0, -0x4(%rax,%r14,4)
js 0x37b02
movq $-0x1, %r12
callq 0x9430
movsd 0x335d7(%rip), %xmm1    # 0x6b098
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), %rax
incq %r12
cmpq %rax, %r12
jl 0x37ab4
incq %r15
movq 0x8(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %r15
jl 0x37aa1
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x37a93
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37c1b
movq %rdi, %rbx
leaq 0x36951(%rip), %rax     # 0x6e49b
movq %rsi, %rdi
movq %rax, %rsi
callq 0x95a0
testq %rax, %rax
je 0x37c24
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
cmpl $0x2, (%rbx)
jl 0x37c0b
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0x37c00
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 0x37bcf
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x37bc1
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 0x9ee9
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37da9
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)
cmpl $0x2, (%rdi)
jl 0x37d6e
movl $0x1, %r15d
movq 0x8(%r14), %rcx
cmpl $0x0, (%rcx,%r15,4)
jle 0x37d5f
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq 0x28(%r14), %rsi
movq (%rax,%r15,8), %rax
movq (%rax,%r12,8), %rax
movslq -0x4(%rcx,%r15,4), %rcx
movsd (%rax,%rcx,8), %xmm0
movq (%rsi,%r15,8), %rdx
movsd %xmm0, (%rdx,%r12,8)
testq %rcx, %rcx
jle 0x37d1a
movq -0x8(%rsi,%r15,8), %rsi
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm1
mulsd (%rax,%rdi,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%r12,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x37cfe
movsd (%rdx,%r12,8), %xmm0
xorpd 0x332f8(%rip), %xmm0    # 0x6b020
callq 0x98d0
movsd 0x33323(%rip), %xmm1    # 0x6b058
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rax
movsd %xmm1, (%rax,%r12,8)
incq %r12
movq 0x8(%r14), %rcx
movslq (%rcx,%r15,4), %rax
cmpq %rax, %r12
jl 0x37cce
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0x37cbc
testq %rbx, %rbx
je 0x37da1
movq 0x8(%r14), %rax
movslq (%r14), %rcx
movslq -0x4(%rax,%rcx,4), %rax
testq %rax, %rax
jle 0x37da1
movq 0x28(%r14), %rdx
movq -0x8(%rdx,%rcx,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rbx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x37d8f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37dee
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 0x37dd2
jmp 0x37df2
xorpd %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x340e7(%rip), %rcx     # 0x6c7a0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x9780
movq 0xd8(%rbx), %rdx
leaq 0x340ca(%rip), %rcx     # 0x6c7a0
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 0x386f6
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 0x38765
movq (%r13), %rsi
incq %rsi
callq 0x94e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x9f49
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x343e8(%rip), %rsi     # 0x6cbdc
leaq -0x90(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x9110
leaq 0x35c8f(%rip), %rsi     # 0x6e49b
movq %r14, %rdi
callq 0x95a0
testq %rax, %rax
je 0x38850
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38900
movq %rbx, %rdi
movq %r14, %rsi
callq 0x389b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38ac2
movq %r14, %rdi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x94b0
movq 0x4e799(%rip), %rbx     # 0x86ff0
leaq 0x34390(%rip), %rsi     # 0x6cbee
movl $0x16, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x36950(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x62, %esi
callq 0x9880
movq %rax, %rbx
leaq 0x34be9(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x3435b(%rip), %rsi     # 0x6cc05
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_O1/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 0x389b2
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdx
leaq 0x342f5(%rip), %rsi     # 0x6cc16
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96d0
movsd 0x20(%r14), %xmm0
leaq 0x342e8(%rip), %rsi     # 0x6cc20
movq %rbx, %rdi
movb $0x1, %al
callq 0x96d0
movsd 0x30(%r14), %xmm0
leaq 0x342da(%rip), %rsi     # 0x6cc29
movq %rbx, %rdi
movb $0x1, %al
callq 0x96d0
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %r8d
leaq 0x342c6(%rip), %rsi     # 0x6cc32
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96d0
movq (%r14), %rdx
movl 0x8(%r14), %ecx
movl 0xc(%r14), %r8d
leaq 0x342c3(%rip), %rsi     # 0x6cc4b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x96d0
movq 0xb0(%r14), %rdx
movl 0x54(%r14), %ecx
leaq 0x342c0(%rip), %rsi     # 0x6cc64
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x96d0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38ac0
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3435b(%rip), %rdi     # 0x6cd30
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x99a0
leaq 0x34284(%rip), %r15     # 0x6cc72
movl $0x26, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x99a0
leaq 0x3428f(%rip), %rdi     # 0x6cc99
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 0x34271(%rip), %rsi     # 0x6ccc0
movq %rbx, %rdi
movb $0x1, %al
callq 0x96d0
xorl %r12d, %r12d
leaq 0x34281(%rip), %r15     # 0x6cce4
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 0x38a63
leaq 0x34264(%rip), %rdi     # 0x6cd0a
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_O1/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 0x38dcd
addq $0x18, %rax
cmpq $0xd8, %rax
jne 0x38dae
jmp 0x38dd4
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 0x38ddc
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38eb0
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
cmpq %rsi, (%rdi)
jle 0x38ebc
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 0x38da8
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq (%rdi), %rsi
callq 0x3a702
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x3a702
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %r12
cmpq %r15, %r12
je 0x3900c
movq %r15, %r14
movq %r14, %rdi
callq 0x38778
addq $0x1c8, %r14            # imm = 0x1C8
cmpq %r12, %r14
jne 0x38ff4
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x390d9
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 0x3918a
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %r15
cmpq %r15, %r14
je 0x390ff
movq %r14, %rdi
callq 0x387ca
addq $0x1c8, %r14            # imm = 0x1C8
jmp 0x390e9
movq 0x120(%rbx), %rdi
testq %rdi, %rdi
je 0x3911a
movq 0x130(%rbx), %rsi
subq %rdi, %rsi
callq 0x94e0
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x39135
movq 0x118(%rbx), %rsi
subq %rdi, %rsi
callq 0x94e0
leaq 0x30(%rbx), %r14
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x39154
movq 0x100(%rbx), %rsi
subq %rdi, %rsi
callq 0x94e0
leaq 0x48(%rbx), %rdi
callq 0x3a652
movq %r14, %rdi
callq 0x3a46c
leaq 0x18(%rbx), %rdi
callq 0x3a4c0
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a4c0
jmp 0x39182
movq %rax, %rdi
callq 0x12d4d
// File: /workspace/github_cpp_makefile_star2_O1/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 0x450ba
cmpb $0x1, 0x5c49(%rax)
jne 0x39873
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %r13 # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %r13
testl %r13d, %r13d
jle 0x397eb
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 0x397f0
incq %r12
addq $0x38, %r15
cmpq %r12, %r13
jne 0x397c4
movq -0x30(%rbp), %r13
movl %r13d, %r12d
jmp 0x397f4
xorl %r12d, %r12d
jmp 0x397f4
movq -0x30(%rbp), %r13
cmpl %r13d, %r12d
jne 0x39855
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
callq 0x55bd8
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 0x3a52a
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x39873
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x39873
callq 0x55bd8
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 0x39884
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x3989c
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0