LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetTurnAction(double)
bool ActionEffector::SetTurnAction(AngleDeg turn_angle) {
  if (mIsTurn == true || mIsMutex == true) {
    return false;
  }

  AngleDeg moment = GetTurnMoment(turn_angle, mSelfState.GetPlayerType(),
                                  mSelfState.GetVel().Mod());

  moment = GetNormalizeMoment(moment);

  if (fabs(moment) < FLOAT_EPS) {
    return false;
  }

  mTurn.Plan(moment);
  mTurn.Execute(mCommandQueue);
  ++mTurnCount;
  mIsTurn = true;
  mIsMutex = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb 0xe91(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0xc80d
movq -0x28(%rbp), %rax
movb 0xe90(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xc816
movb $0x0, -0x1(%rbp)
jmp 0xc8d9
movq -0x28(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x20(%rax), %rdi
callq 0x10a60
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x34(%rbp)
movq 0x20(%rax), %rdi
callq 0x10a80
movq %rax, %rdi
callq 0x104e0
movl -0x34(%rbp), %edi
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
callq 0x10a00
movsd %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10aa0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movaps 0xb47ea(%rip), %xmm0    # 0xc1060
pand %xmm0, %xmm1
movsd 0xb4786(%rip), %xmm0    # 0xc1008
ucomisd %xmm1, %xmm0
jbe 0xc88e
movb $0x0, -0x1(%rbp)
jmp 0xc8d9
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x14590
movq -0x28(%rbp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
addq $0x28, %rsi
callq 0x144b0
movq -0x28(%rbp), %rax
movl 0xe40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe40(%rax)
movb $0x1, 0xe91(%rax)
movb $0x1, 0xe90(%rax)
movb $0x1, -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/ActionEffector.cpp
// Function: ActionEffector::SetTurnNeckAction(double)
bool ActionEffector::SetTurnNeckAction(AngleDeg angle) {
  if (mIsTurnNeck == true) {
    return false;
  }

  if (angle < ServerParam::instance().minNeckMoment() ||
      angle > ServerParam::instance().maxNeckMoment()) {
    return false;
  }

  mTurnNeck.Plan(angle);
  mTurnNeck.Execute(mCommandQueue);
  ++mTurnNeckCount;
  mIsTurnNeck = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb 0xe93(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xcb92
movb $0x0, -0x1(%rbp)
jmp 0xcc2a
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x10da0
movsd -0x28(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
ja 0xcbda
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x10dc0
movsd -0x30(%rbp), %xmm0
ucomisd (%rax), %xmm0
jbe 0xcbe0
movb $0x0, -0x1(%rbp)
jmp 0xcc2a
movq -0x20(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movsd -0x18(%rbp), %xmm0
callq 0x148f0
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x140, %rdi            # imm = 0x140
addq $0x28, %rsi
callq 0x144b0
movq -0x20(%rbp), %rax
movl 0xe48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe48(%rax)
movb $0x1, 0xe93(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetSayAction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ActionEffector::SetSayAction(std::string msg) {
  if (mIsSay == true) {
    return false;
  }

  if (PlayerParam::instance().isCoach()) {
    if (msg.length() > ServerParam::instance().freeformMsgSize()) {
      // false;
    }
  } else {
    if (msg.length() > ServerParam::instance().sayMsgSize()) {
      return false;
    }
  }

  mSay.Plan(msg);
  mSay.Execute(mCommandQueue);
  ++mSayCount;
  mIsSay = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb 0xe94(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xcc78
movb $0x0, -0x1(%rbp)
jmp 0xcd6c
callq 0x798a0
movq %rax, %rdi
callq 0x10de0
testb $0x1, (%rax)
je 0xccb5
movq -0x58(%rbp), %rdi
callq 0xa8f0
movq %rax, -0x60(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x10e00
movl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0xccb3
jmp 0xccb3
jmp 0xcce7
movq -0x58(%rbp), %rdi
callq 0xa8f0
movq %rax, -0x68(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x10e20
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0xcce5
movb $0x0, -0x1(%rbp)
jmp 0xcd6c
jmp 0xcce7
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rax
addq $0x1c0, %rax            # imm = 0x1C0
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xa250
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x14a80
jmp 0xcd15
leaq -0x38(%rbp), %rdi
callq 0xa370
movq -0x50(%rbp), %rsi
movq %rsi, %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
addq $0x28, %rsi
callq 0x144b0
movq -0x50(%rbp), %rax
movl 0xe4c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe4c(%rax)
movb $0x1, 0xe94(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xcd6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa370
jmp 0xcd7a
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetAttentiontoAction(int)
bool ActionEffector::SetAttentiontoAction(Unum num) {
  if (mIsAttentionto == true) {
    return false;
  }

  if (num == 0 || num == mAgent.GetSelfUnum() || num < -TEAMSIZE ||
      num > TEAMSIZE) {
    return false;
  }

  if (mAgent.GetSelf().GetFocusOnUnum() == num) {
    mIsAttentionto = true; // 本周期不再attentionto
    return false;
  }

  mAttentionto.Plan(true, num);
  mAttentionto.Execute(mCommandQueue);
  ++mAttentiontoCount;
  mIsAttentionto = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb 0xe95(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xcdc0
movb $0x0, -0x1(%rbp)
jmp 0xce6c
cmpl $0x0, -0x14(%rbp)
je 0xcdee
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq 0x8(%rax), %rdi
callq 0x10e40
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0xcdee
cmpl $-0xb, -0x14(%rbp)
jl 0xcdee
cmpl $0xb, -0x14(%rbp)
jle 0xcdf4
movb $0x0, -0x1(%rbp)
jmp 0xce6c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10590
movq %rax, %rdi
callq 0x10e60
cmpl -0x14(%rbp), %eax
jne 0xce1f
movq -0x20(%rbp), %rax
movb $0x1, 0xe95(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xce6c
movq -0x20(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
movl -0x14(%rbp), %edx
movl $0x1, %esi
callq 0x14c70
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x240, %rdi            # imm = 0x240
addq $0x28, %rsi
callq 0x144b0
movq -0x20(%rbp), %rax
movl 0xe50(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe50(%rax)
movb $0x1, 0xe95(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetAttentiontoOffAction()
bool ActionEffector::SetAttentiontoOffAction() {
  if (mIsAttentionto == true) {
    return false;
  }

  if (mAgent.GetSelf().GetFocusOnUnum() == 0) {
    mIsAttentionto = true; // 本周期不再attentionto
    return false;
  }

  mAttentionto.Plan(false);
  mAttentionto.Execute(mCommandQueue);
  ++mAttentiontoCount;
  mIsAttentionto = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0xe95(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xceaa
movb $0x0, -0x1(%rbp)
jmp 0xcf1e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10590
movq %rax, %rdi
callq 0x10e60
cmpl $0x0, %eax
jne 0xced5
movq -0x18(%rbp), %rax
movb $0x1, 0xe95(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xcf1e
movq -0x18(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
xorl %edx, %edx
movl %edx, %esi
callq 0x14c70
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x240, %rdi            # imm = 0x240
addq $0x28, %rsi
callq 0x144b0
movq -0x18(%rbp), %rax
movl 0xe50(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe50(%rax)
movb $0x1, 0xe95(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetPointtoAction(double, double)
bool ActionEffector::SetPointtoAction(double dist, AngleDeg angle) {
  if (mIsPointto == true) {
    return false;
  }

  if (mSelfState.GetArmPointMovableBan() > 0) {
    return false;
  }

  mPointto.Plan(true, dist, angle);
  mPointto.Execute(mCommandQueue);
  ++mPointtoCount;
  mIsPointto = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb 0xe98(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xd454
movb $0x0, -0x1(%rbp)
jmp 0xd4c0
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x10ff0
cmpl $0x0, %eax
jle 0xd46c
movb $0x0, -0x1(%rbp)
jmp 0xd4c0
movq -0x28(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movl $0x1, %esi
callq 0x15310
movq -0x28(%rbp), %rsi
movq %rsi, %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
addq $0x28, %rsi
callq 0x144b0
movq -0x28(%rbp), %rax
movl 0xe5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe5c(%rax)
movb $0x1, 0xe98(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetPointtoOffAction()
bool ActionEffector::SetPointtoOffAction() {
  if (mIsPointto == true) {
    return false;
  }

  if (mSelfState.GetArmPointMovableBan() > 0) {
    return false;
  }

  mPointto.Plan(false);
  mPointto.Execute(mCommandQueue);
  ++mPointtoCount;
  mIsPointto = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0xe98(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xd4fa
movb $0x0, -0x1(%rbp)
jmp 0xd55f
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x10ff0
cmpl $0x0, %eax
jle 0xd512
movb $0x0, -0x1(%rbp)
jmp 0xd55f
movq -0x18(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
xorl %esi, %esi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x15310
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
addq $0x28, %rsi
callq 0x144b0
movq -0x18(%rbp), %rax
movl 0xe5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe5c(%rax)
movb $0x1, 0xe98(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetMoveAction(Vector)
bool ActionEffector::SetMoveAction(Vector pos) {
  if (mIsMove == true || mIsMutex == true) {
    return false;
  }

  // goalie move, see SoccerServer player.cpp

  mMove.Plan(pos);
  mMove.Execute(mCommandQueue);
  ++mMoveCount;
  mIsMove = true;
  mIsMutex = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movb 0xe9a(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0xd7a2
movq -0x38(%rbp), %rax
movb 0xe90(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xd7a8
movb $0x0, -0x1(%rbp)
jmp 0xd80e
movq -0x38(%rbp), %rdi
addq $0x4c0, %rdi            # imm = 0x4C0
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x15690
movq -0x38(%rbp), %rsi
movq %rsi, %rdi
addq $0x4c0, %rdi            # imm = 0x4C0
addq $0x28, %rsi
callq 0x144b0
movq -0x38(%rbp), %rax
movl 0xe64(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe64(%rax)
movb $0x1, 0xe9a(%rax)
movb $0x1, 0xe90(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetChangeViewAction(ViewWidth)
bool ActionEffector::SetChangeViewAction(ViewWidth view_width) {
  if (view_width != VW_Narrow && view_width != VW_Normal &&
      view_width != VW_Wide) {
    return false;
  }

  VisualSystem::instance().ChangeViewWidth(mAgent, view_width); //与视觉系统同步

  if (view_width == mSelfState.GetViewWidth()) {
    return true;
  }

  mChangeView.Plan(view_width);
  mChangeView.Execute(mCommandQueue);
  ++mChangeViewCount;
  mIsChangeView = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0xd852
cmpl $0x2, -0x14(%rbp)
je 0xd852
cmpl $0x3, -0x14(%rbp)
je 0xd852
movb $0x0, -0x1(%rbp)
jmp 0xd8d4
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x11030
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq 0x20(%rax), %rdi
callq 0x11070
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jne 0xd88c
movb $0x1, -0x1(%rbp)
jmp 0xd8d4
movq -0x20(%rbp), %rdi
addq $0x540, %rdi            # imm = 0x540
movl -0x14(%rbp), %esi
callq 0x15880
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x540, %rdi            # imm = 0x540
addq $0x28, %rsi
callq 0x144b0
movq -0x20(%rbp), %rax
movl 0xe68(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe68(%rax)
movb $0x1, 0xe9b(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetCompressionAction(int)
bool ActionEffector::SetCompressionAction(int level) {
  if (mIsCompression == true) {
    return false;
  }

  if (level > 9) {
    return false;
  }

  mCompression.Plan(level);
  mCompression.Execute(mCommandQueue);
  ++mCompressionCount;
  mIsCompression = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb 0xe9c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xd90d
movb $0x0, -0x1(%rbp)
jmp 0xd961
cmpl $0x9, -0x14(%rbp)
jle 0xd919
movb $0x0, -0x1(%rbp)
jmp 0xd961
movq -0x20(%rbp), %rdi
addq $0x5c0, %rdi            # imm = 0x5C0
movl -0x14(%rbp), %esi
callq 0x15a20
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x5c0, %rdi            # imm = 0x5C0
addq $0x28, %rsi
callq 0x144b0
movq -0x20(%rbp), %rax
movl 0xe6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe6c(%rax)
movb $0x1, 0xe9c(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetSenseBodyAction()
bool ActionEffector::SetSenseBodyAction() {
  if (mIsSenseBody == true) {
    return false;
  }

  mSenseBody.Plan();
  mSenseBody.Execute(mCommandQueue);
  ++mSenseBodyCount;
  mIsSenseBody = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0xe9d(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xd99a
movb $0x0, -0x1(%rbp)
jmp 0xd9df
movq -0x18(%rbp), %rdi
addq $0x640, %rdi            # imm = 0x640
callq 0x15ba0
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x640, %rdi            # imm = 0x640
addq $0x28, %rsi
callq 0x144b0
movq -0x18(%rbp), %rax
movl 0xe70(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe70(%rax)
movb $0x1, 0xe9d(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetScoreAction()
bool ActionEffector::SetScoreAction() {
  if (mIsScore == true) {
    return false;
  }

  mScore.Plan();
  mScore.Execute(mCommandQueue);
  ++mScoreCount;
  mIsScore = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0xe9e(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xda1a
movb $0x0, -0x1(%rbp)
jmp 0xda5f
movq -0x18(%rbp), %rdi
addq $0x6c0, %rdi            # imm = 0x6C0
callq 0x15cd0
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x6c0, %rdi            # imm = 0x6C0
addq $0x28, %rsi
callq 0x144b0
movq -0x18(%rbp), %rax
movl 0xe74(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe74(%rax)
movb $0x1, 0xe9e(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetByeAction()
bool ActionEffector::SetByeAction() {
  if (mIsBye == true) {
    return false;
  }

  mBye.Plan();
  mBye.Execute(mCommandQueue);
  ++mByeCount;
  mIsBye = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0xe9f(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xda9a
movb $0x0, -0x1(%rbp)
jmp 0xdadf
movq -0x18(%rbp), %rdi
addq $0x740, %rdi            # imm = 0x740
callq 0x15e00
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x740, %rdi            # imm = 0x740
addq $0x28, %rsi
callq 0x144b0
movq -0x18(%rbp), %rax
movl 0xe78(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe78(%rax)
movb $0x1, 0xe9f(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetDoneAction()
bool ActionEffector::SetDoneAction() {
  if (mIsDone == true) {
    return false;
  }

  mDone.Plan();
  mDone.Execute(mCommandQueue);
  ++mDoneCount;
  mIsDone = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0xea0(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xdb1a
movb $0x0, -0x1(%rbp)
jmp 0xdb5f
movq -0x18(%rbp), %rdi
addq $0x7c0, %rdi            # imm = 0x7C0
callq 0x15f30
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x7c0, %rdi            # imm = 0x7C0
addq $0x28, %rsi
callq 0x144b0
movq -0x18(%rbp), %rax
movl 0xe7c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe7c(%rax)
movb $0x1, 0xea0(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetClangAction(int, int)
bool ActionEffector::SetClangAction(int min_ver, int max_ver) {
  //    if (mIsClang == true)
  //    {
  //        return false;
  //    }

  mClang.Plan(min_ver, max_ver);
  mClang.Execute(mCommandQueue);
  ++mClangCount;
  mIsClang = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x840, %rdi            # imm = 0x840
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x16060
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x840, %rdi            # imm = 0x840
addq $0x28, %rsi
callq 0x144b0
movq -0x18(%rbp), %rax
movl 0xe80(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe80(%rax)
movb $0x1, 0xea1(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetEarOnAction(bool, EarMode)
bool ActionEffector::SetEarOnAction(bool our_side, EarMode ear_mode) {
  // ear命令一个周期可以发多个
  if (ear_mode != EM_Partial && ear_mode != EM_Complete) {
    return false;
  }

  mEar.Plan(true, our_side, ear_mode);
  mEar.Execute(mCommandQueue);
  ++mEarCount;
  mIsEar = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x18(%rbp)
je 0xdc11
cmpl $0x2, -0x18(%rbp)
je 0xdc11
movb $0x0, -0x1(%rbp)
jmp 0xdc66
movq -0x20(%rbp), %rdi
addq $0x8c0, %rdi            # imm = 0x8C0
movb -0x11(%rbp), %al
movl -0x18(%rbp), %ecx
movl $0x1, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0x16220
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x8c0, %rdi            # imm = 0x8C0
addq $0x28, %rsi
callq 0x144b0
movq -0x20(%rbp), %rax
movl 0xe84(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe84(%rax)
movb $0x1, 0xea2(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetEarOffAction(bool, EarMode)
bool ActionEffector::SetEarOffAction(bool our_side, EarMode ear_mode) {
  // ear命令一个周期可以发多个
  if (ear_mode != EM_Partial && ear_mode != EM_Complete && ear_mode != EM_All) {
    return false;
  }

  mEar.Plan(false, our_side, ear_mode);
  mEar.Execute(mCommandQueue);
  ++mEarCount;
  mIsEar = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x18(%rbp)
je 0xdcb7
cmpl $0x2, -0x18(%rbp)
je 0xdcb7
cmpl $0x3, -0x18(%rbp)
je 0xdcb7
movb $0x0, -0x1(%rbp)
jmp 0xdd09
movq -0x20(%rbp), %rdi
addq $0x8c0, %rdi            # imm = 0x8C0
movb -0x11(%rbp), %al
movl -0x18(%rbp), %ecx
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0x16220
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x8c0, %rdi            # imm = 0x8C0
addq $0x28, %rsi
callq 0x144b0
movq -0x20(%rbp), %rax
movl 0xe84(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe84(%rax)
movb $0x1, 0xea2(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetSynchSeeAction()
bool ActionEffector::SetSynchSeeAction() {
  //    if (mIsSynchSee == true)
  //    {
  //        return false;
  //    }

  mSynchSee.Plan();
  mSynchSee.Execute(mCommandQueue);
  ++mSynchSeeCount;
  mIsSynchSee = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x940, %rdi            # imm = 0x940
callq 0x16440
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x940, %rdi            # imm = 0x940
addq $0x28, %rsi
callq 0x144b0
movq -0x10(%rbp), %rax
movl 0xe88(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe88(%rax)
movb $0x1, 0xea3(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetChangePlayerTypeAction(int, int)
bool ActionEffector::SetChangePlayerTypeAction(Unum num, int player_type) {
  mChangePlayerType.Plan(num, player_type);
  mChangePlayerType.Execute(mCommandQueue);
  ++mChangePlayerTypeCount;
  mIsChangePlayerType = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x9c0, %rdi            # imm = 0x9C0
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x165b0
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x9c0, %rdi            # imm = 0x9C0
addq $0x28, %rsi
callq 0x144b0
movq -0x18(%rbp), %rax
movl 0xe8c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe8c(%rax)
movb $0x1, 0xea4(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetChangePlayerTypeAction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
bool ActionEffector::SetChangePlayerTypeAction(std::string teamname, Unum num,
                                               int player_type) {
  mChangePlayerType.Plan(teamname, num, player_type);
  mChangePlayerType.Execute(mCommandQueue);
  ++mChangePlayerTypeCount;
  mIsChangePlayerType = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x9c0, %rax            # imm = 0x9C0
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xa250
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x16700
jmp 0xde3a
leaq -0x38(%rbp), %rdi
callq 0xa370
movq -0x60(%rbp), %rsi
movq %rsi, %rdi
addq $0x9c0, %rdi            # imm = 0x9C0
addq $0x28, %rsi
callq 0x144b0
movq -0x60(%rbp), %rax
movl 0xe8c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe8c(%rax)
movb $0x1, 0xea4(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xa370
movq -0x40(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetStartAction()
bool ActionEffector::SetStartAction() {
  mStart.Plan();
  mStart.Execute(mCommandQueue);
  mIsStart = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0xa40, %rdi            # imm = 0xA40
callq 0x168f0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0xa40, %rdi            # imm = 0xA40
addq $0x28, %rsi
callq 0x144b0
movq -0x10(%rbp), %rax
movb $0x1, 0xea5(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetChangePlayModeAction(ServerPlayMode)
bool ActionEffector::SetChangePlayModeAction(ServerPlayMode spm) {
  mChangePlayMode.Plan(spm);
  mChangePlayMode.Execute(mCommandQueue);
  mIsChangePlayMode = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0xac0, %rdi            # imm = 0xAC0
movl -0xc(%rbp), %esi
callq 0x16a20
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0xac0, %rdi            # imm = 0xAC0
addq $0x28, %rsi
callq 0x144b0
movq -0x18(%rbp), %rax
movb $0x1, 0xea6(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetMovePlayerAction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, Vector, Vector, double)
bool ActionEffector::SetMovePlayerAction(std::string team_name, Unum num,
                                         Vector pos, Vector vel, AngleDeg dir) {
  mMovePlayer.Plan(team_name, num, pos, vel, dir);
  mMovePlayer.Execute(mCommandQueue);
  mIsMovePlayer = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movsd %xmm4, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
addq $0xb40, %rax            # imm = 0xB40
movq %rax, -0xa0(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xa250
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl -0x34(%rbp), %edx
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movsd -0x40(%rbp), %xmm4
movsd -0x70(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
movsd -0x80(%rbp), %xmm2
movsd -0x78(%rbp), %xmm3
callq 0x16bb0
jmp 0xdfe8
leaq -0x60(%rbp), %rdi
callq 0xa370
movq -0xa8(%rbp), %rsi
movq %rsi, %rdi
addq $0xb40, %rdi            # imm = 0xB40
addq $0x28, %rsi
callq 0x144b0
movq -0xa8(%rbp), %rax
movb $0x1, 0xea7(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa370
movq -0x88(%rbp), %rdi
callq 0xaa60
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetMoveBallAction(Vector, Vector)
bool ActionEffector::SetMoveBallAction(Vector pos, Vector vel) {
  mMoveBall.Plan(pos, vel);
  mMoveBall.Execute(mCommandQueue);
  mIsMoveBall = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0xbc0, %rdi            # imm = 0xBC0
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
callq 0x16ee0
movq -0x50(%rbp), %rsi
movq %rsi, %rdi
addq $0xbc0, %rdi            # imm = 0xBC0
addq $0x28, %rsi
callq 0x144b0
movq -0x50(%rbp), %rax
movb $0x1, 0xea8(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetLookAction()
bool ActionEffector::SetLookAction() {
  mLook.Plan();
  mLook.Execute(mCommandQueue);
  mIsLook = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0xc40, %rdi            # imm = 0xC40
callq 0x17180
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0xc40, %rdi            # imm = 0xC40
addq $0x28, %rsi
callq 0x144b0
movq -0x10(%rbp), %rax
movb $0x1, 0xea9(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetTeamNamesAction()
bool ActionEffector::SetTeamNamesAction() {
  mTeamNames.Plan();
  mTeamNames.Execute(mCommandQueue);
  mIsTeamNames = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0xcc0, %rdi            # imm = 0xCC0
callq 0x172b0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0xcc0, %rdi            # imm = 0xCC0
addq $0x28, %rsi
callq 0x144b0
movq -0x10(%rbp), %rax
movb $0x1, 0xeaa(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetRecoverAction()
bool ActionEffector::SetRecoverAction() {
  mRecover.Plan();
  mRecover.Execute(mCommandQueue);
  mIsRecover = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0xd40, %rdi            # imm = 0xD40
callq 0x173e0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0xd40, %rdi            # imm = 0xD40
addq $0x28, %rsi
callq 0x144b0
movq -0x10(%rbp), %rax
movb $0x1, 0xeab(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetCheckBallAction()
bool ActionEffector::SetCheckBallAction() {
  mCheckBall.Plan();
  mCheckBall.Execute(mCommandQueue);
  mIsCheckBall = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0xdc0, %rdi            # imm = 0xDC0
callq 0x17510
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0xdc0, %rdi            # imm = 0xDC0
addq $0x28, %rsi
callq 0x144b0
movq -0x10(%rbp), %rax
movb $0x1, 0xeac(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::ComputeInfoAfterDash(double, double, PlayerState const&, Vector&, Vector&)
void ActionEffector::ComputeInfoAfterDash(const double dash_power,
                                          double dash_dir,
                                          const PlayerState &player_state,
                                          Vector &player_pos,
                                          Vector &player_vel) {
  double dir_rate = GetDashDirRate(dash_dir);

  if (dash_power < 0.0) {
    dash_dir += 180.0;
  }
  double eff_dash_power = fabs(dash_power) * player_state.GetEffort() *
                          player_state.GetDashPowerRate() * dir_rate;

  Vector accel =
      Polar2Vector(eff_dash_power,
                   GetNormalizeAngleDeg(player_state.GetBodyDir() + dash_dir));

  player_vel = player_state.GetVel() + accel;
  player_pos = player_state.GetPos() + player_vel;
  player_vel *= player_state.GetPlayerDecay();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x11440
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0xe47c
movsd 0xb2bb6(%rip), %xmm0    # 0xc1028
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movaps 0xb2bd8(%rip), %xmm1    # 0xc1060
pand %xmm1, %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11650
movsd -0x88(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11670
movsd -0x80(%rbp), %xmm0
mulsd (%rax), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11170
movsd (%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movsd 0xb2b4c(%rip), %xmm1    # 0xc1030
movsd %xmm1, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x116b0
movsd %xmm0, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x112c0
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10a80
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x11360
movsd %xmm0, -0x68(%rbp)
movsd %xmm1, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x11360
movsd %xmm0, -0x78(%rbp)
movsd %xmm1, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, (%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x11740
movq %rax, %rsi
movq -0x28(%rbp), %rdi
callq 0x113f0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::Reset()
void ActionEffector::Reset() {
  ActionEffector::CMD_QUEUE_MUTEX.Lock();
  mCommandQueue.clear();
  ActionEffector::CMD_QUEUE_MUTEX.UnLock();

  mIsMutex = false;

  mIsTurn = false;
  mIsDash = false;
  mIsTurnNeck = false;
  mIsSay = false;
  mIsAttentionto = false;
  mIsKick = false;
  mIsTackle = false;
  mIsPointto = false;
  mIsCatch = false;
  mIsMove = false;
  mIsChangeView = false;
  mIsCompression = false;
  mIsSenseBody = false;
  mIsScore = false;
  mIsBye = false;
  mIsDone = false;
  mIsClang = false;
  mIsEar = false;
  mIsSynchSee = false;
  mIsChangePlayerType = false;

  mIsSayMissed = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xeef7d(%rip), %rdi     # 0xfe6c8
callq 0x8ebb0
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x11d10
leaq 0xeef64(%rip), %rdi     # 0xfe6c8
callq 0x8ebe0
movq -0x10(%rbp), %rax
movb $0x0, 0xe90(%rax)
movb $0x0, 0xe91(%rax)
movb $0x0, 0xe92(%rax)
movb $0x0, 0xe93(%rax)
movb $0x0, 0xe94(%rax)
movb $0x0, 0xe95(%rax)
movb $0x0, 0xe96(%rax)
movb $0x0, 0xe97(%rax)
movb $0x0, 0xe98(%rax)
movb $0x0, 0xe99(%rax)
movb $0x0, 0xe9a(%rax)
movb $0x0, 0xe9b(%rax)
movb $0x0, 0xe9c(%rax)
movb $0x0, 0xe9d(%rax)
movb $0x0, 0xe9e(%rax)
movb $0x0, 0xe9f(%rax)
movb $0x0, 0xea0(%rax)
movb $0x0, 0xea1(%rax)
movb $0x0, 0xea2(%rax)
movb $0x0, 0xea3(%rax)
movb $0x0, 0xea4(%rax)
movb $0x0, 0xead(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetSelfViewWidthWithQueuedActions()
ViewWidth ActionEffector::GetSelfViewWidthWithQueuedActions() {
  if (IsChangeView()) {
    ViewWidth view_width = mSelfState.GetViewWidth();
    ActionEffector::CMD_QUEUE_MUTEX.Lock();
    for (std::list<CommandInfo>::iterator it = mCommandQueue.begin();
         it != mCommandQueue.end(); ++it) {
      if (it->mType == CT_ChangeView) {
        view_width = it->mViewWidth;
      }
    }
    ActionEffector::CMD_QUEUE_MUTEX.UnLock();
    return view_width;
  } else {
    return mSelfState.GetViewWidth();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x11f20
testb $0x1, %al
jne 0xfaf2
jmp 0xfb81
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11070
movl %eax, -0x14(%rbp)
leaq 0xeebbf(%rip), %rdi     # 0xfe6c8
callq 0x8ebb0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x11920
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x11980
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11950
testb $0x1, %al
jne 0xfb43
jmp 0xfb6d
leaq -0x20(%rbp), %rdi
callq 0x119b0
cmpl $0xb, (%rax)
jne 0xfb60
leaq -0x20(%rbp), %rdi
callq 0x119b0
movl 0x48(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xfb62
leaq -0x20(%rbp), %rdi
callq 0x11cf0
jmp 0xfb1f
leaq 0xeeb54(%rip), %rdi     # 0xfe6c8
callq 0x8ebe0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfb91
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11070
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetSelfPosWithQueuedActions()
Vector ActionEffector::GetSelfPosWithQueuedActions() {
  if (IsDash()) {
    return mSelfState.GetPredictedPosWithDash(1, mDash.GetPower());
  } else if (IsMove()) {
    Vector player_pos = Vector(0.0, 0.0);
    Vector player_vel = Vector(0.0, 0.0);
    ComputeInfoAfterMove(mMove.GetMovePos(), player_pos, player_vel);
    return player_pos;
  } else
    return mSelfState.GetPredictedPos();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x11f40
testb $0x1, %al
jne 0xfbbf
jmp 0xfbfb
movq -0x50(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, -0x58(%rbp)
addq $0xc0, %rdi
callq 0x11f60
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
movl $0x1, %esi
xorps %xmm1, %xmm1
callq 0x7c840
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
jmp 0xfc8f
movq -0x50(%rbp), %rdi
callq 0x11f80
testb $0x1, %al
jne 0xfc0a
jmp 0xfc6e
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x11a10
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x11a10
movq -0x50(%rbp), %rdi
addq $0x4c0, %rdi            # imm = 0x4C0
callq 0x11fa0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xe5a0
jmp 0xfc8f
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %esi
callq 0x11fc0
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x60, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetSelfVelWithQueuedActions()
Vector ActionEffector::GetSelfVelWithQueuedActions() {
  if (IsDash()) {
    return mSelfState.GetPredictedVelWithDash(1, mDash.GetPower());
  } else if (IsMove()) {
    Vector player_pos = Vector(0.0, 0.0);
    Vector player_vel = Vector(0.0, 0.0);
    ComputeInfoAfterMove(mMove.GetMovePos(), player_pos, player_vel);
    return player_vel;
  } else
    return mSelfState.GetPredictedVel();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x11f40
testb $0x1, %al
jne 0xfcbf
jmp 0xfcfb
movq -0x50(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, -0x58(%rbp)
addq $0xc0, %rdi
callq 0x11f60
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
movl $0x1, %esi
xorps %xmm1, %xmm1
callq 0x7c8c0
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
jmp 0xfd8f
movq -0x50(%rbp), %rdi
callq 0x11f80
testb $0x1, %al
jne 0xfd0a
jmp 0xfd6e
xorps %xmm0, %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
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x11a10
movq -0x50(%rbp), %rdi
addq $0x4c0, %rdi            # imm = 0x4C0
callq 0x11fa0
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xe5a0
jmp 0xfd8f
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %esi
callq 0x11ff0
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x60, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetSelfBodyDirWithQueuedActions()
AngleDeg ActionEffector::GetSelfBodyDirWithQueuedActions() {
  if (IsTurn()) {
    AngleDeg body_dir = 0.0;
    ComputeInfoAfterTurn(mTurn.GetAngle(), mSelfState, body_dir);
    return body_dir;
  } else
    return mSelfState.GetBodyDir();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x12020
testb $0x1, %al
jne 0xfdbf
jmp 0xfdf8
movq -0x20(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
addq $0x40, %rdi
callq 0x12040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movsd (%rcx), %xmm0
movq 0x20(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0xe600
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xfe0e
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x11170
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetBallPosWithQueuedActions()
Vector ActionEffector::GetBallPosWithQueuedActions() {
  if (IsKick()) {
    Vector ball_pos = Vector(0.0, 0.0);
    Vector ball_vel = Vector(0.0, 0.0);
    ComputeInfoAfterKick(mKick.GetPower(), mKick.GetAngle(), mSelfState,
                         mBallState, ball_pos, ball_vel);
    return ball_pos;
  } else
    return mBallState.GetPredictedPos();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x12060
testb $0x1, %al
jne 0xfe42
jmp 0xfeda
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x11a10
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x11a10
movq -0x50(%rbp), %rdi
addq $0x2c0, %rdi            # imm = 0x2C0
callq 0x11f60
movq -0x50(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
addq $0x2c0, %rdi            # imm = 0x2C0
callq 0x12040
movsd -0x58(%rbp), %xmm0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movsd (%rcx), %xmm1
movq 0x20(%rax), %rdi
movq 0x18(%rax), %rsi
leaq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rcx
movl $0x1, %r8d
callq 0xe230
jmp 0xfefb
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x11fc0
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::GetBallVelWithQueuedActions()
Vector ActionEffector::GetBallVelWithQueuedActions() {
  if (IsKick()) {
    Vector ball_pos = Vector(0.0, 0.0);
    Vector ball_vel = Vector(0.0, 0.0);
    ComputeInfoAfterKick(mKick.GetPower(), mKick.GetAngle(), mSelfState,
                         mBallState, ball_pos, ball_vel);
    return ball_vel;
  } else
    return mBallState.GetPredictedVel();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x12060
testb $0x1, %al
jne 0xff32
jmp 0xffca
xorps %xmm0, %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
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x11a10
movq -0x50(%rbp), %rdi
addq $0x2c0, %rdi            # imm = 0x2C0
callq 0x11f60
movq -0x50(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
addq $0x2c0, %rdi            # imm = 0x2C0
callq 0x12040
movsd -0x58(%rbp), %xmm0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movsd (%rcx), %xmm1
movq 0x20(%rax), %rdi
movq 0x18(%rax), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x10(%rbp), %rcx
movl $0x1, %r8d
callq 0xe230
jmp 0xffeb
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x11ff0
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Agent.h
// Function: Agent::GetSelf() const
const PlayerState &GetSelf() const {
    if (!mSelfUnum || mSelfUnum == TRAINER_UNUM) {
      static PlayerState coach; // dummy player state for coach
      return coach;
    }

    return GetWorldState().GetTeammate(mSelfUnum);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x8(%rax)
je 0x105b4
movq -0x28(%rbp), %rax
cmpl $0xc, 0x8(%rax)
jne 0x10629
cmpb $0x0, 0xf02ad(%rip)     # 0x100868
jne 0x10602
leaq 0xf02a4(%rip), %rdi     # 0x100868
callq 0xaad0
cmpl $0x0, %eax
je 0x10602
leaq 0xf011b(%rip), %rdi     # 0x1006f0
callq 0x7c090
jmp 0x105dc
leaq 0x1f1d(%rip), %rdi      # 0x12500
leaq 0xf0106(%rip), %rsi     # 0x1006f0
leaq 0xee027(%rip), %rdx     # 0xfe618
callq 0xa4e0
leaq 0xf026b(%rip), %rdi     # 0x100868
callq 0xa390
leaq 0xf00e7(%rip), %rax     # 0x1006f0
movq %rax, -0x8(%rbp)
jmp 0x10646
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq 0xf0246(%rip), %rdi     # 0x100868
callq 0xa380
jmp 0x10650
movq -0x28(%rbp), %rdi
callq 0x10550
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x12520
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xaa60
nopl (%rax)