LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetCloseTeammateToPlayer(int)
const vector<Unum> &PositionInfo::GetCloseTeammateToPlayer(Unum i) {
  int index = Unum2Index(i);
  if (mTeammate2PlayerList[index].empty()) {
    const vector<Unum> &player2player = GetClosePlayerToPlayer(i);
    for (vector<Unum>::const_iterator it = player2player.begin();
         it != player2player.end(); ++it) {
      if ((*it) > 0) {
        mTeammate2PlayerList[index].push_back(*it);
      }
    }
  }
  return mTeammate2PlayerList[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %esi
callq 0x81120
movq -0x48(%rbp), %rdi
movl %eax, -0x10(%rbp)
addq $0x1348, %rdi           # imm = 0x1348
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x80f90
movq %rax, %rdi
callq 0x1b5d0
testb $0x1, %al
jne 0x806bf
jmp 0x8074e
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x80570
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b670
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b6a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x818d0
testb $0x1, %al
jne 0x806fc
jmp 0x8074c
leaq -0x28(%rbp), %rdi
callq 0x81910
cmpl $0x0, (%rax)
jle 0x8073f
movq -0x48(%rbp), %rdi
addq $0x1348, %rdi           # imm = 0x1348
movslq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x80f90
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x81910
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x81810
jmp 0x80741
leaq -0x28(%rbp), %rdi
callq 0x81930
jmp 0x806dc
jmp 0x8074e
movq -0x48(%rbp), %rdi
addq $0x1348, %rdi           # imm = 0x1348
movslq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x80f90
addq $0x50, %rsp
popq %rbp
retq
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetCloseOpponentToPlayer(int)
const vector<Unum> &PositionInfo::GetCloseOpponentToPlayer(Unum i) {
  int index = Unum2Index(i);
  if (mOpponent2PlayerList[index].empty()) {
    const vector<Unum> &player2player = GetClosePlayerToPlayer(i);
    for (vector<Unum>::const_iterator it = player2player.begin();
         it != player2player.end(); ++it) {
      if ((*it) < 0) {
        mOpponent2PlayerList[index].push_back(-(*it));
      }
    }
  }
  return mOpponent2PlayerList[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0xc(%rbp), %esi
callq 0x81120
movq -0x50(%rbp), %rdi
movl %eax, -0x10(%rbp)
addq $0x1570, %rdi           # imm = 0x1570
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x80f90
movq %rax, %rdi
callq 0x1b5d0
testb $0x1, %al
jne 0x807bf
jmp 0x80859
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x80570
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b670
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b6a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x818d0
testb $0x1, %al
jne 0x807fc
jmp 0x80857
leaq -0x28(%rbp), %rdi
callq 0x81910
cmpl $0x0, (%rax)
jge 0x8084a
movq -0x50(%rbp), %rdi
addq $0x1570, %rdi           # imm = 0x1570
movslq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x80f90
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x81910
movq -0x58(%rbp), %rdi
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x3c(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0x81950
jmp 0x8084c
leaq -0x28(%rbp), %rdi
callq 0x81930
jmp 0x807dc
jmp 0x80859
movq -0x50(%rbp), %rdi
addq $0x1570, %rdi           # imm = 0x1570
movslq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x80f90
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetPlayerWithBallList()
const vector<Unum> &PositionInfo::GetPlayerWithBallList() {
  if (mPlayerWithBallList_UpdateTime != mpWorldState->CurrentTime()) {
    mPlayerWithBallList.clear();
    if (GetClosePlayerToBall().size() > 0) {
      for (unsigned int i = 0; i < GetClosePlayerToBall().size(); ++i) {
        Unum unum = GetClosePlayerToBall()[i];
        if (mpWorldState->GetPlayer(unum).IsKickable()) {
          mPlayerWithBallList.push_back(unum);
        }
      }
    }
    mPlayerWithBallList_UpdateTime = mpWorldState->CurrentTime();
  }
  return mPlayerWithBallList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, %rcx
addq $0x17f0, %rcx           # imm = 0x17F0
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rdi
callq 0x12100
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x175f0
testb $0x1, %al
jne 0x808c0
jmp 0x80997
movq -0x20(%rbp), %rdi
addq $0x17d8, %rdi           # imm = 0x17D8
callq 0x80f70
movq -0x20(%rbp), %rdi
callq 0x80230
movq %rax, %rdi
callq 0x1d7a0
cmpq $0x0, %rax
jbe 0x80979
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x80230
movq %rax, %rdi
callq 0x1d7a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x80977
movq -0x20(%rbp), %rdi
callq 0x80230
movq %rax, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x1b610
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x10(%rbp)
movq 0x10(%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0x23eb0
movq %rax, %rdi
callq 0x10ef0
testb $0x1, %al
jne 0x80953
jmp 0x80967
movq -0x20(%rbp), %rdi
addq $0x17d8, %rdi           # imm = 0x17D8
leaq -0x10(%rbp), %rsi
callq 0x81810
jmp 0x80969
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x808f2
jmp 0x80979
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12100
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x17f0(%rax)
movq -0x20(%rbp), %rax
addq $0x17d8, %rax           # imm = 0x17D8
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetPlayerWithBall(double)
Unum PositionInfo::GetPlayerWithBall(const double buffer) {
  Unum tm_with_ball = GetTeammateWithBall(buffer);
  Unum opp_with_ball = GetOpponentWithBall(buffer);

  if (tm_with_ball > 0)
    return tm_with_ball;
  return -opp_with_ball;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x80a10
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x80b30
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x809f5
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x809fd
xorl %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetTeammateWithBall(double)
Unum PositionInfo::GetTeammateWithBall(const double buffer) {
  if (mpWorldState->GetBall().GetPosConf() < FLOAT_EPS) {
    return 0;
  }

  for (unsigned int i = 0; i < GetCloseTeammateToBall().size(); ++i) {
    Unum tm = GetCloseTeammateToBall()[i];
    if (mpWorldState->GetTeammate(tm).IsKickable(mpWorldState->GetBall(),
                                                 buffer)) {
      return tm;
    }
    if (GetBallDistToTeammate(tm) > 2.0)
      break; //（因为list是按距离顺序排好的，剩下的就不用了）
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rax), %rdi
callq 0x10570
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1d930
movsd 0x405c2(%rip), %xmm0    # 0xc1008
ucomisd (%rax), %xmm0
jbe 0x80a58
movl $0x0, -0x4(%rbp)
jmp 0x80b1f
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x802c0
movq %rax, %rdi
callq 0x1d7a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x80b18
movq -0x28(%rbp), %rdi
callq 0x802c0
movq %rax, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x1b610
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x20(%rbp)
movq 0x10(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12520
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rdi
callq 0x10570
movq -0x38(%rbp), %rdi
movq %rax, %rsi
leaq -0x18(%rbp), %rdx
callq 0x7c320
testb $0x1, %al
jne 0x80ae0
jmp 0x80ae8
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x80b1f
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x81980
movsd (%rax), %xmm0
movsd 0x409b0(%rip), %xmm1    # 0xc14b0
ucomisd %xmm1, %xmm0
jbe 0x80b08
jmp 0x80b18
jmp 0x80b0a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x80a5f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetOpponentWithBall(double)
Unum PositionInfo::GetOpponentWithBall(const double buffer) {
  if (mpWorldState->GetBall().GetPosConf() < FLOAT_EPS) {
    return 0;
  }

  for (unsigned int i = 0; i < GetCloseOpponentToBall().size(); ++i) {
    Unum opp = GetCloseOpponentToBall()[i];
    if (mpWorldState->GetOpponent(opp).IsKickable(mpWorldState->GetBall(),
                                                  buffer)) {
      return opp;
    }
    if (GetBallDistToOpponent(opp) > 2.0)
      break;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rax), %rdi
callq 0x10570
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1d930
movsd 0x404a2(%rip), %xmm0    # 0xc1008
ucomisd (%rax), %xmm0
jbe 0x80b78
movl $0x0, -0x4(%rbp)
jmp 0x80c3f
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x80370
movq %rax, %rdi
callq 0x1d7a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x80c38
movq -0x28(%rbp), %rdi
callq 0x80370
movq %rax, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x1b610
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x20(%rbp)
movq 0x10(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1d480
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rdi
callq 0x10570
movq -0x38(%rbp), %rdi
movq %rax, %rsi
leaq -0x18(%rbp), %rdx
callq 0x7c320
testb $0x1, %al
jne 0x80c00
jmp 0x80c08
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x80c3f
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x819b0
movsd (%rax), %xmm0
movsd 0x40890(%rip), %xmm1    # 0xc14b0
ucomisd %xmm1, %xmm0
jbe 0x80c28
jmp 0x80c38
jmp 0x80c2a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x80b7f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetTeammateWithBall()
Unum PositionInfo::GetTeammateWithBall() {
  if (mpWorldState->GetBall().GetPosConf() < FLOAT_EPS) {
    return 0;
  }

  if (GetPlayerWithBallList().empty()) {
    return 0;
  } else {
    for (unsigned int i = 0; i < GetPlayerWithBallList().size(); ++i) {
      if (GetPlayerWithBallList()[i] > 0) {
        return GetPlayerWithBallList()[i];
      }
    }
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rdi
callq 0x10570
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1d930
movsd 0x40387(%rip), %xmm0    # 0xc1008
ucomisd (%rax), %xmm0
jbe 0x80c93
movl $0x0, -0x4(%rbp)
jmp 0x80d2a
movq -0x20(%rbp), %rdi
callq 0x80880
movq %rax, %rdi
callq 0x1b5d0
testb $0x1, %al
jne 0x80caa
jmp 0x80cb3
movl $0x0, -0x4(%rbp)
jmp 0x80d2a
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x80880
movq %rax, %rdi
callq 0x1d7a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x80d23
movq -0x20(%rbp), %rdi
callq 0x80880
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x1b610
cmpl $0x0, (%rax)
jle 0x80d16
movq -0x20(%rbp), %rdi
callq 0x80880
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x1b610
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x80d2a
jmp 0x80d18
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x80cba
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetOpponentWithBall()
Unum PositionInfo::GetOpponentWithBall() {
  if (mpWorldState->GetBall().GetPosConf() < FLOAT_EPS) {
    return 0;
  }

  if (GetPlayerWithBallList().empty()) {
    return 0;
  } else {
    for (unsigned int i = 0; i < GetPlayerWithBallList().size(); ++i) {
      if (GetPlayerWithBallList()[i] < 0) {
        return -GetPlayerWithBallList()[i];
      }
    }
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rdi
callq 0x10570
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1d930
movsd 0x40297(%rip), %xmm0    # 0xc1008
ucomisd (%rax), %xmm0
jbe 0x80d83
movl $0x0, -0x4(%rbp)
jmp 0x80e1f
movq -0x20(%rbp), %rdi
callq 0x80880
movq %rax, %rdi
callq 0x1b5d0
testb $0x1, %al
jne 0x80d9a
jmp 0x80da3
movl $0x0, -0x4(%rbp)
jmp 0x80e1f
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x80880
movq %rax, %rdi
callq 0x1d7a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x80e18
movq -0x20(%rbp), %rdi
callq 0x80880
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x1b610
cmpl $0x0, (%rax)
jge 0x80e0b
movq -0x20(%rbp), %rdi
callq 0x80880
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x1b610
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x80e1f
jmp 0x80e0d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x80daa
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ServerParam.cpp
// Function: ServerParam::init(int, char**)
void ServerParam::init(int argc, char **argv) {
  // std::cout << "Parsing Server Param From Cmd Line 1st Time..." << std::endl;
  ParseFromCmdLine(
      argc, argv); //首先分析命令行，因为有可能命令行里面改了配置文件的路径
  // std::cout << "Parsing Server Param From Config File " <<
  // M_server_conf_file.c_str() << "..." << std::endl;
  ParseFromConfigFile(M_server_conf_file.c_str()); //分析配置文件
  // std::cout << "Parsing Server Param From Cmd Line 2nd Time..." << std::endl;
  ParseFromCmdLine(
      argc, argv); //再次分析命令行，因为命令行有权更改配置文件里面的默认设置
  MaintainConsistency();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x704a0
movq -0x20(%rbp), %rdi
addq $0x33f0, %rdi           # imm = 0x33F0
callq 0xa240
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x706d0
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x704a0
movq -0x20(%rbp), %rdi
callq 0x85bc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Simulator.cpp
// Function: Simulator::Player::Act(AtomicAction const&)
void Simulator::Player::Act(const AtomicAction &act) {
  switch (act.mType) {
  case CT_Turn:
    Turn(GetTurnMoment(act.mTurnAngle, mPlayerType, mVel.Mod()));
    break;
  case CT_Dash:
    Dash(act.mDashPower, Dasher::GetDashDirIdx(act.mDashDir));
    break;
  case CT_Kick:
    Step();
    break;
  case CT_None:
    break;
  default:
    Assert(0);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x6, %rax
ja 0x88680
movq -0x20(%rbp), %rax
leaq 0x3c640(%rip), %rcx     # 0xc4c38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movl 0x38(%rdi), %eax
movl %eax, -0x34(%rbp)
addq $0x10, %rdi
callq 0x104e0
movl -0x34(%rbp), %edi
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
callq 0x10a00
movq -0x28(%rbp), %rdi
movsd %xmm0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x886f0
jmp 0x88682
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x323e0
movq -0x28(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
movl %eax, %esi
callq 0x88340
jmp 0x88682
movq -0x28(%rbp), %rdi
callq 0x88690
jmp 0x88682
jmp 0x88682
jmp 0x88682
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Simulator.h
// Function: Simulator::Player::Turn(double const&)
void Turn(const AngleDeg &moment) {
      mBodyDir = GetNormalizeAngleDeg(
          mBodyDir +
          GetNormalizeMoment(moment) / (1.0 + PlayerParam::instance()
                                                      .HeteroPlayer(mPlayerType)
                                                      .inertiaMoment() *
                                                  mVel.Mod()));
      Step();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10aa0
movsd %xmm0, -0x30(%rbp)
callq 0x798a0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x38, %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x12a00
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x10, %rdi
callq 0x104e0
movsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
movaps %xmm0, %xmm3
movsd -0x28(%rbp), %xmm0
mulsd %xmm3, %xmm2
movsd 0x3889f(%rip), %xmm3    # 0xc1010
addsd %xmm3, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd 0x388ab(%rip), %xmm1    # 0xc1030
movsd %xmm1, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x116b0
movq -0x20(%rbp), %rdi
movsd %xmm0, 0x20(%rdi)
callq 0x88690
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Strategy.cpp
// Function: Strategy::Strategy(Agent&)
Strategy::Strategy(Agent &agent) : DecisionData(agent) {
  mSituation = ST_Defense;
  mLastController = 0;

  mIsBallActuralKickable = false;
  mIsBallFree = false;
  mController = 0;
  mChallenger = 0;

  mForbiddenDribble = false;

  mIsPenaltyFirstStep = false;
  mPenaltyTaker = 0;
  mPenaltySetupTime = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x32d80
movq -0x38(%rbp), %rdi
leaq 0x75124(%rip), %rax     # 0xfdc50
movq %rax, (%rdi)
addq $0x54, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
jmp 0x88b41
movq -0x38(%rbp), %rdi
addq $0x90, %rdi
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11a10
jmp 0x88b6b
movq -0x38(%rbp), %rdi
addq $0xb0, %rdi
callq 0x4ac30
jmp 0x88b7d
movq -0x38(%rbp), %rax
movl $0x2, 0xa4(%rax)
movl $0x0, 0x5c(%rax)
movb $0x0, 0x40(%rax)
movb $0x0, 0x41(%rax)
movl $0x0, 0x48(%rax)
movl $0x0, 0x4c(%rax)
movb $0x0, 0xa8(%rax)
movb $0x0, 0x140(%rax)
movl $0x0, 0x148(%rax)
movl $0x0, 0x144(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x32eb0
movq -0x18(%rbp), %rdi
callq 0xaa60
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Strategy.cpp
// Function: Strategy::PenaltyAnalyze()
void Strategy::PenaltyAnalyze() {
  if (IsPenaltyPlayMode() == false) {
    return;
  }

  if (mWorldState.GetPlayModeTime() == mWorldState.CurrentTime()) {
    static Unum penalty_taker_seq[] = {1, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2};
    const PlayMode &play_mode = mWorldState.GetPlayMode();
    if (play_mode == PM_Our_Penalty_Setup) {
      while (penalty_taker_seq[++mPenaltySetupTime % TEAMSIZE] ==
             mWorldState.GetTeammateGoalieUnum())
        ;
      mPenaltyTaker = penalty_taker_seq[mPenaltySetupTime % TEAMSIZE];
    } else if (play_mode == PM_Opp_Penalty_Setup) {
      mPenaltyTaker = -1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x8b010
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x88f98
jmp 0x8907a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x253d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rdi
callq 0x12100
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x120a0
testb $0x1, %al
jne 0x88fce
jmp 0x8907a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10ed0
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
jne 0x8905f
jmp 0x88ff1
movq -0x20(%rbp), %rcx
movl 0x144(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x144(%rcx)
movl $0xb, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movslq %edx, %rdx
leaq 0x75666(%rip), %rcx     # 0xfe680
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x2c(%rbp)
movq 0x18(%rax), %rdi
callq 0x1eeb0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0x89034
jmp 0x88ff1
movq -0x20(%rbp), %rax
movl 0x144(%rax), %eax
movl $0xb, %ecx
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movslq %edx, %rdx
leaq 0x7562c(%rip), %rcx     # 0xfe680
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x148(%rax)
jmp 0x89078
movq -0x10(%rbp), %rax
cmpl $0x31, (%rax)
jne 0x89076
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x148(%rax) # imm = 0xFFFFFFFF
jmp 0x89078
jmp 0x8907a
addq $0x30, %rsp
popq %rbp
retq
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Strategy.cpp
// Function: Strategy::SetPlayAnalyse()
bool Strategy::SetPlayAnalyse() {
  PlayMode play_mode = mWorldState.GetPlayMode();
  if (play_mode == PM_Before_Kick_Off) {
    mIsBallFree = true;
    mController = mInfoState.GetPositionInfo().GetClosestPlayerToBall();
    return true;
  } else if (play_mode < PM_Our_Mode && play_mode > PM_Play_On) {
    mIsBallFree = true;
    if (mBallState.GetVel().Mod() < 0.16) { //如果有球速，说明已经发球了
      mController = mInfoState.GetPositionInfo().GetClosestTeammateToBall();
    }
    return true;
  } else if (play_mode > PM_Opp_Mode) {
    mIsBallFree = true;
    if (mBallState.GetVel().Mod() < 0.16) { //如果有球速，说明已经发球了
      mController = -mInfoState.GetPositionInfo().GetClosestOpponentToBall();
    }
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x18(%rax), %rdi
callq 0x10ed0
movl %eax, -0x14(%rbp)
cmpl $0x16, -0x14(%rbp)
jne 0x8a741
movq -0x20(%rbp), %rax
movb $0x1, 0x41(%rax)
movq 0x30(%rax), %rdi
callq 0x49590
movq %rax, %rdi
callq 0x8b270
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x48(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x8a7fb
cmpl $0x15, -0x14(%rbp)
jge 0x8a79b
cmpl $0x1, -0x14(%rbp)
jle 0x8a79b
movq -0x20(%rbp), %rax
movb $0x1, 0x41(%rax)
movq 0x20(%rax), %rdi
callq 0x10a80
movq %rax, %rdi
callq 0x104e0
movaps %xmm0, %xmm1
movsd 0x38107(%rip), %xmm0    # 0xc2878
ucomisd %xmm1, %xmm0
jbe 0x8a795
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x49590
movq %rax, %rdi
callq 0x1b410
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x48(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x8a7fb
cmpl $0x24, -0x14(%rbp)
jle 0x8a7f3
movq -0x20(%rbp), %rax
movb $0x1, 0x41(%rax)
movq 0x20(%rax), %rdi
callq 0x10a80
movq %rax, %rdi
callq 0x104e0
movaps %xmm0, %xmm1
movsd 0x380b3(%rip), %xmm0    # 0xc2878
ucomisd %xmm1, %xmm0
jbe 0x8a7ed
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x49590
movq %rax, %rdi
callq 0x1d4b0
movl %eax, %edx
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
subl %edx, %ecx
movl %ecx, 0x48(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x8a7fb
jmp 0x8a7f5
jmp 0x8a7f7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Strategy.cpp
// Function: Strategy::IsPenaltyPlayMode() const
bool Strategy::IsPenaltyPlayMode() const {
  const PlayMode &play_mode = mWorldState.GetPlayMode();
  return (play_mode == PM_Penalty_On_Our_Field) ||
         (play_mode == PM_Penalty_On_Opp_Field) ||
         (play_mode >= PM_Our_Penalty_Setup &&
          play_mode <= PM_Our_Penalty_Miss) ||
         (play_mode >= PM_Opp_Penalty_Setup &&
          play_mode <= PM_Opp_Penalty_Miss);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10ed0
movl %eax, -0x14(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0x17, (%rcx)
movb %al, -0x15(%rbp)
je 0x8b088
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0x1a, (%rcx)
movb %al, -0x15(%rbp)
je 0x8b088
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
jl 0x8b067
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0x12, (%rcx)
movb %al, -0x15(%rbp)
jle 0x8b088
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x31, (%rcx)
movb %al, -0x16(%rbp)
jl 0x8b082
movq -0x10(%rbp), %rax
cmpl $0x35, (%rax)
setle %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Tackler.cpp
// Function: Tackler::GetBallVelAfterTackle(Agent const&, double)
Vector Tackler::GetBallVelAfterTackle(const Agent &agent,
                                      AngleDeg tackle_angle) {
  UpdateTackleData(agent);

  tackle_angle = GetNormalizeAngleDeg(tackle_angle, 0.0);
  int idx1 = ang2idx(tackle_angle);       //下界
  int idx2 = ang2idx(tackle_angle + 1.0); //上界
  double rate = MinMax(0.0, idx2 - tackle_angle, 1.0);

  return mBallVelAfterTackle[idx1] * rate +
         mBallVelAfterTackle[idx2] * (1.0 - rate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq -0x20(%rbp), %rsi
callq 0x8b480
movsd -0x28(%rbp), %xmm0
movq $0x0, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x116b0
movq -0xb0(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x8c820
movq -0xb0(%rbp), %rdi
movl %eax, -0x34(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x35532(%rip), %xmm1    # 0xc1010
movsd %xmm1, -0xa0(%rbp)
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x8c820
movl %eax, -0x38(%rbp)
movq $0x0, -0x50(%rbp)
cvtsi2sdl -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x12a20
movq -0xb0(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
addq $0xb58, %rdi            # imm = 0xB58
movq %rdi, -0xa8(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x8c8d0
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x13320
movq -0xa8(%rbp), %rdi
movsd %xmm0, -0x70(%rbp)
movsd %xmm1, -0x68(%rbp)
movslq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x8c8d0
movsd -0xa0(%rbp), %xmm0
movq %rax, %rdi
movsd -0x48(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x98(%rbp)
leaq -0x98(%rbp), %rsi
callq 0x13320
movsd %xmm0, -0x88(%rbp)
movsd %xmm1, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x11360
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Tackler.cpp
// Function: Tackler::TackleToDir(Agent&, double const&, bool)
bool Tackler::TackleToDir(Agent &agent, const AngleDeg &dir, bool foul) {
  AngleDeg tackle_angle;
  if (GetTackleAngleToDir(agent, dir, &tackle_angle)) {
    agent.Tackle(tackle_angle, foul);
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x8c250
testb $0x1, %al
jne 0x8c306
jmp 0x8c322
movq -0x18(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x8cac0
movb $0x1, -0x1(%rbp)
jmp 0x8c326
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Thread.cpp
// Function: ThreadCondition::Wait(int)
bool ThreadCondition::Wait(int ms) {
  while (pthread_mutex_lock(&mMutex)) {
  }

  int ret = ETIMEDOUT;
  if (ms > 0) {
    timespec timeout;
    RealTime outtime = GetRealTime();
    outtime = outtime + ms;
    timeout.tv_sec = outtime.GetSec();
    timeout.tv_nsec = outtime.GetUsec() * 1000;
    while ((ret = pthread_cond_timedwait(&mCond, &mMutex, &timeout)) == EINTR) {
    }
  } else {
    ret = pthread_cond_wait(&mCond, &mMutex);
  }

  while (pthread_mutex_unlock(&mMutex)) {
  }
  return (ret == ETIMEDOUT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
callq 0xa8b0
cmpl $0x0, %eax
je 0x8ea4b
jmp 0x8ea37
movl $0x6e, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x8ead7
callq 0x9e560
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x781c0
movl -0xc(%rbp), %esi
leaq -0x30(%rbp), %rdi
callq 0x9e7e0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x64ce0
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x64d00
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, %rsi
addq $0x30, %rsi
leaq -0x20(%rbp), %rdx
callq 0xa900
movl %eax, -0x10(%rbp)
cmpl $0x4, %eax
jne 0x8ead5
jmp 0x8eab7
jmp 0x8eaea
movq -0x58(%rbp), %rdi
movq %rdi, %rsi
addq $0x30, %rsi
callq 0xa920
movl %eax, -0x10(%rbp)
jmp 0x8eaec
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
callq 0xa420
cmpl $0x0, %eax
je 0x8eb00
jmp 0x8eaec
cmpl $0x6e, -0x10(%rbp)
sete %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/TimeTest.cpp
// Function: TimeTest::TimeTest()
TimeTest::TimeTest() {
  mEventQueue.clear();
  mRecordQueue.clear();
  mIsExecute.clear();
  mIsBegin.clear();

  mUpdateTime = Time(-3, 0);
  mUnum = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x3fed0
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0x8fea0
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x38(%rbp)
callq 0x8fec0
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x30(%rbp)
callq 0x8fec0
movq -0x28(%rbp), %rdi
subq $-0x80, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
jmp 0x8ecf9
movq -0x48(%rbp), %rdi
callq 0x40070
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x8fee0
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
callq 0x8ff00
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
callq 0x8ff00
leaq -0x1c(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
jmp 0x8ed3b
movq -0x48(%rbp), %rax
movq -0x1c(%rbp), %rcx
movq %rcx, 0x80(%rax)
movl $0x0, 0x88(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8ff50
movq -0x38(%rbp), %rdi
callq 0x8ff50
movq -0x40(%rbp), %rdi
callq 0x8ff70
movq -0x28(%rbp), %rdi
callq 0x40100
movq -0x10(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/TimeTest.cpp
// Function: TimeTest::Begin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int TimeTest::Begin(std::string func_name) {
  int i = 0;
  if (PlayerParam::instance().TimeTest()) {
    for (; i < (int)mEventQueue.size(); ++i) {
      if (mEventQueue[i] == func_name) {
        break;
      }
    }

    if (i == (int)mEventQueue.size()) {
      TimeRecord time_record;
      mEventQueue.push_back(func_name);
      mRecordQueue.push_back(time_record);
      mIsExecute.push_back(false);
      mIsBegin.push_back(true);
      mRecordQueue[i].mBeginTime = GetRealTime();
    } else if (mIsBegin[i] == false) {
      mIsBegin[i] = true;
      mRecordQueue[i].mBeginTime = GetRealTime();
    } else {
      i = -1;
    }
  }
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x90040
testb $0x1, (%rax)
je 0x8fb0e
jmp 0x8f944
movq -0xd8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0xe4(%rbp)
callq 0x420b0
movq %rax, %rcx
movl -0xe4(%rbp), %eax
cmpl %ecx, %eax
jge 0x8f99a
movq -0xd8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x90000
movq -0xe0(%rbp), %rsi
movq %rax, %rdi
callq 0x5f640
testb $0x1, %al
jne 0x8f98b
jmp 0x8f98d
jmp 0x8f99a
jmp 0x8f98f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8f944
movq -0xd8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0xe8(%rbp)
callq 0x420b0
movq %rax, %rcx
movl -0xe8(%rbp), %eax
cmpl %ecx, %eax
jne 0x8fa5c
leaq -0x90(%rbp), %rdi
callq 0x90140
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdi
callq 0x40090
movq -0xd8(%rbp), %rdi
addq $0x18, %rdi
leaq -0x90(%rbp), %rsi
callq 0x901b0
movq -0xd8(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x90220
movq -0xd8(%rbp), %rdi
addq $0x58, %rdi
movl $0x1, %esi
callq 0x90220
callq 0x9e560
movq -0xd8(%rbp), %rdi
movq %rax, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x90020
movq %rax, %rdi
addq $0x60, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x64b40
jmp 0x8fb0c
movq -0xd8(%rbp), %rdi
addq $0x58, %rdi
movslq -0x14(%rbp), %rsi
callq 0x90060
movq %rax, -0xb0(%rbp)
movq %rdx, -0xa8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x900c0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8fb03
movq -0xd8(%rbp), %rdi
addq $0x58, %rdi
movslq -0x14(%rbp), %rsi
callq 0x90060
movq %rax, -0xc0(%rbp)
movq %rdx, -0xb8(%rbp)
leaq -0xc0(%rbp), %rdi
movl $0x1, %esi
callq 0x900f0
callq 0x9e560
movq -0xd8(%rbp), %rdi
movq %rax, -0xd0(%rbp)
movq %rdx, -0xc8(%rbp)
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x90020
movq %rax, %rdi
addq $0x60, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x64b40
jmp 0x8fb0a
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x8fb0c
jmp 0x8fb0e
movl -0x14(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/TimeTest.h
// Function: TimeCost::TimeCost()
TimeCost() {
    mNum = 0;
    mAveCost = 0;
    mMaxTime = Time(-3, 0);
    mMaxCost = 0;
    mMinTime = Time(-3, 0);
    mMinCost = 1000000;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
leaq -0x10(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq -0x18(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq $0xf4240, 0x28(%rax)    # imm = 0xF4240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::PlayerState::PlayerState(int, Vector, Vector, double, int)
Trainer::PlayerState::PlayerState(Unum num, Vector pos, Vector vel,
                                  AngleDeg dir, int type) {
  mUnum = num;
  mPos = pos;
  mVel = vel;
  mBodyDir = dir;
  mPlayerType = type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movsd %xmm4, -0x38(%rbp)
movl %edx, -0x3c(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x8, %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x11a10
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x11a10
movq -0x68(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x28(%rax)
movl -0x3c(%rbp), %ecx
movl %ecx, 0x30(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Trainer()
Trainer::Trainer() {
  mTrainTime = 0;
  mTrainCount = 0;
  mInitialized = false;
  mConverse = false;
  mPrepared = false;
  mHaveRcg = 0;
  mpEndCondition = new Trainer::Condition(this, ET_Null, 0, 0, 0x0, mConverse);
  mLastStopTime = 0;
  mpObserver->SetSelfUnum(TRAINER_UNUM);
  mInitialTime = 0;
  mPlayerStatesList.clear();
  mBallStateList.clear();
  mNeedOpponentList.clear();
  if (!PlayerParam::instance().ForcePenaltyMode()) {
    ReadConfigFile();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x27fa0
movq -0x28(%rbp), %rdi
leaq 0x6afcc(%rip), %rax     # 0xfdc90
movq %rax, (%rdi)
addq $0x120, %rdi            # imm = 0x120
movq %rdi, -0x48(%rbp)
callq 0x979b0
movq -0x28(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movq %rdi, -0x40(%rbp)
callq 0x43ba0
movq -0x28(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
movq %rdi, -0x38(%rbp)
callq 0x979d0
movq -0x28(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq %rdi, -0x30(%rbp)
callq 0x979f0
movq -0x28(%rbp), %rax
movl $0x0, 0x98(%rax)
movl $0x0, 0x9c(%rax)
movb $0x0, 0x30(%rax)
movb $0x0, 0x33(%rax)
movb $0x0, 0x31(%rax)
movb $0x0, 0x32(%rax)
movl $0x58, %edi
callq 0xa5c0
movq %rax, -0x20(%rbp)
jmp 0x92d4b
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
movzbl 0x33(%rsi), %r8d
andl $0x1, %r8d
xorl %edx, %edx
movl %edx, %ecx
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x97a10
jmp 0x92d6d
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x158(%rax)
movl $0x0, 0x194(%rax)
movq 0x8(%rax), %rdi
movl $0xc, %esi
callq 0x77b30
jmp 0x92d96
movq -0x28(%rbp), %rdi
movl $0x0, 0x138(%rdi)
addq $0x120, %rdi            # imm = 0x120
callq 0x97ab0
movq -0x28(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x97ad0
movq -0x28(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x80f70
callq 0x798a0
movq %rax, -0x50(%rbp)
jmp 0x92ddb
movq -0x50(%rbp), %rdi
callq 0x97af0
movq %rax, -0x58(%rbp)
jmp 0x92dea
movq -0x58(%rbp), %rax
testb $0x1, (%rax)
jne 0x92e2a
movq -0x28(%rbp), %rdi
callq 0x92e70
jmp 0x92dfe
jmp 0x92e2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x92e30
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x58, %esi
callq 0xa5e0
jmp 0x92e30
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x97b10
movq -0x38(%rbp), %rdi
callq 0x97b70
movq -0x40(%rbp), %rdi
callq 0x1f280
movq -0x48(%rbp), %rdi
callq 0x97bd0
movq -0x28(%rbp), %rdi
callq 0x281a0
movq -0x10(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Record()
void Trainer::Record() {
  //记录统计信息
  ofstream os;
  os.open("./train/train.report");
  if (mConverse)
    os << "Converse Train!!" << endl;
  os << "Total Train Count:" << mTrainCount << endl;
  mpEndCondition->Report(os);
  os.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x228(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0xaa30
movq -0x220(%rbp), %rdi
leaq 0x31f78(%rip), %rsi     # 0xc5253
movl $0x10, %edx
callq 0xa090
jmp 0x932e7
movq -0x228(%rbp), %rax
testb $0x1, 0x33(%rax)
je 0x9334a
leaq 0x31f6d(%rip), %rsi     # 0xc5268
leaq -0x208(%rbp), %rdi
callq 0xa5a0
movq %rax, -0x230(%rbp)
jmp 0x93310
movq -0x230(%rbp), %rdi
movq 0x6ac92(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x93325
jmp 0x9334a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0xa8c0
jmp 0x933dc
leaq 0x31f28(%rip), %rsi     # 0xc5279
leaq -0x208(%rbp), %rdi
callq 0xa5a0
movq %rax, -0x238(%rbp)
jmp 0x93366
movq -0x238(%rbp), %rdi
movq -0x228(%rbp), %rax
movl 0x9c(%rax), %esi
callq 0xa7f0
movq %rax, -0x240(%rbp)
jmp 0x93388
movq -0x240(%rbp), %rdi
movq 0x6ac1a(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x9339d
movq -0x228(%rbp), %rax
movq 0x158(%rax), %rdi
leaq -0x208(%rbp), %rsi
callq 0x97430
jmp 0x933b9
leaq -0x208(%rbp), %rdi
callq 0xa880
jmp 0x933c7
leaq -0x208(%rbp), %rdi
callq 0xa8c0
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0xaa60
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::SendOptionToServer()
void Trainer::SendOptionToServer() {
  while (!mpParser->IsEyeOnOk()) {
    UDPSocket::instance().Send("(eye on)");
    WaitFor(200);
  }

  while (!mpParser->IsEarOnOk()) {
    cout << "Send (ear on)" << endl;
    UDPSocket::instance().Send("(ear on)");
    WaitFor(200);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x293a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x93449
jmp 0x93469
callq 0x9e170
movq %rax, %rdi
leaq 0x2ebf0(%rip), %rsi     # 0xc2048
callq 0x9e4c0
movl $0xc8, %edi
callq 0x28840
jmp 0x93434
jmp 0x9346b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x97c50
xorb $-0x1, %al
testb $0x1, %al
jne 0x93480
jmp 0x934c2
movq 0x6ab39(%rip), %rdi     # 0xfdfc0
leaq 0x319fd(%rip), %rsi     # 0xc4e8b
callq 0xa5a0
movq %rax, %rdi
movq 0x6ab13(%rip), %rsi     # 0xfdfb0
callq 0xa630
callq 0x9e170
movq %rax, %rdi
leaq 0x319df(%rip), %rsi     # 0xc4e90
callq 0x9e4c0
movl $0xc8, %edi
callq 0x28840
jmp 0x9346b
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Run()
void Trainer::Run() {
  // TIMETEST("coach_run");

  mpObserver->Lock();

  /** 下面几个更新顺序不能变 */
  mpAgent->CheckCommands(mpObserver); // 检查上周期发送命令情况
  mpWorldModel->Update(mpObserver);

  mpObserver->UnLock();

  DoDecisionMaking();

  Logger::instance().LogSight();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x29870
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x28990
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xaae30
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x298a0
movq -0x10(%rbp), %rdi
callq 0x93540
callq 0x5add0
movq %rax, %rdi
callq 0x5b410
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Score(bool)
void Trainer::Score(bool isLeft) {
  if (mpAgent->World().GetPlayMode() != PM_Play_On) {
    ChangePlayMode(PM_Play_On);
  }
  Vector tmp = FindValidPoint(isLeft) - mpAgent->World().Ball().GetVel();
  if (isLeft) {
    tmp.SetX(Min(tmp.X(), ServerParam::instance().PITCH_LENGTH / 2 - 3.1));
  } else {
    tmp.SetX(Max(tmp.X(), -ServerParam::instance().PITCH_LENGTH / 2 + 3.1));
  }
  MoveBall(tmp, Vector(isLeft ? ServerParam::instance().ballSpeedMax()
                              : -ServerParam::instance().ballSpeedMax(),
                       0));
  mPrepared = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x18(%rax), %rdi
callq 0x1a9b0
movq %rax, %rdi
callq 0x10ed0
cmpl $0x1, %eax
je 0x93763
movq -0x78(%rbp), %rdi
movl $0x1, %esi
callq 0x94c90
movq -0x78(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x976b0
movq -0x78(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
movq 0x18(%rax), %rdi
callq 0x1a9b0
movq %rax, %rdi
callq 0x32f60
movq %rax, %rdi
callq 0x10a80
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x110a0
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x9380c
leaq -0x20(%rbp), %rdi
callq 0x176f0
movq %rax, -0x80(%rbp)
callq 0x855e0
movq -0x80(%rbp), %rdi
leaq 0x30864(%rip), %rax     # 0xc4038
movsd (%rax), %xmm0
movsd 0x2dcd0(%rip), %xmm1    # 0xc14b0
divsd %xmm1, %xmm0
movsd 0x31564(%rip), %xmm1    # 0xc4d50
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x12a60
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x1ee90
jmp 0x9387c
leaq -0x20(%rbp), %rdi
callq 0x176f0
movq %rax, -0x88(%rbp)
callq 0x855e0
movq -0x88(%rbp), %rdi
leaq 0x30809(%rip), %rax     # 0xc4038
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x2dc5e(%rip), %xmm1    # 0xc14b0
divsd %xmm1, %xmm0
movsd 0x314f2(%rip), %xmm1    # 0xc4d50
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x12a90
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x1ee90
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, -0x9(%rbp)
je 0x938ad
callq 0x855e0
movq %rax, %rdi
callq 0x23d60
movsd (%rax), %xmm0
movsd %xmm0, -0x90(%rbp)
jmp 0x938dd
callq 0x855e0
movq %rax, %rdi
callq 0x23d60
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x90(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x11a10
movq -0x78(%rbp), %rdi
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
movsd -0x58(%rbp), %xmm3
callq 0x95250
movq -0x78(%rbp), %rax
movb $0x1, 0x31(%rax)
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::CheckOpponent() const
bool Trainer::CheckOpponent() const {
  WorldState &world = mpAgent->World();
  if (world.CurrentTime().T() > 1) {
    return true; //已经开场之后，如果有人不齐的话，估计就是死了……
  }
  for (std::vector<Unum>::const_iterator it = mNeedOpponentList.begin();
       it != mNeedOpponentList.end(); it++) {
    if (!world.GetOpponent(*it).IsAlive())
      return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x18(%rax), %rdi
callq 0x1a9b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12100
movq %rax, %rdi
callq 0x13040
cmpl $0x1, %eax
jle 0x93980
movb $0x1, -0x1(%rbp)
jmp 0x93a01
movq -0x38(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x1b670
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x1b6a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x818d0
testb $0x1, %al
jne 0x939bb
jmp 0x939fd
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x81910
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1d480
movq %rax, %rdi
callq 0x23f20
testb $0x1, %al
jne 0x939ea
movb $0x0, -0x1(%rbp)
jmp 0x93a01
jmp 0x939ec
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x98c40
movq %rax, -0x30(%rbp)
jmp 0x93994
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)