LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::EvaluatePlayer(PlayerState&)
void WorldStateUpdater::EvaluatePlayer(PlayerState &player) {
  if (!mpObserver->IsNewSight()) {
    return;
  }

  if (player.GetPosDelay() != 0 && player.IsAlive() &&
      SelfState().GetPosDelay() == 0) {
    const Unum player_unum = player.GetUnum();

    if (player.GetGuessedTimes() >= 5) {
      EvaluateForgetPlayer(player);
    } else {
      if (ShouldSee(player.GetPos())) {
        player.UpdateGuessedTimes(player.GetGuessedTimes() + 1);

        const Vector *expected_pos = 0;

        if (player.IsGoalie()) {
          if (player_unum > 0) {
            expected_pos = &ServerParam::instance().ourGoal();
          } else {
            expected_pos = &ServerParam::instance().oppGoal();
          }
        }

        const Vector pos = GetNearSidePos(player.GetPos(), expected_pos);

        player.UpdatePos(pos, player.GetPosDelay(),
                         player.GetPosConf()); // delay和conf在前面更新过

        Logger::instance().GetTextLogger("guess")
            << mpWorldState->CurrentTime() << ": guess player " << player_unum
            << " out of view" << std::endl;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
cmpb $0x1, 0x3382(%rax)
jne 0x68ed0
movq %rsi, %r15
cmpl $0x0, 0x18(%rsi)
je 0x68ed0
cmpb $0x1, 0x112(%r15)
jne 0x68ed0
movq %rdi, %r14
movslq 0x14(%rdi), %rax
movq 0x8(%rdi), %rcx
imulq $0x178, %rax, %rax      # imm = 0x178
cmpl $0x0, -0xb8(%rcx,%rax)
je 0x68edd
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x5, 0x70(%r15)
jl 0x68efb
movq %r14, %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x697b6
leaq 0x8(%r15), %r12
movl 0x11c(%r15), %ebx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6926a
testb %al, %al
je 0x68ed0
incl 0x70(%r15)
cmpb $0x1, 0x175(%r15)
jne 0x68f38
callq 0x4a75c
movq %rax, %rdx
testl %ebx, %ebx
jle 0x68f3c
addq $0x38b0, %rdx           # imm = 0x38B0
jmp 0x68f43
xorl %edx, %edx
jmp 0x68f43
addq $0x38c0, %rdx           # imm = 0x38C0
movq %r14, %rdi
movq %r12, %rsi
callq 0x69458
leaq -0x30(%rbp), %rsi
movsd %xmm0, (%rsi)
movsd %xmm1, 0x8(%rsi)
movl 0x18(%r15), %edx
movsd 0x20(%r15), %xmm0
movq %r15, %rdi
callq 0xf682
callq 0x35b4a
leaq 0x696c(%rip), %rsi      # 0x6f8e5
movq %rax, %rdi
callq 0x35d5e
movq %rax, %r15
movq 0x8(%r14), %r14
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x68fac
addq $0x10, %r14
movq %r15, %rdi
addq $0x210, %rdi            # imm = 0x210
movq %r14, %rsi
callq 0xea74
leaq 0x6967(%rip), %rsi      # 0x6f91a
movq %r15, %rdi
callq 0x6a74c
movq %rax, %r14
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x68fdd
movq %r14, %rdi
addq $0x210, %rdi            # imm = 0x210
movl %ebx, %esi
callq 0x9880
leaq 0x6913(%rip), %rsi      # 0x6f8f7
movq %r14, %rdi
callq 0x1f2f0
movq %rax, %rbx
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x68ed0
addq $0x210, %rbx            # imm = 0x210
movq %rbx, %rdi
callq 0x9240
jmp 0x68ed0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::EvaluateBall()
void WorldStateUpdater::EvaluateBall() {
  // if drop ball just forget
  //
  if (mpWorldState->IsBallDropped() && Ball().GetPosDelay() != 0) {
    EvaluateForgetBall(true);
    return;
  }

  if (!mpObserver->IsNewSight()) {
    return;
  }

  if (Ball().GetPosDelay() != 0 && SelfState().GetPosDelay() == 0) {
    if (Ball().GetGuessedTimes() >= 100) {
      EvaluateForgetBall(false);
    } else {
      if (ShouldSee(Ball().GetPos())) {
        Ball().UpdateGuessedTimes(Ball().GetGuessedTimes() + 1);

        const Vector pos = GetNearSidePos(Ball().GetPos());

        Ball().UpdatePos(pos, Ball().GetPosDelay(), Ball().GetPosConf());

        Logger::instance().GetTextLogger("guess")
            << mpWorldState->CurrentTime() << ": guess ball out of view"
            << std::endl;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpb $0x1, 0x2c(%rsi)
jne 0x69049
cmpl $0x0, 0x48(%rsi)
je 0x69049
movq %rbx, %rdi
movl $0x1, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x6914a
movq (%rbx), %rax
cmpb $0x1, 0x3382(%rax)
jne 0x69070
cmpl $0x0, 0x48(%rsi)
je 0x69070
movslq 0x14(%rbx), %rax
imulq $0x178, %rax, %rax      # imm = 0x178
cmpl $0x0, -0xb8(%rsi,%rax)
je 0x69079
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x64, 0xa0(%rsi)
jl 0x69089
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x6903c
addq $0x38, %rsi
movq %rbx, %rdi
callq 0x6926a
testb %al, %al
je 0x69070
movq 0x8(%rbx), %rsi
incl 0xa0(%rsi)
addq $0x38, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x69458
leaq -0x20(%rbp), %rsi
movsd %xmm0, (%rsi)
movsd %xmm1, 0x8(%rsi)
movq 0x8(%rbx), %rax
leaq 0x30(%rax), %rdi
movl 0x48(%rax), %edx
movsd 0x50(%rax), %xmm0
callq 0xf682
callq 0x35b4a
leaq 0x6806(%rip), %rsi      # 0x6f8e5
movq %rax, %rdi
callq 0x35d5e
movq %rax, %r14
movq 0x8(%rbx), %rbx
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x69112
addq $0x10, %rbx
movq %r14, %rdi
addq $0x210, %rdi            # imm = 0x210
movq %rbx, %rsi
callq 0xea74
leaq 0x67d2(%rip), %rsi      # 0x6f8eb
movq %r14, %rdi
callq 0x6a702
movq %rax, %rbx
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x69070
addq $0x210, %rbx            # imm = 0x210
movq %rbx, %rdi
callq 0x9240
jmp 0x69070
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::EvaluateForgetBall(bool)
void WorldStateUpdater::EvaluateForgetBall(bool use_memory) {
  if (!use_memory) {
    Ball().UpdatePos(Vector(0, 0), Ball().GetPosDelay(), 0); // as WE2008
    Ball().UpdateVel(Vector(0, 0), Ball().GetPosDelay(), 0); // as WE2008
  }

  Ball().UpdateGuessedTimes(100);

  Logger::instance().GetTextLogger("forget")
      << mpWorldState->CurrentTime() << ": forget ball " << use_memory
      << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jne 0x6919f
movq 0x8(%r14), %rdi
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r15
movaps %xmm0, (%r15)
movl 0x48(%rdi), %edx
addq $0x30, %rdi
xorps %xmm0, %xmm0
movq %r15, %rsi
callq 0xf682
movq 0x8(%r14), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movl 0x48(%rdi), %edx
addq $0x30, %rdi
leaq -0x30(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0xf64c
movq 0x8(%r14), %rax
movl $0x64, 0xa0(%rax)
callq 0x35b4a
leaq 0x674b(%rip), %rsi      # 0x6f904
movq %rax, %rdi
callq 0x35d5e
movq %rax, %r15
movq 0x8(%r14), %r14
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x691ec
addq $0x10, %r14
movq %r15, %rdi
addq $0x210, %rdi            # imm = 0x210
movq %r14, %rsi
callq 0xea74
leaq 0x6718(%rip), %rsi      # 0x6f90b
movq %r15, %rdi
callq 0x136bc
movq %rax, %r14
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x6921b
leaq 0x210(%r14), %rdi
movzbl %bl, %esi
callq 0x9820
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x6925e
movq %r14, %rbx
addq $0x210, %rbx            # imm = 0x210
movq 0x210(%r14), %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 $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::ShouldSee(Vector const&)
bool WorldStateUpdater::ShouldSee(const Vector &pos) {
  if (!mpObserver->IsNewSight()) {
    return false;
  }

  const ViewWidth view_width = GetSelf().GetViewWidth();
  const AngleDeg view_angle = sight::ViewAngle(view_width);
  const AngleDeg left = GetSelf().GetNeckGlobalDir() - view_angle * 0.5;
  const AngleDeg right = left + view_angle;
  const Vector self_pos = SelfState().GetPos();
  const Vector rel_pos = (pos - self_pos);
  const double dist = rel_pos.Mod();

  return dist < ServerParam::instance().visibleDistance() - 0.1 ||
         IsAngleDegInBetween(left, rel_pos.Dir(), right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq (%rdi), %rax
cmpb $0x1, 0x3382(%rax)
jne 0x692be
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x14(%rdi), %rax
movq 0x8(%rdi), %rcx
imulq $0x178, %rax, %rax      # imm = 0x178
leaq (%rax,%rcx), %rdi
addq $-0xd0, %rdi
movl 0x118(%rdi), %eax
decl %eax
cmpl $0x2, %eax
ja 0x692c5
movl %eax, %eax
leaq 0x6581(%rip), %rcx      # 0x6f838
movsd (%rcx,%rax,8), %xmm0
jmp 0x692cd
xorl %eax, %eax
jmp 0x6944f
movsd 0x1de3(%rip), %xmm0     # 0x6b0b0
movsd %xmm0, -0x18(%rbp)
callq 0x5b2be
movsd %xmm0, -0x20(%rbp)
movslq 0x14(%r14), %rax
movq 0x8(%r14), %rcx
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm2
imulq $0x178, %rax, %rax      # imm = 0x178
subsd -0xc8(%rax,%rcx), %xmm0
subsd -0xc0(%rax,%rcx), %xmm2
movapd %xmm2, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm0, -0x50(%rbp)
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movapd %xmm2, -0x40(%rbp)
jb 0x69330
sqrtsd %xmm0, %xmm0
jmp 0x69335
callq 0x93c0
movsd %xmm0, -0x28(%rbp)
callq 0x4a75c
movsd 0x3178(%rax), %xmm0
addsd 0x3289(%rip), %xmm0     # 0x6c5d8
movb $0x1, %al
ucomisd -0x28(%rbp), %xmm0
ja 0x6944f
movsd 0x1d24(%rip), %xmm0     # 0x6b088
movsd -0x18(%rbp), %xmm3
mulsd %xmm3, %xmm0
movsd -0x20(%rbp), %xmm4
addsd %xmm0, %xmm4
movapd 0x1c92(%rip), %xmm5     # 0x6b010
movapd -0x50(%rbp), %xmm1
movapd %xmm1, %xmm0
andpd %xmm5, %xmm0
movsd 0x1cad(%rip), %xmm2     # 0x6b040
ucomisd %xmm0, %xmm2
movapd -0x40(%rbp), %xmm6
jbe 0x693ac
andpd %xmm6, %xmm5
xorpd %xmm0, %xmm0
ucomisd %xmm5, %xmm2
ja 0x693d4
movapd %xmm6, %xmm0
movsd %xmm4, -0x20(%rbp)
callq 0x90d0
movsd -0x20(%rbp), %xmm4
movsd -0x18(%rbp), %xmm3
mulsd 0x1c7c(%rip), %xmm0     # 0x6b048
divsd 0x1c7c(%rip), %xmm0     # 0x6b050
addsd %xmm4, %xmm3
movsd 0x1c90(%rip), %xmm1     # 0x6b070
ucomisd %xmm0, %xmm4
jbe 0x693f2
addsd %xmm1, %xmm0
ucomisd %xmm0, %xmm4
ja 0x693e6
jmp 0x6940e
addsd %xmm4, %xmm1
ucomisd %xmm1, %xmm0
jb 0x6940e
movsd 0x1c64(%rip), %xmm2     # 0x6b068
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jae 0x69404
ucomisd %xmm3, %xmm4
jbe 0x69428
movsd 0x1c54(%rip), %xmm1     # 0x6b070
addsd %xmm1, %xmm3
ucomisd %xmm3, %xmm4
ja 0x6941c
jmp 0x69448
addsd 0x1c40(%rip), %xmm4     # 0x6b070
ucomisd %xmm4, %xmm3
jb 0x69448
movsd 0x1c2a(%rip), %xmm1     # 0x6b068
addsd %xmm1, %xmm3
ucomisd %xmm4, %xmm3
jae 0x6943e
ucomisd %xmm0, %xmm3
setae %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::EvaluateForgetPlayer(PlayerState&)
void WorldStateUpdater::EvaluateForgetPlayer(PlayerState &player) {
  // i think it will cause trouble with UpdateUnknownPlayer ,it need test.
  player.SetIsAlive(false);
  player.UpdatePos(Vector(0, 0), player.GetPosDelay(), 0);
  player.UpdateVel(Vector(0, 0), player.GetVelDelay(), 0);
  player.UpdateBodyDir(0, player.GetBodyDirDelay(), 0);
  player.UpdateNeckDir(0, player.GetNeckDirDelay(), 0);
  player.UpdateGuessedTimes(100);

  Logger::instance().GetTextLogger("forget")
      << mpWorldState->CurrentTime() << ": forget player " << player.GetUnum()
      << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, 0x112(%rsi)
addq $0x8, %rsi
movl 0x18(%rbx), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0xf682
leaq 0x30(%rbx), %rsi
movl 0x40(%rbx), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0xf64c
xorl %r12d, %r12d
movq %r12, 0xa8(%rbx)
movq %r12, 0xc0(%rbx)
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r15
movaps %xmm0, (%r15)
movl 0x18(%rbx), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf682
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movl 0x40(%rbx), %edx
leaq -0x30(%rbp), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0xf64c
movq %r12, 0xc0(%rbx)
movq %r12, 0x98(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%rbx)
movl $0x64, 0x70(%rbx)
callq 0x35b4a
leaq 0x609d(%rip), %rsi      # 0x6f904
movq %rax, %rdi
callq 0x35d5e
movq %rax, %r15
movq 0x8(%r14), %r14
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x6989a
addq $0x10, %r14
movq %r15, %rdi
addq $0x210, %rdi            # imm = 0x210
movq %r14, %rsi
callq 0xea74
leaq 0x6089(%rip), %rsi      # 0x6f92a
movq %r15, %rdi
callq 0x6a796
movq %rax, %r14
movl 0x11c(%rbx), %ebx
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x698ce
leaq 0x210(%r14), %rdi
movl %ebx, %esi
callq 0x9880
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x69911
movq %r14, %rbx
addq $0x210, %rbx            # imm = 0x210
movq 0x210(%r14), %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 $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::GetClosestOpponent()
Unum WorldStateUpdater::GetClosestOpponent() {
  double min_dist = 200000;
  int min_index = -1;
  for (int i = 1; i <= TEAMSIZE; i++) {
    if (GetOpponent(i).IsAlive()) {
      if ((GetOpponent(i).GetPos() - SelfState().GetPos()).Mod() < min_dist) {
        min_dist = (GetOpponent(i).GetPos() - SelfState().GetPos()).Mod();
        min_index = i;
      }
    }
  }
  return min_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x5de4(%rip), %xmm3     # 0x6f728
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0x1, %r15d
xorl %r12d, %r12d
xorpd %xmm2, %xmm2
movq 0x8(%rbx), %rax
cmpb $0x1, 0x11e2(%rax,%r12)
jne 0x69a2c
movslq 0x14(%rbx), %rcx
movsd 0x10d8(%rax,%r12), %xmm0
imulq $0x178, %rcx, %rcx      # imm = 0x178
subsd -0xc8(%rcx,%rax), %xmm0
movsd 0x10e0(%rax,%r12), %xmm1
subsd -0xc0(%rcx,%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x699b3
sqrtsd %xmm0, %xmm0
jmp 0x699c6
movsd %xmm3, -0x28(%rbp)
callq 0x93c0
movsd -0x28(%rbp), %xmm3
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm3
jbe 0x69a2c
movq 0x8(%rbx), %rax
movslq 0x14(%rbx), %rcx
movsd 0x10d8(%rax,%r12), %xmm0
imulq $0x178, %rcx, %rcx      # imm = 0x178
subsd -0xc8(%rcx,%rax), %xmm0
movsd 0x10e0(%rax,%r12), %xmm1
subsd -0xc0(%rcx,%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x69a1c
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0x69a29
callq 0x93c0
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
movl %r15d, %r14d
incl %r15d
addq $0x178, %r12            # imm = 0x178
cmpq $0x1028, %r12           # imm = 0x1028
jne 0x69957
movl %r14d, %eax
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/WorldState.cpp
// Function: WorldStateUpdater::GetClosestPlayerToBall()
Unum WorldStateUpdater::GetClosestPlayerToBall() {
  double min_dist = 20000;
  int min_index = 0;
  for (int i = 1; i <= TEAMSIZE; i++) {
    if (GetTeammate(i).IsAlive()) {
      if ((GetTeammate(i).GetPos() - Ball().GetPos()).Mod() < min_dist) {
        min_dist = (GetTeammate(i).GetPos() - Ball().GetPos()).Mod();
        min_index = i;
      }
    }
    if (GetOpponent(i).IsAlive()) {
      if ((GetOpponent(i).GetPos() - Ball().GetPos()).Mod() < min_dist) {
        min_dist = (GetOpponent(i).GetPos() - Ball().GetPos()).Mod();
        min_index = -i;
      }
    }
  }

  return min_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x5d0b(%rip), %xmm3     # 0x6f778
xorl %r15d, %r15d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0x1, %r13d
xorpd %xmm2, %xmm2
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
cmpb $0x1, 0x1ba(%rax,%r15)
jne 0x69b32
movsd 0xb0(%rax,%r15), %xmm0
subsd 0x38(%rax), %xmm0
movsd 0xb8(%rax,%r15), %xmm1
subsd 0x40(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x69acc
sqrtsd %xmm0, %xmm0
jmp 0x69adf
movsd %xmm3, -0x30(%rbp)
callq 0x93c0
movsd -0x30(%rbp), %xmm3
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm3
jbe 0x69b32
movq 0x8(%rbx), %rax
movsd 0xb0(%rax,%r15), %xmm0
subsd 0x38(%rax), %xmm0
movsd 0xb8(%rax,%r15), %xmm1
subsd 0x40(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x69b22
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0x69b2f
callq 0x93c0
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
movl %r13d, %r14d
movq 0x8(%rbx), %rax
cmpb $0x1, 0x11e2(%rax,%r15)
jne 0x69be1
movsd 0x10d8(%rax,%r15), %xmm0
subsd 0x38(%rax), %xmm0
movsd 0x10e0(%rax,%r15), %xmm1
subsd 0x40(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x69b7b
sqrtsd %xmm0, %xmm0
jmp 0x69b8e
movsd %xmm3, -0x30(%rbp)
callq 0x93c0
movsd -0x30(%rbp), %xmm3
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm3
jbe 0x69be1
movq 0x8(%rbx), %rax
movsd 0x10d8(%rax,%r15), %xmm0
subsd 0x38(%rax), %xmm0
movsd 0x10e0(%rax,%r15), %xmm1
subsd 0x40(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x69bd1
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0x69bde
callq 0x93c0
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
movl %r12d, %r14d
decl %r12d
incl %r13d
addq $0x178, %r15            # imm = 0x178
cmpq $0x1028, %r15           # imm = 0x1028
jne 0x69a83
movl %r14d, %eax
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/PlayerParam.h
// Function: PlayerParam::GetEpsInSight(double)
double GetEpsInSight(double dist) {
    Assert(dist >= 0);
    int low = 0;
    int middle = 0;
    int high = SIGHTSIZE - 1;

    while (low <= high) {
      middle = (low + high) / 2;

      if (middle + 1 >= SIGHTSIZE) {
        return mSightChange[SIGHTSIZE - 1][2];
      }

      if (dist >= mSightChange[middle][0] &&
          dist <= mSightChange[middle + 1][0]) {
        if (fabs(dist - mSightChange[middle][0]) <
            fabs(dist - mSightChange[middle + 1][0])) {
          return mSightChange[middle][2];
        } else {
          return mSightChange[middle + 1][2];
        }
      }

      if (middle == 0) {
        return mSightChange[middle][2];
      }

      if (dist < mSightChange[middle][0]) {
        high = middle;
      } else {
        low = middle + 1;
      }
    }

    PRINT_ERROR("can not find this dist " << dist);
    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x3208(%rdi), %rax
xorl %ecx, %ecx
movl $0x3d, %edx
leal (%rdx,%rcx), %r9d
cmpl $0x7a, %r9d
jge 0x6a0cc
movl %r9d, %esi
shrl $0x1f, %esi
addl %r9d, %esi
sarl %esi
leal 0x1(%rsi), %r10d
movslq %esi, %r8
leaq (%r8,%r8,2), %r8
leaq (%rax,%r8,8), %r8
movsd (%r8), %xmm3
ucomisd %xmm3, %xmm0
jb 0x6a005
movslq %r10d, %r11
leaq (%r11,%r11,2), %r11
movsd (%rax,%r11,8), %xmm1
ucomisd %xmm0, %xmm1
jae 0x6a0d6
incl %r9d
cmpl $0x2, %r9d
jbe 0x6a0f8
ucomisd %xmm0, %xmm3
ja 0x6a01d
movl %r10d, %ecx
movl %edx, %esi
movl %esi, %edx
cmpl %esi, %ecx
jle 0x69fbb
movq 0x1cfc6(%rip), %rbx     # 0x86ff0
leaq 0x590a(%rip), %rsi      # 0x6f93b
movl $0x14, %edx
movq %rbx, %rdi
movapd %xmm0, -0x20(%rbp)
callq 0x9560
leaq 0x5178(%rip), %rsi      # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x169, %esi            # imm = 0x169
callq 0x9880
movq %rax, %rbx
leaq 0x3411(%rip), %rsi      # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x58ce(%rip), %rsi      # 0x6f950
movl $0x17, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movapd -0x20(%rbp), %xmm0
callq 0x97d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
xorpd %xmm0, %xmm0
jmp 0x6a0fe
movsd 0x37d0(%rdi), %xmm0
jmp 0x6a0fe
movapd %xmm0, %xmm2
subsd %xmm3, %xmm2
movapd 0xf2a(%rip), %xmm3      # 0x6b010
andpd %xmm3, %xmm2
subsd %xmm1, %xmm0
andpd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jbe 0x6a105
movsd 0x10(%r8), %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq (%rax,%r11,8), %rax
movsd 0x10(%rax), %xmm0
jmp 0x6a0fe
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerParam.h
// Function: PlayerParam::ConvertSightDist(double)
double ConvertSightDist(double dist) {
    Assert(dist >= 0);
    int low = 0;
    int middle = 0;
    int high = SIGHTSIZE;

    while (low <= high) {
      middle = (low + high) / 2;

      if (middle >= SIGHTSIZE || middle < 0) {
        break;
      }

      if (fabs(dist - mSightChange[middle][0]) < 0.01) {
        return mSightChange[middle][1];
      }

      if (dist < mSightChange[middle][0]) {
        high = middle;
      } else {
        low = middle + 1;
      }
    }

    PRINT_ERROR("can not find this dist " << dist);
    return dist;
  }

// Assembly:
addq $0x3208, %rdi           # imm = 0x3208
xorl %eax, %eax
movl $0x3e, %ecx
movapd 0xe96(%rip), %xmm4      # 0x6b010
movsd 0x15be(%rip), %xmm1     # 0x6b740
leal (%rcx,%rax), %edx
addl $-0x7c, %edx
cmpl $-0x7d, %edx
jb 0x6a1cc
leal (%rcx,%rax), %esi
movl %esi, %edx
shrl $0x1f, %edx
addl %esi, %edx
sarl %edx
movl %edx, %esi
leaq (%rsi,%rsi,2), %rsi
movsd (%rdi,%rsi,8), %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
andpd %xmm4, %xmm3
ucomisd %xmm3, %xmm1
ja 0x6a281
ucomisd %xmm0, %xmm2
ja 0x6a1c6
incl %edx
movl %edx, %eax
jmp 0x6a1c8
movl %edx, %ecx
cmpl %ecx, %eax
jle 0x6a182
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x1ce17(%rip), %rbx     # 0x86ff0
leaq 0x575b(%rip), %rsi      # 0x6f93b
movl $0x14, %edx
movq %rbx, %rdi
movsd %xmm0, -0x10(%rbp)
callq 0x9560
leaq 0x4fc9(%rip), %rsi      # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x143, %esi            # imm = 0x143
callq 0x9880
movq %rax, %rbx
leaq 0x3262(%rip), %rsi      # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x571f(%rip), %rsi      # 0x6f950
movl $0x17, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x97d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movsd -0x10(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq (%rdi,%rsi,8), %rax
movsd 0x8(%rax), %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/WorldState.cpp
// Function: WorldStateUpdater::GetSelfVelFromSightDelay(int)
Vector WorldStateUpdater::GetSelfVelFromSightDelay(int sight_delay) {
  Assert(sight_delay >= 0 && sight_delay <= HistoryState::HISTORY_SIZE);

  if (sight_delay == 0) {
    return GetSelf().GetVel();
  } else {
    sight_delay = Min(sight_delay, int(HistoryState::HISTORY_SIZE));
    const PlayerState &player =
        mpWorldState->GetHistory(sight_delay)->GetTeammate(mSelfUnum);
    return player.GetVel()
        .Rotate(-player.GetNeckGlobalDir())
        .Rotate(GetNeckGlobalDirFromSightDelay(sight_delay));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x6a435
cmpl $0xa, %esi
movl $0xa, %ecx
cmovll %esi, %ecx
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movslq %ecx, %r15
imulq $0x66666667, %r15, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %r15d
movl 0x14b90(%rax), %ecx
subl %r15d, %ecx
addl $0xa, %ecx
movslq %ecx, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x22, %rdx
addl %esi, %edx
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
movslq %ecx, %rcx
imulq $0x2128, %rcx, %rcx     # imm = 0x2128
addq %rax, %rcx
movslq 0x14(%rbx), %rax
imulq $0x178, %rax, %rax      # imm = 0x178
leaq (%rax,%rcx), %rdi
addq $-0xd0, %rdi
leaq (%rax,%rcx), %r14
addq $-0xa0, %r14
callq 0x5b2be
xorps 0xce4(%rip), %xmm0      # 0x6b020
leaq -0x38(%rbp), %rsi
movlps %xmm0, (%rsi)
movq %r14, %rdi
callq 0x33428
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movl 0x14b90(%rax), %ecx
subl %r15d, %ecx
addl $0xa, %ecx
movslq %ecx, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x22, %rdx
addl %esi, %edx
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
movslq %ecx, %rcx
imulq $0x2128, %rcx, %r15     # imm = 0x2128
addq %rax, %r15
movslq 0x14(%rbx), %r12
callq 0x4a75c
movq %rax, %r14
callq 0x4a75c
imulq $0x178, %r12, %rcx      # imm = 0x178
movsd -0x38(%rcx,%r15), %xmm1
movsd 0x3160(%rax), %xmm0
maxsd 0x3168(%r14), %xmm1
minsd %xmm1, %xmm0
movslq 0x14(%rbx), %rax
movq 0x8(%rbx), %rcx
imulq $0x178, %rax, %rax      # imm = 0x178
addsd -0x20(%rcx,%rax), %xmm0
mulsd 0xc6b(%rip), %xmm0      # 0x6b050
divsd 0xc5b(%rip), %xmm0      # 0x6b048
leaq -0x48(%rbp), %rbx
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x92d0
movsd (%rbx), %xmm1
movsd (%r14), %xmm2
movsd -0x28(%rbp), %xmm3
movapd %xmm3, %xmm0
mulsd %xmm1, %xmm3
movsd -0x30(%rbp), %xmm4
mulsd %xmm4, %xmm1
mulsd %xmm2, %xmm0
subsd %xmm1, %xmm0
movapd %xmm4, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
jmp 0x6a456
movslq 0x14(%rbx), %rax
movq 0x8(%rbx), %rcx
imulq $0x178, %rax, %rax      # imm = 0x178
movsd -0xa0(%rax,%rcx), %xmm0
movsd -0x98(%rax,%rcx), %xmm1
addq $0x30, %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/PlayerParam.h
// Function: PlayerParam::ConvertMarkDist(double)
double ConvertMarkDist(double dist) {
    Assert(dist >= 0);
    int low = 0;
    int middle = 0;
    int high = MARKSIZE;

    while (low <= high) {
      middle = (low + high) / 2;

      if (middle >= MARKSIZE || middle < 0) {
        break;
      }

      if (fabs(dist - mMarkChange[middle][0]) < 0.01) {
        return mMarkChange[middle][1];
      }

      if (dist < mMarkChange[middle][0]) {
        high = middle;
      } else {
        low = middle + 1;
      }
    }

    PRINT_ERROR("can not find this dist " << dist);
    return dist;
  }

// Assembly:
addq $0x37d8, %rdi           # imm = 0x37D8
xorl %eax, %eax
movl $0x184, %ecx            # imm = 0x184
movapd 0xb96(%rip), %xmm4      # 0x6b010
movsd 0x12be(%rip), %xmm1     # 0x6b740
leal (%rcx,%rax), %edx
addl $0xfffffcf8, %edx       # imm = 0xFFFFFCF8
cmpl $0xfffffcf7, %edx       # imm = 0xFFFFFCF7
jb 0x6a4d2
leal (%rcx,%rax), %esi
movl %esi, %edx
shrl $0x1f, %edx
addl %esi, %edx
sarl %edx
movl %edx, %esi
leaq (%rsi,%rsi,2), %rsi
movsd (%rdi,%rsi,8), %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
andpd %xmm4, %xmm3
ucomisd %xmm3, %xmm1
ja 0x6a587
ucomisd %xmm0, %xmm2
ja 0x6a4cc
incl %edx
movl %edx, %eax
jmp 0x6a4ce
movl %edx, %ecx
cmpl %ecx, %eax
jle 0x6a482
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x1cb11(%rip), %rbx     # 0x86ff0
leaq 0x5455(%rip), %rsi      # 0x6f93b
movl $0x14, %edx
movq %rbx, %rdi
movsd %xmm0, -0x10(%rbp)
callq 0x9560
leaq 0x4cc3(%rip), %rsi      # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x186, %esi            # imm = 0x186
callq 0x9880
movq %rax, %rbx
leaq 0x2f5c(%rip), %rsi      # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x5419(%rip), %rsi      # 0x6f950
movl $0x17, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x97d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movsd -0x10(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq (%rdi,%rsi,8), %rax
movsd 0x8(%rax), %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerParam.h
// Function: PlayerParam::GetEpsInMark(double)
double GetEpsInMark(double dist) {
    Assert(dist >= 0);
    int low = 0;
    int middle = 0;
    int high = MARKSIZE - 1;

    while (low <= high) {
      middle = (low + high) / 2;

      if (middle + 1 >= MARKSIZE) {
        return mMarkChange[MARKSIZE - 1][2];
      }

      if (dist >= mMarkChange[middle][0] &&
          dist <= mMarkChange[middle + 1][0]) {
        if (fabs(dist - mMarkChange[middle][0]) <
            fabs(dist - mMarkChange[middle + 1][0])) {
          return mMarkChange[middle][2];
        } else {
          return mMarkChange[middle + 1][2];
        }
      }

      if (middle == 0) {
        return mMarkChange[middle][2];
      }

      if (dist < mMarkChange[middle][0]) {
        high = middle;
      } else {
        low = middle + 1;
      }
    }

    PRINT_ERROR("can not find this dist " << dist);
    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x37d8(%rdi), %rax
xorl %ecx, %ecx
movl $0x183, %edx            # imm = 0x183
leal (%rdx,%rcx), %r9d
cmpl $0x306, %r9d            # imm = 0x306
jge 0x6a6bd
movl %r9d, %esi
shrl $0x1f, %esi
addl %r9d, %esi
sarl %esi
leal 0x1(%rsi), %r10d
movslq %esi, %r8
leaq (%r8,%r8,2), %r8
leaq (%rax,%r8,8), %r8
movsd (%r8), %xmm3
ucomisd %xmm3, %xmm0
jb 0x6a5f6
movslq %r10d, %r11
leaq (%r11,%r11,2), %r11
movsd (%rax,%r11,8), %xmm1
ucomisd %xmm0, %xmm1
jae 0x6a6c7
incl %r9d
cmpl $0x2, %r9d
jbe 0x6a6e9
ucomisd %xmm0, %xmm3
ja 0x6a60e
movl %r10d, %ecx
movl %edx, %esi
movl %esi, %edx
cmpl %esi, %ecx
jle 0x6a5a9
movq 0x1c9d5(%rip), %rbx     # 0x86ff0
leaq 0x5319(%rip), %rsi      # 0x6f93b
movl $0x14, %edx
movq %rbx, %rdi
movapd %xmm0, -0x20(%rbp)
callq 0x9560
leaq 0x4b87(%rip), %rsi      # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x1ac, %esi            # imm = 0x1AC
callq 0x9880
movq %rax, %rbx
leaq 0x2e20(%rip), %rsi      # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x52dd(%rip), %rsi      # 0x6f950
movl $0x17, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movapd -0x20(%rbp), %xmm0
callq 0x97d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
xorpd %xmm0, %xmm0
jmp 0x6a6ef
movsd 0x5c30(%rdi), %xmm0
jmp 0x6a6ef
movapd %xmm0, %xmm2
subsd %xmm3, %xmm2
movapd 0x939(%rip), %xmm3      # 0x6b010
andpd %xmm3, %xmm2
subsd %xmm1, %xmm0
andpd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jbe 0x6a6f6
movsd 0x10(%r8), %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq (%rax,%r11,8), %rax
movsd 0x10(%rax), %xmm0
jmp 0x6a6ef
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/main.cpp
// Function: main
int main(int argc, char *argv[]) {
  RegisterSignalHandler();

  ServerParam::instance().init(argc, argv);
  PlayerParam::instance().init(argc, argv);

  Client *client = 0;

  if (PlayerParam::instance().isCoach()) {
    client = new Coach;
  } else if (PlayerParam::instance().isTrainer()) {
    client = new Trainer;
  } else {
    client = new Player;
  }

  if (PlayerParam::instance().DynamicDebugMode()) {
    client->RunDynamicDebug(); // 进入动态调试模式
  } else {
    client->RunNormal(); // 进入正常比赛模式
  }

  delete client;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
callq 0x6aceb
callq 0x4a75c
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x4bfda
callq 0x450ba
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x45eb4
callq 0x450ba
cmpb $0x1, 0x31a5(%rax)
jne 0x6ac55
movl $0x30, %edi
callq 0x94c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1c388
jmp 0x6ac8f
callq 0x450ba
cmpb $0x1, 0x31a6(%rax)
jne 0x6ac7a
movl $0x198, %edi            # imm = 0x198
callq 0x94c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x50a20
jmp 0x6ac8f
movl $0x38, %edi
callq 0x94c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x4479c
callq 0x450ba
cmpb $0x1, 0x5c40(%rax)
jne 0x6aca7
movq %rbx, %rdi
callq 0x1bf02
jmp 0x6acaf
movq %rbx, %rdi
callq 0x1c116
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x38, %esi
jmp 0x6acdb
movq %rax, %r14
movl $0x198, %esi            # imm = 0x198
jmp 0x6acdb
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x94e0
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/main.cpp
// Function: RegisterSignalHandler()
void RegisterSignalHandler() {
#ifndef WIN32
  if (signal(SIGINT, signal_catcher) == SIG_ERR) //中断
    perror("SIGINT"), exit(1);
  if (signal(SIGQUIT, signal_catcher) == SIG_ERR) //退出
    perror("SIGQUIT"), exit(1);
  //	if(signal(SIGABRT, signal_catcher) == SIG_ERR)
  ////不能注册SIGABRT，否则调用 abort 时，会产生死循环 		perror("SIGABRT"),
  //exit(1);
  if (signal(SIGSEGV, signal_catcher) == SIG_ERR) //段错误
    perror("SIGSEGV"), exit(1);
  if (signal(SIGILL, signal_catcher) == SIG_ERR) //非法指令
    perror("SIGILL"), exit(1);
  if (signal(SIGFPE, signal_catcher) == SIG_ERR) //浮点异常
    perror("SIGFPE"), exit(1);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x87(%rip), %rsi        # 0x6ad7d
movl $0x2, %edi
callq 0x95b0
cmpq $-0x1, %rax
je 0x6ad64
leaq 0x70(%rip), %rsi        # 0x6ad7d
movl $0x3, %edi
callq 0x95b0
cmpq $-0x1, %rax
je 0x6ad69
leaq 0x59(%rip), %rsi        # 0x6ad7d
movl $0xb, %edi
callq 0x95b0
cmpq $-0x1, %rax
je 0x6ad6e
leaq 0x42(%rip), %rsi        # 0x6ad7d
movl $0x4, %edi
callq 0x95b0
cmpq $-0x1, %rax
je 0x6ad73
leaq 0x2b(%rip), %rsi        # 0x6ad7d
movl $0x8, %edi
callq 0x95b0
cmpq $-0x1, %rax
je 0x6ad78
popq %rbp
retq
callq 0xa616
callq 0xa5fe
callq 0xa5e6
callq 0xa5ce
callq 0xa5b6
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/main.cpp
// Function: (anonymous namespace)::signal_catcher(int)
void signal_catcher(int sig) {
#ifndef WIN32
  signal(sig, signal_catcher);

  std::cerr << "catch signal " << sig << std::endl;

  create_dump(); //先产生coredump

  std::cerr << "exiting safely now" << std::endl;

  Logger::instance().LogSight();
  Logger::instance().SetFlushCond(); // set flush cond and let the logger thread
                                     // flush the logs to file.
  DynamicDebug::instance().AddMessage("---Aborted", MT_Send);

  WaitFor(100); // wait logger thread to finish flushing

  exit(0); //这里会调用静态对象的析构函数
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq -0x10(%rip), %rsi       # 0x6ad7d
callq 0x95b0
movq 0x1c257(%rip), %r14     # 0x86ff0
leaq 0x4bed(%rip), %rsi      # 0x6f98d
movq %r14, %rdi
callq 0x94a0
movq %rax, %rdi
movl %ebx, %esi
callq 0x9880
movq %rax, %rdi
callq 0x9240
callq 0x6ae1a
leaq 0x4bd5(%rip), %rsi      # 0x6f99b
movq %r14, %rdi
callq 0x94a0
movq %rax, %rdi
callq 0x9240
callq 0x35b4a
movq %rax, %rdi
callq 0x35f2c
callq 0x35b4a
movq %rax, %rdi
callq 0x35e4a
callq 0x23390
leaq 0x4bb2(%rip), %rsi      # 0x6f9ae
movq %rax, %rdi
movl $0x3, %edx
callq 0x2371a
movl $0x64, %edi
callq 0x6ae2e
xorl %edi, %edi
callq 0x95d0
// File: /workspace/github_cpp_makefile_star2_O1/MarkOates[P]file-downloader/file_downloader.cpp
// Function: FileDownloader::progress_function(void*, double, double, double, double)
int FileDownloader::progress_function(void *ptr, double download_total, double download_now, double upload_total, double upload_now)
{
   FileDownloader::FileHandle &handle = *static_cast<FileDownloader::FileHandle *>(ptr);
   if (download_total == 0) return 0;
   if (handle.abort) return 1;

   handle.status = DOWNLOADING;
   handle.percentage = download_now / download_total;
   handle.download_size = download_total;

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x403a
jnp 0x4064
movl $0x1, %eax
cmpb $0x0, 0x10(%rdi)
jne 0x4064
movl $0x1, 0x4(%rdi)
divsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, 0xc(%rdi)
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/io.cc
// Function: SimpleFileInput::SimpleFileInput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
SimpleFileInput::SimpleFileInput(string filename)
{
    if (ends_with(filename, ".gz"))
    {
#ifndef NO_ZLIB
        infs = new GZipFileInput(filename);
#else
        cerr << "No ZLIB support" << endl;
        exit(1);
#endif
    }
    else
        infs = new IFStreamInput(filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x2019a(%rip), %rsi     # 0x261fe
leaq 0x20196(%rip), %rdx     # 0x26201
leaq -0x40(%rbp), %rdi
callq 0x5fa4
movq 0x8(%r14), %rsi
movq -0x38(%rbp), %rdx
subq %rdx, %rsi
jae 0x6086
xorl %r12d, %r12d
jmp 0x6098
leaq -0x40(%rbp), %rcx
movq %r14, %rdi
callq 0x4470
testl %eax, %eax
sete %r12b
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x60a6
callq 0x4350
testb %r12b, %r12b
je 0x60fb
movl $0x10, %edi
callq 0x4390
movq %rax, %r15
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x5f0a
leaq 0x2daf5(%rip), %rax     # 0x33bd0
movq %rax, (%r15)
movq -0x80(%rbp), %rdi
leaq 0x203fb(%rip), %rsi     # 0x264e4
callq 0x4500
movq %rax, 0x8(%r15)
movq %r15, (%rbx)
movq -0x80(%rbp), %rdi
jmp 0x6137
movl $0x210, %edi            # imm = 0x210
callq 0x4390
movq %rax, %r15
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x5f0a
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x689e
movq %r15, (%rbx)
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x6141
callq 0x4350
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x615e
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x616f
callq 0x4350
jmp 0x616f
jmp 0x616c
movq %rax, %rbx
movq %r15, %rdi
callq 0x4350
jmp 0x618a
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
jne 0x6172
jmp 0x618a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/io.cc
// Function: GZipFileInput::getline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool
GZipFileInput::getline(string &line)
{
    char buffer[GZIP_BUFFER_SIZE];
    char *res = gzgets(gzf, buffer, GZIP_BUFFER_SIZE-1);
    if (res != NULL) {
        strtok(buffer, "\r\n");
        line.assign(buffer);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100000, %rsp         # imm = 0x100000
movq %rsi, %rbx
movq 0x8(%rdi), %rdi
leaq -0x100020(%rbp), %rsi
movl $0xfffff, %edx          # imm = 0xFFFFF
callq 0x4600
movq %rax, %r14
testq %rax, %rax
je 0x627b
leaq 0x1ffb5(%rip), %rsi     # 0x26202
leaq -0x100020(%rbp), %r15
movq %r15, %rdi
callq 0x4560
movq 0x8(%rbx), %r12
movq %r15, %rdi
callq 0x4170
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x4550
testq %r14, %r14
setne %al
addq $0x100000, %rsp         # imm = 0x100000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/io.cc
// Function: SimpleFileOutput::SimpleFileOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
SimpleFileOutput::SimpleFileOutput(string filename)
{
    if (ends_with(filename, ".gz"))
    {
#ifndef NO_ZLIB
        outfs = new GZipFileOutput(filename);
#else
        cerr << "No ZLIB support" << endl;
        exit(1);
#endif
    }
    else
        outfs = new OFStream(filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ff48(%rip), %rsi     # 0x261fe
leaq 0x1ff44(%rip), %rdx     # 0x26201
leaq -0x40(%rbp), %rdi
callq 0x5fa4
movq 0x8(%r14), %rsi
movq -0x38(%rbp), %rdx
subq %rdx, %rsi
jae 0x62d8
xorl %r12d, %r12d
jmp 0x62ea
leaq -0x40(%rbp), %rcx
movq %r14, %rdi
callq 0x4470
testl %eax, %eax
sete %r12b
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x62f8
callq 0x4350
testb %r12b, %r12b
je 0x6352
movl $0x18, %edi
callq 0x4390
movq %rax, %r15
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x5f0a
leaq 0x2d92b(%rip), %rax     # 0x33c58
movq %rax, (%r15)
movq -0x80(%rbp), %rdi
leaq 0x1feca(%rip), %rsi     # 0x26205
callq 0x4500
movq %rax, 0x8(%r15)
movb $0x1, 0x10(%r15)
movq %r15, (%rbx)
movq -0x80(%rbp), %rdi
jmp 0x638e
movl $0x208, %edi            # imm = 0x208
callq 0x4390
movq %rax, %r15
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x5f0a
leaq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x651a
movq %r15, (%rbx)
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x6398
callq 0x4350
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x63b5
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x63c6
callq 0x4350
jmp 0x63c6
jmp 0x63c3
movq %rax, %rbx
movq %r15, %rdi
callq 0x4350
jmp 0x63e1
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
jne 0x63c9
jmp 0x63e1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4650
nop
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/io.cc
// Function: SimpleFileOutput::close()
void
SimpleFileOutput::close()
{
    if (outfs) {
        outfs->close();
        delete outfs;
        outfs = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x644f
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6448
movq (%rdi), %rax
callq *0x48(%rax)
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/io.cc
// Function: GZipFileOutput::close()
void
GZipFileOutput::close()
{
    if (file_open) {
         gzclose(gzf);
         gzf = NULL;
    }
    file_open = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x677a
movq 0x8(%rbx), %rdi
callq 0x45e0
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Option::get_int() const
int
Option::get_int() const
{
    char *endptr;
    int return_value = strtol(value.c_str(), &endptr, 10);
    if (endptr == value.c_str() || *endptr != 0) {
        fprintf(stderr, "invalid value for option %s: %s\n", name.c_str(),
                value.c_str());
        exit(1);
    }
    return return_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
movl $0xa, %edx
callq 0x44b0
movq (%r14), %rcx
movq 0x28(%rbx), %rsi
cmpq %rsi, %rcx
je 0x69cd
cmpb $0x0, (%rcx)
jne 0x69cd
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x4710
nop
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Option::get_float() const
float
Option::get_float() const
{
    char *endptr;
    double return_value = strtod(value.c_str(), &endptr);
    if (endptr == value.c_str() || *endptr != 0) {
        fprintf(stderr, "invalid value for option %s: %s\n", name.c_str(),
                value.c_str());
        exit(1);
    }
    return return_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x42d0
movq (%r14), %rax
movq 0x28(%rbx), %rsi
cmpq %rsi, %rax
je 0x6a12
cmpb $0x0, (%rax)
jne 0x6a12
cvtsd2ss %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x473e
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Option::get_double() const
double
Option::get_double() const
{
    char *endptr;
    double return_value = strtod(value.c_str(), &endptr);
    if (endptr == value.c_str() || *endptr != 0) {
        fprintf(stderr, "invalid value for option %s: %s\n", name.c_str(),
                value.c_str());
        exit(1);
    }
    return return_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq 0x42d0
movq (%r14), %rax
movq 0x28(%rbx), %rsi
cmpq %rsi, %rax
je 0x6a52
cmpb $0x0, (%rax)
jne 0x6a52
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x476c
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Config::parse(int, char**, bool)
void
Config::parse(int argc, char *argv[], bool override)
{
    std::deque<std::string> argument_queue;
    for (int arg_index = 1; arg_index < argc; arg_index++)
        argument_queue.push_back(argv[arg_index]);
    parse_aux(argument_queue, override);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, -0x30(%rbp)
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, -0x38(%rbp)
xorps %xmm0, %xmm0
leaq -0xb0(%rbp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x8712
cmpl $0x2, %ebx
jl 0x74d8
movl %ebx, %r14d
movl $0x1, %r13d
leaq -0x58(%rbp), %r12
leaq -0xb0(%rbp), %rbx
movq (%r15,%r13,8), %rsi
movq %r12, %rdi
leaq -0x29(%rbp), %rdx
callq 0x4150
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9b4c
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x74d0
callq 0x4350
incq %r13
cmpq %r13, %r14
jne 0x74a3
movzbl -0x30(%rbp), %edx
leaq -0xb0(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x6ede
leaq -0xb0(%rbp), %rdi
callq 0x7fd8
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x750c
movq %rax, %rbx
jmp 0x7526
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x7526
callq 0x4350
leaq -0xb0(%rbp), %rdi
callq 0x7fd8
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Config::default_parse(int, char**)
void
Config::default_parse(int argc, char *argv[])
{
    parse(argc, argv);

    if ((*this)["help"].specified) {
        fputs(help_string().c_str(), stdout);
        exit(0);
    }
    check_required();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl $0x1, %ecx
callq 0x7446
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ead5(%rip), %rsi     # 0x26038
leaq 0x1ead2(%rip), %rdx     # 0x2603c
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x5fa4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x75f4
movb 0x4a(%rax), %r14b
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x7593
callq 0x4350
testb %r14b, %r14b
jne 0x75ab
movq %rbx, %rdi
callq 0x77f8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7630
movq (%r14), %rdi
movq 0x2c9bc(%rip), %rax     # 0x33f80
movq (%rax), %rsi
callq 0x43e0
movq %r14, %rdi
callq 0x4708
xorl %edi, %edi
callq 0x4420
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x75ec
callq 0x4350
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O1/aalto-speech[P]ftk/util/conf.cc
// Function: conf::Config::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
const Option&
Config::operator[](std::string long_name) const
{
    LongMap::const_iterator it = long_map.find(long_name);
    if (it == long_map.end()) {
        fprintf(stderr, "Config::get(): unknown option %s\n", long_name.c_str());
        abort();
    }
    return options[it->second];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x68, %rdi
callq 0x9e3c
leaq 0x70(%rbx), %rcx
cmpq %rcx, %rax
je 0x7628
movslq 0x40(%rax), %rax
leaq (%rax,%rax,8), %rax
shlq $0x4, %rax
addq 0x20(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x48aa