LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::ExtractUnumFromBits(long&, int&)
int CommunicateSystem::ExtractUnumFromBits(DWORD64 &bits, int &bit_left) {
  int num;

  num = static_cast<int>(bits & mUnumMask);
  bits >>= mUnumBitCount;
  bit_left -= mUnumBitCount;

  return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
andq 0x78(%rax), %rcx
movl %ecx, -0x1c(%rbp)
movl 0x70(%rax), %ecx
movq -0x10(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq (%rdx), %rdx
movl %ecx, %ecx
sarq %cl, %rdx
movq -0x28(%rbp), %rcx
movq %rdx, (%rcx)
movl 0x70(%rax), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Dasher.cpp
// Function: Dasher::Dasher()
Dasher::Dasher() {
  Assert(std::fabs(ServerParam::instance().dashAngleStep() - 45.0) < FLOAT_EPS);

  for (int i = 0; i < 8; ++i) {
    DASH_DIR[i] =
        GetNormalizeAngleDeg(ServerParam::instance().dashAngleStep() * i);
    DIR_RATE[i] = GetDashDirRate(DASH_DIR[i]);
  }

  for (int i = 0; i < 8; ++i) {
    ANTI_DIR_IDX[i] = GetDashDirIdx(DASH_DIR[i] + 180.0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x2ec08
callq 0x855e0
movq %rax, %rdi
callq 0x10b90
movsd (%rax), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x924b1(%rip), %xmm1    # 0xc1030
movsd %xmm1, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x116b0
movsd %xmm0, -0x60(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xd63d7(%rip), %rdi     # 0x104f78
leaq -0x20(%rbp), %rsi
callq 0x323c0
movsd -0x60(%rbp), %xmm0
movsd %xmm0, (%rax)
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xd63b6(%rip), %rdi     # 0x104f78
leaq -0x28(%rbp), %rsi
callq 0x323c0
movsd (%rax), %xmm0
callq 0x11440
movsd %xmm0, -0x58(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xd63f0(%rip), %rdi     # 0x104fd8
leaq -0x30(%rbp), %rsi
callq 0x323c0
movsd -0x58(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2eb53
movl $0x0, -0x34(%rbp)
cmpl $0x8, -0x34(%rbp)
jge 0x2ec72
movslq -0x34(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0xd6354(%rip), %rdi     # 0x104f78
leaq -0x48(%rbp), %rsi
callq 0x323c0
movsd 0x923f3(%rip), %xmm0    # 0xc1028
addsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x323e0
movl %eax, -0x64(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xd635f(%rip), %rdi     # 0x104fb8
leaq -0x50(%rbp), %rsi
callq 0x32460
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2ec0f
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Dasher.cpp
// Function: Dasher::GoToPoint(Agent&, Vector, double, double, bool, bool)
bool Dasher::GoToPoint(Agent &agent, Vector pos, double buffer, double power,
                       bool can_inverse, bool turn_first) {
  AtomicAction act;

  GoToPoint(agent, act, agent.GetStrategy().AdjustTargetForSetplay(pos), buffer,
            power, can_inverse, turn_first);
  return act.Execute(agent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %cl, %al
movb %dl, %cl
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
andb $0x1, %cl
movb %cl, -0x31(%rbp)
andb $0x1, %al
movb %al, -0x32(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0x1d620
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14050
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movsd -0x88(%rbp), %xmm0
movsd -0x80(%rbp), %xmm1
callq 0x8aaa0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movsd %xmm0, -0x78(%rbp)
movsd %xmm1, -0x70(%rbp)
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm3
movb -0x31(%rbp), %cl
movb -0x32(%rbp), %al
movsd -0x78(%rbp), %xmm0
movsd -0x70(%rbp), %xmm1
leaq -0x68(%rbp), %rdx
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %ecx
movzbl %al, %r8d
callq 0x2ed20
movq -0x20(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xbef0
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Dasher.cpp
// Function: Dasher::GetTurnBodyToAngleAction(Agent const&, double)
AtomicAction Dasher::GetTurnBodyToAngleAction(const Agent &agent,
                                              AngleDeg ang) {
  AtomicAction action;
  action.mType = CT_Turn;

  double angle_turn = GetNormalizeAngleDeg(ang - agent.GetSelf().GetBodyDir());
  if (fabs(angle_turn) < agent.GetSelf().GetMaxTurnAngle()) {
    action.mSucceed = true;
    action.mTurnAngle = angle_turn;
  } else {
    action.mSucceed = false;
    action.mTurnAngle = Sign(angle_turn) * agent.GetSelf().GetMaxTurnAngle();
  }
  return action;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
xorl %esi, %esi
callq 0x1d620
movq -0x40(%rbp), %rdi
movl $0x1, 0x4(%rdi)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10590
movq %rax, %rdi
callq 0x11170
movsd -0x38(%rbp), %xmm0
subsd (%rax), %xmm0
movsd 0x8fc92(%rip), %xmm1    # 0xc1030
movsd %xmm1, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x116b0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movaps 0x8fca3(%rip), %xmm1    # 0xc1060
pand %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10590
movq %rax, %rdi
callq 0x325d0
movsd -0x30(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x313f5
movq -0x40(%rbp), %rax
movb $0x1, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
jmp 0x31434
movq -0x40(%rbp), %rax
movb $0x0, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x1f2e0
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10590
movq %rax, %rdi
callq 0x325d0
movq -0x40(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Dasher.cpp
// Function: Dasher::GetBall(Agent&, int, bool, bool)
bool Dasher::GetBall(Agent &agent, int int_cycle, bool can_inverse,
                     bool turn_first) {
  AtomicAction act;
  GetBall(agent, act, int_cycle, can_inverse, turn_first);
  if (act.mSucceed) {
    return act.Execute(agent);
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %cl
movb %cl, -0x1d(%rbp)
andb $0x1, %al
movb %al, -0x1e(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x1d620
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %ecx
movb -0x1d(%rbp), %r8b
movb -0x1e(%rbp), %al
leaq -0x50(%rbp), %rdx
andb $0x1, %r8b
andb $0x1, %al
movzbl %r8b, %r8d
movzbl %al, %r9d
callq 0x31680
testb $0x1, -0x50(%rbp)
je 0x31a07
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xbef0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x31a0b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Dasher.cpp
// Function: Dasher::CorrectTurnForDash(PlayerState const&, Vector const&, double)
Vector Dasher::CorrectTurnForDash(const PlayerState &player,
                                  const Vector &target, double fix) {
  if (player.GetPosConf() > 0.99 - FLOAT_EPS &&
      player.GetBodyDirConf() > 0.99 - FLOAT_EPS) {
    Ray body_ray(player.GetPos(), player.GetBodyDir());
    Line body_line(body_ray);
    Vector closest_pt = body_line.GetProjectPoint(target);

    double buffer = 0.05 + ServerParam::instance().ballSize();
    if (closest_pt.Dist(player.GetPos()) >
        player.GetKickableArea() + buffer - fix) {
      if (closest_pt.Dist(target) < player.GetKickableArea() - buffer + fix) {
        return closest_pt;
      }
    }
  }
  return target;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d930
movsd (%rax), %xmm0
movsd 0x9083b(%rip), %xmm1    # 0xc2290
ucomisd %xmm1, %xmm0
jbe 0x31b62
movq -0x20(%rbp), %rdi
callq 0x32a60
movsd 0x90820(%rip), %xmm1    # 0xc2290
ucomisd %xmm1, %xmm0
jbe 0x31b62
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11170
movq -0x78(%rbp), %rsi
movq %rax, %rdx
leaq -0x48(%rbp), %rdi
callq 0x1fde0
leaq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x32670
movq -0x28(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x32800
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x12f10
movsd 0x903fb(%rip), %xmm0    # 0xc1ed8
addsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
callq 0x1d6d0
movsd %xmm0, -0x70(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd -0x70(%rbp), %xmm0
movsd (%rax), %xmm1
addsd -0x68(%rbp), %xmm1
subsd -0x30(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x31b60
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x1d6d0
movsd %xmm0, -0x80(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd -0x80(%rbp), %xmm1
movsd (%rax), %xmm0
subsd -0x68(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x31b5e
jmp 0x31b75
jmp 0x31b60
jmp 0x31b62
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Dasher.h
// Function: Dasher::GetDashDirIdx(double const&)
static int GetDashDirIdx(const AngleDeg &dir) {
    for (int i = 0; i < 8; ++i) {
      if (GetAngleDegDiffer(dir, DASH_DIR[i]) < FLOAT_EPS)
        return i;
    }
    Assert(0);
    return -1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x3244b
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xd2b68(%rip), %rdi     # 0x104f78
leaq -0x20(%rbp), %rsi
callq 0x323c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1d7c0
movaps %xmm0, %xmm1
movsd 0x8ebd8(%rip), %xmm0    # 0xc1008
ucomisd %xmm1, %xmm0
jbe 0x3243e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32452
jmp 0x32440
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x323f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.h
// Function: AtomicAction::Clear()
void Clear() {
    mSucceed = false;
    mType = CT_None;
    mKickVel = Vector(0, 0);
    mTurnAngle = 0.0;
    mDashPower = 0.0;
    mDashDir = 0.0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, (%rax)
movl $0x0, 0x4(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x11a10
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/DecisionTree.cpp
// Function: DecisionTree::Decision(Agent&)
bool DecisionTree::Decision(Agent &agent) {
  Assert(agent.GetSelf().IsAlive());

  ActiveBehavior beh = Search(agent, 1);

  if (beh.GetType() != BT_None) {
    agent.SetActiveBehaviorInAct(beh.GetType());
    Assert(&beh.GetAgent() == &agent);
    return beh.Execute();
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
movl $0x1, %ecx
callq 0x33080
leaq -0xc0(%rbp), %rdi
callq 0x13cd0
cmpl $0x0, (%rax)
je 0x33065
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x13cd0
movq -0xc8(%rbp), %rdi
movl (%rax), %esi
callq 0x13ba0
leaq -0xc0(%rbp), %rdi
callq 0x19ed0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x33069
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/DecisionTree.cpp
// Function: DecisionTree::GetBestActiveBehavior(Agent&, std::__cxx11::list<ActiveBehavior, std::allocator<ActiveBehavior>>&)
ActiveBehavior
DecisionTree::GetBestActiveBehavior(Agent &agent,
                                    std::list<ActiveBehavior> &behavior_list) {
  agent.SaveActiveBehaviorList(
      behavior_list); // behavior_list里面存储了本周期所有behavior决策出的最优activebehavior，这里统一保存一下，供特定behavior下周期plan时用

  behavior_list.sort(std::greater<ActiveBehavior>());

  return behavior_list.front();
}

// 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 %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13c00
movq -0x18(%rbp), %rdi
callq 0x185a0
movq -0x18(%rbp), %rdi
callq 0x189e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl $0xa8, %edx
callq 0xa4b0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/DynamicDebug.cpp
// Function: DynamicDebug::DynamicDebug()
DynamicDebug::DynamicDebug() {
  mpObserver = 0;
  mInitialOK = false;

  mpIndex = 0;
  mpParserTime = 0;
  mpDecisionTime = 0;
  mpCommandSendTime = 0;
  mpCurrentIndex = 0;

  mpFile = 0;
  mpFileStream = 0;
  mpStreamBuffer = std::cin.rdbuf(); // 保存std::cin的流，后面要重定向

  mRunning = false;
  mShowMessage = false;
  mRuntoCycle = Time(-3, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
callq 0x359d0
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x58(%rbp)
callq 0x35a00
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x50(%rbp)
callq 0x35a20
movq -0x30(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x48(%rbp)
callq 0x35a20
movq -0x30(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x40(%rbp)
callq 0x35a20
movq -0x30(%rbp), %rdi
addq $0xb8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x35a40
movq -0x30(%rbp), %rdi
addq $0xf8, %rdi
movq %rdi, -0x28(%rbp)
callq 0x8eb70
jmp 0x336a1
movq -0x30(%rbp), %rdi
addq $0x13c, %rdi            # imm = 0x13C
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
jmp 0x336ba
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movb $0x0, 0x8(%rax)
movq $0x0, 0xd0(%rax)
movq $0x0, 0xd8(%rax)
movq $0x0, 0xe0(%rax)
movq $0x0, 0xe8(%rax)
movq $0x0, 0xf0(%rax)
movq $0x0, 0x120(%rax)
movq $0x0, 0x128(%rax)
movq 0xca8bb(%rip), %rdi     # 0xfdfd8
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa270
movq %rax, -0x60(%rbp)
jmp 0x33732
movq -0x30(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x130(%rax)
movb $0x0, 0x138(%rax)
movb $0x0, 0x139(%rax)
leaq -0x1c(%rbp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
xorl %edx, %edx
callq 0x13c70
jmp 0x33761
movq -0x30(%rbp), %rax
movq -0x1c(%rbp), %rcx
movq %rcx, 0x13c(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x33799
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8eb90
movq -0x38(%rbp), %rdi
callq 0x35a60
movq -0x40(%rbp), %rdi
callq 0x35ac0
movq -0x48(%rbp), %rdi
callq 0x35ac0
movq -0x50(%rbp), %rdi
callq 0x35ac0
movq -0x58(%rbp), %rdi
callq 0x35b20
movq -0x10(%rbp), %rdi
callq 0xaa60
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/DynamicDebug.cpp
// Function: DynamicDebug::~DynamicDebug()
DynamicDebug::~DynamicDebug() {
  Flush();

  if (mpIndex != 0) {
    delete[] mpIndex;
  }

  if (mpParserTime != 0) {
    delete[] mpParserTime;
  }

  if (mpDecisionTime != 0) {
    delete[] mpDecisionTime;
  }

  if (mpCommandSendTime != 0) {
    delete[] mpCommandSendTime;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x33910
jmp 0x337eb
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x33819
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x33817
movq -0x18(%rbp), %rdi
callq 0xa7b0
jmp 0x33819
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x33847
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x33845
movq -0x20(%rbp), %rdi
callq 0xa7b0
jmp 0x33847
movq -0x10(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x33875
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x33873
movq -0x28(%rbp), %rdi
callq 0xa7b0
jmp 0x33875
movq -0x10(%rbp), %rax
cmpq $0x0, 0xe8(%rax)
je 0x338a3
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x338a1
movq -0x30(%rbp), %rdi
callq 0xa7b0
jmp 0x338a3
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
callq 0x8eb90
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0x35a60
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x35ac0
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x35ac0
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x35ac0
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x35b20
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x12860
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/DynamicDebug.cpp
// Function: DynamicDebug::AddMessage(char const*, MessageType)
void DynamicDebug::AddMessage(const char *msg, MessageType msg_type) {
  if (PlayerParam::instance().SaveServerMessage() &&
      !PlayerParam::instance().DynamicDebugMode()) {
    if (!mInitialOK) {
      return; // 没有初始化或者不用记录server信息都返回
    }

    mFileMutex.Lock(); // 有可能多个线程同时在写文件，所以要保证互斥

    MessageIndexTableUnit index_table_unit;
    index_table_unit.mServerTime = mpObserver->CurrentTime();
    index_table_unit.mDataSize = strlen(msg);

    switch (msg_type) {
    case MT_Parse:
      index_table_unit.mTimeOffset = mParserTimeTable.size();
      break;
    case MT_Run:
      index_table_unit.mTimeOffset = mDecisionTimeTable.size();
      break;
    case MT_Send:
      index_table_unit.mTimeOffset = mCommandSendTimeTable.size();
      break;
    default:
      break;
    }

    mMessageTable.push_back(Message(msg_type, msg));
    mIndexTable.push_back(index_table_unit);
    mFileHead.mMaxCycle =
        Max(mFileHead.mMaxCycle, index_table_unit.mServerTime);

    mFileMutex.UnLock();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x798a0
movq %rax, %rdi
callq 0x12160
testb $0x1, (%rax)
je 0x344ac
callq 0x798a0
movq %rax, %rdi
callq 0x12140
testb $0x1, (%rax)
jne 0x344ac
movq -0x78(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0x34379
jmp 0x344ac
movq -0x78(%rbp), %rdi
addq $0xf8, %rdi
callq 0x8ebb0
leaq -0x38(%rbp), %rdi
callq 0x35da0
movq -0x78(%rbp), %rax
movq (%rax), %rdi
callq 0x11a70
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa260
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x7c(%rbp)
subl $0x1, %eax
je 0x343d3
jmp 0x343bf
movl -0x7c(%rbp), %eax
subl $0x2, %eax
je 0x343e6
jmp 0x343c9
movl -0x7c(%rbp), %eax
subl $0x3, %eax
je 0x343fc
jmp 0x34412
movq -0x78(%rbp), %rdi
addq $0x70, %rdi
callq 0x35dd0
movq %rax, -0x20(%rbp)
jmp 0x34414
movq -0x78(%rbp), %rdi
addq $0x88, %rdi
callq 0x35dd0
movq %rax, -0x20(%rbp)
jmp 0x34414
movq -0x78(%rbp), %rdi
addq $0xa0, %rdi
callq 0x35dd0
movq %rax, -0x20(%rbp)
jmp 0x34414
jmp 0x34414
movq -0x78(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x90(%rbp)
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x35e20
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x35df0
jmp 0x34451
leaq -0x60(%rbp), %rdi
callq 0x35ea0
movq -0x78(%rbp), %rdi
addq $0x58, %rdi
leaq -0x38(%rbp), %rsi
callq 0x35ec0
movq -0x78(%rbp), %rdi
addq $0x10, %rdi
leaq -0x38(%rbp), %rsi
callq 0x35f30
movq -0x78(%rbp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rdi)
addq $0xf8, %rdi
callq 0x8ebe0
jmp 0x344ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x35ea0
jmp 0x344b5
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xaa60
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/DynamicDebug.cpp
// Function: DynamicDebug::GetMessage(char*)
MessageType DynamicDebug::GetMessage(char *msg) {
  if (mpCurrentIndex == 0) {
    return MT_Null;
  }

  if (mpCurrentIndex->mServerTime >= mFileHead.mMaxCycle) {
    std::cerr << "End ..." << std::endl;
    return MT_Null;
  } else {
    ++mpCurrentIndex;
  }

  fseek(mpFile, mpCurrentIndex->mDataOffset, SEEK_SET);
  if (fread(msg, 1, 1, mpFile) < 1) // 读取信息类型
  {
    Assert(0);
  }
  MessageType msg_type = (MessageType)msg[0];

  if (mpCurrentIndex->mDataSize > 0 &&
      fread(msg, mpCurrentIndex->mDataSize, 1, mpFile) < 1) // 读取信息内容
  {
    Assert(0);
  }
  msg[mpCurrentIndex->mDataSize] = '\0';

  if (mShowMessage == true) {
    std::cerr << msg << std::endl;
  }

  return msg_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0xf0(%rax)
jne 0x356ae
movl $0x0, -0x4(%rbp)
jmp 0x357e1
movq -0x28(%rbp), %rsi
movq 0xf0(%rsi), %rdi
addq $0x10, %rsi
callq 0x35fd0
testb $0x1, %al
jne 0x356c8
jmp 0x356f6
movq 0xc8921(%rip), %rdi     # 0xfdff0
leaq 0x8cdd0(%rip), %rsi     # 0xc24a6
callq 0xa5a0
movq %rax, %rdi
movq 0xc88cb(%rip), %rsi     # 0xfdfb0
callq 0xa630
movl $0x0, -0x4(%rbp)
jmp 0x357e1
movq -0x28(%rbp), %rax
movq 0xf0(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0xf0(%rax)
movq -0x28(%rbp), %rax
movq 0x120(%rax), %rdi
movq 0xf0(%rax), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
callq 0xa690
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x120(%rax), %rcx
movl $0x1, %edx
movq %rdx, %rsi
callq 0xa8e0
cmpq $0x1, %rax
jae 0x3574d
jmp 0x3574d
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0xf0(%rax), %rax
cmpq $0x0, 0x8(%rax)
jle 0x35795
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0xf0(%rax), %rcx
movq 0x8(%rcx), %rsi
movq 0x120(%rax), %rcx
movl $0x1, %edx
callq 0xa8e0
cmpq $0x1, %rax
jae 0x35795
jmp 0x35795
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0xf0(%rax), %rdx
movq 0x8(%rdx), %rdx
movb $0x0, (%rcx,%rdx)
movb 0x139(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x357db
movq -0x18(%rbp), %rsi
movq 0xc8829(%rip), %rdi     # 0xfdff0
callq 0xa5a0
movq %rax, %rdi
movq 0xc87da(%rip), %rsi     # 0xfdfb0
callq 0xa630
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/DynamicDebug.cpp
// Function: DynamicDebug::FindCycle(int)
bool DynamicDebug::FindCycle(int cycle) {
  Time cycle_time(cycle, 0);
  if (cycle_time == mpObserver->CurrentTime()) {
    return true;
  }

  int begin = 0;
  int end = mFileHead.mIndexTableSize - 1;
  int mid;
  while (begin < end) {
    mid = (begin + end) / 2;
    if (mpIndex[mid].mServerTime == cycle_time) {
      mpCurrentIndex = &mpIndex[mid];
      return true;
    } else if (mpIndex[mid].mServerTime < cycle_time) {
      begin = mid;
    } else {
      end = mid;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %esi
leaq -0x1c(%rbp), %rdi
xorl %edx, %edx
callq 0x13c70
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x11a70
movq %rax, %rsi
leaq -0x1c(%rbp), %rdi
callq 0x120a0
testb $0x1, %al
jne 0x35833
jmp 0x3583c
movb $0x1, -0x1(%rbp)
jmp 0x358f7
movq -0x30(%rbp), %rax
movl $0x0, -0x20(%rbp)
movq 0x18(%rax), %rax
subq $0x1, %rax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x358f3
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x28(%rbp)
movq 0xd0(%rax), %rdi
movslq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x120a0
testb $0x1, %al
jne 0x35896
jmp 0x358b9
movq -0x30(%rbp), %rax
movq 0xd0(%rax), %rcx
movslq -0x28(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq %rcx, 0xf0(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x358f7
movq -0x30(%rbp), %rax
movq 0xd0(%rax), %rdi
movslq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x36140
testb $0x1, %al
jne 0x358de
jmp 0x358e6
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x358ec
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x358ee
jmp 0x35852
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Evaluation.cpp
// Function: Evaluation::EvaluatePosition(Vector const&, bool)
double Evaluation::EvaluatePosition(const Vector &pos, bool ourside) {
  static double input[2];
  static double output[1];

  input[0] = pos.X() / (ServerParam::instance().PITCH_LENGTH * 0.5);
  input[1] =
      fabs(pos.Y()) / (ServerParam::instance().PITCH_WIDTH * 0.5) * 2.0 - 1.0;
  if (!ourside) {
    input[0] *= -1.0;
  }
  mSensitivityNet->Run(input, output);

  return output[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x176f0
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x855e0
movsd -0x28(%rbp), %xmm0
movsd 0x88d1d(%rip), %xmm1    # 0xc1020
leaq 0x8bd2e(%rip), %rax     # 0xc4038
mulsd (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0xcce96(%rip)    # 0x1051b0
movq -0x10(%rbp), %rdi
callq 0x17700
movsd (%rax), %xmm0
movaps 0x88d32(%rip), %xmm1    # 0xc1060
pand %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x855e0
movsd -0x20(%rbp), %xmm0
movsd 0x88cd7(%rip), %xmm1    # 0xc1020
leaq 0x8bcf0(%rip), %rax     # 0xc4040
mulsd (%rax), %xmm1
divsd %xmm1, %xmm0
addsd %xmm0, %xmm0
movsd 0x894c4(%rip), %xmm1    # 0xc1828
addsd %xmm1, %xmm0
movsd %xmm0, 0xcce48(%rip)    # 0x1051b8
testb $0x1, -0x11(%rbp)
jne 0x3838e
movsd 0x894aa(%rip), %xmm0    # 0xc1828
mulsd 0xcce2a(%rip), %xmm0    # 0x1051b0
movsd %xmm0, 0xcce22(%rip)    # 0x1051b0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0xcce14(%rip), %rsi     # 0x1051b0
leaq 0xcce1d(%rip), %rdx     # 0x1051c0
callq 0x60c40
movsd 0xcce10(%rip), %xmm0    # 0x1051c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: RoleType::ToPlayerRole() const
PlayerRole RoleType::ToPlayerRole() const {
  switch (mLineType) {
  case LT_Goalie:
    return PR_Goalie;
  case LT_Defender:
    switch (mPositionType) {
    case PT_Left:
    case PT_Right:
      return PR_BackSide;
    default:
      return PR_BackCenter;
    }
    break;
  case LT_Midfielder:
    switch (mPositionType) {
    case PT_Left:
    case PT_Right:
      return PR_MidSide;
    default:
      return PR_MidCenter;
    }
    break;
  case LT_Forward:
    switch (mPositionType) {
    case PT_Left:
    case PT_Right:
      return PR_ForwardSide;
    default:
      return PR_ForwardCenter;
    }
    break;
  default:
    return PR_Max;
  }
  return PR_Max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x38467
movq -0x18(%rbp), %rax
leaq 0x8a0ec(%rip), %rcx     # 0xc24d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x3846e
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
orl $0x2, %eax
subl $0x3, %eax
je 0x3840f
jmp 0x38418
movl $0x2, -0x4(%rbp)
jmp 0x3846e
movl $0x1, -0x4(%rbp)
jmp 0x3846e
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
orl $0x2, %eax
subl $0x3, %eax
je 0x38432
jmp 0x3843b
movl $0x4, -0x4(%rbp)
jmp 0x3846e
movl $0x3, -0x4(%rbp)
jmp 0x3846e
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
orl $0x2, %eax
subl $0x3, %eax
je 0x38455
jmp 0x3845e
movl $0x6, -0x4(%rbp)
jmp 0x3846e
movl $0x5, -0x4(%rbp)
jmp 0x3846e
movl $0x7, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: FormationBase::SetUnumForPos(int, int, int)
bool FormationBase::SetUnumForPos(Unum player1, int index_i, int index_j) {
  int pos1 = mUnum2Index[player1], pos2 = mPos2Index[index_i][index_j - 1];
  Unum player2 = mIndex2Unum[pos2];
  if (player1 != player2) {
    swap(mIndex2Unum[pos1], mIndex2Unum[pos2]);
    swap(mUnum2Index[player1], mUnum2Index[player2]);
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x350, %rdi            # imm = 0x350
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x3fad0
movq -0x78(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
addq $0x270, %rdi            # imm = 0x270
movslq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x3faf0
movq %rax, %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x3fb10
movq -0x78(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addq $0x320, %rdi            # imm = 0x320
movslq -0x2c(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x3fad0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x44(%rbp), %eax
je 0x3877f
movq -0x78(%rbp), %rdi
addq $0x320, %rdi            # imm = 0x320
movslq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x3fad0
movq -0x78(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x320, %rdi            # imm = 0x320
movslq -0x2c(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x3fad0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x2b370
movq -0x78(%rbp), %rdi
addq $0x350, %rdi            # imm = 0x350
movslq -0x14(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x3fad0
movq -0x78(%rbp), %rdi
movq %rax, -0x80(%rbp)
addq $0x350, %rdi            # imm = 0x350
movslq -0x44(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x3fad0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x2b370
movb $0x1, -0x1(%rbp)
jmp 0x38783
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: FormationBase::GetFormationPoint(WorldState const&, bool, int, double)
Vector FormationBase::GetFormationPoint(const WorldState &world_state,
                                        bool is_teammate, Unum unum,
                                        double min_conf) {
  if (is_teammate) {
    return GetFormationCenter(world_state, is_teammate, min_conf) +
           mOffsetMatrix[0][mUnum2Index[unum]];
  } else {
    return GetFormationCenter(world_state, is_teammate, min_conf) -
           mOffsetMatrix[0][mUnum2Index[unum]];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dl, %al
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movl %ecx, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
testb $0x1, -0x21(%rbp)
je 0x38cfd
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb -0x21(%rbp), %al
movsd -0x30(%rbp), %xmm0
andb $0x1, %al
movzbl %al, %edx
callq 0x387a0
movq -0x68(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x380, %rdi            # imm = 0x380
movq $0x0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x3fb30
movq -0x68(%rbp), %rdi
movq %rax, -0x78(%rbp)
addq $0x350, %rdi            # imm = 0x350
movslq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x3fad0
movq -0x78(%rbp), %rdi
movslq (%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x3fb50
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x11360
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
jmp 0x38d87
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb -0x21(%rbp), %al
movsd -0x30(%rbp), %xmm0
andb $0x1, %al
movzbl %al, %edx
callq 0x387a0
movq -0x68(%rbp), %rdi
movq %rax, -0x80(%rbp)
addq $0x380, %rdi            # imm = 0x380
movq $0x0, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x3fb30
movq -0x68(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x350, %rdi            # imm = 0x350
movslq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x3fad0
movq -0x88(%rbp), %rdi
movslq (%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x3fb50
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: OpponentFormation::OpponentFormation(int, FormationType)
OpponentFormation::OpponentFormation(Unum goalie_unum, FormationType type)
    : FormationBase(type), mGoalieUnum(goalie_unum) {
  mTactics.bzero();
  map<string, FormationTacticType> formation_tactic_map;

  mUsedTimes = 0;
  mHIntervalTimes[0] = 0;
  mHIntervalTimes[1] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl -0x10(%rbp), %esi
callq 0x38480
movq -0x70(%rbp), %rdi
leaq 0xc1e08(%rip), %rax     # 0xfd788
movq %rax, (%rdi)
addq $0xc90, %rdi            # imm = 0xC90
movq %rdi, -0x68(%rbp)
callq 0x40390
jmp 0x3b995
movq -0x70(%rbp), %rdi
addq $0xce0, %rdi            # imm = 0xCE0
callq 0x403e0
jmp 0x3b9a7
movq -0x70(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0xce8(%rdi)
addq $0xcf0, %rdi            # imm = 0xCF0
callq 0x3fd70
jmp 0x3b9c2
movq -0x70(%rbp), %rdi
addq $0xcf0, %rdi            # imm = 0xCF0
callq 0x3fd80
jmp 0x3b9d4
leaq -0x50(%rbp), %rdi
callq 0x3fdb0
movq -0x70(%rbp), %rdi
movq $0x0, 0xcd8(%rdi)
addq $0xce0, %rdi            # imm = 0xCE0
movq $0x0, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x403f0
movq %rax, -0x78(%rbp)
jmp 0x3ba0a
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rax
movl $0x0, (%rax)
addq $0xce0, %rdi            # imm = 0xCE0
movq $0x1, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x403f0
movq %rax, -0x80(%rbp)
jmp 0x3ba36
movq -0x80(%rbp), %rax
movl $0x0, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x40160
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3ba8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3ba83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x40160
movq -0x68(%rbp), %rdi
callq 0x40410
movq -0x70(%rbp), %rdi
callq 0x40d70
movq -0x18(%rbp), %rdi
callq 0xaa60
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: Formation::Formation(Agent&)
Formation::Formation(Agent &agent) : mAgent(agent) {
  if (mAgent.IsReverse()) {
    mpTeammateFormation = &instance.GetOpponentFormation(FT_Attack_Forward);
    mpOpponentFormation = &instance.GetTeammateFormation(FT_Attack_Forward);
  } else {
    mpTeammateFormation = &instance.GetTeammateFormation(FT_Attack_Forward);
    mpOpponentFormation = &instance.GetOpponentFormation(FT_Attack_Forward);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0xc02d9(%rip), %rax     # 0xfd7e8
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
movq %rdi, -0x30(%rbp)
callq 0x40480
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x404b0
movb %al, -0x1d(%rbp)
jmp 0x3d539
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x3d542
jmp 0x3d59b
leaq 0xc7c87(%rip), %rdi     # 0x1051d0
xorl %esi, %esi
callq 0x404d0
movq %rax, -0x38(%rbp)
jmp 0x3d556
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0xc7c67(%rip), %rdi     # 0x1051d0
xorl %esi, %esi
callq 0x40500
movq %rax, -0x40(%rbp)
jmp 0x3d576
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x3d5db
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x40530
jmp 0x3d5e1
leaq 0xc7c2e(%rip), %rdi     # 0x1051d0
xorl %esi, %esi
callq 0x40500
movq %rax, -0x48(%rbp)
jmp 0x3d5af
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0xc7c0e(%rip), %rdi     # 0x1051d0
xorl %esi, %esi
callq 0x404d0
movq %rax, -0x50(%rbp)
jmp 0x3d5cf
movq -0x28(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xaa60
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: Formation::GetTeammateFormationPoint(int, Vector const&)
Vector Formation::GetTeammateFormationPoint(Unum unum, const Vector &ball_pos) {
  Assert(unum >= 1 && unum <= TEAMSIZE);

  Vector point;
  if (unum == mAgent.GetWorldState().GetTeammateGoalieUnum()) {
    return Vector(-47.5, 0);
  }

  point.SetX(ball_pos.X() * mpTeammateFormation->GetHBallFactor() +
             mpTeammateFormation->GetOffside(0, unum).X());
  point.SetY(ball_pos.Y() * mpTeammateFormation->GetVBallFactor() +
             mpTeammateFormation->GetOffside(0, unum).Y());
  return point;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
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 -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, -0x6c(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x1eeb0
movl %eax, %ecx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jne 0x3db8e
movsd 0x849e5(%rip), %xmm0    # 0xc2550
movsd %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x11a10
jmp 0x3dc82
movq -0x28(%rbp), %rdi
callq 0x176f0
movq %rax, %rcx
movq -0x78(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x98(%rbp)
movq 0x10(%rax), %rdi
callq 0x40550
movq -0x78(%rbp), %rax
movsd %xmm0, -0x90(%rbp)
movq 0x10(%rax), %rdi
movl -0x1c(%rbp), %edx
xorl %esi, %esi
callq 0x40570
movq %rax, %rdi
callq 0x176f0
movsd -0x98(%rbp), %xmm0
movsd -0x90(%rbp), %xmm2
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1ee90
movq -0x28(%rbp), %rdi
callq 0x17700
movq %rax, %rcx
movq -0x78(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x88(%rbp)
movq 0x10(%rax), %rdi
callq 0x40600
movq -0x78(%rbp), %rax
movsd %xmm0, -0x80(%rbp)
movq 0x10(%rax), %rdi
movl -0x1c(%rbp), %edx
xorl %esi, %esi
callq 0x40570
movq %rax, %rdi
callq 0x17700
movsd -0x88(%rbp), %xmm0
movsd -0x80(%rbp), %xmm2
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x26210
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: Formation::GetOpponentFormationPoint(int, Vector const&)
Vector Formation::GetOpponentFormationPoint(Unum unum, const Vector &ball_pos) {
  double x = ball_pos.X() * mpOpponentFormation->GetHBallFactor() -
             mpOpponentFormation->GetOffside(0, unum).X();
  if (mAgent.GetWorldState().GetPlayMode() == PM_Our_Kick_Off && x > 0) {
    x = 0.0;
  }
  double y = ball_pos.Y() * mpOpponentFormation->GetVBallFactor() -
             mpOpponentFormation->GetOffside(0, unum).Y();
  return Vector(x, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x176f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x50(%rbp)
movq 0x18(%rax), %rdi
callq 0x40550
movq -0x40(%rbp), %rax
movsd %xmm0, -0x48(%rbp)
movq 0x18(%rax), %rdi
movl -0x1c(%rbp), %edx
xorl %esi, %esi
callq 0x40570
movq %rax, %rdi
callq 0x176f0
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm2
movq %rax, %rcx
movq -0x40(%rbp), %rax
movsd (%rcx), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x10ed0
cmpl $0x2, %eax
jne 0x3e401
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3e401
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x17700
movq %rax, %rcx
movq -0x40(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x60(%rbp)
movq 0x18(%rax), %rdi
callq 0x40600
movq -0x40(%rbp), %rax
movsd %xmm0, -0x58(%rbp)
movq 0x18(%rax), %rdi
movl -0x1c(%rbp), %edx
xorl %esi, %esi
callq 0x40570
movq %rax, %rdi
callq 0x17700
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm2
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x11a10
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x60, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: Formation::IsOpponentRoleValid()
bool Formation::IsOpponentRoleValid() {
  return mAgent.IsReverse()
             ? true
             : (static_cast<OpponentFormation *>(mpOpponentFormation)
                    ->IsRoleValid());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x404b0
testb $0x1, %al
jne 0x3e4a3
jmp 0x3e4aa
movb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x3e4bb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: Formation::SetTeammateFormationType(FormationType)
void Formation::SetTeammateFormationType(FormationType type) {
  if (mAgent.IsReverse()) {
    mpTeammateFormation = &instance.GetOpponentFormation(type);
  } else {
    mpTeammateFormation = &instance.GetTeammateFormation(type);
  }
}

// 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)
movq 0x8(%rax), %rdi
callq 0x404b0
testb $0x1, %al
jne 0x3e4f6
jmp 0x3e512
movl -0xc(%rbp), %esi
leaq 0xc6cd0(%rip), %rdi     # 0x1051d0
callq 0x404d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x3e52c
movl -0xc(%rbp), %esi
leaq 0xc6cb4(%rip), %rdi     # 0x1051d0
callq 0x40500
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: Formation::SetOpponentFormationType(FormationType)
void Formation::SetOpponentFormationType(FormationType type) {
  if (mAgent.IsReverse()) {
    mpOpponentFormation = &instance.GetTeammateFormation(type);
  } else {
    mpOpponentFormation = &instance.GetOpponentFormation(type);
  }
}

// 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)
movq 0x8(%rax), %rdi
callq 0x404b0
testb $0x1, %al
jne 0x3e566
jmp 0x3e582
movl -0xc(%rbp), %esi
leaq 0xc6c60(%rip), %rdi     # 0x1051d0
callq 0x40500
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3e59c
movl -0xc(%rbp), %esi
leaq 0xc6c44(%rip), %rdi     # 0x1051d0
callq 0x404d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Formation.cpp
// Function: Formation::Rollback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Formation::Rollback(std::string update_name) {
  if (!mFormationTypeStack.empty()) {
    mFormationTypeStack.pop();
    if (!mFormationTypeStack.empty()) {
      SetTeammateFormationType(mFormationTypeStack.top().first);
      SetOpponentFormationType(mFormationTypeStack.top().second);
    }
  } else {
    Assert(!"mFormationTypeStack.empty()");
  }

  Logger::instance().GetTextLogger("formation_update")
      << mAgent.GetWorldState().CurrentTime() << ", " << mAgent.GetAgentID()
      << ", -, " << mFormationTypeStack.size() << ": " << update_name << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x20, %rdi
callq 0x40970
testb $0x1, %al
jne 0x3e93a
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x40990
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x40970
testb $0x1, %al
jne 0x3e938
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x409b0
movq -0x40(%rbp), %rdi
movl (%rax), %esi
callq 0x3e4d0
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x409b0
movq -0x40(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x3e540
jmp 0x3e93c
jmp 0x3e93c
callq 0x5add0
movq %rax, %rdi
leaq 0x83c2d(%rip), %rsi     # 0xc2578
callq 0x5b110
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x60(%rbp)
movq 0x8(%rax), %rdi
callq 0x10550
movq %rax, %rdi
callq 0x12100
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1a640
movq %rax, %rdi
leaq 0x83c0a(%rip), %rsi     # 0xc258c
callq 0x40760
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rdi
callq 0x40800
movq -0x58(%rbp), %rdi
movq %rdx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movb -0x24(%rbp), %al
movb %al, -0x14(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x407b0
movq %rax, %rdi
leaq 0x83bc1(%rip), %rsi     # 0xc258f
callq 0x40860
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x20, %rdi
callq 0x40900
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x408b0
movq %rax, %rdi
leaq 0x84b61(%rip), %rsi     # 0xc3560
callq 0x40760
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x40920
movq %rax, %rdi
movq 0xbf596(%rip), %rsi     # 0xfdfb0
callq 0x1a7c0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)