LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::InitializeStadium()
void Trainer::InitializeStadium() {
  for (std::vector<Trainer::PlayerState>::const_iterator it =
           mPlayerStatesList[0].begin();
       it != mPlayerStatesList[0].end(); it++) {
    //		ChangePlayerType(it->mUnum,
    //it->mPlayerType);让教练自己选择异构吧
  }

  for (vector<vector<Trainer::PlayerState>>::iterator it =
           mPlayerStatesList.begin();
       it != mPlayerStatesList.end(); it++) {
    for (std::vector<Trainer::PlayerState>::iterator it2 = it->begin();
         it2 != it->end(); it2++) {
      it2->mVel /=
          PlayerParam::instance().HeteroPlayer(it2->mPlayerType).playerDecay();
      it2->mPos -= it2->mVel;
    }
  }
  mInitialized = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x120, %rdi            # imm = 0x120
xorl %eax, %eax
movl %eax, %esi
callq 0x98c80
movq %rax, %rdi
callq 0x98ca0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x98cd0
movq -0x60(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
xorl %eax, %eax
movl %eax, %esi
callq 0x98c80
movq %rax, %rdi
callq 0x98d50
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x98d10
testb $0x1, %al
jne 0x93a83
jmp 0x93a96
jmp 0x93a85
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x98d80
movq %rax, -0x28(%rbp)
jmp 0x93a50
movq -0x60(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x98dc0
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x98e30
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x98df0
testb $0x1, %al
jne 0x93ad4
jmp 0x93baf
leaq -0x30(%rbp), %rdi
callq 0x98e60
movq %rax, %rdi
callq 0x98ca0
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x98e60
movq %rax, %rdi
callq 0x98d50
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x98e80
testb $0x1, %al
jne 0x93b14
jmp 0x93b99
callq 0x798a0
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x98ec0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
addq $0x30, %rsi
callq 0x129d0
movq %rax, %rdi
callq 0x12fe0
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x98ec0
movq -0x70(%rbp), %rsi
movq %rax, %rdi
addq $0x18, %rdi
callq 0x98290
leaq -0x40(%rbp), %rdi
callq 0x98ec0
addq $0x18, %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x98ec0
movq -0x68(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x32970
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x98ee0
movq %rax, -0x50(%rbp)
jmp 0x93ae9
jmp 0x93b9b
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x98f20
movq %rax, -0x58(%rbp)
jmp 0x93aaa
movq -0x60(%rbp), %rax
movb $0x1, 0x30(%rax)
addq $0x80, %rsp
popq %rbp
retq
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::MovePlayer(int, Vector, Vector, double)
void Trainer::MovePlayer(Unum num, Vector pos, Vector vel, AngleDeg dir) {
  if (num > 0) {
    mpAgent->MovePlayer(PlayerParam::instance().teamName(), num, pos, vel, dir);
  } else {
    mpAgent->MovePlayer(PlayerParam::instance().opponentTeamName(), -num, pos,
                        vel, dir);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
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)
movq -0x28(%rbp), %rax
movq %rax, -0xd8(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x95181
movq -0xd8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xe8(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x11db0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xa250
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movl -0x2c(%rbp), %edx
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movsd -0x38(%rbp), %xmm4
movsd -0x70(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
movsd -0x80(%rbp), %xmm2
movsd -0x78(%rbp), %xmm3
callq 0x97cf0
jmp 0x95153
leaq -0x58(%rbp), %rdi
callq 0xa370
jmp 0x95239
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa370
jmp 0x95242
movq -0xd8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xf8(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5c590
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xa250
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
movl -0x2c(%rbp), %edx
negl %edx
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0xc0(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0xd0(%rbp)
movsd -0x38(%rbp), %xmm4
movsd -0xc0(%rbp), %xmm0
movsd -0xb8(%rbp), %xmm1
movsd -0xd0(%rbp), %xmm2
movsd -0xc8(%rbp), %xmm3
callq 0x97cf0
jmp 0x9520b
leaq -0xb0(%rbp), %rdi
callq 0xa370
jmp 0x95239
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xa370
jmp 0x95242
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0xaa60
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::ChangePlayerType(int, int)
void Trainer::ChangePlayerType(Unum num, int player_type) {
  if (num > 0) {
    mpAgent->ChangePlayerType(PlayerParam::instance().teamName(), num,
                              player_type);
    mpObserver->SetTeammateType(num, player_type);
  } else {
    mpAgent->ChangePlayerType(PlayerParam::instance().opponentTeamName(), -num,
                              player_type);
    mpObserver->SetOpponentType(-num, player_type);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x953dc
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x78(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x11db0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xa250
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x97f10
jmp 0x953a1
leaq -0x30(%rbp), %rdi
callq 0xa370
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x782e0
jmp 0x95459
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa370
jmp 0x95462
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x88(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x5c590
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xa250
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl -0xc(%rbp), %edx
negl %edx
movl -0x10(%rbp), %ecx
callq 0x97f10
jmp 0x95422
leaq -0x60(%rbp), %rdi
callq 0xa370
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
subl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x97fa0
jmp 0x95459
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa370
jmp 0x95462
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xaa60
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Condition::OptimizeConditionTree()
void Trainer::Condition::OptimizeConditionTree() {
  for (std::vector<Trainer::Condition>::iterator it = mSubCondition.begin();
       it != mSubCondition.end();) {
    if (it->mType == ET_Null && it->mSubCondition.empty()) //删除其空子条件
    {
      it = mSubCondition.erase(it);
    } else {
      it->OptimizeConditionTree();
      it++;
    }
  }
  if (mType == ET_Null) {
    if (mSubCondition.size() == 1) //子条件仅有1个时，提升
    {
      Trainer::Condition &sc = mSubCondition[0];
      mType = sc.mType;
      mArg1 = sc.mArg1;
      mArg2 = sc.mArg2;
      mSubCondition = sc.mSubCondition;
    } else {
      PRINT_ERROR("error condition relationship");
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
callq 0x98020
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x98090
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x98050
testb $0x1, %al
jne 0x96838
jmp 0x968ba
leaq -0x10(%rbp), %rdi
callq 0x980c0
cmpl $0x0, (%rax)
jne 0x96895
leaq -0x10(%rbp), %rdi
callq 0x980c0
movq %rax, %rdi
addq $0x18, %rdi
callq 0x97fe0
testb $0x1, %al
jne 0x96861
jmp 0x96895
movq -0x40(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x98530
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x984c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x968b5
leaq -0x10(%rbp), %rdi
callq 0x980c0
movq %rax, %rdi
callq 0x967f0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x980e0
movq %rax, -0x30(%rbp)
jmp 0x96811
movq -0x40(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x9698c
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x98570
cmpq $0x1, %rax
jne 0x9692a
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x985a0
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x38(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rdi)
movq -0x38(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rdi)
movq -0x38(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x985c0
jmp 0x9698a
jmp 0x9692c
movq 0x676bd(%rip), %rdi     # 0xfdff0
leaq 0x2e55f(%rip), %rsi     # 0xc4e99
callq 0xa5a0
movq %rax, %rdi
leaq 0x2e908(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x283, %esi            # imm = 0x283
callq 0xaa40
movq %rax, %rdi
leaq 0x2cbfa(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x2e731(%rip), %rsi     # 0xc50a5
callq 0xa5a0
movq %rax, %rdi
movq 0x6762d(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x9698a
jmp 0x9698c
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::ReadConverseConf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Trainer::ReadConverseConf(const std::string &str) {
  stringstream sin;
  sin.str(str);
  int i = 1;
  for (; i <= TEAMSIZE && sin >> mTm2Opp[i]; mOpp2Tm[mTm2Opp[i]] = i, ++i)
    ;

  if (i == TEAMSIZE + 1) {
    mConverse = true;
    cout << "Conversely train!!" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0xa3e0
movq -0x1b0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa6c0
jmp 0x969e3
movl $0x1, -0x1a8(%rbp)
xorl %eax, %eax
cmpl $0xb, -0x1a8(%rbp)
movb %al, -0x1b9(%rbp)
jg 0x96a52
movq -0x1b8(%rbp), %rax
movslq -0x1a8(%rbp), %rcx
leaq 0x34(%rax,%rcx,4), %rsi
leaq -0x198(%rbp), %rdi
callq 0xa360
movq %rax, -0x1c8(%rbp)
jmp 0x96a26
movq -0x1c8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa780
movb %al, -0x1c9(%rbp)
jmp 0x96a44
movb -0x1c9(%rbp), %al
movb %al, -0x1b9(%rbp)
jmp 0x96a52
movb -0x1b9(%rbp), %al
testb $0x1, %al
jne 0x96a5e
jmp 0x96ab1
jmp 0x96a60
movq -0x1b8(%rbp), %rax
movl -0x1a8(%rbp), %edx
movslq -0x1a8(%rbp), %rcx
movslq 0x34(%rax,%rcx,4), %rcx
movl %edx, 0x64(%rax,%rcx,4)
movl -0x1a8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a8(%rbp)
jmp 0x969ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa410
jmp 0x96b0d
cmpl $0xc, -0x1a8(%rbp)
jne 0x96af8
movq -0x1b8(%rbp), %rax
movb $0x1, 0x33(%rax)
movq 0x674f4(%rip), %rdi     # 0xfdfc0
leaq 0x2e7f1(%rip), %rsi     # 0xc52c4
callq 0xa5a0
movq %rax, -0x1d8(%rbp)
jmp 0x96ae1
movq -0x1d8(%rbp), %rdi
movq 0x674c1(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x96af6
jmp 0x96af8
leaq -0x198(%rbp), %rdi
callq 0xa410
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.h
// Function: Trainer::Condition::Condition(Trainer*, Trainer::ConditionType, double, double, Trainer::Condition*, bool)
Condition(Trainer *trainer, Trainer::ConditionType type, double arg1,
              double arg2, Trainer::Condition *pSuper, bool converse) {
      mpTrainer = trainer;
      mType = type;
      mArg1 = arg1;
      mArg2 = arg2;
      mpSuperCondition = pSuper;
      mMaxInterval = 0;
      mMinInterval = 6000;
      mMinTime = 0;
      mMaxTime = 0;
      mCount = 0;
      mConverse = converse;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
callq 0x99230
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax)
movl $0x0, 0x40(%rax)
movl $0x1770, 0x44(%rax)     # imm = 0x1770
movl $0x0, 0x48(%rax)
movl $0x0, 0x4c(%rax)
movl $0x0, 0x50(%rax)
movb -0x31(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x54(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.h
// Function: Parser::IsEarOnOk()
bool IsEarOnOk() {
    bool ret;
    mOkMutex.Lock();
    ret = mEarOnOk;
    mOkMutex.UnLock();
    return ret;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x20, %rdi
callq 0x8ebb0
movq -0x18(%rbp), %rdi
movb 0x50(%rdi), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
addq $0x20, %rdi
callq 0x8ebe0
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Types.cpp
// Function: abort_with_SIGSEGV(char const*, char const*, int, char const*)
int abort_with_SIGSEGV(const char *expr, const char *file, int line,
                       const char *function) {
  fprintf(stderr, "%s in %s:%d aborted at %s\n", function, file, line, expr);
  int *p = 0;
  *p = 1; // segfault here
  return *p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq 0x5feca(%rip), %rax     # 0xfdfc8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
movq -0x8(%rbp), %r9
leaq 0x271bf(%rip), %rsi     # 0xc52d7
movb $0x0, %al
callq 0xa890
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/UDPSocket.cpp
// Function: UDPSocket::Receive(char*)
int UDPSocket::Receive(char *msg) {
#ifdef WIN32
  int servlen;
#else
  socklen_t servlen;
#endif

  sockaddr_in serv_addr;
  servlen = sizeof(serv_addr);
  int n =
      recvfrom(mSockfd, msg, MAX_MESSAGE, 0, (sockaddr *)&serv_addr, &servlen);
  if (n > 0) {
    msg[n] = '\0'; // rccparser will crash if msg has no end
    mAddress.sin_port = serv_addr.sin_port;
  }

  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x10, -0x14(%rbp)
movl 0x14(%rax), %edi
movq -0x10(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
xorl %ecx, %ecx
leaq -0x24(%rbp), %r8
leaq -0x14(%rbp), %r9
callq 0xa440
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x9e4ab
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movb $0x0, (%rcx,%rdx)
movw -0x22(%rbp), %cx
movw %cx, 0x6(%rax)
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/UDPSocket.cpp
// Function: UDPSocket::Send(char const*)
int UDPSocket::Send(const char *msg) {
  if (mIsInitialOK == true) {
    int n = std::strlen(msg);
    n = sendto(mSockfd, msg, n + 1, 0, (sockaddr *)&mAddress, sizeof(mAddress));
    return n;
  }

  std::cout << msg << std::endl;
  return std::strlen(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x9e521
movq -0x18(%rbp), %rdi
callq 0xa260
movq -0x28(%rbp), %r8
movl %eax, -0x1c(%rbp)
movl 0x14(%r8), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
addq $0x4, %r8
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0xa0b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9e54c
movq -0x18(%rbp), %rsi
movq 0x5fa94(%rip), %rdi     # 0xfdfc0
callq 0xa5a0
movq %rax, %rdi
movq 0x5fa75(%rip), %rsi     # 0xfdfb0
callq 0xa630
movq -0x18(%rbp), %rdi
callq 0xa260
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: GetRealTimeParser()
timeval GetRealTimeParser() {
  if (PlayerParam::instance().DynamicDebugMode() == true) {
    return DynamicDebug::instance().GetTimeParser();
  }

  timeval time_val = GetRealTime();
  DynamicDebug::instance().AddTimeParser(time_val);
  return time_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x798a0
movq %rax, %rdi
callq 0x12140
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x9e5c8
callq 0x33ef0
movq %rax, %rdi
callq 0x35910
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x9e5e6
callq 0x9e560
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
callq 0x33ef0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x344c0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: GetRealTimeDecision()
timeval GetRealTimeDecision() {
  if (PlayerParam::instance().DynamicDebugMode() == true) {
    return DynamicDebug::instance().GetTimeDecision();
  }

  timeval time_val = GetRealTime();
  DynamicDebug::instance().AddTimeDecision(time_val);
  return time_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x798a0
movq %rax, %rdi
callq 0x12140
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x9e638
callq 0x33ef0
movq %rax, %rdi
callq 0x35950
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x9e656
callq 0x9e560
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
callq 0x33ef0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x34520
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: GetRealTimeCommandSend()
timeval GetRealTimeCommandSend() {
  if (PlayerParam::instance().DynamicDebugMode() == true) {
    return DynamicDebug::instance().GetTimeCommandSend();
  }

  timeval time_val = GetRealTime();
  DynamicDebug::instance().AddTimeCommandSend(time_val);
  return time_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x798a0
movq %rax, %rdi
callq 0x12140
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x9e6a8
callq 0x33ef0
movq %rax, %rdi
callq 0x35990
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x9e6c6
callq 0x9e560
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
callq 0x33ef0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x34580
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: RealTime::operator+(RealTime const&) const
RealTime RealTime::operator+(const RealTime &t) const {
  if (GetUsec() + t.GetUsec() >= ONE_MILLION) {
    return RealTime(GetSec() + t.GetSec() + 1,
                    GetUsec() + t.GetUsec() - ONE_MILLION);
  } else {
    return RealTime(GetSec() + t.GetSec(), GetUsec() + t.GetUsec());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x64d00
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x64d00
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
cmpq $0xf4240, %rax          # imm = 0xF4240
jl 0x9e777
movq -0x30(%rbp), %rdi
callq 0x64ce0
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x64ce0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
callq 0x64d00
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x64d00
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
addq %rax, %rdx
subq $0xf4240, %rdx          # imm = 0xF4240
leaq -0x10(%rbp), %rdi
callq 0x651d0
jmp 0x9e7c5
movq -0x30(%rbp), %rdi
callq 0x64ce0
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0x64ce0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x60(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x50(%rbp)
callq 0x64d00
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
callq 0x64d00
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rsi
addq %rax, %rdx
leaq -0x10(%rbp), %rdi
callq 0x651d0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: RealTime::operator+(int) const
RealTime RealTime::operator+(int msec) const {
  int usec = GetUsec() + msec * 1000;
  if (usec >= ONE_MILLION) {
    return RealTime(GetSec() + usec / ONE_MILLION, usec % ONE_MILLION);
  } else {
    return RealTime(GetSec(), usec);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x64d00
imull $0x3e8, -0x1c(%rbp), %ecx # imm = 0x3E8
movslq %ecx, %rcx
addq %rcx, %rax
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rax
cmpq $0xf4240, %rax          # imm = 0xF4240
jl 0x9e84e
movq -0x28(%rbp), %rdi
callq 0x64ce0
movq %rax, %rsi
movslq -0x20(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
addq %rax, %rsi
movslq -0x20(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
leaq -0x10(%rbp), %rdi
callq 0x651d0
jmp 0x9e867
movq -0x28(%rbp), %rdi
callq 0x64ce0
movq %rax, %rsi
movslq -0x20(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x651d0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: RealTime::operator-(int) const
RealTime RealTime::operator-(int msec) const {
  int usec = GetUsec() - msec * 1000;
  if (usec < 0) {
    usec = -usec;
    return RealTime(GetSec() - usec / ONE_MILLION - 1,
                    ONE_MILLION - usec % ONE_MILLION);
  } else {
    return RealTime(GetSec(), usec);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x64d00
imull $0x3e8, -0x1c(%rbp), %ecx # imm = 0x3E8
movslq %ecx, %rcx
subq %rcx, %rax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x9e8ff
movq -0x28(%rbp), %rdi
xorl %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x64ce0
movq %rax, %rsi
movslq -0x20(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
subq %rax, %rsi
subq $0x1, %rsi
movslq -0x20(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rdx, %rax
movl $0xf4240, %edx          # imm = 0xF4240
subq %rax, %rdx
leaq -0x10(%rbp), %rdi
callq 0x651d0
jmp 0x9e918
movq -0x28(%rbp), %rdi
callq 0x64ce0
movq %rax, %rsi
movslq -0x20(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x651d0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: RealTime::operator<(RealTime const&) const
bool RealTime::operator<(const RealTime &t) const {
  if (GetSec() < t.GetSec())
    return true;
  if (GetSec() == t.GetSec() && GetUsec() < t.GetUsec())
    return true;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x64ce0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64ce0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jge 0x9ea6c
movb $0x1, -0x1(%rbp)
jmp 0x9eaba
movq -0x28(%rbp), %rdi
callq 0x64ce0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64ce0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x9eab6
movq -0x28(%rbp), %rdi
callq 0x64d00
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64d00
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jge 0x9eab6
movb $0x1, -0x1(%rbp)
jmp 0x9eaba
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: Time::operator-(int) const
Time Time::operator-(const int a) const {
  int news = S() - a;
  if (news >= 0) {
    return Time(T(), news);
  }
  return Time(T() + news, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x13050
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x9ece1
movq -0x20(%rbp), %rdi
callq 0x13040
movl %eax, %esi
movl -0x18(%rbp), %edx
leaq -0x8(%rbp), %rdi
callq 0x13c70
jmp 0x9ecfa
movq -0x20(%rbp), %rdi
callq 0x13040
movl %eax, %esi
addl -0x18(%rbp), %esi
leaq -0x8(%rbp), %rdi
xorl %edx, %edx
callq 0x13c70
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: Time::operator-(Time const&) const
int Time::operator-(const Time &a) const {
  if (mT == a.T()) {
    return mS - a.S();
  } else {
    return mT - a.T() + mS; //实际可能差更多,不准
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13040
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jne 0x9ed5e
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13050
movl %eax, %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x9ed81
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13040
movq -0x28(%rbp), %rcx
movl %eax, %edx
movl -0x30(%rbp), %eax
subl %edx, %eax
addl 0x4(%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: ServerPlayModeMap::GetServerPlayMode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ServerPlayMode ServerPlayModeMap::GetServerPlayMode(const std::string &str) {
  // special case: server 发过来的是 goal_[lr]_[[:digit:]]
  if (strncmp(str.c_str(), "goal_l", strlen("goal_l")) == 0) {
    return mString2Enum["goal_l"];
  } else if (strncmp(str.c_str(), "goal_r", strlen("goal_r")) == 0) {
    return mString2Enum["goal_r"];
  } else if (mString2Enum.count(str)) {
    return mString2Enum[str];
  } else {
    Assert(!"server playmode error");
    return SPM_Null;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa240
movq %rax, %rdi
leaq 0x234fa(%rip), %rsi     # 0xc48b8
movl $0x6, %edx
callq 0xa2c0
cmpl $0x0, %eax
jne 0xa1472
movq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xaa70
movq -0x88(%rbp), %rdx
leaq 0x234be(%rip), %rsi     # 0xc48b8
leaq -0x38(%rbp), %rdi
callq 0x1a540
jmp 0xa1405
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa1850
movq %rax, -0x98(%rbp)
jmp 0xa141e
movq -0x98(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa370
leaq -0x39(%rbp), %rdi
callq 0xa650
jmp 0xa1561
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xa1464
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa370
leaq -0x39(%rbp), %rdi
callq 0xa650
jmp 0xa156d
movq -0x18(%rbp), %rdi
callq 0xa240
movq %rax, %rdi
leaq 0x23440(%rip), %rsi     # 0xc48c5
movl $0x6, %edx
callq 0xa2c0
cmpl $0x0, %eax
jne 0xa1533
movq -0x80(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xaa70
movq -0xa0(%rbp), %rdx
leaq 0x23404(%rip), %rsi     # 0xc48c5
leaq -0x70(%rbp), %rdi
callq 0x1a540
jmp 0xa14cc
movq -0xa8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa1850
movq %rax, -0xb0(%rbp)
jmp 0xa14e5
movq -0xb0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa370
leaq -0x71(%rbp), %rdi
callq 0xa650
jmp 0xa1561
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xa1528
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa370
leaq -0x71(%rbp), %rdi
callq 0xa650
jmp 0xa156d
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa1930
cmpq $0x0, %rax
je 0xa155a
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa1690
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xa1561
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: ServerPlayModeMap::GetPlayModeString(ServerPlayMode)
const char *ServerPlayModeMap::GetPlayModeString(ServerPlayMode spm) {
  if (mEnum2String.count(spm)) {
    return mEnum2String[spm].c_str();
  } else {
    return "";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x30, %rdi
leaq -0x14(%rbp), %rsi
callq 0xa1990
cmpq $0x0, %rax
je 0xa15c9
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
leaq -0x14(%rbp), %rsi
callq 0xa1770
movq %rax, %rdi
callq 0xa240
movq %rax, -0x8(%rbp)
jmp 0xa15d4
leaq 0x210f5(%rip), %rax     # 0xc26c5
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::VisualSystem()
VisualSystem::VisualSystem() {
  mCanForceChangeViewWidth = false;
  mIsSearching = false;
  mIsCritical = false;
  mForbidden = false;
  mForceToSeeObject.bzero();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq 0x5968d(%rip), %rax     # 0xfdcd8
movq %rax, (%rdi)
addq $0x30, %rdi
callq 0xa8df0
movq -0x40(%rbp), %rdi
addq $0x5f0, %rdi            # imm = 0x5F0
callq 0xa8e10
movq -0x40(%rbp), %rdi
addq $0x608, %rdi            # imm = 0x608
movq %rdi, -0x48(%rbp)
callq 0xa8e30
movq -0x40(%rbp), %rdi
addq $0x650, %rdi            # imm = 0x650
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x11a10
jmp 0xa46a5
movq -0x40(%rbp), %rdi
addq $0x660, %rdi            # imm = 0x660
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x11a10
jmp 0xa46cf
movq -0x40(%rbp), %rdi
addq $0x670, %rdi            # imm = 0x670
xorps %xmm0, %xmm0
movsd 0x1d143(%rip), %xmm1    # 0xc1828
callq 0xa8e50
jmp 0xa46ec
movq -0x40(%rbp), %rdi
addq $0x680, %rdi            # imm = 0x680
callq 0xa8e80
jmp 0xa46fe
movq -0x40(%rbp), %rdi
movb $0x0, 0x639(%rdi)
movb $0x0, 0x63a(%rdi)
movb $0x0, 0x638(%rdi)
movb $0x0, 0x63b(%rdi)
addq $0x5f0, %rdi            # imm = 0x5F0
callq 0xa8eb0
jmp 0xa472c
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xa8ed0
movq -0x20(%rbp), %rdi
callq 0xaa60
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::Initial(Agent*)
void VisualSystem::Initial(Agent *agent) {
  mpAgent = agent;
  mpWorldState = &(agent->World());
  mpInfoState = &(agent->Info());
  mpBallState = &(agent->World().Ball());
  mpSelfState = &(agent->Self());

  mVisualRequest.GetOfBall().mpObject = mpBallState;
  mVisualRequest.GetOfBall().mUnum = 0;

  for (Unum i = 1; i <= TEAMSIZE; ++i) {
    mVisualRequest.GetOfTeammate(i).mpObject = &(mpWorldState->GetTeammate(i));
    mVisualRequest.GetOfOpponent(i).mpObject = &(mpWorldState->GetOpponent(i));
    mVisualRequest.GetOfTeammate(i).mUnum = i;
    mVisualRequest.GetOfOpponent(i).mUnum = -i;
  }
}

// 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)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x1a9b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x1a4a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x1a9b0
movq %rax, %rdi
callq 0x32f60
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x1a3d0
movq -0x20(%rbp), %rdi
movq %rax, 0x20(%rdi)
movq 0x18(%rdi), %rax
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
callq 0xa8ef0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq %rcx, 0x30(%rax)
addq $0x30, %rdi
callq 0xa8ef0
movl $0x0, 0x38(%rax)
movl $0x1, -0x14(%rbp)
cmpl $0xb, -0x14(%rbp)
jg 0xa499c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x12520
movq -0x20(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
leaq -0x14(%rbp), %rsi
callq 0xa8f20
movq -0x40(%rbp), %rdx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rdx, 0x30(%rcx)
movq 0x10(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x1d480
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x30, %rdi
leaq -0x14(%rbp), %rsi
callq 0xa8f50
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq %rcx, 0x30(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
addq $0x30, %rdi
leaq -0x14(%rbp), %rsi
callq 0xa8f20
movl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rdi
movl %ecx, 0x38(%rax)
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x30, %rdi
leaq -0x14(%rbp), %rsi
callq 0xa8f50
movl -0x2c(%rbp), %ecx
movl %ecx, 0x38(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa48e9
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::ResetVisualRequest()
void VisualSystem::ResetVisualRequest() {
  mCanTurn = false;
  mSenseBallCycle = 0;

  if (mpAgent->IsNewSight()) { //有新视觉才重置，否则维持上周期的结果
    mCanForceChangeViewWidth = false;
    mIsSearching = false;
    mIsCritical = false;
    mForbidden = false;

    for (Unum i = -TEAMSIZE; i <= TEAMSIZE; ++i) {
      mVisualRequest[i].Clear();
    }

    mHighPriorityPlayerSet.clear();
    mForceToSeeObject.bzero();
  }

  if (mpSelfState->GetPosConf() < FLOAT_EPS) {
    mIsCritical = true;
    mCanForceChangeViewWidth = false;
  }
  if (mpBallState->GetPosConf() < FLOAT_EPS) {
    RaiseForgotObject(0);
  }

  ViewModeDecision();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, 0x63c(%rax)
movl $0x0, 0x11c8(%rax)
movq 0x8(%rax), %rdi
callq 0xa8f80
testb $0x1, %al
jne 0xa49e4
jmp 0xa4a55
movq -0x18(%rbp), %rax
movb $0x0, 0x639(%rax)
movb $0x0, 0x63a(%rax)
movb $0x0, 0x638(%rax)
movb $0x0, 0x63b(%rax)
movl $0xfffffff5, -0xc(%rbp) # imm = 0xFFFFFFF5
cmpl $0xb, -0xc(%rbp)
jg 0xa4a35
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0xa8fa0
movq %rax, %rdi
callq 0xa9010
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa4a0b
movq -0x18(%rbp), %rdi
addq $0x608, %rdi            # imm = 0x608
callq 0xa9040
movq -0x18(%rbp), %rdi
addq $0x5f0, %rdi            # imm = 0x5F0
callq 0xa8eb0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x8, %rdi
callq 0x1d930
movsd 0x1c59a(%rip), %xmm0    # 0xc1008
ucomisd (%rax), %xmm0
jbe 0xa4a86
movq -0x18(%rbp), %rax
movb $0x1, 0x638(%rax)
movb $0x0, 0x639(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x8, %rdi
callq 0x1d930
movsd 0x1c569(%rip), %xmm0    # 0xc1008
ucomisd (%rax), %xmm0
jbe 0xa4ab0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xa4ac0
movq -0x18(%rbp), %rdi
callq 0xa4b30
addq $0x20, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::RaiseForgotObject(int)
void VisualSystem::RaiseForgotObject(ObjectIndex unum) {
  mIsSearching = true;

  if (unum == 0) {
    mForceToSeeObject.GetOfBall() = true;
  } else {
    mHighPriorityPlayerSet.insert(GetVisualRequest(unum));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x1, 0x63a(%rax)
cmpl $0x0, -0xc(%rbp)
jne 0xa4af9
movq -0x30(%rbp), %rdi
addq $0x5f0, %rdi            # imm = 0x5F0
callq 0xa9140
movb $0x1, (%rax)
jmp 0xa4b2a
movq -0x30(%rbp), %rdi
movq %rdi, %rax
addq $0x608, %rax            # imm = 0x608
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0xa9430
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xa93e0
movq %rax, -0x28(%rbp)
movb %dl, -0x20(%rbp)
addq $0x40, %rsp
popq %rbp
retq
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::ViewModeDecision()
void VisualSystem::ViewModeDecision() {
  ChangeViewWidth(mpSelfState->GetViewWidth());

  if (mpAgent->IsNewSight() == false) {
    ChangeViewWidth(mpSelfState->GetViewWidth());
    return;
  }

  if (mpWorldState->GetPlayMode() != PM_Before_Kick_Off) {
    double balldis = mpInfoState->GetPositionInfo().GetBallDistToTeammate(
        mpSelfState->GetUnum());
    if (balldis > 60.0) {
      ChangeViewWidth(VW_Wide);
    } else if (balldis > 40.0) {
      ChangeViewWidth(VW_Normal);
    } else {
      ChangeViewWidth(VW_Narrow);
    }
  } else {
    ChangeViewWidth(VW_Narrow);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x20(%rax), %rdi
callq 0x11070
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x12ca0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa8f80
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xa4b8c
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11070
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x12ca0
jmp 0xa4c3d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10ed0
cmpl $0x16, %eax
je 0xa4c2f
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x49590
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x20(%rax), %rdi
callq 0x1b470
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x81980
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x1d0ac(%rip), %xmm1    # 0xc1c90
ucomisd %xmm1, %xmm0
jbe 0xa4bfa
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x12ca0
jmp 0xa4c2d
movsd -0x10(%rbp), %xmm0
movsd 0x1e2c9(%rip), %xmm1    # 0xc2ed0
ucomisd %xmm1, %xmm0
jbe 0xa4c1d
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x12ca0
jmp 0xa4c2b
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x12ca0
jmp 0xa4c2d
jmp 0xa4c3d
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x12ca0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::Decision()
void VisualSystem::Decision() {
  if (mpAgent->GetActionEffector().IsTurnNeck())
    return; //其他地方已经产生了转脖子动作
  if (mForbidden)
    return;

  if (!DealWithSetPlayMode()) {
    DoDecision();
  }
}

// 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 0x123a0
movq %rax, %rdi
callq 0xa9060
testb $0x1, %al
jne 0xa4c7b
jmp 0xa4c7d
jmp 0xa4ca2
movq -0x10(%rbp), %rax
testb $0x1, 0x63b(%rax)
je 0xa4c8c
jmp 0xa4ca2
movq -0x10(%rbp), %rdi
callq 0xa4cb0
testb $0x1, %al
jne 0xa4ca2
movq -0x10(%rbp), %rdi
callq 0xa4f40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::DoDecision()
void VisualSystem::DoDecision() {
  if (!mpAgent->IsNewSight()) {
    if (mCanForceChangeViewWidth) {
      mViewWidth = VW_Narrow; //重置为窄视角
    } else {
      mViewWidth = mpSelfState->GetViewWidth();
    }
  }

  DoInfoGather();          //提请求
  EvaluateVisualRequest(); //评价

  if (!ForceSearchBall()) {
    DealVisualRequest(); //处理请求
    DoVisualExecute();   //视觉执行
  }
}

// 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 0xa8f80
testb $0x1, %al
jne 0xa4f99
movq -0x10(%rbp), %rax
testb $0x1, 0x639(%rax)
je 0xa4f7e
movq -0x10(%rbp), %rax
movl $0x1, 0x640(%rax)
jmp 0xa4f97
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11070
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x640(%rax)
jmp 0xa4f99
movq -0x10(%rbp), %rdi
callq 0xa5f10
movq -0x10(%rbp), %rdi
callq 0xa5b80
movq -0x10(%rbp), %rdi
callq 0xa8c10
testb $0x1, %al
jne 0xa4fca
movq -0x10(%rbp), %rdi
callq 0xa4fd0
movq -0x10(%rbp), %rdi
callq 0xa83f0
addq $0x10, %rsp
popq %rbp
retq
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::SetVisualRing()
void VisualSystem::SetVisualRing() {
  mVisualRing.Clear();

  for (int i = -TEAMSIZE; i <= TEAMSIZE; ++i) {
    const VisualRequest &visual_request = mVisualRequest[i];

    if (!visual_request.mValid)
      continue;

    for (double dir = -5.0; dir <= 5.0; dir += 1.0) {
      mVisualRing.Score(visual_request.mPrePos.Dir() - mPreBodyDir + dir) +=
          visual_request.mScore / 11.0;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x680, %rdi            # imm = 0x680
callq 0xa97e0
movl $0xfffffff5, -0xc(%rbp) # imm = 0xFFFFFFF5
cmpl $0xb, -0xc(%rbp)
jg 0xa5429
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0xa8fa0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0xa5385
jmp 0xa541b
movsd 0x20303(%rip), %xmm0    # 0xc5690
movsd %xmm0, -0x20(%rbp)
movsd 0x1c5d6(%rip), %xmm0    # 0xc1970
ucomisd -0x20(%rbp), %xmm0
jb 0xa5419
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x28(%rcx), %xmm0
movsd 0x1cd0a(%rip), %xmm1    # 0xc20c0
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x680, %rax            # imm = 0x680
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10520
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
subsd 0x648(%rax), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xa9500
movsd -0x38(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd 0x1bc06(%rip), %xmm0    # 0xc1010
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0xa5392
jmp 0xa541b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa5357
addq $0x40, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::DoInfoGatherForGoalie()
void VisualSystem::DoInfoGatherForGoalie() {
  const Strategy &strategy = mpAgent->GetStrategy();

  RaiseBall();
  for (Unum i = 1; i <= TEAMSIZE; i++) {
    if (i != mpSelfState->GetUnum()) {
      RaisePlayer(i, 50);
    }
    RaisePlayer(-i, 50);
  }

  //特殊视觉请求
  if (mpInfoState->GetPositionInfo().GetBallDistToTeammate(
          mpSelfState->GetUnum()) < 26.0) {
    SetForceSeeBall();
    if (strategy.IsOppControl()) {
      RaisePlayer(strategy.GetController(), 2.0);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x14050
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
callq 0xa6520
movl $0x1, -0x14(%rbp)
cmpl $0xb, -0x14(%rbp)
jg 0xa6dfb
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq 0x20(%rax), %rdi
callq 0x1b470
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0xa6dda
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd 0x1b033(%rip), %xmm0    # 0xc1e08
callq 0xa62a0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
subl -0x14(%rbp), %esi
movsd 0x1b01d(%rip), %xmm0    # 0xc1e08
callq 0xa62a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa6da4
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x49590
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq 0x20(%rax), %rdi
callq 0x1b470
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x81980
movsd 0x1af21(%rip), %xmm0    # 0xc1d50
ucomisd (%rax), %xmm0
jbe 0xa6e6b
movq -0x20(%rbp), %rdi
callq 0xa6810
movq -0x10(%rbp), %rdi
callq 0x26190
testb $0x1, %al
jne 0xa6e4d
jmp 0xa6e69
movq -0x10(%rbp), %rdi
callq 0xa9380
movq -0x20(%rbp), %rdi
movl %eax, %esi
movsd 0x1a64c(%rip), %xmm0    # 0xc14b0
callq 0xa62a0
jmp 0xa6e6b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::GetBestVisualActionWithViewWidth(ViewWidth, bool)
VisualSystem::VisualAction
VisualSystem::GetBestVisualActionWithViewWidth(ViewWidth view_width,
                                               bool force) {
  if (force || GetSenseBallCycle() >= NewSightComeCycle(view_width)) {
    AngleDeg max_turn_ang = mCanTurn ? mpSelfState->GetMaxTurnAngle() : 0.0;
    AngleDeg half_view_angle = sight::ViewAngle(view_width) * 0.5;
    AngleDeg neck_left_most =
        ServerParam::instance().minNeckAngle() -
        max_turn_ang; //脖子可以到达的极限角度（相对于当前身体正前方而言）
    AngleDeg neck_right_most =
        ServerParam::instance().maxNeckAngle() + max_turn_ang;
    AngleDeg left_most = neck_left_most - half_view_angle;
    AngleDeg right_most = neck_right_most + half_view_angle;

    VisualAction best_visual_action = mVisualRing.GetBestVisualAction(
        left_most, right_most, half_view_angle * 2.0);

    best_visual_action.mScore /= NewSightWaitCycle(view_width);

    Assert(!IsInvalid(best_visual_action.mScore));

    return best_visual_action;
  } else {
    return VisualAction();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0xa8929
movq -0x58(%rbp), %rdi
callq 0xa8a40
movq -0x58(%rbp), %rdi
movl %eax, -0x5c(%rbp)
movl -0x1c(%rbp), %esi
callq 0xa9800
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jl 0xa8a1c
movq -0x58(%rbp), %rax
testb $0x1, 0x63c(%rax)
je 0xa894a
movq -0x58(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x325d0
movsd %xmm0, -0x68(%rbp)
jmp 0xa8954
xorps %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
jmp 0xa8954
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %edi
callq 0x5be10
movsd 0x186b2(%rip), %xmm1    # 0xc1020
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x13000
movsd (%rax), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x13020
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
addq $0x680, %rdi            # imm = 0x680
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd 0x18ac8(%rip), %xmm2    # 0xc14b0
mulsd -0x30(%rbp), %xmm2
callq 0xa8630
movq -0x58(%rbp), %rdi
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movl -0x1c(%rbp), %esi
callq 0xa98e0
cvtsi2sd %eax, %xmm1
movsd -0x8(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xa8a30
leaq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x18dfd(%rip), %xmm1    # 0xc1828
callq 0xa8e50
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x70, %rsp
popq %rbp
retq