LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.cpp
// Function: Ray::GetClosestPoint(Vector const&) const
Vector Ray::GetClosestPoint(const Vector &point) const {
  Line l(*this);
  Vector closest_point = l.GetProjectPoint(point);
  return fabs(GetNormalizeAngleDeg((closest_point - mOrigin).Dir() -
                                   mDirection)) < 90
             ? closest_point
             : this->Origin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2276a
movq %r15, %rdi
movq %r14, %rsi
callq 0x2282c
movapd %xmm0, %xmm6
movapd %xmm1, %xmm5
movapd %xmm0, %xmm1
subsd (%rbx), %xmm1
movapd %xmm5, %xmm2
subsd 0x8(%rbx), %xmm2
movapd 0x412dc(%rip), %xmm3    # 0x6b010
movapd %xmm1, %xmm0
andpd %xmm3, %xmm0
movsd 0x412fc(%rip), %xmm4    # 0x6b040
ucomisd %xmm0, %xmm4
jbe 0x29d58
andpd %xmm2, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm3, %xmm4
ja 0x29d85
movapd %xmm2, %xmm0
movsd %xmm5, -0x20(%rbp)
movapd %xmm6, -0x30(%rbp)
callq 0x90d0
movapd -0x30(%rbp), %xmm6
movsd -0x20(%rbp), %xmm5
mulsd 0x412cb(%rip), %xmm0    # 0x6b048
divsd 0x412cb(%rip), %xmm0    # 0x6b050
subsd 0x10(%rbx), %xmm0
movsd 0x412ce(%rip), %xmm1    # 0x6b060
ucomisd %xmm0, %xmm1
jbe 0x29dac
movsd 0x412d0(%rip), %xmm2    # 0x6b070
addsd %xmm2, %xmm0
ucomisd %xmm0, %xmm1
ja 0x29da0
jmp 0x29dd0
ucomisd 0x41294(%rip), %xmm0    # 0x6b048
jb 0x29dd0
movsd 0x412aa(%rip), %xmm1    # 0x6b068
movsd 0x41282(%rip), %xmm2    # 0x6b048
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jae 0x29dc6
andpd 0x41238(%rip), %xmm0    # 0x6b010
movsd 0x412d0(%rip), %xmm1    # 0x6b0b0
ucomisd %xmm0, %xmm1
ja 0x29deb
movsd 0x8(%rbx), %xmm5
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm6
movsd (%rbx), %xmm1
andnpd %xmm1, %xmm0
orpd %xmm6, %xmm0
movapd %xmm5, %xmm1
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.cpp
// Function: Line::IsInBetween(Vector const&, Vector const&, Vector const&) const
bool Line::IsInBetween(const Vector &pt, const Vector &end1,
                       const Vector &end2) const {
  Assert(IsOnLine(end1) && IsOnLine(end2));

  Vector project_pt = GetProjectPoint(pt);
  double dist2 = end1.Dist2(end2);

  return (project_pt.Dist2(end1) < dist2 + FLOAT_EPS &&
          project_pt.Dist2(end2) < dist2 + FLOAT_EPS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
callq 0x2282c
movsd (%rbx), %xmm4
movsd 0x8(%rbx), %xmm3
movsd (%r14), %xmm2
movsd 0x8(%r14), %xmm5
movapd %xmm0, %xmm6
subsd %xmm2, %xmm6
subsd %xmm4, %xmm2
movapd %xmm1, %xmm7
subsd %xmm5, %xmm7
subsd %xmm3, %xmm5
mulsd %xmm5, %xmm5
mulsd %xmm2, %xmm2
addsd %xmm5, %xmm2
mulsd %xmm7, %xmm7
mulsd %xmm6, %xmm6
addsd %xmm7, %xmm6
addsd 0x411d2(%rip), %xmm2    # 0x6b040
ucomisd %xmm6, %xmm2
jbe 0x29e91
subsd %xmm4, %xmm0
subsd %xmm3, %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
seta %al
jmp 0x29e93
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.cpp
// Function: Line::Intersection(Line const&) const
Vector Line::Intersection(const Line &l) const {
  Vector point;
  if (Intersection(l, point)) {
    return point;
  }
  return Vector(0.0, 0.0); // as WE2008
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorps %xmm0, %xmm0
leaq -0x10(%rbp), %rdx
movaps %xmm0, (%rdx)
callq 0x29b3c
testb %al, %al
jne 0x29ebb
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
jmp 0x29ec5
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.cpp
// Function: Line::Intersection(Ray const&, Vector&) const
bool Line::Intersection(const Ray &r, Vector &point) const {
  Line l(r);

  if (!Intersection(l, point)) {
    return false;
  } else {
    return r.IsInRightDir(point);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x2276a
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x29b3c
testb %al, %al
je 0x29f0f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ac24
jmp 0x29f11
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.cpp
// Function: Line::GetClosestPointInBetween(Vector const&, Vector const&, Vector const&) const
Vector Line::GetClosestPointInBetween(const Vector &pt, const Vector &end1,
                                      const Vector &end2) const {
  Assert(IsOnLine(end1) && IsOnLine(end2));

  if (IsInBetween(pt, end1, end2))
    return GetProjectPoint(pt);
  else if (end1.Dist2(pt) < end2.Dist2(pt))
    return end1;
  else
    return end2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
callq 0x29e10
testb %al, %al
je 0x29f4b
movq %r12, %rdi
movq %r14, %rsi
callq 0x2282c
jmp 0x29fbd
movsd (%r15), %xmm2
movsd 0x8(%r15), %xmm1
movsd (%r14), %xmm4
movsd 0x8(%r14), %xmm5
movapd %xmm2, %xmm0
subsd %xmm4, %xmm0
movapd %xmm1, %xmm3
subsd %xmm5, %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
movsd (%rbx), %xmm6
movsd 0x8(%rbx), %xmm3
movapd %xmm6, %xmm7
subsd %xmm4, %xmm7
movapd %xmm3, %xmm4
subsd %xmm5, %xmm4
mulsd %xmm4, %xmm4
mulsd %xmm7, %xmm7
addsd %xmm4, %xmm7
ucomisd %xmm0, %xmm7
cmpltsd %xmm7, %xmm0
andpd %xmm0, %xmm2
andnpd %xmm6, %xmm0
orpd %xmm2, %xmm0
ja 0x29fbd
movapd %xmm3, %xmm1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.cpp
// Function: Rectangular::Intersection(Ray const&) const
Vector Rectangular::Intersection(const Ray &r) const {
  Vector point;
  bool ret = Intersection(r, point);
  if (!ret)
    return r.Origin(); // as WE2008
  return point;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
leaq -0x28(%rbp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r15)
leaq -0x30(%rbp), %r14
movq %r14, %rdx
callq 0x2a010
leaq 0x8(%rbx), %rcx
testb %al, %al
cmovneq %r15, %rcx
cmovneq %r14, %rbx
movsd (%rcx), %xmm1
movsd (%rbx), %xmm0
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/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 0x40ae1(%rip), %xmm0    # 0x6b0a0
divsd 0x40a81(%rip), %xmm0    # 0x6b048
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 0x409f6(%rip), %xmm4    # 0x6b010
andpd %xmm1, %xmm4
xorl %eax, %eax
ucomisd %xmm5, %xmm4
jae 0x2a697
mulsd %xmm7, %xmm2
mulsd %xmm3, %xmm6
subsd %xmm2, %xmm6
ucomisd %xmm0, %xmm4
jae 0x2a654
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2a66a
sqrtsd %xmm0, %xmm0
jmp 0x2a679
movsd 0x4211c(%rip), %xmm1    # 0x6c778
addsd %xmm6, %xmm1
movsd 0x42118(%rip), %xmm0    # 0x6c780
jmp 0x2a681
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_O1/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, %r14
callq 0x2b48a
testq %rax, %rax
je 0x2b480
movq %rax, %rbx
movq 0x10(%r14), %rdi
movl 0x5c(%rax), %eax
cmpl 0x14(%rdi), %eax
jne 0x2b461
movl 0x10(%rdi), %eax
cmpl %eax, 0x58(%rbx)
je 0x2b482
addq $0x30, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2b50a
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x58(%rbx)
jmp 0x2b482
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
leal -0x1(%rsi), %edx
leaq 0x10d0(%rax), %rcx
addq $0xa8, %rax
testl %esi, %esi
movl %esi, %r8d
notl %r8d
movl %r8d, %r9d
cmovgl %edx, %r9d
movq %rcx, %r10
cmovgq %rax, %r10
movslq %r9d, %r9
imulq $0x178, %r9, %r9        # imm = 0x178
cmpb $0x1, 0x112(%r10,%r9)
jne 0x2b506
leaq 0x650(%rdi), %r9
addq $0x20, %rdi
testl %esi, %esi
cmovgl %edx, %r8d
cmovleq %r9, %rdi
movslq %r8d, %rdx
leaq (%rdx,%rdx,8), %rsi
cmovgq %rax, %rcx
shlq $0x4, %rsi
leaq (%rdi,%rsi), %rax
imulq $0x178, %rdx, %rdx      # imm = 0x178
addq %rcx, %rdx
movq %rdx, 0x60(%rdi,%rsi)
jmp 0x2b508
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b730
movl $0x0, 0x88(%rbx)
movq 0x68(%rdi), %rdi
callq 0x22890
movups (%rax), %xmm0
movups %xmm0, 0x78(%rbx)
callq 0x4a75c
movsd 0x37f0(%rax), %xmm1
addsd 0x41033(%rip), %xmm1    # 0x6c788
movsd 0x78(%rbx), %xmm0
movl $0x1, %ecx
ucomisd %xmm1, %xmm0
jb 0x2b7b4
movsd 0x37f8(%rax), %xmm1
addsd 0x40bb3(%rip), %xmm1    # 0x6c328
ucomisd %xmm0, %xmm1
jb 0x2b7b4
movsd 0x80(%rbx), %xmm0
movsd 0x3800(%rax), %xmm1
addsd 0x40ff5(%rip), %xmm1    # 0x6c788
ucomisd %xmm1, %xmm0
jb 0x2b7b4
movsd 0x3808(%rax), %xmm1
addsd 0x40b7f(%rip), %xmm1    # 0x6c328
ucomisd %xmm0, %xmm1
jb 0x2b7b4
movl $0x2, %ecx
movl %ecx, 0x8c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/BaseState.h
// Function: MobileState::Predictor::GetPredictedVel(int)
const Vector &GetPredictedVel(int step = 1) {
      step = Min(step, int(MAX_STEP));

      if (step <= mPredictedStep) {
        return mPredictedVel[step];
      } else {
        PredictTo(step);

        return mPredictedVel[step];
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x32, %esi
movl $0x32, %eax
cmovll %esi, %eax
movq %rdi, %rbx
movl %eax, -0x14(%rbp)
cmpl 0x668(%rdi), %eax
jle 0x2ba06
leaq -0x14(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf062
movl (%r14), %eax
cltq
shlq $0x4, %rax
addq %rbx, %rax
addq $0x338, %rax            # imm = 0x338
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47a2a
leaq 0x3f0ce(%rip), %rsi     # 0x6c811
movq %rax, %rdi
xorl %eax, %eax
callq 0x47ac6
callq 0x47a2a
leaq 0x3f0c5(%rip), %rsi     # 0x6c81e
movq %rax, %rdi
xorl %eax, %eax
callq 0x47ac6
callq 0x47a2a
leaq 0x3f0be(%rip), %rsi     # 0x6c82d
movq %rax, %rdi
xorl %eax, %eax
callq 0x47ac6
callq 0x47a2a
leaq 0x3f0d9(%rip), %rsi     # 0x6c85e
movq %rax, %rdi
xorl %eax, %eax
callq 0x47ac6
callq 0x47a2a
leaq 0x3f0e4(%rip), %rsi     # 0x6c87f
movq %rax, %rdi
xorl %eax, %eax
callq 0x47ac6
callq 0x47a2a
leaq 0x3f0ec(%rip), %rsi     # 0x6c89d
movq %rax, %rdi
movsd -0x8(%rbp), %xmm0
movb $0x1, %al
callq 0x47ac6
callq 0x47a2a
leaq 0x3f0d9(%rip), %rsi     # 0x6c8a5
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
callq 0x47ac6
callq 0x47a2a
leaq 0x3f0c6(%rip), %rsi     # 0x6c8ad
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
movb $0x1, %al
callq 0x47ac6
callq 0x47a2a
leaq 0x3f0b3(%rip), %rsi     # 0x6c8b5
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
movb $0x1, %al
callq 0x47ac6
callq 0x47a2a
leaq 0x3f0a0(%rip), %rsi     # 0x6c8bd
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
movb $0x1, %al
callq 0x47ac6
callq 0x47a2a
leaq 0x3f08d(%rip), %rsi     # 0x6c8c5
movq %rax, %rdi
movsd -0x30(%rbp), %xmm0
movb $0x1, %al
callq 0x47ac6
callq 0x47a2a
movsd -0x38(%rbp), %xmm0
addsd 0x3d7ff(%rip), %xmm0    # 0x6b058
leaq 0x3f06d(%rip), %rsi     # 0x6c8cd
movq %rax, %rdi
movb $0x1, %al
callq 0x47ac6
callq 0x47a2a
leaq 0x3f068(%rip), %rsi     # 0x6c8de
movq %rax, %rdi
xorl %eax, %eax
callq 0x47ac6
callq 0x47a2a
leaq 0x3f061(%rip), %rsi     # 0x6c8ed
movq %rax, %rdi
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
jmp 0x47ac6
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ec60(%rip), %rsi     # 0x6c940
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 0x2dd9e
movq 0x592e0(%rip), %rdi     # 0x86ff0
leaq 0x3ec3b(%rip), %rsi     # 0x6c952
movl $0x11, %edx
callq 0x9560
movq 0x592c8(%rip), %rdi     # 0x86ff0
leaq 0x41493(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
callq 0x9560
movq 0x592b0(%rip), %rdi     # 0x86ff0
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x9880
movq %rax, %rbx
leaq 0x3f72b(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x3ebfc(%rip), %rsi     # 0x6c964
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 0x2ddc5
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_O1/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 0x2de9c
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 0x308fc
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 0x338f6
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
addq $-0x30, %rcx
cmpq %rcx, %rax
movq %r14, -0x38(%rbp)
je 0x2fc07
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 0x2fc13
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x33afc
movl $0x1, 0x4(%rbx)
movb -0x70(%rbp), %al
movb %al, (%rbx)
testb %al, %al
jne 0x2fcd6
cmpb $0x0, -0x2c(%rbp)
je 0x2fc4e
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq -0x78(%rbp), %r8
movl $0x1, %r9d
callq 0x31816
jmp 0x2fc65
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x30bc8
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 0x2fcd6
movq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x335ec
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
addq $-0x30, %rcx
cmpq %rcx, %rax
je 0x2fcc7
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 0x2fcd3
leaq -0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x33afc
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2fcef
jmp 0x2fcef
movq %rax, %rbx
movq -0x38(%rbp), %rdi
callq 0x33aa2
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2de9c
cmpl $0x1, %ebx
je 0x30fc6
movb -0x30(%rbp), %al
movb %al, %r12b
leaq 0x3b972(%rip), %rax     # 0x6c930
movsd (%rax,%r12,8), %xmm0
jmp 0x30fce
movsd 0x3b33a(%rip), %xmm0    # 0x6c308
movsd %xmm0, -0x30(%rbp)
callq 0x4a75c
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 0x2eb5c
movsd 0x3a738(%rip), %xmm1    # 0x6b740
ucomisd %xmm0, %xmm1
ja 0x3101e
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
ucomisd -0x38(%rbp), %xmm1
ja 0x3102f
movl %ebx, -0x40(%rbp)
incl %ebx
cmpl $0x6, %ebx
jne 0x30fe9
movl $0x1, %ebx
jmp 0x3103b
minsd -0x38(%rbp), %xmm0
decl %ebx
movsd %xmm0, -0x38(%rbp)
movq -0x48(%rbp), %rcx
testq %rcx, %rcx
je 0x31049
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 0x2f49c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x20, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2de9c
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rbx)
movups %xmm0, 0x14(%rbx)
movups %xmm0, 0x20(%rbx)
movl $0x6, 0x4(%rbx)
movsd 0x2b45a8(%r12), %xmm0
xorpd 0x37fd9(%rip), %xmm0    # 0x6b020
leaq -0x38(%rbp), %rsi
movlpd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x33428
subsd 0x2b45c0(%r12), %xmm0
movsd %xmm0, -0x30(%rbp)
subsd 0x2b45c8(%r12), %xmm1
movsd %xmm1, -0x28(%rbp)
movq %r14, %rdi
callq 0xe85a
movsd 0x130(%rax), %xmm0
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setae %al
movapd 0x37f76(%rip), %xmm2    # 0x6b010
andpd %xmm0, %xmm2
leaq 0x3951b(%rip), %rcx     # 0x6c5c0
movsd (%rcx,%rax,8), %xmm3
cmpltsd 0x37f8d(%rip), %xmm2    # 0x6b040
andpd %xmm2, %xmm3
andnpd %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
orpd %xmm3, %xmm2
divsd %xmm2, %xmm0
movsd -0x28(%rbp), %xmm3
divsd %xmm2, %xmm3
movsd %xmm0, 0x8(%rbx)
movsd %xmm3, 0x10(%rbx)
mulsd %xmm3, %xmm3
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
ucomisd %xmm1, %xmm0
jb 0x330f3
sqrtsd %xmm0, %xmm0
jmp 0x330f8
callq 0x93c0
movsd %xmm0, -0x28(%rbp)
callq 0x4a75c
movsd 0x3130(%rax), %xmm0
ucomisd -0x28(%rbp), %xmm0
jae 0x33138
leaq 0x8(%rbx), %r14
movb $0x0, (%rbx)
callq 0x4a75c
leaq 0x3130(%rax), %rsi
movq %r14, %rdi
callq 0x33662
movsd %xmm0, 0x8(%rbx)
movsd %xmm1, 0x10(%rbx)
jmp 0x3313b
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x20, %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/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 $0x28, %rsp
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2de9c
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rbx)
movups %xmm0, 0x14(%rbx)
movups %xmm0, 0x20(%rbx)
movl $0x6, 0x4(%rbx)
movq %r14, %rdi
callq 0xe85a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movsd -0x30(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd 0x37e90(%rip), %xmm0    # 0x6b050
divsd 0x37e80(%rip), %xmm0    # 0x6b048
leaq -0x40(%rbp), %r12
leaq -0x48(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x92d0
movsd (%r13), %xmm1
movsd -0x30(%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, -0x38(%rbp)
subsd 0x2b45c8(%r15), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %r14, %rdi
callq 0xe85a
movsd 0x130(%rax), %xmm0
xorpd %xmm3, %xmm3
xorl %eax, %eax
ucomisd %xmm3, %xmm0
setae %al
movapd 0x37dbb(%rip), %xmm1    # 0x6b010
andpd %xmm0, %xmm1
leaq 0x39360(%rip), %rcx     # 0x6c5c0
movsd (%rcx,%rax,8), %xmm2
cmpltsd 0x37dd2(%rip), %xmm1    # 0x6b040
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
orpd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd -0x30(%rbp), %xmm2
divsd %xmm1, %xmm2
leaq 0x8(%rbx), %r14
movsd %xmm0, 0x8(%rbx)
movsd %xmm2, 0x10(%rbx)
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm3, %xmm0
jb 0x332b2
sqrtsd %xmm0, %xmm0
jmp 0x332b7
callq 0x93c0
addsd 0x39661(%rip), %xmm0    # 0x6c920
leaq -0x40(%rbp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x33662
movsd %xmm0, 0x8(%rbx)
movsd %xmm1, 0x10(%rbx)
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd 0x37da3(%rip), %xmm0    # 0x6b090
jb 0x332f5
sqrtsd %xmm0, %xmm0
jmp 0x332fa
callq 0x93c0
movsd %xmm0, -0x30(%rbp)
callq 0x4a75c
movsd 0x3130(%rax), %xmm0
ucomisd -0x30(%rbp), %xmm0
setae (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.h
// Function: ReciprocalCurve::Interpolate(double const&, double const&, double const&, double const&, double const&, double const&)
void Interpolate(const double &x1, const double &y1, const double &x2,
                   const double &y2, const double &x3, const double &y3) {
    Assert(((x1 - x2) / (y2 - y1) - (x1 - x3) / (y3 - y1)) != 0);
    Assert((y1 - y2) != 0);

    mA = ((x1 * y1 - x2 * y2) / (y2 - y1) - (x1 * y1 - x3 * y3) / (y3 - y1)) /
         ((x1 - x2) / (y2 - y1) - (x1 - x3) / (y3 - y1));
    mC = (mA * (x1 - x2) - (x1 * y1 - x2 * y2)) / (y1 - y2);
    mB = (y1 - mA) * (x1 + mC);
    mB = (y2 - mA) * (x2 + mC);
    mB = (y3 - mA) * (x3 + mC);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movsd (%rsi), %xmm1
movsd (%rdx), %xmm2
movsd (%rcx), %xmm3
movsd (%r8), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm3, %xmm5
movapd %xmm1, %xmm6
mulsd %xmm2, %xmm6
movapd %xmm6, %xmm0
subsd %xmm5, %xmm0
subsd %xmm2, %xmm4
divsd %xmm4, %xmm0
movsd (%r9), %xmm5
movsd (%rax), %xmm7
movapd %xmm7, %xmm8
mulsd %xmm5, %xmm8
subsd %xmm8, %xmm6
subsd %xmm2, %xmm7
divsd %xmm7, %xmm6
subsd %xmm6, %xmm0
movapd %xmm1, %xmm2
subsd %xmm3, %xmm2
divsd %xmm4, %xmm2
subsd %xmm5, %xmm1
divsd %xmm7, %xmm1
subsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, (%rdi)
movsd (%rsi), %xmm2
movsd (%rcx), %xmm3
movapd %xmm2, %xmm1
subsd %xmm3, %xmm1
movsd (%rdx), %xmm4
movsd (%r8), %xmm5
mulsd %xmm5, %xmm3
mulsd %xmm4, %xmm2
subsd %xmm3, %xmm2
mulsd %xmm0, %xmm1
subsd %xmm2, %xmm1
subsd %xmm5, %xmm4
divsd %xmm4, %xmm1
movsd %xmm1, 0x10(%rdi)
movsd (%rdx), %xmm2
subsd %xmm0, %xmm2
movsd (%rsi), %xmm3
addsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rdi)
movsd (%r8), %xmm2
subsd %xmm0, %xmm2
movsd (%rcx), %xmm3
addsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rdi)
movsd (%rax), %xmm2
subsd %xmm0, %xmm2
addsd (%r9), %xmm1
mulsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, %rdi
callq 0xe804
subsd (%r15), %xmm0
mulsd 0x37b89(%rip), %xmm0    # 0x6b050
divsd 0x37b79(%rip), %xmm0    # 0x6b048
leaq -0x50(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x92d0
movsd (%r15), %xmm2
movsd (%r12), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jb 0x33519
sqrtsd %xmm0, %xmm0
jmp 0x3352c
movapd %xmm2, -0x40(%rbp)
callq 0x93c0
xorpd %xmm3, %xmm3
movapd -0x40(%rbp), %xmm2
mulsd %xmm0, %xmm2
movapd 0x37ad8(%rip), %xmm0    # 0x6b010
andpd %xmm2, %xmm0
movsd (%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x335db
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jb 0x3356d
sqrtsd %xmm0, %xmm0
jmp 0x33580
movapd %xmm2, -0x40(%rbp)
callq 0x93c0
xorpd %xmm3, %xmm3
movapd -0x40(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd (%rbx), %xmm0
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm0
subsd %xmm2, %xmm0
ucomisd %xmm3, %xmm0
jb 0x335aa
sqrtsd %xmm0, %xmm0
jmp 0x335af
callq 0x93c0
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
callq 0x4a75c
movsd 0x30f8(%rax), %xmm3
xorpd %xmm0, %xmm0
movsd -0x28(%rbp), %xmm1
maxsd %xmm0, %xmm1
minsd %xmm1, %xmm3
movapd %xmm3, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38a25(%rip), %rsi     # 0x6cd31
movq %r14, %rdi
callq 0x9970
movl 0x2e0(%rbx), %r14d
incl %r14d
movl %r14d, 0x2e0(%rbx)
callq 0x450ba
cmpl 0x3008(%rax), %r14d
jl 0x3433a
movb $0x1, 0x2e4(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x450ba
cmpb $0x1, 0x5c44(%rax)
jne 0x353b9
leaq 0x228(%r15), %rbx
movq %rbx, %rdi
callq 0x4f686
movq 0x258(%r15), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2f0(%r15)
leaq -0x1c8(%rbp), %rdi
callq 0x9350
leaq -0x1b8(%rbp), %r12
leaq 0x377db(%rip), %rsi     # 0x6ca50
movl $0x5, %edx
movq %r12, %rdi
callq 0x9560
movl 0x18(%r14), %esi
movq %r12, %rdi
callq 0x9880
movq %rax, %r12
leaq 0x373cc(%rip), %rsi     # 0x6c664
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x20(%r14), %xmm0
movq %r12, %rdi
callq 0x97d0
movq %rax, %r12
leaq 0x3812d(%rip), %rsi     # 0x6d3ea
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 0x3776e(%rip), %rsi     # 0x6ca56
movl $0x5, %edx
movq %rax, %rdi
callq 0x9560
movl 0x40(%r14), %esi
movq %r12, %rdi
callq 0x9880
movq %rax, %r12
leaq 0x37359(%rip), %rsi     # 0x6c664
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movsd 0x48(%r14), %xmm0
movq %r12, %rdi
callq 0x97d0
movq %rax, %r12
leaq 0x380ba(%rip), %rsi     # 0x6d3ea
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 0x369c6
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35392
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x4f6a2
movq 0x51bf7(%rip), %rsi     # 0x86f98
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 0x353ec
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x353ec
jmp 0x353e9
movq %rax, %rbx
movq 0x51ba5(%rip), %rsi     # 0x86f98
leaq -0x1c8(%rbp), %rdi
callq 0x9370
leaq -0x148(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3586a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x200(%rdi), %r14
movq %r14, %rdi
callq 0x4f686
movq 0x250(%rbx), %rax
movl 0x24(%rax), %eax
cmpl %eax, 0x2e8(%rbx)
je 0x35737
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 0x357c7
movl 0x2fc(%rbx), %ecx
cmpl 0x211c(%rax), %ecx
jne 0x357c7
callq 0x450ba
movq 0x310(%rbx), %rdx
cmpq 0x3140(%rax), %rdx
jne 0x357c7
testq %rdx, %rdx
je 0x35796
movq 0x3138(%rax), %rsi
movq 0x308(%rbx), %rdi
callq 0x94f0
testl %eax, %eax
jne 0x357c7
callq 0x450ba
movq 0x330(%rbx), %rdx
cmpq 0x3168(%rax), %rdx
jne 0x357c7
testq %rdx, %rdx
je 0x3581d
movq 0x3160(%rax), %rsi
movq 0x328(%rbx), %rdi
callq 0x94f0
testl %eax, %eax
je 0x3581d
callq 0x450ba
leaq 0x3138(%rax), %rsi
leaq 0x308(%rbx), %rdi
callq 0x92a0
callq 0x450ba
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 0x3583c
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4f6a2
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x450ba
movq 0x3138(%rax), %rdx
movl 0x2c(%r12), %ecx
leaq 0x371b6(%rip), %rsi     # 0x6ca69
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 0x3597c
movq 0x51700(%rip), %rdi     # 0x86ff0
leaq 0x370ca(%rip), %rsi     # 0x6c9c1
movl $0x11, %edx
callq 0x9560
movq 0x516e8(%rip), %rdi     # 0x86ff0
leaq 0x398b3(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
callq 0x9560
movq 0x516d0(%rip), %rdi     # 0x86ff0
movl $0x135, %esi            # imm = 0x135
callq 0x9880
movq %rax, %r15
leaq 0x37b4b(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x37137(%rip), %rsi     # 0x6ca7f
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 0x359af
movq %rax, %r15
movq 0x515fd(%rip), %rsi     # 0x86f98
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_O1/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 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x35ac7
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 0x35abf
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x9330
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x36cca(%rip), %rdx     # 0x6c7a0
leaq -0x30(%rbp), %rdi
movq %rdx, %rsi
callq 0x13766
addq $0x218, %rbx            # imm = 0x218
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x9730
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x35b0a
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 0x35b31
jmp 0x35b42
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x35b42
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x35b42
movq %rax, %rbx
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x50d99(%rip), %rax     # 0x86980
movq %rax, (%rdi)
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x35c08
movq %r14, %rdi
callq 0x340ec
movl $0x450, %esi            # imm = 0x450
movq %r14, %rdi
callq 0x94e0
movq 0x40(%rbx), %r14
leaq 0x30(%rbx), %r12
cmpq %r12, %r14
je 0x35c43
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x35c33
movq %r15, %rdi
callq 0x359f4
movl $0x388, %esi            # imm = 0x388
movq %r15, %rdi
callq 0x94e0
movq %r14, %rdi
callq 0x9340
movq %rax, %r14
cmpq %r12, %rax
jne 0x35c15
leaq 0x28(%rbx), %r14
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x4f570
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x36ec4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35cde
callq 0x34340
movq 0x40(%rbx), %r14
addq $0x30, %rbx
cmpq %rbx, %r14
je 0x35d04
movq 0x40(%r14), %rdi
callq 0x35a68
movq %r14, %rdi
callq 0x9340
movq %rax, %r14
cmpq %rbx, %rax
jne 0x35ceb
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x35dff
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %rbx, %rsi
callq 0x24892
leaq 0x28(%r14), %r15
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x372d6
movq %rax, %r12
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35dbd
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
leaq 0x30(%r14), %rax
cmpq %rax, %r12
jne 0x35df8
movl $0x388, %edi            # imm = 0x388
callq 0x94c0
movq %rax, %r12
movq 0x10(%r14), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x3586c
leaq -0x48(%rbp), %rsi
movq %rbx, (%rsi)
movq %r12, 0x8(%rsi)
movq %r15, %rdi
callq 0x37374
movq %rax, %r12
movq 0x40(%r12), %rax
jmp 0x35e06
leaq 0x3203b2(%rip), %rax    # 0x3561b8
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 0x35e37
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35e41
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x35e41
movq %rax, %rbx
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x450ba
cmpb $0x0, 0x5c43(%rax)
jne 0x35e7d
callq 0x450ba
cmpb $0x0, 0x5c44(%rax)
jne 0x35e7d
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x35e8f
addq $0x58, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4f638
addq $0x8, %rsp
popq %rbx
popq %rbp
retq