LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: MoveBall::Plan(Vector, Vector)
void MoveBall::Plan(Vector pos, Vector vel) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(move (ball) " << pos.X() << " " << pos.Y() << " "
          << " 0 " << vel.X() << " " << vel.Y() << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movsd %xmm3, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1c8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x57a2d(%rip), %rsi     # 0x693e8
movl $0xd, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1c8(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5b1e1(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5b1bd(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x579db(%rip), %rsi     # 0x693f6
movl $0x3, %edx
movq %r14, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5b185(%rip), %rsi     # 0x6cbc4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x97d0
leaq 0x57828(%rip), %rsi     # 0x69288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1c0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x50(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x11aa8
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x72509(%rip), %rsi     # 0x83fb8
leaq -0x1c8(%rbp), %rdi
callq 0x9290
leaq -0x158(%rbp), %rdi
callq 0x91c0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x11ad5
movq %rax, %rbx
movq 0x724d9(%rip), %rsi     # 0x83fb8
leaq -0x1c8(%rbp), %rdi
callq 0x9290
leaq -0x158(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Look::Plan()
void Look::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(look)";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x5787f(%rip), %rsi     # 0x693fa
movl $0x6, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x11bc3
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x723ee(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x11bf0
movq %rax, %rbx
movq 0x723be(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: TeamNames::Plan()
void TeamNames::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(team_names)";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x5776c(%rip), %rsi     # 0x69401
movl $0xc, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x11cdd
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x722d4(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x11d0a
movq %rax, %rbx
movq 0x722a4(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Recover::Plan()
void Recover::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(recover)";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x5765f(%rip), %rsi     # 0x6940e
movl $0x9, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x11df7
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x721ba(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x11e24
movq %rax, %rbx
movq 0x7218a(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: CheckBall::Plan()
void CheckBall::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(check_ball)";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1a8(%rbp), %r14
movq %r14, %rdi
callq 0x9660
leaq 0x5754f(%rip), %rsi     # 0x69418
movl $0xc, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x11f11
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x720a0(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x11f3e
movq %rax, %rbx
movq 0x72070(%rip), %rsi     # 0x83fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorBase.cpp
// Function: ActiveBehavior::Execute()
bool ActiveBehavior::Execute() {
  BehaviorExecutable *behavior =
      BehaviorFactory::instance().CreateBehavior(GetAgent(), GetType());

  if (behavior) {
    Logger::instance().GetTextLogger("executing")
        << GetAgent().GetWorldState().CurrentTime() << " "
        << BehaviorFactory::instance().GetBehaviorName(GetType())
        << " executing" << std::endl;

    behavior->SubmitVisualRequest(*this);
    bool ret = behavior->Execute(*this);

    delete behavior;
    return ret;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x130d4
movl (%rbx), %eax
testq %rax, %rax
je 0x130c1
leaq 0x73780(%rip), %r13     # 0x86730
movq 0x8(%r13,%rax,8), %rax
testq %rax, %rax
je 0x130c1
movq 0x8(%rbx), %rdi
callq *%rax
testq %rax, %rax
je 0x130c1
movq %rax, %r14
callq 0x34c60
leaq 0x565cd(%rip), %rsi     # 0x695a9
movq %rax, %rdi
callq 0x34e74
movq %rax, %r15
movq 0x8(%rbx), %rax
movq 0x18(%rax), %r12
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x13013
addq $0x10, %r12
movq %r15, %rdi
addq $0x210, %rdi            # imm = 0x210
movq %r12, %rsi
callq 0xe974
leaq 0x59baa(%rip), %rsi     # 0x6cbc4
movq %r15, %rdi
callq 0x13482
movq %rax, %r15
callq 0x130d4
movl (%rbx), %eax
shlq $0x5, %rax
movq 0x70(%rax,%r13), %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x134cc
leaq 0x5655d(%rip), %rsi     # 0x695a8
movq %rax, %rdi
callq 0x13538
movq %rax, %r15
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x13099
movq %r15, %r12
addq $0x210, %r12            # imm = 0x210
movq 0x210(%r15), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r12, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movq (%r14), %rax
xorps %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movl %eax, %ebx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x130c3
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorBase.cpp
// Function: BehaviorFactory::CreateBehavior(Agent&, BehaviorType)
BehaviorExecutable *BehaviorFactory::CreateBehavior(Agent &agent,
                                                    BehaviorType type) {
  if (type == BT_None) {
    return 0;
  }

  BehaviorCreator creator = mCreatorMap[type];

  if (creator) {
    return creator(agent);
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
je 0x1310c
movl %edx, %eax
movq 0x8(%rdi,%rax,8), %rax
testq %rax, %rax
je 0x1310c
movq %rsi, %rdi
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorBase.cpp
// Function: ActiveBehavior::SubmitVisualRequest(double)
void ActiveBehavior::SubmitVisualRequest(double plus) {
  BehaviorExecutable *behavior =
      BehaviorFactory::instance().CreateBehavior(GetAgent(), GetType());

  if (behavior) {
    Logger::instance().GetTextLogger("executing")
        << GetAgent().GetWorldState().CurrentTime() << " "
        << BehaviorFactory::instance().GetBehaviorName(GetType())
        << " visual plus: " << plus << std::endl;

    behavior->SubmitVisualRequest(*this, plus);

    delete behavior;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, -0x30(%rbp)
movq %rdi, %rbx
callq 0x130d4
movl (%rbx), %eax
testq %rax, %rax
je 0x13262
leaq 0x735f0(%rip), %r13     # 0x86730
movq 0x8(%r13,%rax,8), %rax
testq %rax, %rax
je 0x13262
movq 0x8(%rbx), %rdi
callq *%rax
testq %rax, %rax
je 0x13262
movq %rax, %r14
callq 0x34c60
leaq 0x5643d(%rip), %rsi     # 0x695a9
movq %rax, %rdi
callq 0x34e74
movq %rax, %r15
movq 0x8(%rbx), %rax
movq 0x18(%rax), %r12
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x131a3
addq $0x10, %r12
movq %r15, %rdi
addq $0x210, %rdi            # imm = 0x210
movq %r12, %rsi
callq 0xe974
leaq 0x59a1a(%rip), %rsi     # 0x6cbc4
movq %r15, %rdi
callq 0x13482
movq %rax, %r15
callq 0x130d4
movl (%rbx), %eax
shlq $0x5, %rax
movq 0x70(%rax,%r13), %rax
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x134cc
leaq 0x563d8(%rip), %rsi     # 0x695b3
movq %rax, %rdi
callq 0x13582
movq %rax, %r15
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x13205
leaq 0x210(%r15), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x97d0
callq 0x43dce
cmpb $0x1, 0x5c45(%rax)
jne 0x13248
movq %r15, %r12
addq $0x210, %r12            # imm = 0x210
movq 0x210(%r15), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r12, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movsd -0x30(%rbp), %xmm0
callq *0x18(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Agent.h
// Function: Agent::Self()
PlayerState &Self() {
    if (!mSelfUnum || mSelfUnum == TRAINER_UNUM) {
      static PlayerState coach; // dummy player state for coach
      return coach;
    }

    return World().Teammate(mSelfUnum);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq 0x8(%rdi), %rax
cmpq $0xc, %rax
je 0x133a6
testl %eax, %eax
jne 0x133fa
movb 0x73714(%rip), %al      # 0x86ac0
leaq 0x73595(%rip), %rbx     # 0x86948
testb %al, %al
jne 0x13410
leaq 0x73702(%rip), %rdi     # 0x86ac0
callq 0x9900
testl %eax, %eax
je 0x13410
leaq 0x7357a(%rip), %rbx     # 0x86948
movq %rbx, %rdi
callq 0x454d4
leaq -0x4565(%rip), %rdi     # 0xee78
leaq 0x71114(%rip), %rdx     # 0x844f8
movq %rbx, %rsi
callq 0x9410
leaq 0x736cd(%rip), %rdi     # 0x86ac0
callq 0x9300
jmp 0x13410
movq 0x18(%rdi), %rcx
imulq $0x178, %rax, %rax      # imm = 0x178
leaq (%rax,%rcx), %rbx
addq $-0xd0, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x7369c(%rip), %rdi     # 0x86ac0
callq 0x92f0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorBlock.cpp
// Function: BehaviorBlockPlanner::Plan(std::__cxx11::list<ActiveBehavior, std::allocator<ActiveBehavior>>&)
void BehaviorBlockPlanner::Plan(std::list<ActiveBehavior> &behavior_list) {
  Unum closest_tm = mPositionInfo.GetClosestTeammateToBall();
  if (mWorldState.GetPlayMode() >= PM_Opp_Corner_Kick &&
      mWorldState.GetPlayMode() <= PM_Opp_Offside_Kick) {
    return;
  }

  if (closest_tm == mSelfState.GetUnum() ||
      mStrategy.GetMyInterCycle() <= mStrategy.GetSureTmInterCycle()) {
    ActiveBehavior block(mAgent, BT_Block);

    block.mBuffer = 0.5;
    block.mPower = mSelfState.CorrectDashPowerForStamina(
        ServerParam::instance().maxDashPower());
    block.mTarget = mAnalyser.mLightHouse;
    block.mEvaluation = 1.0 + FLOAT_EPS;

    behavior_list.push_back(block);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x13ab2
movq 0x10(%r14), %rcx
movl 0x1c(%rcx), %ecx
addl $-0x27, %ecx
cmpl $0x6, %ecx
jb 0x13938
movq 0x20(%r14), %r15
cmpl 0x11c(%r15), %eax
je 0x13874
movq 0x38(%r14), %rax
movl 0x64(%rax), %ecx
cmpl 0x7c(%rax), %ecx
jg 0x13938
movq 0x8(%r14), %r12
callq 0x49360
movsd 0x33c0(%rax), %xmm0
movq %r15, %rdi
callq 0x45d84
movsd %xmm0, -0x28(%rbp)
movq 0x48(%r14), %rax
movups 0x40(%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
movl $0xb8, %edi
callq 0x94c0
movl $0xb, 0x10(%rax)
movq %r12, 0x18(%rax)
movabsq $0x3ff000064a9cdc44, %rcx # imm = 0x3FF000064A9CDC44
movq %rcx, 0x20(%rax)
xorl %ecx, %ecx
movl %ecx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movaps -0x40(%rbp), %xmm0
movups %xmm0, 0x38(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movb $0x0, 0x60(%rax)
movl %ecx, 0x68(%rax)
movq %rcx, 0x70(%rax)
movl %ecx, 0x78(%rax)
movq %rcx, 0x80(%rax)
movl %ecx, 0x88(%rax)
movq %rcx, 0x90(%rax)
movl %ecx, 0x98(%rax)
movq %rcx, 0xa0(%rax)
movl %ecx, 0xa8(%rax)
movabsq $0x3fe0000000000000, %rcx # imm = 0x3FE0000000000000
movq %rcx, 0xb0(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x90b0
incq 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorBase.h
// Function: bool BehaviorExecutable::AutoRegister<BehaviorBlockExecuter>()
static bool AutoRegister() {
    std::string behavior_name;

#ifndef WIN32
    std::string function_name = __PRETTY_FUNCTION__;

    size_t end = function_name.find("Executer");
    if (end != std::string::npos) {
      size_t begin = end;
      while (begin && isalpha(function_name[begin--]))
        ;
      begin += 2;
      if (begin < end) {
        behavior_name = function_name.substr(begin, end - begin);
      }
    }
#endif

    return BehaviorFactory::instance().RegisterBehavior(
        BehaviorDerived::BEHAVIOR_TYPE, Creator<BehaviorDerived>,
        behavior_name.c_str());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq -0x58(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x55cc0(%rip), %rsi     # 0x6963a
leaq 0x55d11(%rip), %rdx     # 0x69692
leaq -0x48(%rbp), %rdi
callq 0x1362e
leaq 0x55d02(%rip), %rsi     # 0x69693
leaq -0x48(%rbp), %rdi
movl $0x8, %ecx
xorl %edx, %edx
callq 0x9890
cmpq $-0x1, %rax
je 0x13a1b
movq %rax, %rbx
movl $0x2, %edx
testq %rax, %rax
je 0x139d8
movq -0x48(%rbp), %r12
leaq 0x2(%rbx), %rdx
movq %rdx, %r13
movsbl -0x2(%r12,%rdx), %edi
callq 0x97c0
leaq -0x1(%r13), %rdx
cmpq $0x3, %r13
je 0x139d8
testl %eax, %eax
jne 0x139bc
subq %rdx, %rbx
jbe 0x13a1b
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %rbx, %rcx
callq 0x9500
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rbx
movq %rbx, %rsi
callq 0x95f0
movq (%rbx), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x13a1b
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x94e0
callq 0x130d4
movq -0x68(%rbp), %rcx
leaq 0xbd(%rip), %rdx        # 0x13ae8
movq %rax, %rdi
movl $0xb, %esi
callq 0x13332
movl %eax, %ebx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x13a4f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x13a64
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x94e0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13a7c
movq %rax, %rbx
jmp 0x13a94
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x13a94
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x13aa9
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorDefense.cpp
// Function: BehaviorDefensePlanner::Plan(std::__cxx11::list<ActiveBehavior, std::allocator<ActiveBehavior>>&)
void BehaviorDefensePlanner::Plan(std::list<ActiveBehavior> &behavior_list) {
  BehaviorFormationPlanner(mAgent).Plan(behavior_list);
  BehaviorBlockPlanner(mAgent).Plan(behavior_list);
  BehaviorMarkPlanner(mAgent).Plan(behavior_list);

  if (!mActiveBehaviorList.empty()) {
    mActiveBehaviorList.sort(std::greater<ActiveBehavior>());
    behavior_list.push_back(mActiveBehaviorList.front());

    if (mActiveBehaviorList.size() > 1) { //允许非最优行为提交视觉请求
      double plus = 1.0;
      ActiveBehaviorPtr it = mActiveBehaviorList.begin();
      for (++it; it != mActiveBehaviorList.end(); ++it) {
        it->SubmitVisualRequest(plus);
        plus *= 2.0;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq -0x98(%rbp), %r15
movq %r15, %rdi
callq 0x1525a
movq %r15, %rdi
movq %r14, %rsi
callq 0x152ba
leaq -0x98(%rbp), %rdi
callq 0x1528e
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x137c6
movq %r15, %rdi
movq %r14, %rsi
callq 0x13826
leaq -0x98(%rbp), %rdi
callq 0x137fa
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x179c4
movq %r15, %rdi
movq %r14, %rsi
callq 0x17a24
leaq -0x98(%rbp), %rdi
callq 0x179f8
leaq 0x50(%rbx), %r15
cmpq %r15, 0x50(%rbx)
je 0x13cfc
movq %r15, %rdi
callq 0x12934
movq 0x50(%rbx), %r12
addq $0x10, %r12
movl $0xb8, %edi
callq 0x94c0
movq %rax, %r13
leaq 0x10(%rax), %rdi
movl $0xa8, %edx
movq %r12, %rsi
callq 0x93e0
movq %r13, %rdi
movq %r14, %rsi
callq 0x90b0
incq 0x10(%r14)
cmpq $0x2, 0x60(%rbx)
jb 0x13cfc
movq (%r15), %rax
movq (%rax), %rbx
cmpq %r15, %rbx
je 0x13cfc
movsd 0x55380(%rip), %xmm0    # 0x69058
movsd %xmm0, -0x30(%rbp)
leaq 0x10(%rbx), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x13110
movsd -0x30(%rbp), %xmm0
addsd %xmm0, %xmm0
movq (%rbx), %rbx
cmpq %r15, %rbx
jne 0x13cd8
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x179f8
jmp 0x13d3c
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x137fa
jmp 0x13d3c
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x1528e
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorDribble.h
// Function: BehaviorDribbleExecuter::SubmitVisualRequest(ActiveBehavior const&, double)
void SubmitVisualRequest(const ActiveBehavior &dribble, double plus = 0.0) {
    Assert(dribble.mKeyOppGB.mUnum >= 0);
    Assert(dribble.mKeyOppGT.mUnum >= 0);

    VisualSystem::instance().RaisePlayer(mAgent, -dribble.mKeyOppGB.mUnum,
                                         2.0 + plus);
    VisualSystem::instance().RaisePlayer(mAgent, -dribble.mKeyOppGT.mUnum,
                                         2.0 + plus);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rsi, %rbx
movq %rdi, %r14
callq 0x565ee
movsd -0x18(%rbp), %xmm0
addsd 0x54826(%rip), %xmm0    # 0x69780
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x14f7b
xorl %esi, %esi
subl 0x78(%rbx), %esi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x576ea
callq 0x565ee
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
je 0x14f93
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %esi, %esi
subl 0x88(%rbx), %esi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x576ea
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorFormation.cpp
// Function: BehaviorFormationExecuter::Execute(ActiveBehavior const&)
bool BehaviorFormationExecuter::Execute(const ActiveBehavior &beh) {
  Logger::instance().LogGoToPoint(mSelfState.GetPos(), beh.mTarget,
                                  "@Formation");

  return Dasher::instance().GoToPoint(mAgent, beh.mTarget, beh.mBuffer,
                                      beh.mPower, false, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x34c60
movq 0x20(%r14), %rsi
addq $0x8, %rsi
leaq 0x28(%rbx), %rdx
leaq 0x546b2(%rip), %rcx     # 0x698c3
movq %rax, %rdi
callq 0x35100
callq 0x1f148
movq 0x8(%r14), %rsi
movsd 0x28(%rbx), %xmm0
movsd 0x30(%rbx), %xmm1
movsd 0xa0(%rbx), %xmm2
movsd 0x38(%rbx), %xmm3
movq %rax, %rdi
xorl %edx, %edx
movl $0x1, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x20f68
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.h
// Function: Line::IsPointInSameSide(Vector const&, Vector const&) const
bool IsPointInSameSide(const Vector &pt1, const Vector &pt2) const {
    Line tl(pt1, pt2);
    if (IsSameSlope(tl))
      return true;

    Vector inter_point;
    Intersection(tl, inter_point);

    return (inter_point.X() - pt1.X()) * (pt2.X() - inter_point.X()) <= 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movsd (%rsi), %xmm2
movsd (%rdx), %xmm3
movapd %xmm2, %xmm1
subsd %xmm3, %xmm1
andpd 0x53621(%rip), %xmm1    # 0x69010
movsd 0x53649(%rip), %xmm0    # 0x69040
ucomisd %xmm1, %xmm0
jbe 0x15a13
xorpd 0x5361b(%rip), %xmm2    # 0x69020
xorpd %xmm3, %xmm3
movsd 0x53647(%rip), %xmm1    # 0x69058
jmp 0x15a3e
movsd 0x8(%r14), %xmm1
movsd 0x8(%rbx), %xmm4
subsd %xmm4, %xmm1
subsd %xmm2, %xmm3
divsd %xmm3, %xmm1
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm4
movsd 0x5365e(%rip), %xmm3    # 0x69098
movapd %xmm4, %xmm2
movsd %xmm1, -0x30(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd 0x8(%rdi), %xmm2
movapd 0x535b6(%rip), %xmm4    # 0x69010
movapd %xmm2, %xmm5
andpd %xmm4, %xmm5
ucomisd %xmm5, %xmm0
movb $0x1, %al
jbe 0x15a74
andpd %xmm3, %xmm4
ucomisd %xmm4, %xmm0
ja 0x15acc
movsd (%rdi), %xmm4
divsd %xmm2, %xmm4
divsd %xmm3, %xmm1
subsd %xmm1, %xmm4
andpd 0x53584(%rip), %xmm4    # 0x69010
ucomisd %xmm4, %xmm0
ja 0x15acc
xorpd %xmm0, %xmm0
leaq -0x40(%rbp), %r15
movapd %xmm0, (%r15)
leaq -0x30(%rbp), %rsi
movq %r15, %rdx
callq 0x292d2
movsd (%r15), %xmm0
movsd (%r14), %xmm1
subsd %xmm0, %xmm1
subsd (%rbx), %xmm0
mulsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
setae %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorGoalie.cpp
// Function: BehaviorGoalieExecuter::Execute(ActiveBehavior const&)
bool BehaviorGoalieExecuter::Execute(const ActiveBehavior &act_bhv) {
  if (act_bhv.mDetailType == BDT_Goalie_Position) {
    return Dasher::instance().GoToPoint(mAgent, act_bhv.mTarget);
  } else if (act_bhv.mDetailType == BDT_Goalie_Catch) {
    return mAgent.Catch(
        GetNormalizeAngleDeg((mBallState.GetPos() - mSelfState.GetPos()).Dir() -
                             mSelfState.GetBodyDir()));
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl 0x98(%rsi), %eax
cmpl $0xd, %eax
je 0x15b93
cmpl $0xc, %eax
jne 0x15c26
movq %rsi, %rbx
callq 0x1f148
movq 0x8(%r14), %rsi
movsd 0x28(%rbx), %xmm0
movsd 0x30(%rbx), %xmm1
movsd 0x53d04(%rip), %xmm2    # 0x69878
movsd 0x53bb4(%rip), %xmm3    # 0x69730
movq %rax, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x20f68
movq 0x8(%r14), %rbx
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rax
movsd 0x8(%rcx), %xmm1
movsd 0x10(%rcx), %xmm0
subsd 0x8(%rax), %xmm1
subsd 0x10(%rax), %xmm0
movapd 0x53455(%rip), %xmm2    # 0x69010
movapd %xmm1, %xmm4
andpd %xmm2, %xmm4
movsd 0x53475(%rip), %xmm3    # 0x69040
ucomisd %xmm4, %xmm3
jbe 0x15bdf
andpd %xmm0, %xmm2
xorpd %xmm4, %xmm4
ucomisd %xmm2, %xmm3
ja 0x15bfc
callq 0x90d0
movapd %xmm0, %xmm4
mulsd 0x53458(%rip), %xmm4    # 0x69048
divsd 0x53458(%rip), %xmm4    # 0x69050
movq 0x20(%r14), %rax
subsd 0xb0(%rax), %xmm4
movsd 0x53454(%rip), %xmm0    # 0x69060
ucomisd %xmm4, %xmm0
jbe 0x15c31
movsd 0x53456(%rip), %xmm1    # 0x69070
addsd %xmm1, %xmm4
ucomisd %xmm4, %xmm0
ja 0x15c1a
jmp 0x15c55
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
ucomisd 0x5340f(%rip), %xmm4    # 0x69048
jb 0x15c55
movsd 0x53425(%rip), %xmm0    # 0x69068
movsd 0x533fd(%rip), %xmm1    # 0x69048
addsd %xmm0, %xmm4
ucomisd %xmm1, %xmm4
jae 0x15c4b
movsd %xmm4, -0x18(%rbp)
movq %rbx, %rdi
callq 0xee28
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xc562
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorHold.cpp
// Function: BehaviorHoldExecuter::Execute(ActiveBehavior const&)
bool BehaviorHoldExecuter::Execute(const ActiveBehavior &hold) {
  Logger::instance().LogDribble(mBallState.GetPos(), hold.mTarget, "@Hold",
                                true);
  //	Logger::instance().GetTextLogger("Hold")<< mWorldState.CurrentTime(). +
  //"Hold";
  if (hold.mDetailType == BDT_Hold_Turn) {
    return Dasher::instance()
        .GetTurnBodyToAngleAction(mAgent, hold.mAngle)
        .Execute(mAgent);
  } else
    return Kicker::instance().KickBallCloseToBody(mAgent, hold.mAngle, 0.6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x34c60
movq 0x18(%rbx), %rsi
addq $0x8, %rsi
leaq 0x28(%r14), %rdx
leaq 0x5366c(%rip), %rcx     # 0x69a31
movq %rax, %rdi
movl $0x1, %r8d
callq 0x35578
cmpl $0xa, 0x98(%r14)
jne 0x16410
callq 0x1f148
movq 0x8(%rbx), %rdx
movsd 0x20(%r14), %xmm0
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x21200
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0xb2fc
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2d3f2
movq 0x8(%rbx), %rsi
movsd 0x20(%r14), %xmm0
movsd 0x53599(%rip), %xmm1    # 0x699c0
movq %rax, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x30fb4
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorHold.h
// Function: BehaviorHoldExecuter::SubmitVisualRequest(ActiveBehavior const&, double)
void SubmitVisualRequest(const ActiveBehavior &hold, double plus = 0.0) {
    Assert(hold.mKeyOppGB.mUnum >= 0);
    Assert(hold.mKeyOppGT.mUnum >= 0);

    VisualSystem::instance().RaisePlayer(mAgent, -hold.mKeyOppGB.mUnum,
                                         2.0 + plus);
    VisualSystem::instance().RaisePlayer(mAgent, -hold.mKeyOppGT.mUnum,
                                         2.0 + plus);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rsi, %rbx
movq %rdi, %r14
callq 0x565ee
movsd -0x18(%rbp), %xmm0
addsd 0x52a46(%rip), %xmm0    # 0x69780
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x16d5b
xorl %esi, %esi
subl 0x78(%rbx), %esi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x576ea
callq 0x565ee
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
je 0x16d73
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %esi, %esi
subl 0x88(%rbx), %esi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x576ea
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorPass.cpp
// Function: BehaviorPassExecuter::Execute(ActiveBehavior const&)
bool BehaviorPassExecuter::Execute(const ActiveBehavior &pass) {
  Logger::instance().LogPass(false, mBallState.GetPos(), pass.mTarget, "@Pass",
                             true);
  if (pass.mDetailType == BDT_Pass_Direct)
    return Kicker::instance().KickBall(mAgent, pass.mTarget, pass.mKickSpeed,
                                       KM_Quick);
  if (pass.mDetailType == BDT_Pass_Clear) {
    //		Logger::instance().GetTextLogger("Clear")<<
    //mWorldState.CurrentTime().S() + "Clear";
    if (Tackler::instance().CanTackleToDir(mAgent, pass.mAngle) &&
        Tackler::instance().GetBallVelAfterTackle(mAgent, pass.mAngle).Mod() >
            Kicker::instance().GetMaxSpeed(mAgent, pass.mTarget, 1) - 0.08)
      return Tackler::instance().TackleToDir(mAgent, pass.mAngle);
    else
      return Kicker::instance().KickBall(mAgent, pass.mTarget,
                                         ServerParam::instance().ballSpeedMax(),
                                         KM_Quick, 0);
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x34c60
movq 0x18(%r14), %rdx
addq $0x8, %rdx
leaq 0x28(%r15), %rbx
leaq 0x51cd0(%rip), %r8      # 0x69c61
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rcx
movl $0x1, %r9d
callq 0x35624
movl 0x98(%r15), %eax
cmpl $0x4, %eax
je 0x17fed
cmpl $0x3, %eax
jne 0x180b8
callq 0x2d3f2
movq 0x8(%r14), %rsi
movsd 0x48(%r15), %xmm0
movq %rax, %rdi
movq %rbx, %rdx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3043a
callq 0x4c9fe
movq 0x8(%r14), %rsi
addq $0x20, %r15
movq %rax, %rdi
movq %r15, %rdx
callq 0x4d640
testb %al, %al
je 0x18083
callq 0x4c9fe
movq 0x8(%r14), %rsi
movsd (%r15), %xmm0
movq %rax, %rdi
callq 0x4cfe2
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x2d3f2
movq 0x8(%r14), %rsi
leaq -0x2c(%rbp), %rcx
movl $0x1, (%rcx)
movq %rax, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2e0a6
addsd 0x51bb0(%rip), %xmm0    # 0x69c10
movsd -0x28(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x18083
callq 0x4c9fe
movq 0x8(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x4d684
jmp 0x180b5
callq 0x2d3f2
movq %rax, %r15
movq 0x8(%r14), %r14
callq 0x49360
movsd 0x30f8(%rax), %xmm0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x3043a
movl %eax, %r12d
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorPass.h
// Function: BehaviorPassExecuter::SubmitVisualRequest(ActiveBehavior const&, double)
void SubmitVisualRequest(const ActiveBehavior &pass, double plus = 0.0) {
    if (pass.mKickCycle == 1) {
      VisualSystem::instance().RaisePlayer(mAgent, pass.mKeyTm.mUnum,
                                           3.0 + plus);
      VisualSystem::instance().RaisePlayer(mAgent, -pass.mKeyOppGB.mUnum,
                                           3.0 + plus);
      VisualSystem::instance().RaisePlayer(mAgent, -pass.mKeyOppGT.mUnum,
                                           3.0 + plus);
    } else {
      VisualSystem::instance().RaisePlayer(mAgent, pass.mKeyTm.mUnum,
                                           2.0 + plus);
      VisualSystem::instance().RaisePlayer(mAgent, -pass.mKeyOppGB.mUnum,
                                           3.0 + plus);
      VisualSystem::instance().RaisePlayer(mAgent, -pass.mKeyOppGT.mUnum,
                                           2.0 + plus);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, -0x20(%rbp)
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rsi), %r15d
callq 0x565ee
movq 0x8(%r14), %rcx
movq 0x8(%rax), %rdx
cmpl $0x1, %r15d
jne 0x193fa
movsd -0x20(%rbp), %xmm0
addsd 0x50882(%rip), %xmm0    # 0x69c20
movsd %xmm0, -0x20(%rbp)
cmpq %rcx, %rdx
jne 0x193b8
movl 0x58(%rbx), %esi
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x576ea
callq 0x565ee
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x193d9
xorl %esi, %esi
subl 0x78(%rbx), %esi
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x576ea
callq 0x565ee
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x19459
xorl %esi, %esi
subl 0x88(%rbx), %esi
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
jmp 0x19474
movsd 0x5037e(%rip), %xmm0    # 0x69780
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
cmpq %rcx, %rdx
jne 0x19421
movl 0x58(%rbx), %esi
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x576ea
callq 0x565ee
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x1944a
movsd -0x20(%rbp), %xmm0
addsd 0x507e3(%rip), %xmm0    # 0x69c20
xorl %esi, %esi
subl 0x78(%rbx), %esi
movq %rax, %rdi
callq 0x576ea
callq 0x565ee
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
je 0x19464
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
subl 0x88(%rbx), %esi
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x576ea
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorPosition.cpp
// Function: BehaviorPositionExecuter::Execute(ActiveBehavior const&)
bool BehaviorPositionExecuter::Execute(const ActiveBehavior &beh) {
  Logger::instance().LogGoToPoint(mSelfState.GetPos(), beh.mTarget,
                                  "@Position");

  return Dasher::instance().GoToPoint(mAgent, beh.mTarget, beh.mBuffer,
                                      beh.mPower, false, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x34c60
movq 0x20(%r14), %rsi
addq $0x8, %rsi
leaq 0x28(%rbx), %rdx
leaq 0x4fd38(%rip), %rcx     # 0x69e19
movq %rax, %rdi
callq 0x35100
callq 0x1f148
movq 0x8(%r14), %rsi
movsd 0x28(%rbx), %xmm0
movsd 0x30(%rbx), %xmm1
movsd 0xa0(%rbx), %xmm2
movsd 0x38(%rbx), %xmm3
movq %rax, %rdi
xorl %edx, %edx
movl $0x1, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x20f68
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorPosition.h
// Function: BehaviorPositionExecuter::SubmitVisualRequest(ActiveBehavior const&, double)
void SubmitVisualRequest(const ActiveBehavior &position, double plus = 0.0) {
    (void)position;
    (void)plus;

    if (fabs(mSelfState.GetPos().X() - mPositionInfo.GetTeammateOffsideLine()) <
        30.0) {
      VisualSystem::instance().RaisePlayer(
          mAgent, -mPositionInfo.GetTeammateOffsideLineOpp(), 3.0);
    }

    if (mSelfState.GetUnum() == mPositionInfo.GetCloseTeammateToBall()[0] ||
        mSelfState.GetUnum() == mPositionInfo.GetCloseTeammateToBall()[1]) {
      VisualSystem::instance().RaiseBall(mAgent, 2);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rdi
movsd 0x8(%rax), %xmm0
subsd 0x17a0(%rdi), %xmm0
andpd 0x4e80b(%rip), %xmm0    # 0x69010
movsd 0x4ef2b(%rip), %xmm1    # 0x69738
ucomisd %xmm0, %xmm1
jbe 0x1a842
callq 0x565ee
movq 0x8(%rax), %rcx
movq 0x28(%rbx), %rdi
cmpq 0x8(%rbx), %rcx
jne 0x1a842
xorl %esi, %esi
subl 0x1798(%rdi), %esi
movsd 0x4f3ea(%rip), %xmm0    # 0x69c20
movq %rax, %rdi
callq 0x576ea
movq 0x28(%rbx), %rdi
movq 0x20(%rbx), %rax
movl 0x11c(%rax), %r14d
callq 0x47a42
movq (%rax), %rax
cmpl (%rax), %r14d
je 0x1a877
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdi
movl 0x11c(%rax), %r14d
callq 0x47a42
movq (%rax), %rax
cmpl 0x4(%rax), %r14d
jne 0x1a886
callq 0x565ee
movq 0x8(%rax), %rcx
cmpq 0x8(%rbx), %rcx
je 0x1a88b
popq %rbx
popq %r14
popq %rbp
retq
movsd 0x4eeed(%rip), %xmm0    # 0x69780
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x57908
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorSetplay.cpp
// Function: BehaviorSetplayExecuter::Execute(ActiveBehavior const&)
bool BehaviorSetplayExecuter::Execute(const ActiveBehavior &setplay) {
  if (mWorldState.GetPlayMode() == PM_Before_Kick_Off) {
    if (setplay.mDetailType == BDT_Setplay_Move) {
      return mAgent.Move(setplay.mTarget);
    } else if (setplay.mDetailType == BDT_Setplay_Scan) {
      VisualSystem::instance().ForbidDecision(mAgent);
      return mAgent.Turn(50.0);
    } else {
      PRINT_ERROR("Setplay Detail Type Error");
      return false;
    }
  } else {
    if (setplay.mDetailType == BDT_Setplay_Scan) {
      return true; //交给视觉决策
    } else if (setplay.mDetailType == BDT_Setplay_GetBall) {
      return Dasher::instance().GetBall(mAgent);
    }
    if (setplay.mDetailType == BDT_Setplay_Move) {
      return mAgent.Move(setplay.mTarget);
    } else {
      PRINT_ERROR("Setplay Detail Type Error");
      return false;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpl $0x16, 0x1c(%rax)
movl 0x98(%rsi), %eax
jne 0x1a9fe
cmpl $0x10, %eax
je 0x1aa6e
cmpl $0xf, %eax
je 0x1aa39
movq 0x69627(%rip), %rbx     # 0x83ff0
leaq 0x4f4ef(%rip), %rsi     # 0x69ebf
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x527ae(%rip), %rsi     # 0x6d192
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x45, %esi
jmp 0x1aadd
cmpl $0xf, %eax
je 0x1aa39
cmpl $0x10, %eax
je 0x1aa9f
cmpl $0x11, %eax
jne 0x1aaa6
callq 0x1f148
movq 0x8(%rbx), %rsi
movq %rax, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x216f6
movq 0x8(%rbx), %rdi
movsd 0x28(%rsi), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x30(%rsi), %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0xee28
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xc61a
callq 0x565ee
movq 0x8(%rbx), %rdi
cmpq %rdi, 0x8(%rax)
jne 0x1aa84
movb $0x1, 0x63b(%rax)
callq 0xee28
movsd 0x4f3ef(%rip), %xmm0    # 0x69e80
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xbb88
movb $0x1, %al
jmp 0x1ab36
movq 0x69543(%rip), %rbx     # 0x83ff0
leaq 0x4f40b(%rip), %rsi     # 0x69ebf
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x526ca(%rip), %rsi     # 0x6d192
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x51, %esi
callq 0x9880
movq %rax, %rbx
leaq 0x5096b(%rip), %rsi     # 0x6b457
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x4f3da(%rip), %rsi     # 0x69eda
movl $0x19, %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
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorShoot.cpp
// Function: BehaviorShootExecuter::Execute(ActiveBehavior const&)
bool BehaviorShootExecuter::Execute(const ActiveBehavior &shoot) {
  Logger::instance().LogShoot(mBallState.GetPos(), shoot.mTarget, "@Shoot");
  if (shoot.mDetailType == BDT_Shoot_Tackle)
    return Tackler::instance().TackleToDir(mAgent, shoot.mAngle);
  else
    return Kicker::instance().KickBall(mAgent, shoot.mTarget,
                                       ServerParam::instance().ballSpeedMax(),
                                       KM_Quick, 0, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x34c60
movq 0x18(%r14), %rsi
addq $0x8, %rsi
leaq 0x28(%rbx), %r15
leaq 0x4ed83(%rip), %rcx     # 0x69f8b
movq %rax, %rdi
movq %r15, %rdx
callq 0x351aa
cmpl $0x9, 0x98(%rbx)
jne 0x1b240
callq 0x4c9fe
movq 0x8(%r14), %rsi
addq $0x20, %rbx
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4d684
callq 0x2d3f2
movq %rax, %rbx
movq 0x8(%r14), %r14
callq 0x49360
movsd 0x30f8(%rax), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x2, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3043a
nop
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorShoot.h
// Function: BehaviorShootExecuter::SubmitVisualRequest(ActiveBehavior const&, double)
void SubmitVisualRequest(const ActiveBehavior &shoot, double plus = 0.0) {
    Assert(shoot.mKeyOppGT.mUnum >= 0);
    Assert(shoot.mKeyOppGB.mUnum >= 0);

    VisualSystem::instance().RaisePlayer(
        mAgent, -mWorldState.GetOpponentGoalieUnum(), 1.0 + plus);
    VisualSystem::instance().RaisePlayer(mAgent, -shoot.mKeyOppGT.mUnum,
                                         2.0 + plus);
    VisualSystem::instance().RaisePlayer(mAgent, -shoot.mKeyOppGB.mUnum,
                                         2.0 + plus);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rsi, %rbx
movq %rdi, %r14
callq 0x565ee
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x1b8b4
movsd 0x4d7bd(%rip), %xmm0    # 0x69058
addsd -0x18(%rbp), %xmm0
movq 0x10(%r14), %rcx
xorl %esi, %esi
subl 0x2114(%rcx), %esi
movq %rax, %rdi
callq 0x576ea
callq 0x565ee
movsd -0x18(%rbp), %xmm0
addsd 0x4deba(%rip), %xmm0    # 0x69780
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x1b8ea
xorl %esi, %esi
subl 0x88(%rbx), %esi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x576ea
callq 0x565ee
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
je 0x1b902
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %esi, %esi
subl 0x78(%rbx), %esi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x576ea
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Client.cpp
// Function: Client::Client()
Client::Client() {
  srand(time(0)); // global srand once
  srand48(time(0));

  /** Observer and World Model */
  mpAgent = 0;
  mpObserver = new Observer;
  mpWorldModel = new WorldModel;

  // instance放在这里创建以节省后面的运行效率，部分instance不能放在这里，需要时创建

  /** Assistant instance */

  TimeTest::instance();
  NetworkTest::instance();
  DynamicDebug::instance();
  Logger::instance().Initial(mpObserver, &(mpWorldModel->World(false)));
  Plotter::instance();

  /** Param */
  ServerParam::instance();
  PlayerParam::instance();

  /** Base Model */
  InterceptModel::instance();

  /** Smart Action */
  Dasher::instance();
  Tackler::instance();
  Kicker::instance();

  /** Other Useful instance */
  BehaviorFactory::instance();
  UDPSocket::instance();
  VisualSystem::instance();
  CommunicateSystem::instance();

  /** Parser thread and CommandSend thread */
  mpCommandSender = new CommandSender(mpObserver);

  // ServerPlayModeMap::instance();

  mpParser = new Parser(mpObserver);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x67c4c(%rip), %rax     # 0x835e8
movq %rax, (%rdi)
xorl %edi, %edi
callq 0x9440
movl %eax, %edi
callq 0x9470
xorl %edi, %edi
callq 0x9440
movq %rax, %rdi
callq 0x9830
movq $0x0, 0x18(%rbx)
movl $0x56d0, %edi           # imm = 0x56D0
callq 0x94c0
movq %rax, %r14
movq %rax, %rdi
callq 0x3a40c
movq %r14, 0x8(%rbx)
movl $0x28, %edi
callq 0x94c0
movq %rax, %r14
movq %rax, %rdi
callq 0x59f90
movq %r14, 0x10(%rbx)
callq 0x4e858
callq 0x38882
callq 0x22cde
callq 0x34c60
movq %rax, %r14
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0x5a176
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x34cda
callq 0x46686
callq 0x49360
callq 0x43dce
callq 0x2b84e
callq 0x1f148
callq 0x4c9fe
callq 0x2d3f2
callq 0x130d4
callq 0x54038
callq 0x565ee
callq 0x1d004
movl $0x20, %edi
callq 0x94c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x1cc14
movq %r14, 0x28(%rbx)
movl $0x60, %edi
callq 0x94c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3d9c4
movq %r14, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x60, %esi
jmp 0x1bacc
movq %rax, %rbx
movl $0x20, %esi
jmp 0x1bacc
movq %rax, %rbx
movl $0x28, %esi
jmp 0x1bacc
movq %rax, %rbx
movl $0x56d0, %esi           # imm = 0x56D0
movq %r14, %rdi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/Client.cpp
// Function: Client::~Client()
Client::~Client() {
  delete mpCommandSender;
  delete mpParser;

  delete mpObserver;
  delete mpWorldModel;
  delete mpAgent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x67afc(%rip), %rax     # 0x835e8
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1bafe
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb0d
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb1c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb2b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1bb40
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop