LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseObjType(char*)
Parser::ObjType Parser::ParseObjType(char *msg) {
  switch (*msg) {
  case 'g':
  case 'G':
    return ParseGoal(msg);
  case 'f':
  case 'F':
    return ParseMarker(msg);
  case 'l':
    return ParseLine(msg);
  case 'p':
  case 'P':
    return ParsePlayer(msg);
  case 'b':
  case 'B':
    return ParseBall(msg);
  default:
    PARSE_ERROR("unknown object");
    break;
  }

  ObjType result;
  result.type = OBJ_None;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
addl $-0x42, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x2e, %eax
ja 0x76398
movq -0x18(%rbp), %rax
leaq 0x4d014(%rip), %rcx     # 0xc3344
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
callq 0x768d0
jmp 0x763ad
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
callq 0x76970
jmp 0x763ad
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
callq 0x77230
jmp 0x763ad
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
callq 0x772e0
jmp 0x763ad
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
callq 0x76890
jmp 0x763ad
jmp 0x7639a
movq -0x30(%rbp), %rdi
callq 0x783d0
movq -0x30(%rbp), %rax
movl $0x5, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParsePlayer_Fullstate(char*)
Parser::ObjType Parser::ParsePlayer_Fullstate(char *msg) {
  //((p l 1 g 8) -47.5 0 0 0 -66.8915 -80 (stamina 8000 0.829636 1 130600))
  //((p r 11 14) 0.385 -7.01275e-12 -1.15337e-23 -8.33192e-24 46.129 0 (stamina
  //8000 0.933173 1 124249)))

  ObjType result;

  result.type = OBJ_Player;
  msg += 2; // 'p '
  result.side = *msg;
  result.num = parser::get_int(&msg);
  msg += 1;

  if (*msg == 'g') {
    if (result.side != mpObserver->OurInitSide()) {
      mpObserver->SeeOppGoalie(result.num);
    }
  }

  result.player_type = parser::get_int(&msg);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x783d0
movq -0x18(%rbp), %rdi
movl $0x4, (%rdi)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, 0xc(%rdi)
leaq -0x10(%rbp), %rdi
callq 0x77bf0
movq -0x18(%rbp), %rdi
movl %eax, 0x10(%rdi)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x67, %eax
jne 0x7686a
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl 0xc(%rcx), %ecx
movl %ecx, -0x2c(%rbp)
movq 0x10(%rax), %rdi
callq 0x6e590
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x76868
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
movl 0x10(%rax), %esi
callq 0x78410
jmp 0x7686a
leaq -0x10(%rbp), %rdi
callq 0x77bf0
movq -0x18(%rbp), %rcx
movl %eax, %edx
movq -0x28(%rbp), %rax
movl %edx, 0x14(%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseBall(char*)
Parser::ObjType Parser::ParseBall(char *msg) {
  (void)msg;
  ObjType result;
  result.type = OBJ_Ball;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x783d0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x1, (%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseGoal(char*)
Parser::ObjType Parser::ParseGoal(char *msg) {
  ObjType result;
  if (*msg == 'g') { // goal
    result.type = OBJ_Marker;
    msg += 2; // 'g '
    if (*msg == 'r') {
      result.marker = Goal_R;
    } else if (*msg == 'l') {
      result.marker = Goal_L;
    } else {
      PARSE_ERROR("goal ?");
    }
  } else if (*msg == 'G') { // goal behind
    result.type = OBJ_Marker_Behind;
    // result.marker = _pMem->ClosestGoal(); TODO: how to process?
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x783d0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x67, %eax
jne 0x7694a
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x7692b
movq -0x20(%rbp), %rax
movl $0x1, 0x4(%rax)
jmp 0x76948
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0x76944
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x76946
jmp 0x76946
jmp 0x76948
jmp 0x76962
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x47, %eax
jne 0x76960
movq -0x20(%rbp), %rax
movl $0x3, (%rax)
jmp 0x76962
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseLine(char*)
Parser::ObjType Parser::ParseLine(char *msg) {
  ObjType result;
  result.type = OBJ_Line;
  msg += 2; // 'l'
  if (*msg == 'r') {
    result.line = SL_Right;
  } else if (*msg == 'l') {
    result.line = SL_Left;
  } else if (*msg == 't') {
    result.line = SL_Top;
  } else if (*msg == 'b') {
    result.line = SL_Bottom;
  } else {
    PARSE_ERROR("line ?");
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x783d0
movq -0x18(%rbp), %rdi
movl $0x0, (%rdi)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x7727f
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x772d2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0x77298
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x772d0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x74, %eax
jne 0x772b1
movq -0x18(%rbp), %rax
movl $0x2, 0x8(%rax)
jmp 0x772ce
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x62, %eax
jne 0x772ca
movq -0x18(%rbp), %rax
movl $0x3, 0x8(%rax)
jmp 0x772cc
jmp 0x772cc
jmp 0x772ce
jmp 0x772d0
jmp 0x772d2
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseRefereeMsg(char*)
void Parser::ParseRefereeMsg(char *msg) {
  if (msg[0] == 'y' || msg[0] == 'r')
    ParseCard(msg);
  else
    ParsePlayMode(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x79, %eax
je 0x77870
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x7787f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x778a0
jmp 0x7788c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x75220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseCard(char*)
void Parser::ParseCard(char *msg) {
  CardType card_type;
  switch (msg[0]) {
  case 'y':
    card_type = CR_Yellow;
    break;
  case 'r':
    card_type = CR_Red;
    break;
  default:
    card_type = CR_None;
    break;
  }
  Unum player;

  if (msg[7] == 'd') {
    if (msg[9] == mpObserver->OurInitSide()) {
      player = parser::get_int(&msg);
      mpObserver->SetTeammateCardType(player, card_type);
    } else {
      player = parser::get_int(&msg);
      mpObserver->SetOpponentCardType(player, card_type);
    }
  } else {
    if (msg[12] == mpObserver->OurInitSide()) {
      player = parser::get_int(&msg);
      mpObserver->SetTeammateCardType(player, card_type);
    } else {
      player = parser::get_int(&msg);
      mpObserver->SetOpponentCardType(player, card_type);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x72, %eax
je 0x778dc
jmp 0x778c9
movl -0x1c(%rbp), %eax
subl $0x79, %eax
jne 0x778e5
jmp 0x778d3
movl $0x1, -0x14(%rbp)
jmp 0x778ec
movl $0x2, -0x14(%rbp)
jmp 0x778ec
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x7(%rax), %eax
cmpl $0x64, %eax
jne 0x77964
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl 0x9(%rcx), %ecx
movl %ecx, -0x2c(%rbp)
movq 0x10(%rax), %rdi
callq 0x6e590
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x77941
leaq -0x10(%rbp), %rdi
callq 0x77bf0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq 0x10(%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x78880
jmp 0x77962
leaq -0x10(%rbp), %rdi
callq 0x77bf0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq 0x10(%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x788c0
jmp 0x779cf
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl 0xc(%rcx), %ecx
movl %ecx, -0x30(%rbp)
movq 0x10(%rax), %rdi
callq 0x6e590
movq %rax, %rcx
movl -0x30(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x779ac
leaq -0x10(%rbp), %rdi
callq 0x77bf0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq 0x10(%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x78880
jmp 0x779cd
leaq -0x10(%rbp), %rdi
callq 0x77bf0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq 0x10(%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x788c0
jmp 0x779cf
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.h
// Function: parser::get_int(char**)
inline int get_int(char **str_ptr) {
  while (!isdigit(**str_ptr) && **str_ptr != '-' && **str_ptr != '+' &&
         **str_ptr != '.' && **str_ptr)
    (*str_ptr)++;
  return static_cast<int>(strtol(*str_ptr, str_ptr, 10));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xa500
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
jne 0x77c63
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2d, %ecx
movb %al, -0x9(%rbp)
je 0x77c63
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2b, %ecx
movb %al, -0x9(%rbp)
je 0x77c63
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x9(%rbp)
je 0x77c63
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x77c6c
jmp 0x77c7c
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x77bfc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movl $0xa, %edx
callq 0xa840
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.h
// Function: parser::get_double(char**)
inline double get_double(char **str_ptr) {
  while (!isdigit(**str_ptr) && **str_ptr != '-' && **str_ptr != '+' &&
         **str_ptr != '.' && **str_ptr)
    (*str_ptr)++;
  return strtod(*str_ptr, str_ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xa500
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
jne 0x77dd3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2d, %ecx
movb %al, -0x9(%rbp)
je 0x77dd3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2b, %ecx
movb %al, -0x9(%rbp)
je 0x77dd3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x9(%rbp)
je 0x77dd3
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x77ddc
jmp 0x77dec
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x77d6c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xa450
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.h
// Function: PlayerState::UpdatePlayerType(int)
inline void PlayerState::UpdatePlayerType(int type) {
  if (mPlayerType != type) {
    mPlayerType = type;

    SetDecay(PlayerParam::instance().HeteroPlayer(mPlayerType).playerDecay());
    SetEffectiveSpeedMax(
        PlayerParam::instance().HeteroPlayer(mPlayerType).effectiveSpeedMax());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x114(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x77ee8
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x114(%rax)
callq 0x798a0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x114, %rsi            # imm = 0x114
callq 0x129d0
movq %rax, %rdi
callq 0x12fe0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x78950
callq 0x798a0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x114, %rsi            # imm = 0x114
callq 0x129d0
movq %rax, %rdi
callq 0x29430
movq -0x18(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x78970
addq $0x20, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.h
// Function: PlayerState::UpdateArmPoint(double, int, double, double, int, int)
inline void PlayerState::UpdateArmPoint(AngleDeg dir, int delay, double conf,
                                        double dist, int move_ban,
                                        int expire_ban) {
  ArmPoint arm;
  arm.mTargetDir = GetNormalizeAngleDeg(dir);
  arm.mTargetDist = dist;
  arm.mMovableBan = move_ban;
  arm.mExpireBan = expire_ban;

  mArmPoint.mValue = arm;
  mArmPoint.mCycleDelay = delay;
  mArmPoint.mConf = conf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movl %edx, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x1de60
movsd -0x10(%rbp), %xmm0
movsd 0x48f5c(%rip), %xmm1    # 0xc1030
movsd %xmm1, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x116b0
movq -0x58(%rbp), %rax
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x2c(%rbp), %ecx
movl %ecx, -0x48(%rbp)
movl -0x30(%rbp), %ecx
movl %ecx, -0x44(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, 0xd0(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0xd8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0xe0(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0xe8(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0xf0(%rax)
addq $0x60, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Player.cpp
// Function: Player::SendOptionToServer()
void Player::SendOptionToServer() {
  while (!mpParser->IsClangOk()) {
    mpAgent->CheckCommands(mpObserver);
    mpAgent->Clang(7, 8);
    mpObserver->SetCommandSend();
    WaitFor(200);
  }

  while (!mpParser->IsSyncOk()) {
    mpAgent->CheckCommands(mpObserver);
    mpAgent->SynchSee();
    mpObserver->SetCommandSend();
    WaitFor(200);
  }

  mpAgent->CheckCommands(mpObserver);
  mpAgent->EarOff(false);
  mpObserver->SetCommandSend();
  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 0x78f70
xorb $-0x1, %al
testb $0x1, %al
jne 0x78bf9
jmp 0x78c3a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x28990
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x7, %esi
movl $0x8, %edx
callq 0x78fb0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6d960
movl $0xc8, %edi
callq 0x28840
jmp 0x78be4
jmp 0x78c3c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x78ff0
xorb $-0x1, %al
testb $0x1, %al
jne 0x78c51
jmp 0x78c88
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x28990
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x79030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6d960
movl $0xc8, %edi
callq 0x28840
jmp 0x78c3c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x28990
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x79060
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6d960
movl $0xc8, %edi
callq 0x28840
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.h
// Function: void ParamEngine::AddParam<int>(char const*, int*, int)
void AddParam(const char *name, T *address, T value) {
    if (address) {
      // assign default value
      *address = value;

      // allocate Param struct
      Param param(name, static_cast<void *>(address), ParamTypes<T>::TYPE);

      if (param.type == V_NONE) {
        std::cerr << __FILE__ << ":" << __LINE__ << ": param type error \""
                  << name << "\"" << std::endl;
        return;
      }
      // put into list
      int id = hash(name);
      if (id > -1) {
        this->mParamLists[id].push_back(param);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7b182
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movl $0x1, %ecx
callq 0x7bc90
cmpl $0x0, -0x28(%rbp)
jne 0x7b10b
movq 0x82fb3(%rip), %rdi     # 0xfdff0
leaq 0x47ff3(%rip), %rsi     # 0xc3037
callq 0xa5a0
movq %rax, -0x80(%rbp)
jmp 0x7b04f
movq -0x80(%rbp), %rdi
leaq 0x4a1f7(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, -0x88(%rbp)
jmp 0x7b068
movq -0x88(%rbp), %rdi
movl $0x7a, %esi
callq 0xaa40
movq %rax, -0x90(%rbp)
jmp 0x7b082
movq -0x90(%rbp), %rdi
leaq 0x48d93(%rip), %rsi     # 0xc3e23
callq 0xa5a0
movq %rax, -0x98(%rbp)
jmp 0x7b09e
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa5a0
movq %rax, -0xa0(%rbp)
jmp 0x7b0b7
movq -0xa0(%rbp), %rdi
leaq 0x49f7d(%rip), %rsi     # 0xc5042
callq 0xa5a0
movq %rax, -0xa8(%rbp)
jmp 0x7b0d3
movq -0xa8(%rbp), %rdi
movq 0x82ecf(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x7b0e8
movl $0x1, -0x60(%rbp)
jmp 0x7b16c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7bbe0
jmp 0x7b18b
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x70af0
movl %eax, -0xac(%rbp)
jmp 0x7b120
movl -0xac(%rbp), %eax
movl %eax, -0x64(%rbp)
cmpl $-0x1, -0x64(%rbp)
jle 0x7b165
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
movslq -0x64(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x70b70
movq %rax, -0xb8(%rbp)
jmp 0x7b151
movq -0xb8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7bd20
jmp 0x7b163
jmp 0x7b165
movl $0x0, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7bbe0
movl -0x60(%rbp), %eax
testl %eax, %eax
je 0x7b180
jmp 0x7b17e
jmp 0x7b182
jmp 0x7b182
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::IsKickable(BallState const&, double const&) const
bool PlayerState::IsKickable(const BallState &ball_state,
                             const double &buffer) const {
  if (ball_state.GetPosConf() < FLOAT_EPS || GetPosConf() < FLOAT_EPS)
    return false;
  double dis2self = GetPos().Dist(ball_state.GetPos());
  return (dis2self <= GetKickableArea() - buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d930
movsd 0x44cb7(%rip), %xmm0    # 0xc1008
ucomisd (%rax), %xmm0
ja 0x7c372
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d930
movsd 0x44c9c(%rip), %xmm0    # 0xc1008
ucomisd (%rax), %xmm0
jbe 0x7c378
movb $0x0, -0x1(%rbp)
jmp 0x7c3d8
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1d6d0
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movsd -0x38(%rbp), %xmm1
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
subsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, -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/PlayerState.cpp
// Function: PlayerState::GetPredictedPosWithDash(int, double, double) const
Vector PlayerState::GetPredictedPosWithDash(int steps, double dash_power,
                                            AngleDeg dash_dir) const {
  Simulator::Player self(*this);
  int dash_dir_idx = Dasher::GetDashDirIdx(dash_dir);

  for (int i = 0; i < steps; ++i) {
    self.Dash(dash_power, dash_dir_idx);
  }

  return self.mPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x7d590
leaq -0x30(%rbp), %rdi
callq 0x323e0
movl %eax, -0x74(%rbp)
movl $0x0, -0x78(%rbp)
movl -0x78(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7c8a0
movsd -0x28(%rbp), %xmm0
movl -0x74(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0x88340
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x7c87c
movups -0x70(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetPredictedVelWithDash(int, double, double) const
Vector PlayerState::GetPredictedVelWithDash(int steps, double dash_power,
                                            AngleDeg dash_dir) const {
  Simulator::Player self(*this);
  int dash_dir_idx = Dasher::GetDashDirIdx(dash_dir);

  for (int i = 0; i < steps; ++i) {
    self.Dash(dash_power, dash_dir_idx);
  }

  return self.mVel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x7d590
leaq -0x30(%rbp), %rdi
callq 0x323e0
movl %eax, -0x74(%rbp)
movl $0x0, -0x78(%rbp)
movl -0x78(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7c920
movsd -0x28(%rbp), %xmm0
movl -0x74(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0x88340
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x7c8fc
movups -0x60(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::CorrectDashPowerForStamina(double) const
double PlayerState::CorrectDashPowerForStamina(double dash_power) const {
  double stamina = GetStamina();

  if (IsOutOfStamina()) {
    return dash_power; //已经没有容量了，不需要在控制了
  }

  double new_power;

  if (dash_power >= 0) {
    new_power = Min(dash_power, stamina - PlayerParam::instance().MinStamina());
    if (new_power < 0)
      new_power = 0;
  } else {
    new_power = Min(-dash_power,
                    (stamina - PlayerParam::instance().MinStamina()) / 2.0);
    if (new_power < 0)
      new_power = 0;

    new_power = -new_power;
  }

  return new_power;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x10cd0
movq -0x48(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x10d30
testb $0x1, %al
jne 0x7c976
jmp 0x7c985
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7ca8a
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7c9e5
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x12c00
movsd -0x50(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12a60
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x7c9e0
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x7ca80
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x12c00
movsd -0x58(%rbp), %xmm0
subsd (%rax), %xmm0
movsd 0x44a82(%rip), %xmm1    # 0xc14b0
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x12a60
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x7ca5f
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetControlBallProb(Vector const&) const
double PlayerState::GetControlBallProb(const Vector &ball_pos) const {
  const double dist = GetPos().Dist(ball_pos);

  if (dist < GetKickableArea()) {
    return 1.0; //已经可踢了
  }

  if (IsGoalie()) {
    return Max(GetCatchProb(dist),
               ::GetTackleProb(ball_pos, GetPos(), GetBodyDir(), false));
  } else {
    return ::GetTackleProb(ball_pos, GetPos(), GetBodyDir(), false);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x11090
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1d6d0
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movsd -0x40(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7cdd7
movsd 0x44243(%rip), %xmm0    # 0xc1010
movsd %xmm0, -0x8(%rbp)
jmp 0x7ce8e
movq -0x48(%rbp), %rdi
callq 0x1d780
testb $0x1, %al
jne 0x7cde6
jmp 0x7ce4f
movq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7cea0
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
callq 0x11090
movq -0x48(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x11170
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
movb $0x0, -0x31(%rbp)
leaq -0x31(%rbp), %rcx
callq 0x7d690
movsd %xmm0, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12a90
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7ce8e
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x8, %rdi
callq 0x11090
movq -0x48(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x11170
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
movb $0x0, -0x32(%rbp)
leaq -0x32(%rbp), %rcx
callq 0x7d690
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.h
// Function: PlayerState::UpdateFocusOn(char, int, int, double)
inline void PlayerState::UpdateFocusOn(char side, Unum num, int delay,
                                       double conf) {
  FocusOn focus;
  focus.mFocusSide = side;
  focus.mFocusNum = num;

  mFocusOn.mValue = focus;
  mFocusOn.mCycleDelay = delay;
  mFocusOn.mConf = conf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x1de90
movq -0x30(%rbp), %rax
movb -0x9(%rbp), %cl
movb %cl, -0x28(%rbp)
movl -0x10(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0xf8(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x100(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x108(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Plotter.cpp
// Function: Plotter::Init()
void Plotter::Init() {
#ifndef WIN32
  mIsDisplayOk = getenv("DISPLAY") != 0;

  if (PlayerParam::instance().UsePlotter()) {
    mpGnupolot = popen("gnuplot", "w");
  }

  if (mpGnupolot) {
    if (mIsDisplayOk) {
      GnuplotExecute("set terminal x11");
    }
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x4631b(%rip), %rdi     # 0xc3e46
callq 0xa750
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq $0x0, %rcx
setne %cl
andb $0x1, %cl
movb %cl, 0x8(%rax)
callq 0x798a0
movq %rax, %rdi
callq 0x7df60
testb $0x1, (%rax)
je 0x7db74
leaq 0x462f1(%rip), %rdi     # 0xc3e4e
leaq 0x46a57(%rip), %rsi     # 0xc45bb
callq 0xa200
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7db9d
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x7db9b
movq -0x10(%rbp), %rdi
leaq 0x462c2(%rip), %rsi     # 0xc3e56
movb $0x0, %al
callq 0x7dcf0
jmp 0x7db9d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Plotter.cpp
// Function: Plotter::Close()
void Plotter::Close() {
#ifndef WIN32
  if (mpGnupolot && pclose(mpGnupolot) == -1) {
    fprintf(stderr, "problem closing communication to gnuplot\n");
    return;
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x7dc25
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa860
cmpl $-0x1, %eax
jne 0x7dc25
movq 0x803b4(%rip), %rax     # 0xfdfc8
movq (%rax), %rdi
leaq 0x46249(%rip), %rsi     # 0xc3e67
movb $0x0, %al
callq 0xa890
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Plotter.cpp
// Function: Plotter::GnuplotExecute(char const*, ...)
void Plotter::GnuplotExecute(const char *cmd, ...) {
#ifndef WIN32
  if (!mpGnupolot)
    return;

  va_list ap;
  char local_cmd[GP_CMD_SIZE];

  va_start(ap, cmd);
  vsprintf(local_cmd, cmd, ap);
  va_end(ap);

  strcat(local_cmd, "\n");

  fputs(local_cmd, mpGnupolot);
  fflush(mpGnupolot);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp            # imm = 0x8F0
testb %al, %al
je 0x7dd37
movaps %xmm0, -0x8b0(%rbp)
movaps %xmm1, -0x8a0(%rbp)
movaps %xmm2, -0x890(%rbp)
movaps %xmm3, -0x880(%rbp)
movaps %xmm4, -0x870(%rbp)
movaps %xmm5, -0x860(%rbp)
movaps %xmm6, -0x850(%rbp)
movaps %xmm7, -0x840(%rbp)
movq %r9, -0x8b8(%rbp)
movq %r8, -0x8c0(%rbp)
movq %rcx, -0x8c8(%rbp)
movq %rdx, -0x8d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8e8(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x7dd6f
jmp 0x7dde5
leaq -0x30(%rbp), %rax
leaq -0x8e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x830(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xa2b0
leaq -0x30(%rbp), %rax
leaq -0x830(%rbp), %rdi
leaq 0x44ecc(%rip), %rsi     # 0xc2c85
callq 0xaa80
movq -0x8e8(%rbp), %rax
leaq -0x830(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0xa6a0
movq -0x8e8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa700
addq $0x8f0, %rsp            # imm = 0x8F0
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::UpdateRoutine()
void PositionInfo::UpdateRoutine() {
  UpdateDistMatrix();
  UpdateOffsideLine();
  UpdateOppGoalInfo();

  /** 每个周期clear一次 */
  mPlayer2BallList.clear();
  mTeammate2BallList.clear();
  mOpponent2BallList.clear();

  for (int i = 0; i < 1 + 2 * TEAMSIZE; ++i) {
    mPlayer2PlayerList[i].clear();
    mTeammate2PlayerList[i].clear();
    mOpponent2PlayerList[i].clear();
  }

  mXSortTeammateList.clear();
  mXSortOpponentList.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x7e320
movq -0x30(%rbp), %rdi
callq 0x7e860
movq -0x30(%rbp), %rdi
callq 0x7edb0
movq -0x30(%rbp), %rdi
addq $0x10d8, %rdi           # imm = 0x10D8
callq 0x80f70
movq -0x30(%rbp), %rdi
addq $0x10f0, %rdi           # imm = 0x10F0
callq 0x80f70
movq -0x30(%rbp), %rdi
addq $0x1108, %rdi           # imm = 0x1108
callq 0x80f70
movl $0x0, -0xc(%rbp)
cmpl $0x17, -0xc(%rbp)
jge 0x7e2ef
movq -0x30(%rbp), %rdi
addq $0x1120, %rdi           # imm = 0x1120
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x80f90
movq %rax, %rdi
callq 0x80f70
movq -0x30(%rbp), %rdi
addq $0x1348, %rdi           # imm = 0x1348
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x80f90
movq %rax, %rdi
callq 0x80f70
movq -0x30(%rbp), %rdi
addq $0x1570, %rdi           # imm = 0x1570
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x80f90
movq %rax, %rdi
callq 0x80f70
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7e272
movq -0x30(%rbp), %rdi
addq $0x10a8, %rdi           # imm = 0x10A8
callq 0x80fb0
movq -0x30(%rbp), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
callq 0x80fb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::UpdateOppGoalInfo()
void PositionInfo::UpdateOppGoalInfo() {
  mOppGoal2Ball = Vector(ServerParam::instance().PITCH_LENGTH / 2.0, 0.0) -
                  mpWorldState->GetBall().GetPos();
  mOppLeftPost2Ball = ServerParam::instance().oppLeftGoalPost() -
                      mpWorldState->GetBall().GetPos();
  mOppRightPost2Ball = ServerParam::instance().oppRightGoalPost() -
                       mpWorldState->GetBall().GetPos();
  mOppGoal2BallAngle = mOppGoal2Ball.Dir();
  mOppLeftPost2BallAngle = mOppLeftPost2Ball.Dir();
  mOppRightPost2BallAngle = mOppRightPost2Ball.Dir();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x855e0
leaq 0x45268(%rip), %rax     # 0xc4038
movsd (%rax), %xmm0
movsd 0x426d4(%rip), %xmm1    # 0xc14b0
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x11a10
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10570
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x110a0
movq -0x60(%rbp), %rax
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18a8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18b0(%rax)
callq 0x855e0
movq %rax, %rdi
callq 0x27df0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq 0x10(%rax), %rdi
callq 0x10570
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
movq -0x60(%rbp), %rax
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, 0x18b8(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18c0(%rax)
callq 0x855e0
movq %rax, %rdi
callq 0x27e10
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq 0x10(%rax), %rdi
callq 0x10570
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
movq -0x60(%rbp), %rdi
movsd %xmm0, -0x58(%rbp)
movsd %xmm1, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, 0x18c8(%rdi)
movq -0x50(%rbp), %rax
movq %rax, 0x18d0(%rdi)
addq $0x18a8, %rdi           # imm = 0x18A8
callq 0x10520
movq -0x60(%rbp), %rdi
movsd %xmm0, 0x18d8(%rdi)
addq $0x18b8, %rdi           # imm = 0x18B8
callq 0x10520
movq -0x60(%rbp), %rdi
movsd %xmm0, 0x18e0(%rdi)
addq $0x18c8, %rdi           # imm = 0x18C8
callq 0x10520
movq -0x60(%rbp), %rax
movsd %xmm0, 0x18e8(%rax)
addq $0x70, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetXSortTeammate[abi:cxx11]()
const list<KeyPlayerInfo> &PositionInfo::GetXSortTeammate() {
  if (mXSortTeammateList.empty()) {
    KeyPlayerInfo kp;
    for (int i = 1; i <= TEAMSIZE; i++) {
      if (mpWorldState->GetTeammate(i).IsAlive() == true &&
          mpWorldState->GetTeammate(i).GetPosConf() > FLOAT_EPS) {
        kp.mUnum = i;
        kp.mValue = mpWorldState->GetTeammate(i).GetPos().X();
        mXSortTeammateList.push_back(kp);
      }
    }
    mXSortTeammateList.sort();
  }
  return mXSortTeammateList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10a8, %rdi           # imm = 0x10A8
callq 0x811f0
testb $0x1, %al
jne 0x7f049
jmp 0x7f11d
leaq -0x18(%rbp), %rdi
callq 0x1b700
movl $0x1, -0x1c(%rbp)
cmpl $0xb, -0x1c(%rbp)
jg 0x7f10d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x12520
movq %rax, %rdi
callq 0x23f20
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x7f0fd
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x12520
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1d930
movsd (%rax), %xmm0
movsd 0x41f59(%rip), %xmm1    # 0xc1008
ucomisd %xmm1, %xmm0
jbe 0x7f0fd
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movq 0x10(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x12520
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, %rdi
callq 0x176f0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
addq $0x10a8, %rdi           # imm = 0x10A8
leaq -0x18(%rbp), %rsi
callq 0x81210
jmp 0x7f0ff
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7f059
movq -0x28(%rbp), %rdi
addq $0x10a8, %rdi           # imm = 0x10A8
callq 0x81250
movq -0x28(%rbp), %rax
addq $0x10a8, %rax           # imm = 0x10A8
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetXSortOpponent[abi:cxx11]()
const list<KeyPlayerInfo> &PositionInfo::GetXSortOpponent() {
  if (mXSortOpponentList.empty()) {
    KeyPlayerInfo kp;
    for (int i = 1; i <= TEAMSIZE; i++) {
      if (mpWorldState->GetOpponent(i).IsAlive() == true &&
          mpWorldState->GetOpponent(i).GetPosConf() > FLOAT_EPS) {
        kp.mUnum = i;
        kp.mValue = mpWorldState->GetOpponent(i).GetPos().X();
        mXSortOpponentList.push_back(kp);
      }
    }
    mXSortOpponentList.sort();
  }
  return mXSortOpponentList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10c0, %rdi           # imm = 0x10C0
callq 0x811f0
testb $0x1, %al
jne 0x7f159
jmp 0x7f22d
leaq -0x18(%rbp), %rdi
callq 0x1b700
movl $0x1, -0x1c(%rbp)
cmpl $0xb, -0x1c(%rbp)
jg 0x7f21d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1d480
movq %rax, %rdi
callq 0x23f20
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x7f20d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1d480
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1d930
movsd (%rax), %xmm0
movsd 0x41e49(%rip), %xmm1    # 0xc1008
ucomisd %xmm1, %xmm0
jbe 0x7f20d
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movq 0x10(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1d480
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, %rdi
callq 0x176f0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
addq $0x10c0, %rdi           # imm = 0x10C0
leaq -0x18(%rbp), %rsi
callq 0x81210
jmp 0x7f20f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7f169
movq -0x28(%rbp), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
callq 0x81250
movq -0x28(%rbp), %rax
addq $0x10c0, %rax           # imm = 0x10C0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetCloseTeammateToBall()
const vector<Unum> &PositionInfo::GetCloseTeammateToBall() {
  if (mTeammate2BallList.empty()) {
    const vector<Unum> &player2ball = GetClosePlayerToBall();
    for (vector<Unum>::const_iterator it = player2ball.begin();
         it != player2ball.end(); ++it) {
      if ((*it) > 0) {
        mTeammate2BallList.push_back(*it);
      }
    }
  }
  return mTeammate2BallList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10f0, %rdi           # imm = 0x10F0
callq 0x1b5d0
testb $0x1, %al
jne 0x802e6
jmp 0x80360
movq -0x28(%rbp), %rdi
callq 0x80230
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b670
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b6a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x818d0
testb $0x1, %al
jne 0x80320
jmp 0x8035e
leaq -0x18(%rbp), %rdi
callq 0x81910
cmpl $0x0, (%rax)
jle 0x80351
movq -0x28(%rbp), %rax
addq $0x10f0, %rax           # imm = 0x10F0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x81910
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x81810
jmp 0x80353
leaq -0x18(%rbp), %rdi
callq 0x81930
jmp 0x80300
jmp 0x80360
movq -0x28(%rbp), %rax
addq $0x10f0, %rax           # imm = 0x10F0
addq $0x30, %rsp
popq %rbp
retq
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetCloseOpponentToBall()
const vector<Unum> &PositionInfo::GetCloseOpponentToBall() {
  if (mOpponent2BallList.empty()) {
    const vector<Unum> &player2ball = GetClosePlayerToBall();
    for (vector<Unum>::const_iterator it = player2ball.begin();
         it != player2ball.end(); ++it) {
      if ((*it) < 0) {
        mOpponent2BallList.push_back(-(*it));
      }
    }
  }
  return mOpponent2BallList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x1108, %rdi           # imm = 0x1108
callq 0x1b5d0
testb $0x1, %al
jne 0x80399
jmp 0x8041e
movq -0x30(%rbp), %rdi
callq 0x80230
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b670
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b6a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x818d0
testb $0x1, %al
jne 0x803d3
jmp 0x8041c
leaq -0x18(%rbp), %rdi
callq 0x81910
cmpl $0x0, (%rax)
jge 0x8040f
movq -0x30(%rbp), %rax
addq $0x1108, %rax           # imm = 0x1108
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x81910
movq -0x38(%rbp), %rdi
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x81950
jmp 0x80411
leaq -0x18(%rbp), %rdi
callq 0x81930
jmp 0x803b3
jmp 0x8041e
movq -0x30(%rbp), %rax
addq $0x1108, %rax           # imm = 0x1108
addq $0x40, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetCloseOpponentToPoint(Vector const&)
vector<Unum> PositionInfo::GetCloseOpponentToPoint(const Vector &bp) {
  vector<Unum> opp2point;
  const vector<Unum> &player2ball = GetClosePlayerToPoint(bp);
  for (vector<Unum>::const_iterator it = player2ball.begin();
       it != player2ball.end(); ++it) {
    if ((*it) < 0) {
      opp2point.push_back(-(*it));
    }
  }

  return opp2point;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x43ba0
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x0, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rcx
callq 0x7ff30
jmp 0x80484
leaq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1b670
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1b6a0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x818d0
testb $0x1, %al
jne 0x804b9
jmp 0x80520
leaq -0x60(%rbp), %rdi
callq 0x81910
cmpl $0x0, (%rax)
jge 0x80510
leaq -0x60(%rbp), %rdi
callq 0x81910
movq -0x88(%rbp), %rdi
movl (%rax), %eax
negl %eax
movl %eax, -0x6c(%rbp)
leaq -0x6c(%rbp), %rsi
callq 0x81950
jmp 0x804e9
jmp 0x80510
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8054c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1f280
jmp 0x8054c
jmp 0x80512
leaq -0x60(%rbp), %rdi
callq 0x81930
jmp 0x80499
movb $0x1, -0x19(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1f280
testb $0x1, -0x19(%rbp)
jne 0x8053f
movq -0x88(%rbp), %rdi
callq 0x1f280
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1f280
movq -0x50(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::GetClosePlayerToPlayer(int)
const vector<Unum> &PositionInfo::GetClosePlayerToPlayer(Unum i) {
  int index = Unum2Index(i);
  if (mPlayer2PlayerList[index].empty()) {
    mPlayer2PlayerList[index] =
        GetClosePlayerToPoint(mpWorldState->GetPlayer(i).GetPos(), i);
  }
  return mPlayer2PlayerList[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl -0xc(%rbp), %esi
callq 0x81120
movq -0x58(%rbp), %rdi
movl %eax, -0x10(%rbp)
addq $0x1120, %rdi           # imm = 0x1120
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x80f90
movq %rax, %rdi
callq 0x1b5d0
testb $0x1, %al
jne 0x805bf
jmp 0x80645
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0xc(%rbp), %rsi
movq %rsi, -0x68(%rbp)
callq 0x23eb0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x68(%rbp), %rcx
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq -0x30(%rbp), %rdi
callq 0x7ff30
movq -0x58(%rbp), %rdi
addq $0x1120, %rdi           # imm = 0x1120
movslq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x80f90
movq %rax, -0x60(%rbp)
jmp 0x80616
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x818a0
leaq -0x30(%rbp), %rdi
callq 0x1f280
jmp 0x80645
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1f280
jmp 0x80667
movq -0x58(%rbp), %rdi
addq $0x1120, %rdi           # imm = 0x1120
movslq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x80f90
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xaa60