LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, -0xc0(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x50020
movq -0xa0(%rbp), %rdi
xorl %esi, %esi
callq 0x1d620
movq -0xb0(%rbp), %rax
movq -0xa0(%rbp), %rdi
movl $0x6, 0x4(%rdi)
addq $0x2b4580, %rax         # imm = 0x2B4580
addq $0x18, %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10590
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd (%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x112c0
movq -0xb8(%rbp), %rdi
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x11360
movq -0xb0(%rbp), %rsi
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
addq $0x2b4580, %rsi         # imm = 0x2B4580
addq $0x30, %rsi
leaq -0x30(%rbp), %rdi
callq 0x110a0
movq -0xb0(%rbp), %rsi
movsd %xmm0, -0x78(%rbp)
movsd %xmm1, -0x70(%rbp)
addq $0x2b4580, %rsi         # imm = 0x2B4580
addq $0x40, %rsi
leaq -0x78(%rbp), %rdi
callq 0x110a0
movsd %xmm0, -0x68(%rbp)
movsd %xmm1, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10590
movq %rax, %rdi
callq 0x11190
leaq -0x68(%rbp), %rdi
callq 0x1eef0
movq -0xa0(%rbp), %rdi
movsd %xmm0, -0x58(%rbp)
movsd %xmm1, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x50(%rbp), %rax
movq %rax, 0x10(%rdi)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0xa8(%rbp)
addq $0x8, %rdi
callq 0x104e0
movq -0xa8(%rbp), %rdi
movsd 0x6b3b1(%rip), %xmm1    # 0xc16d0
subsd %xmm1, %xmm0
movsd %xmm0, -0x90(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x3fcd0
movq -0xa0(%rbp), %rdi
movsd %xmm0, -0x88(%rbp)
movsd %xmm1, -0x80(%rbp)
movq -0x88(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x80(%rbp), %rax
movq %rax, 0x10(%rdi)
addq $0x8, %rdi
callq 0x104e0
movsd %xmm0, -0x98(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x10f10
movsd -0x98(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x5639a
movq -0xa0(%rbp), %rax
movb $0x1, (%rax)
jmp 0x563a4
movq -0xa0(%rbp), %rax
movb $0x0, (%rax)
movq -0xc0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10520
movq -0x20(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12dc0
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x12e40
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x104e0
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm1
movaps 0x6a624(%rip), %xmm0    # 0xc1060
pand %xmm0, %xmm1
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x56aff
leaq -0x38(%rbp), %rdi
callq 0x12e20
movsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x104e0
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movq -0x28(%rbp), %rax
movsd (%rax), %xmm2
movsd -0x48(%rbp), %xmm1
mulsd -0x48(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x12420
addsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x23d60
movq %rax, %rdx
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x12a20
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x56b07
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.h
// Function: ReciprocalCurve::GetOutput(double const&, bool) const
double GetOutput(const double &x, const bool limited = true) const {
    double value = mA + mB / (x + mC);
    if (limited == true) {
      if (value < mOutMin) {
        value = mOutMin;
      } else if (value > mOutMax) {
        value = mOutMax;
      }
    }
    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm2
addsd 0x10(%rax), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x56e01
movq -0x28(%rbp), %rax
movsd -0x20(%rbp), %xmm1
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x56ddf
movq -0x28(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x56dff
movq -0x28(%rbp), %rax
movsd -0x20(%rbp), %xmm0
ucomisd 0x20(%rax), %xmm0
jbe 0x56dfd
movq -0x28(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x56dff
jmp 0x56e01
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.h
// Function: GetMaxKickRand(Vector const&, Vector const&, int, double)
inline double GetMaxKickRand(const Vector &ball_2_player,
                             const Vector &ball_vel, const int player_type,
                             const double kick_power) {
  double dir_diff = fabs(ball_2_player.Dir());
  double dist_ball =
      ball_2_player.Mod() -
      PlayerParam::instance().HeteroPlayer(player_type).playerSize() -
      ServerParam::instance().ballSize();

  double pos_rate = 0.5 + 0.25 * (dir_diff / 180.0 +
                                  dist_ball / PlayerParam::instance()
                                                  .HeteroPlayer(player_type)
                                                  .kickableMargin());

  double speed_rate =
      0.5 + 0.5 * (ball_vel.Mod() / (ServerParam::instance().ballSpeedMax() *
                                     ServerParam::instance().ballDecay()));

  return (PlayerParam::instance().HeteroPlayer(player_type).kickRand() *
          (kick_power / ServerParam::instance().maxPower()) *
          (pos_rate + speed_rate));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10520
movaps 0x6a225(%rip), %xmm1    # 0xc1060
pand %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x104e0
movsd %xmm0, -0x80(%rbp)
callq 0x798a0
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x12ef0
movsd -0x80(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x12f10
movsd -0x78(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x6a187(%rip), %xmm1    # 0xc1028
divsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
callq 0x798a0
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x12f50
movsd -0x70(%rbp), %xmm1
movsd -0x68(%rbp), %xmm0
divsd (%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0x6a151(%rip), %xmm1    # 0xc1038
mulsd %xmm1, %xmm0
movsd 0x6a12d(%rip), %xmm1    # 0xc1020
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x104e0
movsd %xmm0, -0x58(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x23d60
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x113d0
movsd -0x60(%rbp), %xmm1
movsd -0x58(%rbp), %xmm0
mulsd (%rax), %xmm1
divsd %xmm1, %xmm0
movsd 0x6a0d9(%rip), %xmm1    # 0xc1020
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x798a0
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x58040
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x10f10
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
divsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd -0x38(%rbp), %xmm1
addsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.h
// Function: GetMaxTurnAngle(int, double)
inline AngleDeg GetMaxTurnAngle(const int player_type,
                                const double player_speed) {
  return (
      ServerParam::instance().maxMoment() /
      (1.0 + PlayerParam::instance().HeteroPlayer(player_type).inertiaMoment() *
                 player_speed));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x10f50
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x798a0
movq %rax, %rdi
leaq -0x4(%rbp), %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x12a00
movsd -0x18(%rbp), %xmm0
movsd (%rax), %xmm1
movsd -0x10(%rbp), %xmm2
mulsd %xmm2, %xmm1
movsd 0x69f17(%rip), %xmm2    # 0xc1010
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
addq $0x2c0, %rdi            # imm = 0x2C0
callq 0xa560
movq -0x20(%rbp), %rdi
addq $0x2c0, %rdi            # imm = 0x2C0
leaq 0x69bdb(%rip), %rsi     # 0xc2c85
callq 0xa560
movq -0x20(%rbp), %rax
movl 0x2e0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2e0(%rax)
movl 0x2e0(%rax), %eax
movl %eax, -0x14(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5bd50
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jl 0x590ec
movq -0x20(%rbp), %rax
movb $0x1, 0x2e4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x140(%rbp)
movq %rdi, %rax
movq %rax, -0x148(%rbp)
callq 0xaa30
movq -0x140(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
movq %rdi, -0x138(%rbp)
callq 0xa3e0
jmp 0x5aa5d
leaq -0x130(%rbp), %rax
movq %rax, -0x158(%rbp)
callq 0x798a0
movq %rax, -0x150(%rbp)
jmp 0x5aa79
movq -0x150(%rbp), %rdi
callq 0x11db0
movq %rax, -0x160(%rbp)
jmp 0x5aa8e
movq -0x160(%rbp), %rdi
callq 0xa240
movq %rax, -0x170(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11dd0
movq %rax, -0x168(%rbp)
jmp 0x5aab3
movq -0x170(%rbp), %rdx
movq -0x158(%rbp), %rdi
movq -0x168(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %r8
leaq 0x67f10(%rip), %rsi     # 0xc29e5
xorl %eax, %eax
callq 0xa130
movq -0x148(%rbp), %rdi
leaq -0x130(%rbp), %rsi
movl $0x10, %edx
callq 0xa090
jmp 0x5aaf6
movq -0x148(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xaa20
movb %al, -0x171(%rbp)
jmp 0x5ab14
movb -0x171(%rbp), %al
testb $0x1, %al
jne 0x5abf3
jmp 0x5ab24
jmp 0x5ab26
movq 0xa34c3(%rip), %rdi     # 0xfdff0
leaq 0x67e09(%rip), %rsi     # 0xc293d
callq 0xa5a0
movq %rax, -0x180(%rbp)
jmp 0x5ab42
movq -0x180(%rbp), %rdi
leaq 0x6a701(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, -0x188(%rbp)
jmp 0x5ab5e
movq -0x188(%rbp), %rdi
movl $0x135, %esi            # imm = 0x135
callq 0xaa40
movq %rax, -0x190(%rbp)
jmp 0x5ab78
movq -0x190(%rbp), %rdi
leaq 0x689d9(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, -0x198(%rbp)
jmp 0x5ab94
movq -0x198(%rbp), %rdi
leaq 0x67e59(%rip), %rsi     # 0xc29fb
callq 0xa5a0
movq %rax, -0x1a0(%rbp)
jmp 0x5abb0
movq -0x1a0(%rbp), %rdi
movq 0xa33f2(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x5abc5
jmp 0x5abc7
jmp 0x5abc9
jmp 0x5abf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5abfc
movq -0x138(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xa410
jmp 0x5abfc
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq -0x140(%rbp), %rdi
callq 0xa8c0
movq -0x20(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x1aaf0
testb $0x1, (%rax)
je 0x5ad3e
movq -0x68(%rbp), %rsi
addq $0x200, %rsi            # imm = 0x200
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xa590
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0xa4f0
jmp 0x5ad10
leaq -0x28(%rbp), %rdi
callq 0xa370
movq -0x68(%rbp), %rdi
callq 0xa3a0
jmp 0x5ad3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa370
jmp 0x5adc5
movq -0x68(%rbp), %rax
addq $0x200, %rax            # imm = 0x200
movq %rax, -0x80(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xaa70
movq -0x78(%rbp), %rdx
leaq 0x67961(%rip), %rsi     # 0xc26c5
leaq -0x58(%rbp), %rdi
callq 0x1a540
jmp 0x5ad6f
movq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa6c0
jmp 0x5ad7e
leaq -0x58(%rbp), %rdi
callq 0xa370
leaq -0x59(%rbp), %rdi
callq 0xa650
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x5adbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa370
leaq -0x59(%rbp), %rdi
callq 0xa650
movq -0x30(%rbp), %rdi
callq 0xaa60
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xa2ad5(%rip), %rcx     # 0xfd980
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5aed7
movq -0x20(%rbp), %rdi
callq 0x58ee0
movq -0x20(%rbp), %rdi
movl $0x450, %esi            # imm = 0x450
callq 0xa5e0
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x5c7e0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x5c840
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5c810
testb $0x1, %al
jne 0x5af0c
jmp 0x5af47
leaq -0x10(%rbp), %rdi
callq 0x5c870
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5af3a
movq -0x30(%rbp), %rdi
callq 0x5ac70
movq -0x30(%rbp), %rdi
movl $0x388, %esi            # imm = 0x388
callq 0xa5e0
jmp 0x5af3c
leaq -0x10(%rbp), %rdi
callq 0x5c890
jmp 0x5aee8
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
callq 0x8e9f0
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x5c8c0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x5b028
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x59100
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x5c7e0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x5c840
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5c810
testb $0x1, %al
jne 0x5b05d
jmp 0x5b07a
leaq -0x10(%rbp), %rdi
callq 0x5c870
movq 0x20(%rax), %rdi
callq 0x5acc0
leaq -0x10(%rbp), %rdi
callq 0x5c890
jmp 0x5b039
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x1aaf0
testb $0x1, (%rax)
je 0x5b2ea
movq -0xa0(%rbp), %rax
addq $0x28, %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xaa70
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x1a540
jmp 0x5b18a
movq -0xb8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5c900
movq %rax, -0xc0(%rbp)
jmp 0x5b1a3
movq -0xc0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa370
leaq -0x41(%rbp), %rdi
callq 0xa650
movq -0xa0(%rbp), %rdi
addq $0x28, %rdi
callq 0x5c840
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5c930
testb $0x1, %al
jne 0x5b1ea
jmp 0x5b2d7
movq -0xa0(%rbp), %rax
addq $0x28, %rax
movq %rax, -0xd0(%rbp)
movl $0x388, %edi            # imm = 0x388
callq 0xa5c0
movq %rax, %rdi
movq -0xa0(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0xc8(%rbp)
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x5aa10
jmp 0x5b229
movq -0xc8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5c9a0
movq -0xd0(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x5c960
movb %dl, -0x90(%rbp)
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x70(%rbp)
movb -0x90(%rbp), %al
movb %al, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x5b2d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5b2ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa370
leaq -0x41(%rbp), %rdi
callq 0xa650
jmp 0x5b302
movq -0xc8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x388, %esi            # imm = 0x388
callq 0xa5e0
jmp 0x5b302
leaq -0x20(%rbp), %rdi
callq 0x5c870
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5b2f5
leaq 0x372027(%rip), %rax    # 0x3cd318
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xaa60
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5bd70
testb $0x1, (%rax)
jne 0x5b35a
callq 0x798a0
movq %rax, %rdi
callq 0x5be80
testb $0x1, (%rax)
jne 0x5b35a
callq 0x798a0
movq %rax, %rdi
callq 0x1aaf0
testb $0x1, (%rax)
je 0x5b367
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x8eb10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5bd70
testb $0x1, (%rax)
je 0x5b407
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x6, %eax
je 0x5b3be
jmp 0x5b3aa
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x5b3d5
jmp 0x5b3b4
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0x5b3ec
jmp 0x5b403
movq -0x20(%rbp), %rdi
callq 0x5b080
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x58fd0
jmp 0x5b405
movq -0x20(%rbp), %rdi
callq 0x5b080
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x59020
jmp 0x5b405
movq -0x20(%rbp), %rdi
callq 0x5b080
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x59070
jmp 0x5b405
jmp 0x5b405
jmp 0x5b407
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5be80
testb $0x1, (%rax)
je 0x5b4bd
movq -0x30(%rbp), %rdi
callq 0x5b080
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5c5e0
movq -0x28(%rbp), %rdi
callq 0x5c610
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x5c6b0
movq -0x28(%rbp), %rdi
callq 0x5c730
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5be80
testb $0x1, (%rax)
je 0x5b570
movq -0x38(%rbp), %rdi
callq 0x5b080
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5c5e0
movq -0x28(%rbp), %rdi
callq 0x5c610
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5c6b0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsd 0x673ac(%rip), %xmm0    # 0xc28f0
movsd %xmm0, -0x30(%rbp)
leaq -0x30(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5c9d0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5ca20
movq -0x28(%rbp), %rdi
callq 0x5c730
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5be80
testb $0x1, (%rax)
je 0x5b606
movq -0x30(%rbp), %rdi
callq 0x5b080
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5c5e0
movq -0x28(%rbp), %rdi
callq 0x5c610
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x6, %ecx
callq 0x5c6b0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x6, %ecx
callq 0x5ca20
movq -0x28(%rbp), %rdi
callq 0x5c730
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5be80
testb $0x1, (%rax)
je 0x5b69f
movq -0x30(%rbp), %rdi
callq 0x5b080
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5c5e0
movq -0x20(%rbp), %rdi
callq 0x5c610
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x5, %ecx
callq 0x5c6b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd 0x66e8d(%rip), %xmm0    # 0xc2510
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
movl $0x5, %ecx
callq 0x5c9d0
movq -0x20(%rbp), %rdi
callq 0x5c730
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5be80
testb $0x1, (%rax)
je 0x5b735
movq -0x38(%rbp), %rdi
callq 0x5b080
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5c5e0
movq -0x30(%rbp), %rdi
callq 0x5c610
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5c6b0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5ca20
movq -0x30(%rbp), %rdi
callq 0x5c730
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5be80
testb $0x1, (%rax)
je 0x5b7ad
movq -0x30(%rbp), %rdi
callq 0x5b080
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5c5e0
movq -0x28(%rbp), %rdi
callq 0x5c610
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5c9d0
movq -0x28(%rbp), %rdi
callq 0x5c730
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogRectangular(Rectangular const&, SightLogger::Color)
void Logger::LogRectangular(const Rectangular &rect, SightLogger::Color color) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();

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

    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5be80
testb $0x1, (%rax)
je 0x5b954
movq -0xa8(%rbp), %rdi
callq 0x5b080
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5c5e0
movq -0x20(%rbp), %rdi
callq 0x5c610
movq -0x20(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49350
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49380
movq -0xc8(%rbp), %rdi
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movl -0x14(%rbp), %ecx
leaq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x5ca20
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49350
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x493c0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0x60(%rbp)
movsd %xmm1, -0x58(%rbp)
movl -0x14(%rbp), %ecx
leaq -0x50(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x5ca20
movq -0x20(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x493c0
movsd %xmm0, -0x70(%rbp)
movsd %xmm1, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x493f0
movq -0xb8(%rbp), %rdi
movsd %xmm0, -0x80(%rbp)
movsd %xmm1, -0x78(%rbp)
movl -0x14(%rbp), %ecx
leaq -0x70(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x5ca20
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x493f0
movsd %xmm0, -0x90(%rbp)
movsd %xmm1, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49380
movq -0xb0(%rbp), %rdi
movsd %xmm0, -0xa0(%rbp)
movsd %xmm1, -0x98(%rbp)
movl -0x14(%rbp), %ecx
leaq -0x90(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x5ca20
movq -0x20(%rbp), %rdi
callq 0x5c730
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogDribble(Vector const&, Vector const&, char const*, bool)
void Logger::LogDribble(const Vector &start, const Vector &target,
                        const char *comment, bool is_execute) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();

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

    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5be80
testb $0x1, (%rax)
je 0x5b9f4
movq -0x38(%rbp), %rdi
callq 0x5b080
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5c5e0
movq -0x30(%rbp), %rdi
callq 0x5c610
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
callq 0x5c6b0
testb $0x1, -0x21(%rbp)
je 0x5b9eb
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x5ca20
movq -0x30(%rbp), %rdi
callq 0x5c730
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.cpp
// Function: Logger::LogPass(bool, Vector const&, Vector const&, char const*, bool)
void Logger::LogPass(const bool reverse, const Vector &start,
                     const Vector &target, const char *comment,
                     bool is_execute) {
  if (PlayerParam::instance().SaveDecLog()) {
    SightLogger *pSightLogger = GetSightLogger();
    pSightLogger->DecLock();
    pSightLogger->LogDec();

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

    pSightLogger->DecUnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %sil
movb %sil, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5be80
testb $0x1, (%rax)
je 0x5bb80
movq -0x88(%rbp), %rdi
callq 0x5b080
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5c5e0
movq -0x38(%rbp), %rdi
callq 0x5c610
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
testb $0x1, -0x9(%rbp)
je 0x5baa5
movq -0x20(%rbp), %rdi
movsd 0x6559d(%rip), %xmm0    # 0xc1028
movsd %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x11110
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x40(%rbp)
jmp 0x5bab8
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x90(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rsi
xorl %ecx, %ecx
callq 0x5c6b0
testb $0x1, -0x29(%rbp)
je 0x5bb77
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
testb $0x1, -0x9(%rbp)
je 0x5bb0f
movq -0x18(%rbp), %rdi
movsd 0x65533(%rip), %xmm0    # 0xc1028
movsd %xmm0, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x11110
movsd %xmm0, -0x60(%rbp)
movsd %xmm1, -0x58(%rbp)
jmp 0x5bb22
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
testb $0x1, -0x9(%rbp)
je 0x5bb4e
movq -0x20(%rbp), %rdi
movsd 0x654f4(%rip), %xmm0    # 0xc1028
movsd %xmm0, -0x80(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x11110
movsd %xmm0, -0x78(%rbp)
movsd %xmm1, -0x70(%rbp)
jmp 0x5bb61
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x78(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x78(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5ca20
movq -0x38(%rbp), %rdi
callq 0x5c730
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.h
// Function: sight::ViewAngle(ViewWidth)
inline AngleDeg ViewAngle(ViewWidth view_width) {
  switch (view_width) {
  case VW_Narrow:
    return 60.0;
  case VW_Normal:
    return 120.0;
  case VW_Wide:
    return 180.0;
  default:
    Assert(0);
    return 90.0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x5be38
jmp 0x5be24
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x5be47
jmp 0x5be2e
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x5be56
jmp 0x5be65
movsd 0x65e50(%rip), %xmm0    # 0xc1c90
movsd %xmm0, -0x8(%rbp)
jmp 0x5be72
movsd 0x66a99(%rip), %xmm0    # 0xc28e8
movsd %xmm0, -0x8(%rbp)
jmp 0x5be72
movsd 0x651ca(%rip), %xmm0    # 0xc1028
movsd %xmm0, -0x8(%rbp)
jmp 0x5be72
movsd 0x651d3(%rip), %xmm0    # 0xc1040
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.h
// Function: SightLogger::ItemShape::color() const
const char *color() const {
      switch (line_color) {
      case Red:
        return "red";
      case Blue:
        return "blue";
      case Green:
        return "green";
      case Navy:
        return "navy";
      case Orange:
        return "orange";
      case Cyan:
        return "cyan";
      case Purple:
        return "purple";
      case White:
        return "white";
      case Black:
        return "black";
      case Yellow:
        return "yellow";
      case Olive:
        return "olive";
      }
      return "black";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0xa, %rax
ja 0x5cd55
movq -0x18(%rbp), %rax
leaq 0x65c41(%rip), %rcx     # 0xc28f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x65d53(%rip), %rax     # 0xc2a1a
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65d47(%rip), %rax     # 0xc2a1e
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65d3c(%rip), %rax     # 0xc2a23
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65d35(%rip), %rax     # 0xc2a29
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65d2d(%rip), %rax     # 0xc2a2e
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65d27(%rip), %rax     # 0xc2a35
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65d1f(%rip), %rax     # 0xc2a3a
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65d19(%rip), %rax     # 0xc2a41
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65d12(%rip), %rax     # 0xc2a47
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65d0b(%rip), %rax     # 0xc2a4d
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65d05(%rip), %rax     # 0xc2a54
movq %rax, -0x8(%rbp)
jmp 0x5cd60
leaq 0x65ceb(%rip), %rax     # 0xc2a47
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.h
// Function: SightLogger::PointShape::PointShape(Vector const&, SightLogger::Color, char const*)
PointShape(const Vector &point, Color color, const char *cmt = 0)
        : ItemShape(color) {
      x = point.X();
      y = point.Y();
      if (cmt) {
        comment.assign(cmt);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0x5d790
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0xa820
movq -0x10(%rbp), %rdi
callq 0x176f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x17700
movq %rax, %rcx
movq -0x38(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x5ce3d
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0xab80
jmp 0x5ce24
jmp 0x5ce3d
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xa370
jmp 0x5ce43
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Logger.h
// Function: SightLogger::LineShape::LineShape(Vector const&, Vector const&, SightLogger::Color)
LineShape(const Vector &from, const Vector &to, Color color)
        : ItemShape(color) {
      x1 = from.X();
      y1 = from.Y();
      x2 = to.X();
      y2 = to.Y();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x1c(%rbp), %esi
callq 0x5d790
movq -0x10(%rbp), %rdi
callq 0x176f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x17700
movq %rax, %rcx
movq -0x28(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x176f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x17700
movq %rax, %rcx
movq -0x28(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::Construct(int, int*)
void Net::Construct(int layers, int *units) {
  if (layers == 0)
    return;
  mLayers = layers;
  mUnits = new int[mLayers];
  if (units != 0) {
    for (int i = 0; i < mLayers; ++i) {
      mUnits[i] = units[i];
    }
  }

  Memaloc();
  SetDefaultValue();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x600e6
jmp 0x60170
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movslq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xa050
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x6015e
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0x6015c
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6012c
jmp 0x6015e
movq -0x28(%rbp), %rdi
callq 0x605d0
movq -0x28(%rbp), %rdi
callq 0x608d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::SetDefaultValue()
void Net::SetDefaultValue() {
  SetLearningRate(0.7);
  SetAlpha(0.0);
  SetDesiredError(0.01);
  SetMaxEpochs(1000);
  InitWeight();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movsd 0x62194(%rip), %xmm0    # 0xc2a80
callq 0x60b70
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x60b90
movq -0x10(%rbp), %rdi
movsd 0x60dc7(%rip), %xmm0    # 0xc16d0
callq 0x60bb0
movq -0x10(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60c20
movq -0x10(%rbp), %rdi
callq 0x60930
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Net.cpp
// Function: Net::InitWeight()
void Net::InitWeight() {
  for (int i = 1; i < mLayers; ++i) {
    for (int j = 0; j < mUnits[i]; ++j) {
      for (int k = 0; k < mUnits[i - 1] + 1; ++k) {
        mWeight[i][j][k] = small_rand();
        mDeltaWeight[i][j][k] = 0.0;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x60a13
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
movq 0x8(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x60a03
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movq 0x8(%rcx), %rcx
movl -0xc(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x609f3
movq -0x20(%rbp), %rdi
callq 0x61500
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x14(%rbp), %rdx
movsd %xmm0, (%rcx,%rdx,8)
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x60980
jmp 0x609f5
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x60961
jmp 0x60a05
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6094b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)