LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.cpp
// Function: Circle::Intersection(Ray const&, double&, double&, double const&) const
int Circle::Intersection(const Ray &r, double &t1, double &t2,
                         const double &buffer) const {
  Vector rel_center = (mCenter - r.Origin()).Rotate(-r.Dir());

  if ((mRadius + buffer) <= fabs(rel_center.Y())) {
    return 0;
  } else if (mRadius <= fabs(rel_center.Y())) {
    t1 = rel_center.X() - 0.13;
    t2 = rel_center.X() + 0.13;
    return 2;
  } else {
    double dis = Sqrt(mRadius * mRadius - rel_center.Y() * rel_center.Y());
    t1 = rel_center.X() - dis;
    t2 = rel_center.X() + dis;
    return 2;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, -0x38(%rbp)
movq %rdx, %r14
movq %rdi, %r12
movsd (%rdi), %xmm0
subsd (%rsi), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x8(%rdi), %xmm0
subsd 0x8(%rsi), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x10(%rsi), %xmm0
mulsd 0x3f3cb(%rip), %xmm0    # 0x690a0
divsd 0x3f36b(%rip), %xmm0    # 0x69048
leaq -0x50(%rbp), %r13
leaq -0x48(%rbp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x92d0
movsd -0x40(%rbp), %xmm7
movsd -0x30(%rbp), %xmm6
movsd (%r13), %xmm2
movsd (%rbx), %xmm3
movapd %xmm6, %xmm0
mulsd %xmm2, %xmm0
movapd %xmm7, %xmm1
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%r12), %xmm0
movsd (%r15), %xmm5
addsd %xmm0, %xmm5
movapd 0x3f2e0(%rip), %xmm4    # 0x69010
andpd %xmm1, %xmm4
xorl %eax, %eax
ucomisd %xmm5, %xmm4
jae 0x29dad
mulsd %xmm7, %xmm2
mulsd %xmm3, %xmm6
subsd %xmm2, %xmm6
ucomisd %xmm0, %xmm4
jae 0x29d6a
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x29d80
sqrtsd %xmm0, %xmm0
jmp 0x29d8f
movsd 0x409f6(%rip), %xmm1    # 0x6a768
addsd %xmm6, %xmm1
movsd 0x409f2(%rip), %xmm0    # 0x6a770
jmp 0x29d97
movsd %xmm6, -0x30(%rbp)
callq 0x93c0
movsd -0x30(%rbp), %xmm6
movapd %xmm6, %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r14)
addsd %xmm0, %xmm6
movq -0x38(%rbp), %rax
movsd %xmm6, (%rax)
movl $0x2, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/InterceptInfo.cpp
// Function: InterceptInfo::VerifyIntInfo(int)
PlayerInterceptInfo *InterceptInfo::VerifyIntInfo(Unum unum) {
  PlayerInterceptInfo *pInfo = GetPlayerInterceptInfo(unum);
  if (!pInfo) {
    return 0;
  }

  if (pInfo->mTime != mpWorldState->CurrentTime()) {
    CalcTightInterception(mpWorldState->GetBall(), pInfo);
    pInfo->mTime = mpWorldState->CurrentTime();
  }

  return pInfo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testl %esi, %esi
jle 0x2ab58
decl %esi
imulq $0x178, %rsi, %rcx      # imm = 0x178
cmpb $0x0, 0x1ba(%rdi,%rcx)
je 0x2abc0
leaq 0xa8(%rdi), %rax
leaq (%rsi,%rsi,8), %rdx
shlq $0x4, %rdx
leaq (%rbx,%rdx), %r14
addq $0x20, %r14
jmp 0x2ab88
notl %esi
movslq %esi, %rdx
imulq $0x178, %rdx, %rcx      # imm = 0x178
cmpb $0x0, 0x11e2(%rdi,%rcx)
je 0x2abc0
leaq 0x10d0(%rdi), %rax
leaq (%rdx,%rdx,8), %rdx
shlq $0x4, %rdx
leaq (%rbx,%rdx), %r14
addq $0x650, %r14            # imm = 0x650
addq %rcx, %rax
movq %rax, 0x60(%r14)
movl 0x5c(%r14), %eax
cmpl 0x14(%rdi), %eax
jne 0x2aba1
movl 0x10(%rdi), %eax
cmpl %eax, 0x58(%r14)
je 0x2abc3
addq $0x30, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x2ac3e
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%r14)
jmp 0x2abc3
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/InterceptInfo.cpp
// Function: InterceptInfo::GetPlayerInterceptInfo(int) const
PlayerInterceptInfo *InterceptInfo::GetPlayerInterceptInfo(Unum unum) const {
  if (!mpWorldState->GetPlayer(unum).IsAlive()) {
    return 0;
  }

  PlayerInterceptInfo *pInfo = const_cast<PlayerInterceptInfo *>(
      unum > 0 ? &(mTeammateInterceptInfo[unum])
               : &(mOpponentInterceptInfo[-unum]));
  pInfo->mpPlayer = &(mpWorldState->GetPlayer(unum));
  return pInfo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rcx
testl %esi, %esi
jle 0x2ac03
decl %esi
imulq $0x178, %rsi, %rdx      # imm = 0x178
cmpb $0x0, 0x1ba(%rcx,%rdx)
je 0x2ac3a
addq $0xa8, %rcx
leaq (%rsi,%rsi,8), %rax
shlq $0x4, %rax
addq %rdi, %rax
addq $0x20, %rax
jmp 0x2ac31
notl %esi
movslq %esi, %rax
imulq $0x178, %rax, %rdx      # imm = 0x178
cmpb $0x0, 0x11e2(%rcx,%rdx)
je 0x2ac3a
addq $0x10d0, %rcx           # imm = 0x10D0
leaq (%rax,%rax,8), %rax
shlq $0x4, %rax
addq %rdi, %rax
addq $0x650, %rax            # imm = 0x650
addq %rdx, %rcx
movq %rcx, 0x60(%rax)
jmp 0x2ac3c
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/InterceptInfo.cpp
// Function: InterceptInfo::AnalyseInterceptSolution(BallState const&, PlayerInterceptInfo*)
void InterceptInfo::AnalyseInterceptSolution(const BallState &ball,
                                             PlayerInterceptInfo *pInfo) {
  pInfo->mIntervals = (pInfo->solution.interc == 1) ? 1 : 2;
  pInfo->mMinCycle = pInfo->mInterCycle[0];
  if (pInfo->mMinCycle == 0)
    pInfo->mIntervals = 0; //表示可踢
  pInfo->mInterPos = ball.GetPredictedPos(pInfo->mMinCycle);

  if (!ServerParam::instance().pitchRectanglar().IsWithin(pInfo->mInterPos,
                                                          4.0)) {
    pInfo->mRes = IR_Failure;
  } else {
    pInfo->mRes = IR_Success;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x68(%rsi), %esi
xorl %eax, %eax
cmpl $0x1, 0x4(%rbx)
setne %al
incl %eax
movl %eax, 0x88(%rbx)
movl %esi, 0x74(%rbx)
testl %esi, %esi
jne 0x2ae52
movl $0x0, 0x88(%rbx)
callq 0x220a4
movups (%rax), %xmm0
movups %xmm0, 0x78(%rbx)
callq 0x49360
movsd 0x37f0(%rax), %xmm1
addsd 0x3f905(%rip), %xmm1    # 0x6a778
movsd 0x78(%rbx), %xmm0
movl $0x1, %ecx
ucomisd %xmm1, %xmm0
jb 0x2aed2
movsd 0x37f8(%rax), %xmm1
addsd 0x3f485(%rip), %xmm1    # 0x6a318
ucomisd %xmm0, %xmm1
jb 0x2aed2
movsd 0x80(%rbx), %xmm0
movsd 0x3800(%rax), %xmm1
addsd 0x3f8c7(%rip), %xmm1    # 0x6a778
ucomisd %xmm1, %xmm0
jb 0x2aed2
movsd 0x3808(%rax), %xmm1
addsd 0x3f451(%rip), %xmm1    # 0x6a318
ucomisd %xmm0, %xmm1
jb 0x2aed2
movl $0x2, %ecx
movl %ecx, 0x8c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/InterceptModel.cpp
// Function: InterceptModel::PlotInterceptCurve(double, double, double, double, double, double, double)
void InterceptModel::PlotInterceptCurve(double x0, double y0, double v0,
                                        double vp, double ka, double cd,
                                        double max_x) {
  Plotter::instance().GnuplotExecute("alpha = 0.94");
  Plotter::instance().GnuplotExecute("ln(x) = log(x)");
  Plotter::instance().GnuplotExecute(
      "bt(x) = ln(1 - x * (1 - alpha) / v0) / ln(alpha)");
  Plotter::instance().GnuplotExecute("s(x) = sqrt((x - x0)**2 + y0**2)");
  Plotter::instance().GnuplotExecute("pt(x) = (s(x) - ka) / vp - cd");

  Plotter::instance().GnuplotExecute("x0 = %g", x0);
  Plotter::instance().GnuplotExecute("y0 = %g", y0);
  Plotter::instance().GnuplotExecute("v0 = %g", v0);
  Plotter::instance().GnuplotExecute("vp = %g", vp);
  Plotter::instance().GnuplotExecute("ka = %g", ka);
  Plotter::instance().GnuplotExecute("cd = %g", cd);

  Plotter::instance().GnuplotExecute("set xrange[0:%g]", max_x + 1.0);
  Plotter::instance().GnuplotExecute("set yrange[0:]");

  Plotter::instance().GnuplotExecute("plot bt(x), pt(x)");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm6, -0x38(%rbp)
movsd %xmm5, -0x30(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
callq 0x46686
leaq 0x3dab8(%rip), %rsi     # 0x6a801
movq %rax, %rdi
xorl %eax, %eax
callq 0x46722
callq 0x46686
leaq 0x3daaf(%rip), %rsi     # 0x6a80e
movq %rax, %rdi
xorl %eax, %eax
callq 0x46722
callq 0x46686
leaq 0x3daa8(%rip), %rsi     # 0x6a81d
movq %rax, %rdi
xorl %eax, %eax
callq 0x46722
callq 0x46686
leaq 0x3dac3(%rip), %rsi     # 0x6a84e
movq %rax, %rdi
xorl %eax, %eax
callq 0x46722
callq 0x46686
leaq 0x3dace(%rip), %rsi     # 0x6a86f
movq %rax, %rdi
xorl %eax, %eax
callq 0x46722
callq 0x46686
leaq 0x3dad6(%rip), %rsi     # 0x6a88d
movq %rax, %rdi
movsd -0x8(%rbp), %xmm0
movb $0x1, %al
callq 0x46722
callq 0x46686
leaq 0x3dac3(%rip), %rsi     # 0x6a895
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
callq 0x46722
callq 0x46686
leaq 0x3dab0(%rip), %rsi     # 0x6a89d
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
movb $0x1, %al
callq 0x46722
callq 0x46686
leaq 0x3da9d(%rip), %rsi     # 0x6a8a5
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
movb $0x1, %al
callq 0x46722
callq 0x46686
leaq 0x3da8a(%rip), %rsi     # 0x6a8ad
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
movb $0x1, %al
callq 0x46722
callq 0x46686
leaq 0x3da77(%rip), %rsi     # 0x6a8b5
movq %rax, %rdi
movsd -0x30(%rbp), %xmm0
movb $0x1, %al
callq 0x46722
callq 0x46686
movsd -0x38(%rbp), %xmm0
addsd 0x3c1f9(%rip), %xmm0    # 0x69058
leaq 0x3da57(%rip), %rsi     # 0x6a8bd
movq %rax, %rdi
movb $0x1, %al
callq 0x46722
callq 0x46686
leaq 0x3da52(%rip), %rsi     # 0x6a8ce
movq %rax, %rdi
xorl %eax, %eax
callq 0x46722
callq 0x46686
leaq 0x3da4b(%rip), %rsi     # 0x6a8dd
movq %rax, %rdi
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
jmp 0x46722
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Kicker.cpp
// Function: Kicker::ReadUtilityTable()
void Kicker::ReadUtilityTable() {
  std::ifstream in_file("data/kicker_value", std::ios::binary);
  if (!in_file) {
    PRINT_ERROR("open file error");
    return;
  }
  in_file.read((char *)mKickerValue, sizeof(mKickerValue));
  in_file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq 0x3d658(%rip), %rsi     # 0x6a930
leaq -0x218(%rbp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x9920
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x2d396
movq 0x56ce8(%rip), %rdi     # 0x83ff0
leaq 0x3d633(%rip), %rsi     # 0x6a942
movl $0x11, %edx
callq 0x9560
movq 0x56cd0(%rip), %rdi     # 0x83ff0
leaq 0x3fe6b(%rip), %rsi     # 0x6d192
movl $0x1, %edx
callq 0x9560
movq 0x56cb8(%rip), %rdi     # 0x83ff0
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x9880
movq %rax, %rbx
leaq 0x3e10b(%rip), %rsi     # 0x6b457
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x3d5f4(%rip), %rsi     # 0x6a954
movl $0xf, %edx
movq %rbx, %rdi
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
jmp 0x2d3bd
addq $0x558, %rbx            # imm = 0x558
leaq -0x218(%rbp), %rdi
movl $0x2b3fb0, %edx         # imm = 0x2B3FB0
movq %rbx, %rsi
callq 0x9610
leaq -0x218(%rbp), %rdi
callq 0x9120
leaq -0x218(%rbp), %rdi
callq 0x9170
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x9170
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Kicker.cpp
// Function: Kicker::OneCycleKick(Agent const&, bool)
ActionPlan Kicker::OneCycleKick(const Agent &agent, bool is_shoot) {
  UpdateKickData(agent);

  AtomicAction a = GetKickOutAction(agent, mInput.mBallPos, mInput.mBallVel);

  ActionPlan p;
  p.mActionQueue.push_back(a);
  p.mCycle = 1;
  p.mSucceed = a.mSucceed;

  if (p.mSucceed ==
      false) /** mKickSpeed太大或者太小，一脚不能达到该速度，如果是射门则以最大速度射，否则先停球 */
  {
    if (is_shoot) {
      a = GetMaxKickOutAction(agent, mInput.mBallPos, mInput.mBallVel);
    } else {
      a = GetStopBallAction(agent);
    }

    if (a.mSucceed == true) {
      p.mActionQueue.clear();
      p.mActionQueue.push_back(a);
      p.mSucceed = true;
    }
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2d494
leaq 0x2b45b0(%r12), %r13
leaq 0x2b45c0(%r12), %r8
leaq -0x70(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %r8, -0x78(%rbp)
movl $0x1, %r9d
callq 0x2fe76
movb $0x0, (%rbx)
leaq 0x8(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rbx)
movups %xmm0, 0x14(%rbx)
movups %xmm0, 0x24(%rbx)
movups %xmm0, 0x34(%rbx)
movups %xmm0, 0x44(%rbx)
movl $0x0, 0x54(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x32a30
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
addq $-0x30, %rcx
cmpq %rcx, %rax
movq %r14, -0x38(%rbp)
je 0x2f1a1
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups -0x50(%rbp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x30, 0x38(%rbx)
jmp 0x2f1ad
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x32c42
movl $0x1, 0x4(%rbx)
movb -0x70(%rbp), %al
movb %al, (%rbx)
testb %al, %al
jne 0x2f270
cmpb $0x0, -0x2c(%rbp)
je 0x2f1e8
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq -0x78(%rbp), %r8
movl $0x1, %r9d
callq 0x30c6e
jmp 0x2f1ff
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x30116
movups -0xa8(%rbp), %xmm0
movups -0x98(%rbp), %xmm1
movups -0x88(%rbp), %xmm2
movaps %xmm2, -0x50(%rbp)
movaps %xmm1, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
cmpb $0x1, -0x70(%rbp)
jne 0x2f270
movq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x327e2
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
addq $-0x30, %rcx
cmpq %rcx, %rax
je 0x2f261
movaps -0x70(%rbp), %xmm0
movaps -0x60(%rbp), %xmm1
movaps -0x50(%rbp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x30, 0x38(%rbx)
jmp 0x2f26d
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x32c42
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f289
jmp 0x2f289
movq %rax, %rbx
movq -0x38(%rbp), %rdi
callq 0x32bdc
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Kicker.cpp
// Function: Kicker::KickBall(Agent&, Vector const&, double, KickMode, int*, bool)
bool Kicker::KickBall(Agent &agent, const Vector &target, double speed_out,
                      KickMode mode, int *cycle_left, bool is_shoot) {
  UpdateKickData(agent);

  double speed_buf = 0.0;
  switch (mode) {
  case KM_Hard:
    speed_buf = 0.04;
    break;
  case KM_Quick:
    speed_buf = 0.08; // 要快速踢出去，速度小一点也没关系
    break;
  default:
    speed_buf = 0.06;
    break;
  }

  double speed[] = {0.0, 0.0, 0.0, 0.0, ServerParam::instance().ballSpeedMax()};
  int kick_cycle = 1;
  double kick_speed = speed_out;

  for (int i = 1; i <= 4; ++i) {
    speed[i] = GetMaxSpeed(agent, target, i);

    if (speed[i] < 0.01) // 能产生的速度太小，不考虑
    {
      continue;
    }
    if (speed[i] + speed_buf > speed_out) {
      kick_cycle = i;
      kick_speed = Min(speed_out, speed[i]);
      break;
    }
  }

  if (cycle_left != 0) {
    *cycle_left = kick_cycle - 1;
  }

  bool rt = KickBall(
      agent, target, kick_speed, kick_cycle,
      is_shoot); // 花kick_cycle周期踢球，目标点为target，出球速度为SpeedOut
  return rt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, -0x3c(%rbp)
movq %r8, -0x48(%rbp)
movl %ecx, %ebx
movsd %xmm0, -0x38(%rbp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
xorl %r12d, %r12d
cmpl $0x2, %ecx
sete -0x30(%rbp)
callq 0x2d494
cmpl $0x1, %ebx
je 0x3048c
movb -0x30(%rbp), %al
movb %al, %r12b
leaq 0x3a49c(%rip), %rax     # 0x6a920
movsd (%rax,%r12,8), %xmm0
jmp 0x30494
movsd 0x39e64(%rip), %xmm0    # 0x6a2f8
movsd %xmm0, -0x30(%rbp)
callq 0x49360
leaq -0x40(%rbp), %r12
movl $0x1, (%r12)
movl $0x2, %ebx
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2e0a6
movsd 0x39272(%rip), %xmm1    # 0x69740
ucomisd %xmm0, %xmm1
ja 0x304e4
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
ucomisd -0x38(%rbp), %xmm1
ja 0x304f5
movl %ebx, -0x40(%rbp)
incl %ebx
cmpl $0x6, %ebx
jne 0x304af
movl $0x1, %ebx
jmp 0x30501
minsd -0x38(%rbp), %xmm0
decl %ebx
movsd %xmm0, -0x38(%rbp)
movq -0x48(%rbp), %rcx
testq %rcx, %rcx
je 0x3050f
leal -0x1(%rbx), %eax
movl %eax, (%rcx)
movzbl -0x3c(%rbp), %r8d
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movsd -0x38(%rbp), %xmm0
movl %ebx, %ecx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e9f6
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Kicker.cpp
// Function: Kicker::GetAccelerateBallAction(Agent const&, Vector&)
AtomicAction Kicker::GetAccelerateBallAction(const Agent &agent,
                                             Vector &goal_vel) {
  UpdateKickData(agent);

  AtomicAction action;
  action.mType = CT_Kick;

  Vector accel = goal_vel.Rotate(-mInput.mPlayerBodyDir) - mInput.mBallVel;
  action.mKickVel = accel / agent.GetSelf().GetKickRate();
  if (action.mKickVel.Mod() <= ServerParam::instance().maxPower()) {
    action.mSucceed = true;
  } else {
    action.mSucceed = false;
    action.mKickVel =
        action.mKickVel.SetLength(ServerParam::instance().maxPower());
  }

  return action;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2d494
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq $0x0, 0x28(%rbx)
movl $0x6, 0x4(%rbx)
movsd 0x2b45a8(%r12), %xmm0
xorpd 0x36da2(%rip), %xmm0    # 0x69020
leaq -0x48(%rbp), %rsi
movlpd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x3268c
subsd 0x2b45c0(%r12), %xmm0
movsd %xmm0, -0x28(%rbp)
subsd 0x2b45c8(%r12), %xmm1
movapd %xmm1, -0x40(%rbp)
movq %r14, %rdi
callq 0xe75a
movsd 0x130(%rax), %xmm0
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setae %al
movapd 0x36d3f(%rip), %xmm1    # 0x69010
andpd %xmm0, %xmm1
leaq 0x382d4(%rip), %rcx     # 0x6a5b0
movsd (%rcx,%rax,8), %xmm2
cmpltsd 0x36d56(%rip), %xmm1    # 0x69040
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
movsd -0x28(%rbp), %xmm2
divsd %xmm1, %xmm2
movapd -0x40(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm2, 0x8(%rbx)
movsd %xmm0, 0x10(%rbx)
movapd %xmm0, -0x40(%rbp)
mulsd %xmm0, %xmm0
movsd %xmm2, -0x28(%rbp)
movapd %xmm2, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x49360
movsd -0x30(%rbp), %xmm1
movsd 0x3130(%rax), %xmm0
ucomisd %xmm1, %xmm0
jae 0x32386
movb $0x0, (%rbx)
callq 0x49360
movsd -0x30(%rbp), %xmm4
ucomisd 0x36d2b(%rip), %xmm4    # 0x69090
movsd 0x3130(%rax), %xmm0
divsd %xmm4, %xmm0
movapd -0x40(%rbp), %xmm2
mulsd %xmm0, %xmm2
xorpd %xmm3, %xmm3
ja 0x3238b
xorpd %xmm0, %xmm0
jmp 0x32398
movb $0x1, (%rbx)
jmp 0x323ab
movsd -0x28(%rbp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
cmpltsd %xmm4, %xmm3
andpd %xmm2, %xmm3
movsd %xmm0, 0x8(%rbx)
movlpd %xmm3, 0x10(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Kicker.cpp
// Function: Kicker::GetKickBallToAngleAction(Agent const&, double, double)
AtomicAction Kicker::GetKickBallToAngleAction(const Agent &agent,
                                              AngleDeg rel_angle,
                                              double rel_dist_rate) {
  UpdateKickData(agent);

  AtomicAction action;
  action.mType = CT_Kick;

  Vector target =
      mInput.mPlayerVel +
      Polar2Vector(agent.GetSelf().GetKickableArea() * rel_dist_rate,
                   rel_angle);
  action.mKickVel = (target - mInput.mBallPos - mInput.mBallVel) /
                    agent.GetSelf().GetKickRate();
  action.mKickVel = action.mKickVel.SetLength(action.mKickVel.Mod() - 0.01);
  if (action.mKickVel.Mod() <= ServerParam::instance().maxPower()) {
    action.mSucceed = true;
    return action;
  } else {
    action.mSucceed = false;
    return action;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movaps %xmm1, -0x40(%rbp)
movsd %xmm0, -0x48(%rbp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2d494
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq $0x0, 0x28(%rbx)
movl $0x6, 0x4(%rbx)
movq %r14, %rdi
callq 0xe75a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movapd -0x40(%rbp), %xmm0
mulsd (%rax), %xmm0
movapd %xmm0, -0x40(%rbp)
movsd -0x48(%rbp), %xmm0
mulsd 0x36c24(%rip), %xmm0    # 0x69050
divsd 0x36c14(%rip), %xmm0    # 0x69048
leaq -0x58(%rbp), %r12
leaq -0x50(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x92d0
movsd (%r13), %xmm1
movapd -0x40(%rbp), %xmm0
mulsd %xmm0, %xmm1
mulsd (%r12), %xmm0
addsd 0x2b4598(%r15), %xmm1
addsd 0x2b45a0(%r15), %xmm0
subsd 0x2b45b0(%r15), %xmm1
subsd 0x2b45b8(%r15), %xmm0
subsd 0x2b45c0(%r15), %xmm1
movsd %xmm1, -0x48(%rbp)
subsd 0x2b45c8(%r15), %xmm0
movapd %xmm0, -0x40(%rbp)
movq %r14, %rdi
callq 0xe75a
movsd -0x48(%rbp), %xmm4
movsd 0x130(%rax), %xmm1
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setae %al
movapd 0x36b4a(%rip), %xmm2    # 0x69010
andpd %xmm1, %xmm2
leaq 0x380df(%rip), %rcx     # 0x6a5b0
movsd (%rcx,%rax,8), %xmm3
cmpltsd 0x36b61(%rip), %xmm2    # 0x69040
andpd %xmm2, %xmm3
andnpd %xmm1, %xmm2
orpd %xmm3, %xmm2
movapd -0x40(%rbp), %xmm3
divsd %xmm2, %xmm4
divsd %xmm2, %xmm3
movapd %xmm3, %xmm1
mulsd %xmm3, %xmm1
movapd %xmm4, %xmm2
mulsd %xmm4, %xmm2
addsd %xmm1, %xmm2
xorps %xmm1, %xmm1
sqrtsd %xmm2, %xmm1
movsd 0x383f5(%rip), %xmm2    # 0x6a910
addsd %xmm1, %xmm2
ucomisd %xmm0, %xmm1
divsd %xmm1, %xmm2
mulsd %xmm2, %xmm3
ja 0x32533
xorpd %xmm4, %xmm4
jmp 0x32537
mulsd %xmm2, %xmm4
cmpltsd %xmm1, %xmm0
andpd %xmm3, %xmm0
movsd %xmm4, 0x8(%rbx)
movlpd %xmm0, 0x10(%rbx)
mulsd %xmm0, %xmm0
mulsd %xmm4, %xmm4
addsd %xmm0, %xmm4
xorps %xmm0, %xmm0
sqrtsd %xmm4, %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x49360
movsd 0x3130(%rax), %xmm0
ucomisd -0x40(%rbp), %xmm0
setae (%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Kicker.h
// Function: Kicker::GetOneKickMaxSpeed(Vector const&, double const&, double const&)
double GetOneKickMaxSpeed(const Vector &ball_vel, const double &kick_angle,
                            const double &max_accel) {
    SinCosT value = SinCos(ball_vel.Dir() - kick_angle);

    double y = Sin(value) * ball_vel.Mod();

    if (fabs(y) < max_accel) {
      double x = Cos(value) * ball_vel.Mod();
      return (MinMax(0.0, Sqrt(max_accel * max_accel - y * y) + x,
                     ServerParam::instance().ballSpeedMax()));
    } else {
      return 0.0;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rdi
callq 0xe702
subsd (%r14), %xmm0
mulsd 0x36927(%rip), %xmm0    # 0x69050
divsd 0x36917(%rip), %xmm0    # 0x69048
leaq -0x30(%rbp), %r14
leaq -0x28(%rbp), %rsi
movq %r14, %rdi
callq 0x92d0
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm4
movsd (%r14), %xmm2
mulsd %xmm4, %xmm2
movapd 0x368a3(%rip), %xmm3    # 0x69010
andpd %xmm2, %xmm3
movsd (%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm3, %xmm0
jbe 0x327d2
mulsd -0x28(%rbp), %xmm4
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm0
subsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x3279c
sqrtsd %xmm0, %xmm0
jmp 0x327ab
movsd %xmm4, -0x20(%rbp)
callq 0x93c0
movsd -0x20(%rbp), %xmm4
addsd %xmm0, %xmm4
movsd %xmm4, -0x20(%rbp)
callq 0x49360
movsd -0x20(%rbp), %xmm0
maxsd 0x368ca(%rip), %xmm0    # 0x69090
movsd 0x30f8(%rax), %xmm1
minsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: SightLogger::SetPlayerTypeMsg(char const*)
void SightLogger::SetPlayerTypeMsg(const char *msg) {
  mPlayerTypeMsg += msg;
  mPlayerTypeMsg += "\n";
  mLoggedPlayerTypeCount++;

  if (mLoggedPlayerTypeCount >= PlayerParam::instance().playerTypes()) {
    mHeaderReady = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2c0(%rdi), %r14
movq %r14, %rdi
callq 0x9970
leaq 0x378cd(%rip), %rsi     # 0x6ad21
movq %r14, %rdi
callq 0x9970
movl 0x2e0(%rbx), %r14d
incl %r14d
movl %r14d, 0x2e0(%rbx)
callq 0x43dce
cmpl 0x3008(%rax), %r14d
jl 0x33482
movb $0x1, 0x2e4(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: SightLogger::LogBallInfo(BallState const&)
void SightLogger::LogBallInfo(const BallState &ball) {
  if (PlayerParam::instance().SaveDecLog()) {
    DecLock();
    LogDec();

    std::stringstream ss;
    ss << "pos [" << ball.GetPosDelay() << ", " << ball.GetPosConf() << "]"
       << '#' << "vel [" << ball.GetVelDelay() << ", " << ball.GetVelConf()
       << "]" << '#';
    AddPoint(ball.GetPos(), ss.str().c_str(), White);

    DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %r15
callq 0x43dce
cmpb $0x1, 0x5c44(%rax)
jne 0x344cf
leaq 0x228(%r15), %rbx
movq %rbx, %rdi
callq 0x4e01a
movq 0x258(%r15), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r15)
leaq -0x1c8(%rbp), %rdi
callq 0x9350
leaq -0x1b8(%rbp), %r12
leaq 0x366b5(%rip), %rsi     # 0x6aa40
movl $0x5, %edx
movq %r12, %rdi
callq 0x9560
movl 0x18(%r14), %esi
movq %r12, %rdi
callq 0x9880
movq %rax, %r12
leaq 0x362a6(%rip), %rsi     # 0x6a654
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x20(%r14), %xmm0
movq %r12, %rdi
callq 0x97d0
movq %rax, %r12
leaq 0x36fef(%rip), %rsi     # 0x6b3c2
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x40(%rbp), %rsi
movb $0x23, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x9560
movq %rax, %r12
leaq 0x36648(%rip), %rsi     # 0x6aa46
movl $0x5, %edx
movq %rax, %rdi
callq 0x9560
movl 0x40(%r14), %esi
movq %r12, %rdi
callq 0x9880
movq %rax, %r12
leaq 0x36233(%rip), %rsi     # 0x6a654
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x48(%r14), %xmm0
movq %r12, %rdi
callq 0x97d0
movq %rax, %r12
leaq 0x36f7c(%rip), %rsi     # 0x6b3c2
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x40(%rbp), %rsi
movb $0x23, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x9560
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x97a0
addq $0x8, %r14
movq -0x40(%rbp), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl $0x7, %ecx
callq 0x35ad0
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x344a8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x4e036
movq 0x4fae1(%rip), %rsi     # 0x83f98
leaq -0x1c8(%rbp), %rdi
callq 0x9370
leaq -0x148(%rbp), %rdi
callq 0x91c0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34502
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x34502
jmp 0x344ff
movq %rax, %rbx
movq 0x4fa8f(%rip), %rsi     # 0x83f98
leaq -0x1c8(%rbp), %rdi
callq 0x9370
leaq -0x148(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: SightLogger::LogSight()
void SightLogger::LogSight() {
  if (mHeaderReady) {
    mSightMutex.Lock();

    if (mServerPlayMode != mpObserver->GetServerPlayMode()) {
      mServerPlayMode = mpObserver->GetServerPlayMode();
      mServerPlayMode_dirty = true;
    }

    mTime = mpWorldState->CurrentTime();

    if (mLeftScore != mpWorldState->GetTeammateScore() ||
        mRightScore != mpWorldState->GetOpponentScore() ||
        mLeftName != PlayerParam::instance().teamName() ||
        mRightName != PlayerParam::instance().opponentTeamName()) {
      mLeftName = PlayerParam::instance().teamName();
      mRightName = PlayerParam::instance().opponentTeamName();
      mLeftScore = mpWorldState->GetTeammateScore();
      mRightScore = mpWorldState->GetOpponentScore();
      mTeamState_dirty = true;
    }

    mpBall = &(mpWorldState->Ball());

    for (Unum i = 1; i <= TEAMSIZE; ++i) {
      mpLeftTeam[i] = &(mpWorldState->Teammate(i));
      mpRightTeam[i] = &(mpWorldState->Opponent(i));
    }

    mSightMutex.UnLock();
  }
}

// Assembly:
cmpb $0x1, 0x2e4(%rdi)
jne 0x34980
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x200(%rdi), %r14
movq %r14, %rdi
callq 0x4e01a
movq 0x250(%rbx), %rax
movl 0x24(%rax), %eax
cmpl %eax, 0x2e8(%rbx)
je 0x3484d
movl %eax, 0x2e8(%rbx)
movb $0x1, 0x2ec(%rbx)
movq 0x258(%rbx), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x2f0(%rbx)
movl 0x2f8(%rbx), %ecx
cmpl 0x2118(%rax), %ecx
jne 0x348dd
movl 0x2fc(%rbx), %ecx
cmpl 0x211c(%rax), %ecx
jne 0x348dd
callq 0x43dce
movq 0x310(%rbx), %rdx
cmpq 0x3140(%rax), %rdx
jne 0x348dd
testq %rdx, %rdx
je 0x348ac
movq 0x3138(%rax), %rsi
movq 0x308(%rbx), %rdi
callq 0x94f0
testl %eax, %eax
jne 0x348dd
callq 0x43dce
movq 0x330(%rbx), %rdx
cmpq 0x3168(%rax), %rdx
jne 0x348dd
testq %rdx, %rdx
je 0x34933
movq 0x3160(%rax), %rsi
movq 0x328(%rbx), %rdi
callq 0x94f0
testl %eax, %eax
je 0x34933
callq 0x43dce
leaq 0x3138(%rax), %rsi
leaq 0x308(%rbx), %rdi
callq 0x92a0
callq 0x43dce
leaq 0x3160(%rax), %rsi
leaq 0x328(%rbx), %rdi
callq 0x92a0
movq 0x258(%rbx), %rax
movl 0x2118(%rax), %ecx
movl %ecx, 0x2f8(%rbx)
movl 0x211c(%rax), %eax
movl %eax, 0x2fc(%rbx)
movb $0x1, 0x348(%rbx)
movq 0x258(%rbx), %rax
leaq 0x30(%rax), %rcx
movq %rcx, 0x350(%rbx)
addq $0x10d0, %rax           # imm = 0x10D0
movq $-0xb, %rcx
leaq -0x1028(%rax), %rdx
movq %rdx, 0x3b0(%rbx,%rcx,8)
movq %rax, 0x408(%rbx,%rcx,8)
addq $0x178, %rax            # imm = 0x178
incq %rcx
jne 0x34952
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4e036
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: TextLogger::TextLogger(Observer*, char const*)
TextLogger::TextLogger(Observer *observer, const char *log_name) {
  char file_name[256];

  Assert(std::string(log_name) != std::string("msg"));
  Assert(std::string(log_name) != std::string("sight"));

  sprintf(file_name, "Logfiles/%s-%d-%s.log",
          PlayerParam::instance().teamName().c_str(), observer->SelfUnum(),
          log_name);
  os.open(file_name);
  if (!os.good()) {
    PRINT_ERROR("open log file error");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x9870
leaq 0x200(%rbx), %r14
movq %r14, %rdi
callq 0x9350
callq 0x43dce
movq 0x3138(%rax), %rdx
movl 0x2c(%r12), %ecx
leaq 0x36090(%rip), %rsi     # 0x6aa59
leaq -0x120(%rbp), %r12
movq %r12, %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0x9110
movq %rbx, %rdi
movq %r12, %rsi
movl $0x10, %edx
callq 0x9090
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
je 0x34a92
movq 0x4f5ea(%rip), %rdi     # 0x83ff0
leaq 0x35fa4(%rip), %rsi     # 0x6a9b1
movl $0x11, %edx
callq 0x9560
movq 0x4f5d2(%rip), %rdi     # 0x83ff0
leaq 0x3876d(%rip), %rsi     # 0x6d192
movl $0x1, %edx
callq 0x9560
movq 0x4f5ba(%rip), %rdi     # 0x83ff0
movl $0x135, %esi            # imm = 0x135
callq 0x9880
movq %rax, %r15
leaq 0x36a0d(%rip), %rsi     # 0x6b457
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x36011(%rip), %rsi     # 0x6aa6f
movl $0x13, %edx
movq %r15, %rdi
callq 0x9560
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r15, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x34ac5
movq %rax, %r15
movq 0x4f4e7(%rip), %rsi     # 0x83f98
movq %r14, %rdi
callq 0x9370
leaq 0x280(%rbx), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x9700
movq %r15, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: TextLogger::Flush()
void TextLogger::Flush() {
  if (PlayerParam::instance().SaveTextLog()) {
    os << mBuffer.str();
    os.flush();
  }
  mBuffer.str("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x34bdd
leaq 0x218(%rbx), %rsi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x97a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x9560
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34bd5
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x9330
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x35ba4(%rip), %rdx     # 0x6a790
leaq -0x30(%rbp), %rdi
movq %rdx, %rsi
callq 0x1362e
addq $0x218, %rbx            # imm = 0x218
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x9730
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x34c20
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x34c47
jmp 0x34c58
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x34c58
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x34c58
movq %rax, %rbx
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::~Logger()
Logger::~Logger() {
  delete mpSightLogger;
  for (std::map<std::string, TextLogger *>::iterator i = mTextLoggers.begin();
       i != mTextLoggers.end(); ++i) {
    delete i->second;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x4ec83(%rip), %rax     # 0x83980
movq %rax, (%rdi)
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x34d11
movq %r14, %rdi
callq 0x33234
movl $0x450, %esi            # imm = 0x450
movq %r14, %rdi
callq 0x94e0
movq 0x40(%rbx), %r14
leaq 0x30(%rbx), %r12
cmpq %r12, %r14
je 0x34d59
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x34d3c
movq %r15, %rdi
callq 0x34b0a
movl $0x388, %esi            # imm = 0x388
movq %r15, %rdi
callq 0x94e0
movq %r14, %rdi
callq 0x9340
movq %rax, %r14
cmpq %r12, %rax
jne 0x34d2b
leaq 0x28(%rbx), %r14
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x4df04
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x35fd6
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::Flush()
void Logger::Flush() {
  if (mpSightLogger) {
    mpSightLogger->Flush();
  }

  for (std::map<std::string, TextLogger *>::iterator i = mTextLoggers.begin();
       i != mTextLoggers.end(); ++i) {
    i->second->Flush();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x34df4
callq 0x33488
movq 0x40(%rbx), %r14
addq $0x30, %rbx
cmpq %rbx, %r14
je 0x34e1a
movq 0x40(%r14), %rdi
callq 0x34b7e
movq %r14, %rdi
callq 0x9340
movq %rax, %r14
cmpq %rbx, %rax
jne 0x34e01
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::GetTextLogger(char const*)
TextLogger &Logger::GetTextLogger(const char *log_name) {
  if (PlayerParam::instance().SaveTextLog()) {
    std::map<std::string, TextLogger *>::iterator logger =
        mTextLoggers.find(log_name);
    if (logger == mTextLoggers.end()) {
      logger = mTextLoggers
                   .insert(std::make_pair(log_name,
                                          new TextLogger(mpObserver, log_name)))
                   .first;
    }
    return *(logger->second);
  } else {
    return mTextLoggerNull;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x34f15
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %rbx, %rsi
callq 0x241d4
leaq 0x28(%r14), %r15
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x363e8
movq %rax, %r12
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34ed3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
leaq 0x30(%r14), %rax
cmpq %rax, %r12
jne 0x34f0e
movl $0x388, %edi            # imm = 0x388
callq 0x94c0
movq %rax, %r12
movq 0x10(%r14), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x34982
leaq -0x48(%rbp), %rsi
movq %rbx, (%rsi)
movq %r12, 0x8(%rsi)
movq %r15, %rdi
callq 0x36486
movq %rax, %r12
movq 0x40(%r12), %rax
jmp 0x34f1c
leaq 0x31e29c(%rip), %rax    # 0x3531b8
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x388, %esi            # imm = 0x388
movq %r12, %rdi
jmp 0x34f4d
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34f57
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x34f57
movq %rax, %rbx
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::SetFlushCond()
void Logger::SetFlushCond() {
  if (PlayerParam::instance().SaveSightLog() ||
      PlayerParam::instance().SaveDecLog() ||
      PlayerParam::instance().SaveTextLog())
    mCondFlush.Set();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x43dce
cmpb $0x0, 0x5c43(%rax)
jne 0x34f93
callq 0x43dce
cmpb $0x0, 0x5c44(%rax)
jne 0x34f93
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x34fa5
addq $0x58, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4dfcc
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43dce
cmpb $0x1, 0x5c43(%rax)
jne 0x34ffc
cmpl $0xa, %r15d
je 0x35024
cmpl $0x7, %r15d
je 0x35007
cmpl $0x6, %r15d
jne 0x34ffc
movq %r14, %rdi
callq 0x34e20
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x33390
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x34e20
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x333e2
movq %r14, %rdi
callq 0x34e20
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x33434
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43dce
cmpb $0x1, 0x5c44(%rax)
jne 0x350f1
movq %r12, %rdi
callq 0x34e20
movq %rax, %r12
leaq 0x228(%rax), %r13
movq %r13, %rdi
callq 0x4e01a
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 0x35ad0
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e036
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::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 0x43dce
cmpb $0x1, 0x5c44(%rax)
jne 0x3519a
movq %r15, %rdi
callq 0x34e20
movq %rax, %r13
leaq 0x228(%rax), %r15
movq %r15, %rdi
callq 0x4e01a
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 0x35ad0
movabsq $0x3fc999999999999a, %rax # imm = 0x3FC999999999999A
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
movq %r13, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x35bac
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x35c12
movq %r15, %rdi
callq 0x4e036
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/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 0x43dce
cmpb $0x1, 0x5c44(%rax)
jne 0x3523c
movq %r12, %rdi
callq 0x34e20
movq %rax, %r12
leaq 0x228(%rax), %r13
movq %r13, %rdi
callq 0x4e01a
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 0x35ad0
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x6, %ecx
callq 0x35c12
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e036
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43dce
cmpb $0x1, 0x5c44(%rax)
jne 0x352da
movq %r15, %rdi
callq 0x34e20
movq %rax, %r15
leaq 0x228(%rax), %r12
movq %r12, %rdi
callq 0x4e01a
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 0x35ad0
movabsq $0x3fb999999999999a, %rax # imm = 0x3FB999999999999A
leaq -0x28(%rbp), %rdx
movq %rax, (%rdx)
movq %r15, %rdi
movq %rbx, %rsi
movl $0x5, %ecx
callq 0x35bac
movq %r12, %rdi
callq 0x4e036
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43dce
cmpb $0x1, 0x5c44(%rax)
jne 0x35379
movq %r13, %rdi
callq 0x34e20
movq %rax, %r13
movq %r15, -0x30(%rbp)
leaq 0x228(%rax), %r15
movq %r15, %rdi
callq 0x4e01a
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 0x35ad0
movq %r13, %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x35c12
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e036
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::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 0x43dce
cmpb $0x1, 0x5c44(%rax)
jne 0x35403
movq %r12, %rdi
callq 0x34e20
movq %rax, %r12
leaq 0x228(%rax), %r13
movq %r13, %rdi
callq 0x4e01a
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 0x35bac
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e036
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq