LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Clang::Plan(int, int)
void Clang::Plan(int min_ver, int max_ver) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  mCommandInfo.mMinVer = min_ver;
  mCommandInfo.mMaxVer = max_ver;
  std::ostringstream cmd_str;
  cmd_str << "(clang (ver " << mCommandInfo.mMinVer << " "
          << mCommandInfo.mMaxVer << "))";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x1c(%rax)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xa800
movq -0x1c8(%rbp), %rdi
leaq 0xab22a(%rip), %rsi     # 0xc12f9
callq 0xa5a0
movq %rax, -0x1c0(%rbp)
jmp 0x160dd
movq -0x1c0(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movl 0x18(%rax), %esi
callq 0xaa40
movq %rax, -0x1d8(%rbp)
jmp 0x160fc
movq -0x1d8(%rbp), %rdi
leaq 0xaebd2(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x1e0(%rbp)
jmp 0x16118
movq -0x1e0(%rbp), %rdi
movq -0x1d0(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xaa40
movq %rax, -0x1e8(%rbp)
jmp 0x16137
movq -0x1e8(%rbp), %rdi
leaq 0xac85e(%rip), %rsi     # 0xc29a3
callq 0xa5a0
jmp 0x1614c
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa600
jmp 0x16161
movq -0x1d0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xa760
leaq -0x1b8(%rbp), %rdi
callq 0xa370
leaq -0x188(%rbp), %rdi
callq 0xa190
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa190
movq -0x190(%rbp), %rdi
callq 0xaa60
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Ear::Plan(bool, bool, EarMode)
void Ear::Plan(bool on, bool our_side, EarMode ear_mode) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();

  const char *on_string;
  const char *side_string;
  const char *ear_mode_string;

  if (on == true) {
    on_string = "on";
  } else {
    on_string = "off";
  }

  if (our_side) {
    side_string = " our";
  } else {
    side_string = " opp";
  }

  if (ear_mode == EM_Partial) {
    ear_mode_string = " partial";
  } else if (ear_mode == EM_Complete) {
    ear_mode_string = " complete";
  } else {
    ear_mode_string = "";
  }

  std::ostringstream cmd_str;
  cmd_str << "(ear (" << on_string << side_string << ear_mode_string << "))";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movb %dl, %al
movb %sil, %dl
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movl %ecx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d8(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x16289
leaq 0xaf0f4(%rip), %rax     # 0xc5377
movq %rax, -0x18(%rbp)
jmp 0x16294
leaq 0xaf0d4(%rip), %rax     # 0xc5364
movq %rax, -0x18(%rbp)
testb $0x1, -0xa(%rbp)
je 0x162a7
leaq 0xab065(%rip), %rax     # 0xc1306
movq %rax, -0x20(%rbp)
jmp 0x162b2
leaq 0xab05d(%rip), %rax     # 0xc130b
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0x162c5
leaq 0xab051(%rip), %rax     # 0xc1310
movq %rax, -0x28(%rbp)
jmp 0x162e5
cmpl $0x2, -0x10(%rbp)
jne 0x162d8
leaq 0xab047(%rip), %rax     # 0xc1319
movq %rax, -0x28(%rbp)
jmp 0x162e3
leaq 0xac3e6(%rip), %rax     # 0xc26c5
movq %rax, -0x28(%rbp)
jmp 0x162e5
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0xa800
movq -0x1e8(%rbp), %rdi
leaq 0xab01d(%rip), %rsi     # 0xc1323
callq 0xa5a0
movq %rax, -0x1e0(%rbp)
jmp 0x16314
movq -0x1e0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa5a0
movq %rax, -0x1f0(%rbp)
jmp 0x1632d
movq -0x1f0(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa5a0
movq %rax, -0x1f8(%rbp)
jmp 0x16346
movq -0x1f8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa5a0
movq %rax, -0x200(%rbp)
jmp 0x1635f
movq -0x200(%rbp), %rdi
leaq 0xac636(%rip), %rsi     # 0xc29a3
callq 0xa5a0
jmp 0x16374
leaq -0x1d0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xa600
jmp 0x16389
movq -0x1d8(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xa760
leaq -0x1d0(%rbp), %rdi
callq 0xa370
leaq -0x1a0(%rbp), %rdi
callq 0xa190
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0xa190
movq -0x1a8(%rbp), %rdi
callq 0xaa60
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: SynchSee::Plan()
void SynchSee::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(synch_see)";
  mCommandInfo.mString = cmd_str.str();
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1e0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0xa800
movq -0x1d8(%rbp), %rdi
leaq 0xaae8d(%rip), %rsi     # 0xc132a
callq 0xa5a0
jmp 0x164a4
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xa600
jmp 0x164b9
movq -0x1e0(%rbp), %rdi
addq $0x60, %rdi
leaq -0x1b0(%rbp), %rsi
movq %rsi, -0x1e8(%rbp)
callq 0xa760
movq -0x1e8(%rbp), %rdi
callq 0xa370
leaq -0x1d0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xa600
jmp 0x164f8
movq -0x1e0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xa760
leaq -0x1d0(%rbp), %rdi
callq 0xa370
leaq -0x180(%rbp), %rdi
callq 0xa190
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa190
movq -0x188(%rbp), %rdi
callq 0xaa60
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: ChangePlayerType::Plan(int, int)
void ChangePlayerType::Plan(Unum num, int player_type) {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(change_player_type " << num << " " << player_type << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xa800
movq -0x1c8(%rbp), %rdi
leaq 0xaad23(%rip), %rsi     # 0xc1336
callq 0xa5a0
movq %rax, -0x1c0(%rbp)
jmp 0x16621
movq -0x1c0(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaa40
movq %rax, -0x1d8(%rbp)
jmp 0x16639
movq -0x1d8(%rbp), %rdi
leaq 0xae695(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x1e0(%rbp)
jmp 0x16655
movq -0x1e0(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xaa40
movq %rax, -0x1e8(%rbp)
jmp 0x1666d
movq -0x1e8(%rbp), %rdi
leaq 0xaab95(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x16682
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa600
jmp 0x16697
movq -0x1d0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xa760
leaq -0x1b8(%rbp), %rdi
callq 0xa370
leaq -0x188(%rbp), %rdi
callq 0xa190
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa190
movq -0x190(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: ChangePlayerType::Plan(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void ChangePlayerType::Plan(std::string teamname, Unum num, int player_type) {
  mCommandInfo.mType = CT_ChangePlayerTypeForTrainer;
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(change_player_type " << teamname << " " << num << " "
          << player_type << ")";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rsi, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movl $0x15, 0x10(%rax)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d8(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0xa800
movq -0x1d0(%rbp), %rdi
leaq 0xaabc1(%rip), %rsi     # 0xc1336
callq 0xa5a0
movq %rax, -0x1c8(%rbp)
jmp 0x16783
movq -0x1e0(%rbp), %rsi
movq -0x1c8(%rbp), %rdi
callq 0xa4f0
movq %rax, -0x1e8(%rbp)
jmp 0x1679f
movq -0x1e8(%rbp), %rdi
leaq 0xae52f(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x1f0(%rbp)
jmp 0x167bb
movq -0x1f0(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xaa40
movq %rax, -0x1f8(%rbp)
jmp 0x167d3
movq -0x1f8(%rbp), %rdi
leaq 0xae4fb(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x200(%rbp)
jmp 0x167ef
movq -0x200(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xaa40
movq %rax, -0x208(%rbp)
jmp 0x16807
movq -0x208(%rbp), %rdi
leaq 0xaa9fb(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x1681c
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xa600
jmp 0x16831
movq -0x1d8(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xa760
leaq -0x1c0(%rbp), %rdi
callq 0xa370
leaq -0x190(%rbp), %rdi
callq 0xa190
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0xa190
movq -0x198(%rbp), %rdi
callq 0xaa60
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BasicCommand.cpp
// Function: Start::Plan()
void Start::Plan() {
  mCommandInfo.mTime = mAgent.GetWorldState().CurrentTime();
  std::ostringstream cmd_str;
  cmd_str << "(start)";
  mCommandInfo.mString = cmd_str.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xa800
movq -0x1b8(%rbp), %rdi
leaq 0xaa9fe(%rip), %rsi     # 0xc134b
callq 0xa5a0
jmp 0x16954
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xa600
jmp 0x16969
movq -0x1c0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa760
leaq -0x1b0(%rbp), %rdi
callq 0xa370
leaq -0x180(%rbp), %rdi
callq 0xa190
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa190
movq -0x188(%rbp), %rdi
callq 0xaa60
nop
// File: 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
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1d0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xa800
movq -0x1c8(%rbp), %rdi
leaq 0xaa8d3(%rip), %rsi     # 0xc1353
callq 0xa5a0
movq %rax, -0x1c0(%rbp)
jmp 0x16a8e
callq 0x9ed90
movq %rax, -0x1d8(%rbp)
jmp 0x16a9c
movq -0x1d8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xa1580
movq %rax, -0x1e0(%rbp)
jmp 0x16ab4
movq -0x1e0(%rbp), %rsi
movq -0x1c0(%rbp), %rdi
callq 0xa5a0
movq %rax, -0x1e8(%rbp)
jmp 0x16ad0
movq -0x1e8(%rbp), %rdi
leaq 0xaa732(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x16ae5
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa600
jmp 0x16afa
movq -0x1d0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xa760
leaq -0x1b8(%rbp), %rdi
callq 0xa370
leaq -0x188(%rbp), %rdi
callq 0xa190
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa190
movq -0x190(%rbp), %rdi
callq 0xaa60
// File: 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
subq $0x250, %rsp            # imm = 0x250
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1e8(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0xa800
movq -0x1e0(%rbp), %rdi
leaq 0xaa41f(%rip), %rsi     # 0xc1370
callq 0xa5a0
movq %rax, -0x1d8(%rbp)
jmp 0x16f5f
leaq -0x10(%rbp), %rdi
callq 0x176f0
movq %rax, -0x1f0(%rbp)
jmp 0x16f71
movq -0x1d8(%rbp), %rdi
movq -0x1f0(%rbp), %rax
movsd (%rax), %xmm0
callq 0xab60
movq %rax, -0x1f8(%rbp)
jmp 0x16f91
movq -0x1f8(%rbp), %rdi
leaq 0xadd3d(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x200(%rbp)
jmp 0x16fad
leaq -0x10(%rbp), %rdi
callq 0x17700
movq %rax, -0x208(%rbp)
jmp 0x16fbf
movq -0x200(%rbp), %rdi
movq -0x208(%rbp), %rax
movsd (%rax), %xmm0
callq 0xab60
movq %rax, -0x210(%rbp)
jmp 0x16fdf
movq -0x210(%rbp), %rdi
leaq 0xadcef(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x218(%rbp)
jmp 0x16ffb
movq -0x218(%rbp), %rdi
leaq 0xaa375(%rip), %rsi     # 0xc137e
callq 0xa5a0
movq %rax, -0x220(%rbp)
jmp 0x17017
leaq -0x20(%rbp), %rdi
callq 0x176f0
movq %rax, -0x228(%rbp)
jmp 0x17029
movq -0x220(%rbp), %rdi
movq -0x228(%rbp), %rax
movsd (%rax), %xmm0
callq 0xab60
movq %rax, -0x230(%rbp)
jmp 0x17049
movq -0x230(%rbp), %rdi
leaq 0xadc85(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, -0x238(%rbp)
jmp 0x17065
leaq -0x20(%rbp), %rdi
callq 0x17700
movq %rax, -0x240(%rbp)
jmp 0x17077
movq -0x238(%rbp), %rdi
movq -0x240(%rbp), %rax
movsd (%rax), %xmm0
callq 0xab60
movq %rax, -0x248(%rbp)
jmp 0x17097
movq -0x248(%rbp), %rdi
leaq 0xaa16b(%rip), %rsi     # 0xc1210
callq 0xa5a0
jmp 0x170ac
leaq -0x1d0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xa600
jmp 0x170c1
movq -0x1e8(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xa760
leaq -0x1d0(%rbp), %rdi
callq 0xa370
leaq -0x1a0(%rbp), %rdi
callq 0xa190
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0xa190
movq -0x1a8(%rbp), %rdi
callq 0xaa60
nopw (%rax,%rax)
// File: 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
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xa800
movq -0x1b8(%rbp), %rdi
leaq 0xaa1a5(%rip), %rsi     # 0xc1382
callq 0xa5a0
jmp 0x171e4
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xa600
jmp 0x171f9
movq -0x1c0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa760
leaq -0x1b0(%rbp), %rdi
callq 0xa370
leaq -0x180(%rbp), %rdi
callq 0xa190
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa190
movq -0x188(%rbp), %rdi
callq 0xaa60
nop
// File: 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
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xa800
movq -0x1b8(%rbp), %rdi
leaq 0xaa07c(%rip), %rsi     # 0xc1389
callq 0xa5a0
jmp 0x17314
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xa600
jmp 0x17329
movq -0x1c0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa760
leaq -0x1b0(%rbp), %rdi
callq 0xa370
leaq -0x180(%rbp), %rdi
callq 0xa190
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa190
movq -0x188(%rbp), %rdi
callq 0xaa60
nop
// File: 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
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xa800
movq -0x1b8(%rbp), %rdi
leaq 0xa9f59(%rip), %rsi     # 0xc1396
callq 0xa5a0
jmp 0x17444
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xa600
jmp 0x17459
movq -0x1c0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa760
leaq -0x1b0(%rbp), %rdi
callq 0xa370
leaq -0x180(%rbp), %rdi
callq 0xa190
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa190
movq -0x188(%rbp), %rdi
callq 0xaa60
nop
// File: 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
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq %rax, %rcx
movq -0x1c0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xa800
movq -0x1b8(%rbp), %rdi
leaq 0xa9e33(%rip), %rsi     # 0xc13a0
callq 0xa5a0
jmp 0x17574
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xa600
jmp 0x17589
movq -0x1c0(%rbp), %rdi
addq $0x10, %rdi
addq $0x50, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xa760
leaq -0x1b0(%rbp), %rdi
callq 0xa370
leaq -0x180(%rbp), %rdi
callq 0xa190
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa190
movq -0x188(%rbp), %rdi
callq 0xaa60
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x1a020
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x1a620
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x13cd0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl (%rax), %edx
callq 0x1a0b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1a003
callq 0x5add0
movq %rax, %rdi
leaq 0xa75e1(%rip), %rsi     # 0xc1511
callq 0x5b110
movq -0x40(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x1a620
movq %rax, %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movq %rax, %rdi
leaq 0xaad74(%rip), %rsi     # 0xc4cdc
callq 0x1a690
movq %rax, -0x50(%rbp)
callq 0x1a020
movq -0x40(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x13cd0
movq -0x58(%rbp), %rdi
movl (%rax), %esi
callq 0x1a730
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x1a6e0
movq %rax, %rdi
leaq 0xa7567(%rip), %rsi     # 0xc1510
callq 0x1a770
movq %rax, %rdi
movq 0xe3ff8(%rip), %rsi     # 0xfdfb0
callq 0x1a7c0
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
xorps %xmm0, %xmm0
callq *0x18(%rax)
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x19ff9
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1a007
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x1a0db
movq $0x0, -0x8(%rbp)
jmp 0x1a119
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1a970
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1a111
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x1a119
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x1a020
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x1a620
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x13cd0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl (%rax), %edx
callq 0x1a0b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1a25b
callq 0x5add0
movq %rax, %rdi
leaq 0xa737c(%rip), %rsi     # 0xc1511
callq 0x5b110
movq -0x38(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x1a620
movq %rax, %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movq %rax, %rdi
leaq 0xaab0f(%rip), %rsi     # 0xc4cdc
callq 0x1a690
movq %rax, -0x48(%rbp)
callq 0x1a020
movq -0x38(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x13cd0
movq -0x50(%rbp), %rdi
movl (%rax), %esi
callq 0x1a730
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x1a6e0
movq %rax, %rdi
leaq 0xa730d(%rip), %rsi     # 0xc151b
callq 0x1a810
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x1a860
movq %rax, %rdi
movq 0xe3d87(%rip), %rsi     # 0xfdfb0
callq 0x1a7c0
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1a259
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1a25b
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x1a3b4
cmpl $0xd, -0x14(%rbp)
jge 0x1a3b4
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1a970
cmpq $0x0, (%rax)
jne 0x1a3b2
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x1a970
movq -0x58(%rbp), %rcx
movq -0x48(%rbp), %rdi
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x70, %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x1a990
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0xa810
movb $0x1, -0x1(%rbp)
jmp 0x1a3b8
jmp 0x1a3b4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x8(%rax)
je 0x1a3f4
movq -0x28(%rbp), %rax
cmpl $0xc, 0x8(%rax)
jne 0x1a469
cmpb $0x0, 0xe6815(%rip)     # 0x100c10
jne 0x1a442
leaq 0xe680c(%rip), %rdi     # 0x100c10
callq 0xaad0
cmpl $0x0, %eax
je 0x1a442
leaq 0xe6683(%rip), %rdi     # 0x100a98
callq 0x7c090
jmp 0x1a41c
leaq -0x7f23(%rip), %rdi     # 0x12500
leaq 0xe666e(%rip), %rsi     # 0x100a98
leaq 0xe41e7(%rip), %rdx     # 0xfe618
callq 0xa4e0
leaq 0xe67d3(%rip), %rdi     # 0x100c10
callq 0xa390
leaq 0xe664f(%rip), %rax     # 0x100a98
movq %rax, -0x8(%rbp)
jmp 0x1a486
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq 0xe67ae(%rip), %rdi     # 0x100c10
callq 0xa380
jmp 0x1a490
movq -0x28(%rbp), %rdi
callq 0x1a9b0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x1a9d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq 0x28(%rax), %rdi
callq 0x1b410
movl %eax, %ecx
movq -0xc8(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq 0x10(%rax), %rdi
callq 0x10ed0
cmpl $0x27, %eax
jl 0x1b06b
movq -0xc8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10ed0
cmpl $0x2c, %eax
jg 0x1b06b
jmp 0x1b16b
movq -0xc8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0xcc(%rbp)
movq 0x20(%rax), %rdi
callq 0x1b470
movl %eax, %ecx
movl -0xcc(%rbp), %eax
cmpl %ecx, %eax
je 0x1b0c8
movq -0xc8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1b490
movl %eax, %ecx
movq -0xc8(%rbp), %rax
movl %ecx, -0xd0(%rbp)
movq 0x38(%rax), %rdi
callq 0x1b4b0
movl %eax, %ecx
movl -0xd0(%rbp), %eax
cmpl %ecx, %eax
jg 0x1b16b
movq -0xc8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0xc0(%rbp), %rdi
movl $0xb, %edx
xorl %ecx, %ecx
callq 0x1b4d0
movq -0xc8(%rbp), %rax
movsd 0xa5f2b(%rip), %xmm0    # 0xc1020
movsd %xmm0, -0x20(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0xd8(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x12b60
movq -0xd8(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x7c940
movq -0xc8(%rbp), %rax
movsd %xmm0, -0x88(%rbp)
movq 0x48(%rax), %rax
movq 0x40(%rax), %rcx
movq %rcx, -0x98(%rbp)
movq 0x48(%rax), %rax
movq %rax, -0x90(%rbp)
movsd 0xa6445(%rip), %xmm0    # 0xc1598
movsd %xmm0, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x189a0
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0xb0, %rsp
leaq -0x20(%rbp), %rdi
callq 0xa820
leaq -0x41(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xaa70
movq -0x90(%rbp), %rdx
leaq 0xa6428(%rip), %rsi     # 0xc15da
leaq -0x40(%rbp), %rdi
callq 0x1a540
jmp 0x1b1bd
leaq -0x41(%rbp), %rdi
callq 0xa650
leaq -0x40(%rbp), %rdi
leaq 0xa6462(%rip), %rsi     # 0xc1633
xorl %eax, %eax
movl %eax, %edx
callq 0xabf0
movq %rax, -0x60(%rbp)
cmpq $-0x1, -0x60(%rbp)
je 0x1b2ce
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x68(%rbp)
movb %al, -0x91(%rbp)
je 0x1b23b
movq -0x68(%rbp), %rsi
movq %rsi, %rax
decq %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xac00
movq %rax, -0xa0(%rbp)
jmp 0x1b220
movq -0xa0(%rbp), %rax
movsbl (%rax), %edi
callq 0xa980
cmpl $0x0, %eax
setne %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x1b247
jmp 0x1b27d
jmp 0x1b1f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0xa650
jmp 0x1b32b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa370
jmp 0x1b32b
movq -0x68(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x1b2cc
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
subq %rdx, %rcx
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xa610
jmp 0x1b2b0
leaq -0x20(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xa760
leaq -0x88(%rbp), %rdi
callq 0xa370
jmp 0x1b2ce
callq 0x1a020
movq %rax, -0xa8(%rbp)
jmp 0x1b2dc
leaq -0x20(%rbp), %rdi
callq 0xa240
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
leaq 0x42a(%rip), %rdx       # 0x1b720
movl $0xb, %esi
callq 0x1a310
movb %al, -0xa9(%rbp)
jmp 0x1b308
leaq -0x40(%rbp), %rdi
callq 0xa370
leaq -0x20(%rbp), %rdi
callq 0xa370
movb -0xa9(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0xa370
movq -0x50(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: 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
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x188(%rbp)
movq 0x8(%rax), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x1e1d0
movq -0x180(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e260
jmp 0x1b984
leaq -0x78(%rbp), %rdi
callq 0x1e210
movq -0x188(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0x1af80
movq -0x190(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b010
jmp 0x1b9bd
leaq -0xf0(%rbp), %rdi
callq 0x1afc0
movq -0x188(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x158(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x21c50
movq -0x198(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21ce0
jmp 0x1b9f9
leaq -0x158(%rbp), %rdi
callq 0x21c90
movq -0x188(%rbp), %rdi
addq $0x50, %rdi
callq 0x18580
testb $0x1, %al
jne 0x1bb71
movq -0x188(%rbp), %rdi
addq $0x50, %rdi
callq 0x185a0
movq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x1a0(%rbp)
addq $0x50, %rdi
callq 0x189e0
movq -0x1a0(%rbp), %rdi
movq %rax, %rsi
callq 0x189a0
movq -0x188(%rbp), %rdi
addq $0x50, %rdi
callq 0x18a10
cmpq $0x1, %rax
jbe 0x1bb6f
movq -0x188(%rbp), %rdi
movsd 0xa5590(%rip), %xmm0    # 0xc1010
movsd %xmm0, -0x168(%rbp)
addq $0x50, %rdi
callq 0x18a40
movq %rax, -0x170(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x18a70
movq -0x188(%rbp), %rdi
addq $0x50, %rdi
callq 0x18ac0
movq %rax, -0x178(%rbp)
leaq -0x170(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x18a90
testb $0x1, %al
jne 0x1bad7
jmp 0x1bb6d
leaq -0x170(%rbp), %rdi
callq 0x18af0
movq %rax, %rdi
movsd -0x168(%rbp), %xmm0
callq 0x1a130
movsd 0xa59b5(%rip), %xmm0    # 0xc14b0
mulsd -0x168(%rbp), %xmm0
movsd %xmm0, -0x168(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x18a70
jmp 0x1baa4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1e210
jmp 0x1bb7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1afc0
jmp 0x1bb7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x21c90
jmp 0x1bb7a
jmp 0x1bb6f
jmp 0x1bb71
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
xorl %edx, %edx
subl 0x78(%rax), %edx
movsd 0xa3b02(%rip), %xmm0    # 0xc14b0
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
xorl %edx, %edx
subl 0x88(%rax), %edx
movsd 0xa3ad4(%rip), %xmm0    # 0xc14b0
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x5add0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq 0x20(%rax), %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
addq $0x28, %rdx
leaq 0xa3720(%rip), %rcx     # 0xc186b
callq 0x5b4d0
callq 0x2ec90
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0xa0(%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm3
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
xorl %edx, %edx
movl $0x1, %ecx
callq 0x30f80
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Geometry.h
// Function: Line::Line(Vector const&, Vector const&)
Line(const Vector &point1, const Vector &point2) {
    if (fabs(point1.X() - point2.X()) < FLOAT_EPS) {
      mA = 1.0;
      mB = 0.0;
      mC = -point1.X();
    } else {
      mA = (point2.Y() - point1.Y()) / (point2.X() - point1.X());
      mB = -1.0;
      mC = point1.Y() - point1.X() * mA;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x176f0
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x176f0
movsd -0x20(%rbp), %xmm1
subsd (%rax), %xmm1
movaps 0xa2059(%rip), %xmm0    # 0xc1060
pand %xmm0, %xmm1
movsd 0xa1ff5(%rip), %xmm0    # 0xc1008
ucomisd %xmm1, %xmm0
jbe 0x1f066
movq -0x28(%rbp), %rax
movsd 0xa1feb(%rip), %xmm0    # 0xc1010
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x176f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movsd (%rcx), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0x1f127
movq -0x18(%rbp), %rdi
callq 0x17700
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17700
movsd -0x48(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x176f0
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x176f0
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movq %rax, %rcx
movq -0x28(%rbp), %rax
subsd (%rcx), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd 0xa2759(%rip), %xmm0    # 0xc1828
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x17700
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x176f0
movsd -0x30(%rbp), %xmm1
movq %rax, %rcx
movq -0x28(%rbp), %rax
movsd (%rcx), %xmm0
movsd (%rax), %xmm2
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1efc0
movq -0x68(%rbp), %rdi
movsd 0xa1e9c(%rip), %xmm0    # 0xc1008
movsd %xmm0, -0x40(%rbp)
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x1f310
testb $0x1, %al
jne 0x1f184
jmp 0x1f18d
movb $0x1, -0x1(%rbp)
jmp 0x1f224
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x11a10
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x474f0
leaq -0x50(%rbp), %rdi
callq 0x176f0
movsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x176f0
movsd -0x80(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x20(%rbp), %rdi
callq 0x176f0
movsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x176f0
movsd -0x78(%rbp), %xmm0
movsd -0x70(%rbp), %xmm1
subsd (%rax), %xmm0
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xc, 0x98(%rax)
jne 0x1f669
callq 0x2ec90
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd 0xa19d5(%rip), %xmm2    # 0xc1020
movsd 0xa2085(%rip), %xmm3    # 0xc16d8
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x30f80
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1f70f
movq -0x18(%rbp), %rax
cmpl $0xd, 0x98(%rax)
jne 0x1f70b
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x18(%rax), %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x60(%rbp)
movq 0x20(%rax), %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10520
movq -0x48(%rbp), %rax
movsd %xmm0, -0x58(%rbp)
movq 0x20(%rax), %rdi
callq 0x11170
movsd -0x58(%rbp), %xmm0
subsd (%rax), %xmm0
movsd 0xa1943(%rip), %xmm1    # 0xc1030
movsd %xmm1, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x116b0
movq -0x50(%rbp), %rdi
callq 0x1fdb0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1f70f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x5add0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq 0x18(%rax), %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
addq $0x28, %rdx
leaq 0xa195e(%rip), %rcx     # 0xc19b9
movl $0x1, %r8d
callq 0x5b960
movq -0x18(%rbp), %rax
cmpl $0xa, 0x98(%rax)
jne 0x200ad
callq 0x2ec90
movq %rax, %rsi
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
leaq -0x48(%rbp), %rdi
callq 0x31340
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0xbef0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x200d8
callq 0x4ff20
movq %rax, %rdi
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd 0xa189a(%rip), %xmm1    # 0xc1968
callq 0x54e40
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
xorl %edx, %edx
subl 0x78(%rax), %edx
movsd 0xa0a12(%rip), %xmm0    # 0xc14b0
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
xorl %edx, %edx
subl 0x88(%rax), %edx
movsd 0xa09e4(%rip), %xmm0    # 0xc14b0
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)