LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: ChangePlayMode::Plan(ServerPlayMode)
void ChangePlayMode::Plan(ServerPlayMode spm) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(change_mode "
          << ServerPlayModeMap::instance().GetPlayModeString(spm) << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1b0(%rbp), %r15
movq %r15, %rdi
callq 0x9660
leaq 0x59cdb(%rip), %rsi     # 0x6b3cb
movl $0xd, %edx
movq %r15, %rdi
callq 0x9560
callq 0x55f0c
movq %rax, %rdi
movl %r14d, %esi
callq 0x572ae
movq %rax, %r14
testq %rax, %rax
je 0x11731
movq %r14, %rdi
callq 0x9200
leaq -0x1b0(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x11752
movq -0x1b0(%rbp), %rax
movq -0x18(%rax), %rax
leaq (%rax,%rbp), %rdi
addq $-0x1b0, %rdi           # imm = 0xFE50
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x9860
leaq 0x59b2f(%rip), %rsi     # 0x6b288
leaq -0x1b0(%rbp), %rdi
movl $0x1, %edx
callq 0x9560
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x117a5
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x7580c(%rip), %rsi     # 0x86fb8
leaq -0x1b0(%rbp), %rdi
callq 0x9290
leaq -0x140(%rbp), %rdi
callq 0x91c0
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x117d4
movq %rax, %rbx
movq 0x757da(%rip), %rsi     # 0x86fb8
leaq -0x1b0(%rbp), %rdi
callq 0x9290
leaq -0x140(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: MovePlayer::Plan(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, Vector, Vector, double)
void MovePlayer::Plan(std::string team_name, Unum num, Vector pos, Vector vel,
                      AngleDeg dir) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(move (player " << team_name << " " << num << ") " << pos.X()
          << " " << pos.Y() << " " << dir << " " << vel.X() << " " << vel.Y()
          << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movsd %xmm4, -0x38(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm1, -0x40(%rbp)
movsd %xmm0, -0x48(%rbp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x24(%rdi)
leaq -0x1e0(%rbp), %r12
movq %r12, %rdi
callq 0x9660
leaq 0x59b3d(%rip), %rsi     # 0x6b3d9
movl $0xe, %edx
movq %r12, %rdi
callq 0x9560
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq -0x1e0(%rbp), %rdi
callq 0x9560
movq %rax, %r15
leaq 0x5d32e(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r15, %rdi
movl %r14d, %esi
callq 0x9880
movq %rax, %r14
leaq 0x5d6a9(%rip), %rsi     # 0x6ef91
movl $0x2, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x48(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5d2e8(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x40(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5d2c4(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x38(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5d2a0(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5d27c(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x97d0
leaq 0x598ef(%rip), %rsi     # 0x6b288
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq -0x1d8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x97a0
addq $0x60, %rbx
leaq -0x68(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95f0
movq (%r14), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x119e1
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x755d0(%rip), %rsi     # 0x86fb8
leaq -0x1e0(%rbp), %rdi
callq 0x9290
leaq -0x170(%rbp), %rdi
callq 0x91c0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11a12
movq %rax, %rbx
movq 0x7559c(%rip), %rsi     # 0x86fb8
leaq -0x1e0(%rbp), %rdi
callq 0x9290
leaq -0x170(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5991d(%rip), %rsi     # 0x6b3e8
movl $0xd, %edx
movq %r14, %rdi
callq 0x9560
leaq -0x1c8(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5d101(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5d0dd(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x598cb(%rip), %rsi     # 0x6b3f6
movl $0x3, %edx
movq %r14, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x97d0
movq %rax, %r14
leaq 0x5d0a5(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %rax, %rdi
callq 0x9560
movq %r14, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x97d0
leaq 0x59718(%rip), %rsi     # 0x6b288
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 0x11bb8
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x753f9(%rip), %rsi     # 0x86fb8
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 0x11be5
movq %rax, %rbx
movq 0x753c9(%rip), %rsi     # 0x86fb8
leaq -0x1c8(%rbp), %rdi
callq 0x9290
leaq -0x158(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5976f(%rip), %rsi     # 0x6b3fa
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 0x11cd3
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x752de(%rip), %rsi     # 0x86fb8
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 0x11d00
movq %rax, %rbx
movq 0x752ae(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5965c(%rip), %rsi     # 0x6b401
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 0x11ded
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x751c4(%rip), %rsi     # 0x86fb8
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 0x11e1a
movq %rax, %rbx
movq 0x75194(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5954f(%rip), %rsi     # 0x6b40e
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 0x11f07
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x750aa(%rip), %rsi     # 0x86fb8
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 0x11f34
movq %rax, %rbx
movq 0x7507a(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5943f(%rip), %rsi     # 0x6b418
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 0x12021
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x94e0
movq 0x74f90(%rip), %rsi     # 0x86fb8
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 0x1204e
movq %rax, %rbx
movq 0x74f60(%rip), %rsi     # 0x86fb8
leaq -0x1a8(%rbp), %rdi
callq 0x9290
leaq -0x138(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x13210
movl (%rbx), %eax
testq %rax, %rax
je 0x130fa
leaq 0x7664b(%rip), %rcx     # 0x89730
movq 0x8(%rcx,%rax,8), %rax
testq %rax, %rax
je 0x130fa
movq 0x8(%rbx), %rdi
callq *%rax
movq %rax, %r14
jmp 0x130fd
xorl %r14d, %r14d
testq %r14, %r14
je 0x131fe
callq 0x35b4a
leaq 0x58497(%rip), %rsi     # 0x6b5a9
movq %rax, %rdi
callq 0x35d5e
movq %rax, %r15
movq 0x8(%rbx), %rax
movq 0x18(%rax), %r12
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x13149
addq $0x10, %r12
movq %r15, %rdi
addq $0x210, %rdi            # imm = 0x210
movq %r12, %rsi
callq 0xea74
leaq 0x5baa4(%rip), %rsi     # 0x6ebf4
movq %r15, %rdi
callq 0x135bc
movq %rax, %r15
callq 0x13210
movl (%rbx), %eax
shlq $0x5, %rax
leaq 0x765c3(%rip), %rcx     # 0x89730
movq 0x70(%rax,%rcx), %rax
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x13606
leaq 0x58420(%rip), %rsi     # 0x6b5a8
movq %rax, %rdi
callq 0x13672
movq %rax, %r15
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x131d6
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 0x13200
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/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 0x13248
movl %edx, %eax
movq 0x8(%rdi,%rax,8), %rax
testq %rax, %rax
je 0x13248
movq %rsi, %rdi
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x28(%rbp)
movq %rdi, %rbx
callq 0x13210
movl (%rbx), %eax
testq %rax, %rax
je 0x1328b
leaq 0x764ba(%rip), %rcx     # 0x89730
movq 0x8(%rcx,%rax,8), %rax
testq %rax, %rax
je 0x1328b
movq 0x8(%rbx), %rdi
callq *%rax
movq %rax, %r14
jmp 0x1328e
xorl %r14d, %r14d
testq %r14, %r14
je 0x133a0
callq 0x35b4a
leaq 0x58306(%rip), %rsi     # 0x6b5a9
movq %rax, %rdi
callq 0x35d5e
movq %rax, %r15
movq 0x8(%rbx), %rax
movq 0x18(%rax), %r12
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x132da
addq $0x10, %r12
movq %r15, %rdi
addq $0x210, %rdi            # imm = 0x210
movq %r12, %rsi
callq 0xea74
leaq 0x5b913(%rip), %rsi     # 0x6ebf4
movq %r15, %rdi
callq 0x135bc
movq %rax, %r15
callq 0x13210
movl (%rbx), %eax
shlq $0x5, %rax
leaq 0x76432(%rip), %rcx     # 0x89730
movq 0x70(%rax,%rcx), %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x13606
leaq 0x5829a(%rip), %rsi     # 0x6b5b3
movq %rax, %rdi
callq 0x136bc
movq %rax, %r15
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x13343
leaq 0x210(%r15), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x97d0
callq 0x450ba
cmpb $0x1, 0x5c45(%rax)
jne 0x13386
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 -0x28(%rbp), %xmm0
callq *0x18(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorBase.cpp
// Function: BehaviorFactory::RegisterBehavior(BehaviorType, BehaviorExecutable* (*)(Agent&), char const*)
bool BehaviorFactory::RegisterBehavior(BehaviorType type,
                                       BehaviorCreator creator,
                                       const char *behavior_name) {
  if (type > BT_None && type < BT_Max) {
    if (mCreatorMap[type] == 0) {
      mCreatorMap[type] = creator;
      mNameMap[type] = behavior_name;
      return true;
    }
  }

  return false;
}

// Assembly:
leal -0x1(%rsi), %eax
cmpl $0xb, %eax
ja 0x13480
movl %esi, %eax
cmpq $0x0, 0x8(%rdi,%rax,8)
je 0x13483
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, 0x8(%rdi,%rax,8)
shlq $0x5, %rax
leaq (%rdi,%rax), %r14
addq $0x70, %r14
movq 0x8(%r14), %r15
movq %rcx, %rdi
callq 0x9200
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x9780
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x134e2
testl %eax, %eax
jne 0x13536
movb 0x765d8(%rip), %al      # 0x89ac0
leaq 0x76459(%rip), %rbx     # 0x89948
testb %al, %al
jne 0x1354c
leaq 0x765c6(%rip), %rdi     # 0x89ac0
callq 0x9900
testl %eax, %eax
je 0x1354c
leaq 0x7643e(%rip), %rbx     # 0x89948
movq %rbx, %rdi
callq 0x46810
leaq -0x45a3(%rip), %rdi     # 0xef76
leaq 0x73fd8(%rip), %rdx     # 0x874f8
movq %rbx, %rsi
callq 0x9410
leaq 0x76591(%rip), %rdi     # 0x89ac0
callq 0x9300
jmp 0x1354c
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 0x76560(%rip), %rdi     # 0x89ac0
callq 0x92f0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x13c00
movq 0x10(%r14), %rcx
movl 0x1c(%rcx), %ecx
addl $-0x27, %ecx
cmpl $0x6, %ecx
jb 0x13a84
movq 0x20(%r14), %r15
cmpl 0x11c(%r15), %eax
je 0x139aa
movq 0x38(%r14), %rax
movl 0x64(%rax), %ecx
cmpl 0x7c(%rax), %ecx
jg 0x13a84
movq 0x8(%r14), %r13
xorl %r12d, %r12d
movq %r12, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x48(%rbp)
callq 0x4a75c
movsd 0x33c0(%rax), %xmm0
movq %r15, %rdi
callq 0x470e2
movsd %xmm0, -0x30(%rbp)
movq 0x48(%r14), %rax
movups 0x40(%rax), %xmm0
movups %xmm0, -0x40(%rbp)
movl $0xb8, %edi
callq 0x94c0
movl $0xb, 0x10(%rax)
movq %r13, 0x18(%rax)
movabsq $0x3ff000064a9cdc44, %rcx # imm = 0x3FF000064A9CDC44
movq %rcx, 0x20(%rax)
movl %r12d, 0x28(%rax)
movups -0x4c(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups %xmm0, 0x2c(%rax)
movups %xmm1, 0x38(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rax)
movb $0x0, 0x60(%rax)
movl %r12d, 0x68(%rax)
movq %r12, 0x70(%rax)
movl %r12d, 0x78(%rax)
movq %r12, 0x80(%rax)
movl %r12d, 0x88(%rax)
movq %r12, 0x90(%rax)
movl %r12d, 0x98(%rax)
movq %r12, 0xa0(%rax)
movl %r12d, 0xa8(%rax)
movabsq $0x3fe0000000000000, %rcx # imm = 0x3FE0000000000000
movq %rcx, 0xb0(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x90b0
incq 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/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 0x57b72(%rip), %rsi     # 0x6b63a
leaq 0x57bc3(%rip), %rdx     # 0x6b692
leaq -0x48(%rbp), %rdi
callq 0x13766
leaq 0x57bb4(%rip), %rsi     # 0x6b693
leaq -0x48(%rbp), %rdi
movl $0x8, %ecx
xorl %edx, %edx
callq 0x9890
cmpq $-0x1, %rax
je 0x13b69
movq %rax, %rbx
movl $0x2, %edx
testq %rax, %rax
je 0x13b26
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 0x13b26
testl %eax, %eax
jne 0x13b0a
subq %rdx, %rbx
jbe 0x13b69
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 0x13b69
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x94e0
callq 0x13210
movq -0x68(%rbp), %rcx
leaq 0xbd(%rip), %rdx        # 0x13c36
movq %rax, %rdi
movl $0xb, %esi
callq 0x1346e
movl %eax, %ebx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x13b9d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x13bb2
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 0x13bca
movq %rax, %rbx
jmp 0x13be2
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x13be2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x94e0
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x13bf7
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15472
movq %r15, %rdi
movq %r14, %rsi
callq 0x154d2
leaq -0x98(%rbp), %rdi
callq 0x154a6
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x138fa
movq %r15, %rdi
movq %r14, %rsi
callq 0x1395a
leaq -0x98(%rbp), %rdi
callq 0x1392e
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x17c98
movq %r15, %rdi
movq %r14, %rsi
callq 0x17cf8
leaq -0x98(%rbp), %rdi
callq 0x17ccc
leaq 0x50(%rbx), %r15
cmpq %r15, 0x50(%rbx)
je 0x13e68
movq %r15, %rdi
callq 0x12a4c
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 0x13e68
movq (%r15), %rax
movq (%rax), %rbx
cmpq %r15, %rbx
je 0x13e68
movsd 0x57214(%rip), %xmm0    # 0x6b058
movsd %xmm0, -0x30(%rbp)
leaq 0x10(%rbx), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x1324c
movsd -0x30(%rbp), %xmm0
addsd %xmm0, %xmm0
movq (%rbx), %rbx
cmpq %r15, %rbx
jne 0x13e44
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x17ccc
jmp 0x13ea8
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x1392e
jmp 0x13ea8
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x154a6
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x57e2a
movsd -0x18(%rbp), %xmm0
addsd 0x5662a(%rip), %xmm0    # 0x6b780
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x15177
xorl %esi, %esi
subl 0x78(%rbx), %esi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x58f34
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
je 0x1518f
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 0x58f34
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35b4a
movq 0x20(%r14), %rsi
addq $0x8, %rsi
leaq 0x28(%rbx), %rdx
leaq 0x5649a(%rip), %rcx     # 0x6b8c3
movq %rax, %rdi
callq 0x35fea
callq 0x1f5e8
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 0x2157e
// File: /workspace/github_cpp_makefile_star2_O1/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), %xmm1
movsd (%rdx), %xmm2
movapd %xmm1, %xmm3
subsd %xmm2, %xmm3
andpd 0x553fb(%rip), %xmm3    # 0x6b010
movsd 0x55423(%rip), %xmm0    # 0x6b040
ucomisd %xmm3, %xmm0
jbe 0x15c43
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
xorpd 0x553df(%rip), %xmm1    # 0x6b020
jmp 0x15c79
movsd 0x8(%r14), %xmm3
movsd 0x8(%rbx), %xmm4
subsd %xmm4, %xmm3
subsd %xmm1, %xmm2
divsd %xmm2, %xmm3
movsd %xmm3, -0x30(%rbp)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, -0x28(%rbp)
mulsd %xmm1, %xmm3
subsd %xmm3, %xmm4
movapd %xmm4, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd 0x8(%rdi), %xmm1
movapd 0x55385(%rip), %xmm2    # 0x6b010
andpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x15caa
movsd -0x28(%rbp), %xmm2
andpd 0x5536e(%rip), %xmm2    # 0x6b010
movb $0x1, %al
ucomisd %xmm2, %xmm0
ja 0x15d0a
movsd (%rdi), %xmm2
movsd -0x30(%rbp), %xmm3
divsd -0x28(%rbp), %xmm3
divsd %xmm1, %xmm2
subsd %xmm3, %xmm2
andpd 0x55348(%rip), %xmm2    # 0x6b010
movb $0x1, %al
ucomisd %xmm2, %xmm0
ja 0x15d0a
xorpd %xmm0, %xmm0
leaq -0x40(%rbp), %r15
movapd %xmm0, (%r15)
leaq -0x30(%rbp), %rsi
movq %r15, %rdx
callq 0x29b3c
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_O1/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 0x15dd3
cmpl $0xc, %eax
jne 0x15e66
movq %rsi, %rbx
callq 0x1f5e8
movq 0x8(%r14), %rsi
movsd 0x28(%rbx), %xmm0
movsd 0x30(%rbx), %xmm1
movsd 0x55ac4(%rip), %xmm2    # 0x6b878
movsd 0x55974(%rip), %xmm3    # 0x6b730
movq %rax, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2157e
movq 0x8(%r14), %rbx
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm0
subsd 0x8(%rcx), %xmm1
subsd 0x10(%rcx), %xmm0
movapd 0x55215(%rip), %xmm2    # 0x6b010
movapd %xmm1, %xmm4
andpd %xmm2, %xmm4
movsd 0x55235(%rip), %xmm3    # 0x6b040
ucomisd %xmm4, %xmm3
jbe 0x15e1f
andpd %xmm0, %xmm2
xorpd %xmm4, %xmm4
ucomisd %xmm2, %xmm3
ja 0x15e38
callq 0x90d0
movapd %xmm0, %xmm4
mulsd 0x55218(%rip), %xmm4    # 0x6b048
divsd 0x55218(%rip), %xmm4    # 0x6b050
movq 0x20(%r14), %rax
subsd 0xb0(%rax), %xmm4
movsd 0x55214(%rip), %xmm0    # 0x6b060
ucomisd %xmm4, %xmm0
jbe 0x15e71
movsd 0x55216(%rip), %xmm1    # 0x6b070
addsd %xmm1, %xmm4
ucomisd %xmm4, %xmm0
ja 0x15e5a
jmp 0x15e95
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
ucomisd 0x551cf(%rip), %xmm4    # 0x6b048
jb 0x15e95
movsd 0x551e5(%rip), %xmm0    # 0x6b068
movsd 0x551bd(%rip), %xmm1    # 0x6b048
addsd %xmm0, %xmm4
ucomisd %xmm1, %xmm4
jae 0x15e8b
movsd %xmm4, -0x18(%rbp)
movq %rbx, %rdi
callq 0xef28
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xc632
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35b4a
movq 0x18(%rbx), %rsi
addq $0x8, %rsi
leaq 0x28(%r14), %rdx
leaq 0x55424(%rip), %rcx     # 0x6ba31
movq %rax, %rdi
movl $0x1, %r8d
callq 0x36462
cmpl $0xa, 0x98(%r14)
jne 0x16658
callq 0x1f5e8
movq 0x8(%rbx), %rdx
movsd 0x20(%r14), %xmm0
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2182c
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0xb38c
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2ddfa
movq 0x8(%rbx), %rsi
movsd 0x20(%r14), %xmm0
movsd 0x55351(%rip), %xmm1    # 0x6b9c0
movq %rax, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x31b82
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x57e2a
movsd -0x18(%rbp), %xmm0
addsd 0x547ae(%rip), %xmm0    # 0x6b780
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x16ff3
xorl %esi, %esi
subl 0x78(%rbx), %esi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x58f34
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
je 0x1700b
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 0x58f34
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35b4a
movq 0x18(%r14), %rdx
addq $0x8, %rdx
leaq 0x28(%r15), %rbx
leaq 0x53a04(%rip), %r8      # 0x6bc61
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rcx
movl $0x1, %r9d
callq 0x3650e
movl 0x98(%r15), %eax
cmpl $0x4, %eax
je 0x182b9
cmpl $0x3, %eax
jne 0x18399
callq 0x2ddfa
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 0x30f74
callq 0x4df3a
movq 0x8(%r14), %rsi
addq $0x20, %r15
movq %rax, %rdi
movq %r15, %rdx
callq 0x4ecac
testb %al, %al
je 0x18364
callq 0x4df3a
movq 0x8(%r14), %rsi
movsd (%r15), %xmm0
movq %rax, %rdi
callq 0x4e614
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1830b
sqrtsd %xmm0, %xmm0
jmp 0x18310
callq 0x93c0
movsd %xmm0, -0x28(%rbp)
callq 0x2ddfa
movq 0x8(%r14), %rsi
leaq -0x2c(%rbp), %rcx
movl $0x1, (%rcx)
movq %rax, %rdi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2eb5c
addsd 0x538cf(%rip), %xmm0    # 0x6bc10
movsd -0x28(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x18364
callq 0x4df3a
movq 0x8(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x4ecf0
jmp 0x18396
callq 0x2ddfa
movq %rax, %r15
movq 0x8(%r14), %r14
callq 0x4a75c
movsd 0x30f8(%rax), %xmm0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x30f74
movl %eax, %r12d
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/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 0x57e2a
movq 0x8(%r14), %rcx
movq 0x8(%rax), %rdx
cmpl $0x1, %r15d
jne 0x19736
movsd -0x20(%rbp), %xmm0
addsd 0x52546(%rip), %xmm0    # 0x6bc20
movsd %xmm0, -0x20(%rbp)
cmpq %rcx, %rdx
jne 0x196f4
movl 0x58(%rbx), %esi
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x58f34
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x19715
xorl %esi, %esi
subl 0x78(%rbx), %esi
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x58f34
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x19795
xorl %esi, %esi
subl 0x88(%rbx), %esi
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
jmp 0x197b0
movsd 0x52042(%rip), %xmm0    # 0x6b780
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
cmpq %rcx, %rdx
jne 0x1975d
movl 0x58(%rbx), %esi
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x58f34
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x19786
movsd -0x20(%rbp), %xmm0
addsd 0x524a7(%rip), %xmm0    # 0x6bc20
xorl %esi, %esi
subl 0x78(%rbx), %esi
movq %rax, %rdi
callq 0x58f34
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
je 0x197a0
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 0x58f34
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35b4a
movq 0x20(%r14), %rsi
addq $0x8, %rsi
leaq 0x28(%rbx), %rdx
leaq 0x519f8(%rip), %rcx     # 0x6be19
movq %rax, %rdi
callq 0x35fea
callq 0x1f5e8
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 0x2157e
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movsd 0x8(%rax), %xmm0
subsd 0x17a0(%rcx), %xmm0
andpd 0x504a9(%rip), %xmm0    # 0x6b010
movsd 0x50bc9(%rip), %xmm1    # 0x6b738
ucomisd %xmm0, %xmm1
jbe 0x1aba0
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x1aba0
movq 0x28(%rbx), %rcx
xorl %esi, %esi
subl 0x1798(%rcx), %esi
movsd 0x51088(%rip), %xmm0    # 0x6bc20
movq %rax, %rdi
callq 0x58f34
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdi
movl 0x11c(%rax), %r14d
callq 0x48db8
movq (%rax), %rax
cmpl (%rax), %r14d
je 0x1abd9
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdi
movl 0x11c(%rax), %r14d
callq 0x48db8
movq (%rax), %rax
cmpl 0x4(%rax), %r14d
jne 0x1abe8
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%rbx), %rcx
je 0x1abed
popq %rbx
popq %r14
popq %rbp
retq
movsd 0x50b8b(%rip), %xmm0    # 0x6b780
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x59178
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ad5e
cmpl $0x10, %eax
je 0x1adce
cmpl $0xf, %eax
je 0x1ad99
movq 0x6c2c7(%rip), %rbx     # 0x86ff0
leaq 0x5118f(%rip), %rsi     # 0x6bebf
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x5447e(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x45, %esi
jmp 0x1ae3d
cmpl $0xf, %eax
je 0x1ad99
cmpl $0x10, %eax
je 0x1adff
cmpl $0x11, %eax
jne 0x1ae06
callq 0x1f5e8
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 0x21d26
movq 0x8(%rbx), %rdi
movsd 0x28(%rsi), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x30(%rsi), %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0xef28
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xc6ea
callq 0x57e2a
movq 0x8(%rbx), %rdi
cmpq %rdi, 0x8(%rax)
jne 0x1ade4
movb $0x1, 0x63b(%rax)
callq 0xef28
movsd 0x5108f(%rip), %xmm0    # 0x6be80
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xbc38
movb $0x1, %al
jmp 0x1ae96
movq 0x6c1e3(%rip), %rbx     # 0x86ff0
leaq 0x510ab(%rip), %rsi     # 0x6bebf
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x5439a(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x51, %esi
callq 0x9880
movq %rax, %rbx
leaq 0x52633(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x5107a(%rip), %rsi     # 0x6beda
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_O1/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 0x35b4a
movq 0x18(%r14), %rsi
addq $0x8, %rsi
leaq 0x28(%rbx), %r15
leaq 0x509ff(%rip), %rcx     # 0x6bf8b
movq %rax, %rdi
movq %r15, %rdx
callq 0x36094
cmpl $0x9, 0x98(%rbx)
jne 0x1b5c4
callq 0x4df3a
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 0x4ecf0
callq 0x2ddfa
movq %rax, %rbx
movq 0x8(%r14), %r14
callq 0x4a75c
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 0x30f74
nop