LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorPass.h
// Function: BehaviorPassExecuter::SubmitVisualRequest(ActiveBehavior const&, double)
void SubmitVisualRequest(const ActiveBehavior &pass, double plus = 0.0) {
    if (pass.mKickCycle == 1) {
      VisualSystem::instance().RaisePlayer(mAgent, pass.mKeyTm.mUnum,
                                           3.0 + plus);
      VisualSystem::instance().RaisePlayer(mAgent, -pass.mKeyOppGB.mUnum,
                                           3.0 + plus);
      VisualSystem::instance().RaisePlayer(mAgent, -pass.mKeyOppGT.mUnum,
                                           3.0 + plus);
    } else {
      VisualSystem::instance().RaisePlayer(mAgent, pass.mKeyTm.mUnum,
                                           2.0 + plus);
      VisualSystem::instance().RaisePlayer(mAgent, -pass.mKeyOppGB.mUnum,
                                           3.0 + plus);
      VisualSystem::instance().RaisePlayer(mAgent, -pass.mKeyOppGT.mUnum,
                                           2.0 + plus);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x24052
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edx
movsd 0x9dbce(%rip), %xmm0    # 0xc1bb8
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
xorl %edx, %edx
subl 0x78(%rax), %edx
movsd 0x9dba3(%rip), %xmm0    # 0xc1bb8
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
xorl %edx, %edx
subl 0x88(%rax), %edx
movsd 0x9db75(%rip), %xmm0    # 0xc1bb8
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
jmp 0x240d4
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %edx
movsd 0x9d43f(%rip), %xmm0    # 0xc14b0
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
xorl %edx, %edx
subl 0x78(%rax), %edx
movsd 0x9db1c(%rip), %xmm0    # 0xc1bb8
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
xorl %edx, %edx
subl 0x88(%rax), %edx
movsd 0x9d3e6(%rip), %xmm0    # 0xc14b0
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorPosition.h
// Function: BehaviorPositionExecuter::SubmitVisualRequest(ActiveBehavior const&, double)
void SubmitVisualRequest(const ActiveBehavior &position, double plus = 0.0) {
    (void)position;
    (void)plus;

    if (fabs(mSelfState.GetPos().X() - mPositionInfo.GetTeammateOffsideLine()) <
        30.0) {
      VisualSystem::instance().RaisePlayer(
          mAgent, -mPositionInfo.GetTeammateOffsideLineOpp(), 3.0);
    }

    if (mSelfState.GetUnum() == mPositionInfo.GetCloseTeammateToBall()[0] ||
        mSelfState.GetUnum() == mPositionInfo.GetCloseTeammateToBall()[1]) {
      VisualSystem::instance().RaiseBall(mAgent, 2);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rax), %rdi
addq $0x8, %rdi
callq 0x11090
movq %rax, %rdi
callq 0x176f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x28(%rax), %rdi
callq 0x26500
movsd -0x20(%rbp), %xmm1
subsd (%rax), %xmm1
movaps 0x9aca5(%rip), %xmm0    # 0xc1060
pand %xmm0, %xmm1
movsd 0x9b319(%rip), %xmm0    # 0xc16e0
ucomisd %xmm1, %xmm0
jbe 0x26407
callq 0xa47b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x28(%rax), %rdi
callq 0x26520
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
subl (%rax), %edx
movsd 0x9b7b6(%rip), %xmm0    # 0xc1bb8
callq 0x1ded0
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1b470
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x3c(%rbp)
movq 0x28(%rax), %rdi
callq 0x802c0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b610
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl (%rcx), %eax
je 0x26472
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1b470
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x40(%rbp)
movq 0x28(%rax), %rdi
callq 0x802c0
movq %rax, %rdi
movl $0x1, %esi
callq 0x1b610
movq %rax, %rcx
movl -0x40(%rbp), %eax
cmpl (%rcx), %eax
jne 0x2648f
callq 0xa47b0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movsd 0x9b026(%rip), %xmm0    # 0xc14b0
callq 0x25370
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorShoot.cpp
// Function: BehaviorShootExecuter::Execute(ActiveBehavior const&)
bool BehaviorShootExecuter::Execute(const ActiveBehavior &shoot) {
  Logger::instance().LogShoot(mBallState.GetPos(), shoot.mTarget, "@Shoot");
  if (shoot.mDetailType == BDT_Shoot_Tackle)
    return Tackler::instance().TackleToDir(mAgent, shoot.mAngle);
  else
    return Kicker::instance().KickBall(mAgent, shoot.mTarget,
                                       ServerParam::instance().ballSpeedMax(),
                                       KM_Quick, 0, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x5add0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
addq $0x28, %rdx
leaq 0x9a8e0(%rip), %rcx     # 0xc1f1b
callq 0x5b580
movq -0x18(%rbp), %rax
cmpl $0x9, 0x98(%rax)
jne 0x27673
callq 0x8b3f0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
addq $0x20, %rdx
xorl %ecx, %ecx
callq 0x8c2d0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x276ce
callq 0x4ff20
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
callq 0x855e0
movq %rax, %rdi
callq 0x23d60
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movsd (%rax), %xmm0
movl $0x2, %ecx
xorl %eax, %eax
movl %eax, %r8d
movl $0x1, %r9d
callq 0x541f0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/BehaviorShoot.h
// Function: BehaviorShootExecuter::SubmitVisualRequest(ActiveBehavior const&, double)
void SubmitVisualRequest(const ActiveBehavior &shoot, double plus = 0.0) {
    Assert(shoot.mKeyOppGT.mUnum >= 0);
    Assert(shoot.mKeyOppGB.mUnum >= 0);

    VisualSystem::instance().RaisePlayer(
        mAgent, -mWorldState.GetOpponentGoalieUnum(), 1.0 + plus);
    VisualSystem::instance().RaisePlayer(mAgent, -shoot.mKeyOppGT.mUnum,
                                         2.0 + plus);
    VisualSystem::instance().RaisePlayer(mAgent, -shoot.mKeyOppGB.mUnum,
                                         2.0 + plus);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xa47b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rdi
callq 0x25310
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
subl %eax, %edx
movsd 0x9918e(%rip), %xmm0    # 0xc1010
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
xorl %edx, %edx
subl 0x88(%rax), %edx
movsd 0x99600(%rip), %xmm0    # 0xc14b0
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
callq 0xa47b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
xorl %edx, %edx
subl 0x78(%rax), %edx
movsd 0x995d5(%rip), %xmm0    # 0xc14b0
addsd -0x18(%rbp), %xmm0
callq 0x1ded0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Client.cpp
// Function: Client::~Client()
Client::~Client() {
  delete mpCommandSender;
  delete mpParser;

  delete mpObserver;
  delete mpWorldModel;
  delete mpAgent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xd53c5(%rip), %rcx     # 0xfd580
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x281da
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x281f6
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x28212
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2822e
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2824a
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Client.cpp
// Function: Client::RunDynamicDebug()
void Client::RunDynamicDebug() {
  static char msg[MAX_MESSAGE];
  DynamicDebug::instance().Initial(
      mpObserver); // 动态调试的初始化，注意位置不能移动

  DynamicDebug::instance().Run(msg); // 初始化信息
  mpParser->ParseInitializeMsg(msg);

  ConstructAgent();

  MessageType msg_type;

  bool first_parse = true;

  while (true) {
    msg_type = DynamicDebug::instance().Run(msg);

    switch (msg_type) {
    case MT_Parse:
      if (first_parse) {
        mpObserver->Reset();
        first_parse = false;
      }
      mpParser->Parse(msg);
      break;
    case MT_Run:
      Run();
      Logger::instance().Flush(); // flush log
      mpObserver->SetPlanned();
      break;
    case MT_Send:
      mpCommandSender->Run();
      first_parse = true;
      break;
    default:
      return;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x33ef0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x33f80
callq 0x33ef0
movq %rax, %rdi
leaq 0xd89b8(%rip), %rsi     # 0x100c50
callq 0x345e0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0xd89a4(%rip), %rsi     # 0x100c50
callq 0x71fb0
movq -0x18(%rbp), %rdi
callq 0x28370
movb $0x1, -0xd(%rbp)
callq 0x33ef0
movq %rax, %rdi
leaq 0xd8983(%rip), %rsi     # 0x100c50
callq 0x345e0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x282f6
jmp 0x282e2
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x28323
jmp 0x282ec
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x28349
jmp 0x28360
testb $0x1, -0xd(%rbp)
je 0x2830d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x68d80
movb $0x0, -0xd(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0xd8934(%rip), %rsi     # 0x100c50
callq 0x71640
jmp 0x28366
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
callq 0x5add0
movq %rax, %rdi
callq 0x5b000
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28820
jmp 0x28366
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2bda0
movb $0x1, -0xd(%rbp)
jmp 0x28366
addq $0x20, %rsp
popq %rbp
retq
jmp 0x282be
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Client.cpp
// Function: Client::RunNormal()
void Client::RunNormal() {

  mpCommandSender->Start();   //发送命令线程，向server发送信息
  Logger::instance().Start(); // log线程
  mpParser->Start();          //分析线程，接受server发来的信息

  int past_cycle = 0;
  do {
    WaitFor(100); // wait for the parser thread to connect the server
    if (++past_cycle > 20) {
      std::cout << PlayerParam::instance().teamName()
                << ": Connect Server Error ..." << std::endl;
      return;
    }
  } while (mpParser->IsConnectServerOk() == false);

  ConstructAgent();

  SendOptionToServer();

  MainLoop();

  WaitFor(mpObserver->SelfUnum() * 100);
  if (mpObserver->SelfUnum() == 0) {
    std::cout << PlayerParam::instance().teamName() << " Coach: Bye ..."
              << std::endl;
  } else {
    std::cout << PlayerParam::instance().teamName() << " "
              << mpObserver->SelfUnum() << ": Bye ..." << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x28(%rax), %rdi
callq 0x8ec30
callq 0x5add0
movq %rax, %rdi
callq 0x8ec30
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x8ec30
movl $0x0, -0xc(%rbp)
movl $0x64, %edi
callq 0x28840
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x14, %eax
jle 0x285f5
callq 0x798a0
movq %rax, %rdi
callq 0x11db0
movq %rax, %rsi
movq 0xd59f3(%rip), %rdi     # 0xfdfc0
callq 0xa4f0
movq %rax, %rdi
leaq 0x9999f(%rip), %rsi     # 0xc1f7b
callq 0xa5a0
movq %rax, %rdi
movq 0xd59c5(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x286f5
jmp 0x285f7
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x28860
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x2859e
movq -0x18(%rbp), %rdi
callq 0x28370
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x28700
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11dd0
imull $0x64, (%rax), %edi
callq 0x28840
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11dd0
cmpl $0x0, (%rax)
jne 0x2868d
callq 0x798a0
movq %rax, %rdi
callq 0x11db0
movq %rax, %rsi
movq 0xd5958(%rip), %rdi     # 0xfdfc0
callq 0xa4f0
movq %rax, %rdi
leaq 0x9991f(%rip), %rsi     # 0xc1f96
callq 0xa5a0
movq %rax, %rdi
movq 0xd592a(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x286f5
callq 0x798a0
movq %rax, %rdi
callq 0x11db0
movq %rax, %rsi
movq 0xd591c(%rip), %rdi     # 0xfdfc0
callq 0xa4f0
movq %rax, %rdi
leaq 0x9c629(%rip), %rsi     # 0xc4cdc
callq 0xa5a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x11dd0
movq -0x20(%rbp), %rdi
movl (%rax), %esi
callq 0xaa40
movq %rax, %rdi
leaq 0x998bb(%rip), %rsi     # 0xc1f9c
callq 0xa5a0
movq %rax, %rdi
movq 0xd58c0(%rip), %rsi     # 0xfdfb0
callq 0xa630
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Client.cpp
// Function: Client::MainLoop()
void Client::MainLoop() {
  while (mpObserver->WaitForNewInfo()) // 等待新视觉
  {
    NetworkTest::instance().AddDecisionBegin();

    // 比赛结束，bye ...
    if (mpObserver->GetPlayMode() == PM_Time_Over) {
      mpAgent->CheckCommands(mpObserver);
      mpAgent->Bye();

      mpObserver->SetPlanned();
      mpObserver->SetCommandSend();
      Logger::instance().SetFlushCond();

      break;
    }

    DynamicDebug::instance().AddMessage("\0", MT_Run); // 动态调试记录Run信息
    Run();

    mpObserver->SetPlanned();
    mpObserver->SetCommandSend();      //唤醒发送命令的线程
    Logger::instance().SetFlushCond(); // set flush cond and let the logger
                                       // thread flush the logs to file.

    NetworkTest::instance().AddDecisionEnd(mpObserver->CurrentTime());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6d480
testb $0x1, %al
jne 0x2872a
jmp 0x2880c
callq 0x63700
movq %rax, %rdi
callq 0x64420
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28970
cmpl $0x1d, (%rax)
jne 0x28790
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x28990
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x28a00
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28820
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6d960
callq 0x5add0
movq %rax, %rdi
callq 0x5b310
jmp 0x2880c
callq 0x33ef0
movq %rax, %rdi
leaq 0x9989f(%rip), %rsi     # 0xc203e
movl $0x2, %edx
callq 0x34320
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28820
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6d960
callq 0x5add0
movq %rax, %rdi
callq 0x5b310
callq 0x63700
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x11a70
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x64470
jmp 0x28714
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.h
// Function: Parser::IsConnectServerOk()
bool IsConnectServerOk() {
    bool ret;
    mOkMutex.Lock();
    ret = mConnectServerOk;
    mOkMutex.UnLock();
    return ret;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x20, %rdi
callq 0x8ebb0
movq -0x18(%rbp), %rdi
movb 0x4c(%rdi), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
addq $0x20, %rdi
callq 0x8ebe0
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.h
// Function: PlayerState::SetIsAlive(bool)
inline void PlayerState::SetIsAlive(bool alive) {
  mIsAlive = alive;

  if (!mIsAlive) {
    UpdatePos(GetPos(), GetPosDelay(), 0.0);
    UpdateVel(GetVel(), GetVelDelay(), 0.0);

    mNeckDir.mConf = 0.0;
    mBodyDir.mConf = 0.0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x112(%rax)
testb $0x1, 0x112(%rax)
jne 0x28943
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x11090
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x1ddd0
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
movl %eax, %edx
xorps %xmm0, %xmm0
callq 0x142f0
movq -0x18(%rbp), %rdi
callq 0x10a80
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x28a30
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
movl %eax, %edx
xorps %xmm0, %xmm0
callq 0x142a0
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0xa8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Coach.cpp
// Function: Coach::Run()
void Coach::Run() {
  mpObserver->Lock();

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

  mpObserver->UnLock();

  // do planning...

  if (ServerParam::instance().synchMode()) {
    mpAgent->Done();
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x29870
leaq 0xdbe9c(%rip), %rdi     # 0x1051d0
callq 0x3ee20
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x28990
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0xaae30
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x298a0
callq 0x855e0
movq %rax, %rdi
callq 0x298d0
testb $0x1, %al
jne 0x2937b
jmp 0x29388
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x298f0
callq 0x5add0
movq %rax, %rdi
callq 0x5b410
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.h
// Function: Parser::IsEyeOnOk()
bool IsEyeOnOk() {
    bool ret;
    mOkMutex.Lock();
    ret = mEyeOnOk;
    mOkMutex.UnLock();
    return ret;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x20, %rdi
callq 0x8ebb0
movq -0x18(%rbp), %rdi
movb 0x4f(%rdi), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
addq $0x20, %rdi
callq 0x8ebe0
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommandSender.cpp
// Function: CommandSender::StartRoutine()
void CommandSender::StartRoutine() {
  static char msg[MAX_MESSAGE];

  while (mpObserver->WaitForCommandSend()) {
    NetworkTest::instance().AddCommandSendBegin();

    strcpy(msg, "record_cmd: ");
    Run(msg);
    DynamicDebug::instance().AddMessage(msg, MT_Send);

    NetworkTest::instance().AddCommandSendEnd(mpObserver->CurrentTime());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6d810
testb $0x1, %al
jne 0x2bd17
jmp 0x2bd92
callq 0x63700
movq %rax, %rdi
callq 0x64510
leaq 0xd6f45(%rip), %rdi     # 0x102c70
leaq 0x96340(%rip), %rsi     # 0xc2072
callq 0xa540
movq -0x18(%rbp), %rdi
leaq 0xd6f2e(%rip), %rsi     # 0x102c70
callq 0x2bda0
callq 0x33ef0
movq %rax, %rdi
leaq 0xd6f1a(%rip), %rsi     # 0x102c70
movl $0x3, %edx
callq 0x34320
callq 0x63700
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rdi
callq 0x11a70
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x64560
jmp 0x2bd04
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommandSender.cpp
// Function: CommandSender::Run(char*)
void CommandSender::Run(char *msg) {
  if (mpAgent != 0) {
    mpAgent->SendCommands(msg);
  } else {
    PRINT_ERROR("null agent");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x2bdd2
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2be60
jmp 0x2be32
jmp 0x2bdd4
movq 0xd2215(%rip), %rdi     # 0xfdff0
leaq 0x9629d(%rip), %rsi     # 0xc207f
callq 0xa5a0
movq %rax, %rdi
leaq 0x99460(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x3e, %esi
callq 0xaa40
movq %rax, %rdi
leaq 0x97752(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x9627c(%rip), %rsi     # 0xc2098
callq 0xa5a0
movq %rax, %rdi
movq 0xd2185(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x2be32
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::BitCountOfEps(double, CommunicateSystem::CodecType)
int CommunicateSystem::BitCountOfEps(double eps, CodecType type) {
  double min = 0.0, max = 1.0;
  GetCodecRange(type, min, max);

  double range = (max - min) / eps;
  return static_cast<int>(ceil(log(range) / log(2.0)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x94da8(%rip), %xmm0    # 0xc1010
movsd %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %esi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x2c3d0
movsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
divsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa490
movsd %xmm0, -0x38(%rbp)
movsd 0x95208(%rip), %xmm0    # 0xc14b0
callq 0xa490
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0xa110
cvttsd2si %xmm0, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::GetCodecRange(CommunicateSystem::CodecType, double&, double&)
void CommunicateSystem::GetCodecRange(CodecType type, double &min,
                                      double &max) {
  switch (type) {
  case POS_X:
    min = -ServerParam::instance().PITCH_LENGTH * 0.5;
    max = ServerParam::instance().PITCH_LENGTH * 0.5;
    break;
  case POS_Y:
    min = -ServerParam::instance().PITCH_WIDTH * 0.5;
    max = ServerParam::instance().PITCH_WIDTH * 0.5;
    break;
  case BALL_SPEED:
    min = 0.0;
    max = ServerParam::instance().ballSpeedMax();
    break;
  case PLAYER_SPEED:
    min = 0.0;
    max = ServerParam::instance().playerSpeedMax();
    break;
  case DIR:
    min = -180.0;
    max = 180.0;
    break;
  default:
    PRINT_ERROR("unknown codec type");
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x2c540
movq -0x28(%rbp), %rax
leaq 0x95cdd(%rip), %rcx     # 0xc20e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x855e0
leaq 0x97c20(%rip), %rax     # 0xc4038
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x94be5(%rip), %xmm1    # 0xc1020
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
callq 0x855e0
movsd 0x94bcc(%rip), %xmm0    # 0xc1020
leaq 0x97bdd(%rip), %rax     # 0xc4038
mulsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x2c5a0
callq 0x855e0
leaq 0x97bc8(%rip), %rax     # 0xc4040
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x94b85(%rip), %xmm1    # 0xc1020
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
callq 0x855e0
movsd 0x94b6c(%rip), %xmm0    # 0xc1020
leaq 0x97b85(%rip), %rax     # 0xc4040
mulsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x2c5a0
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
callq 0x855e0
movq %rax, %rdi
callq 0x23d60
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x2c5a0
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
callq 0x855e0
movq %rax, %rdi
callq 0x2e600
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x2c5a0
movq -0x18(%rbp), %rax
movsd 0x94b06(%rip), %xmm0    # 0xc1030
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd 0x94aee(%rip), %xmm0    # 0xc1028
movsd %xmm0, (%rax)
jmp 0x2c5a0
jmp 0x2c542
movq 0xd1aa7(%rip), %rdi     # 0xfdff0
leaq 0x95c0a(%rip), %rsi     # 0xc215a
callq 0xa5a0
movq %rax, %rdi
leaq 0x98cf2(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0xa0, %esi
callq 0xaa40
movq %rax, %rdi
leaq 0x96fe4(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x95bed(%rip), %rsi     # 0xc2177
callq 0xa5a0
movq %rax, %rdi
movq 0xd1a17(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x2c5a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::DoubleToBit(double, CommunicateSystem::CodecType)
CommunicateSystem::DWORD64
CommunicateSystem::DoubleToBit(double value,
                               CommunicateSystem::CodecType type) {
  int range = static_cast<int>((*mpCodecMask)[type]); // [0, range]

  double min = 0.0, max = 1.0;
  GetCodecRange(type, min, max);

  if (value > max) {
    value = max - 0.001 * max;
  } else if (value < min) {
    value = min + 0.001 * min;
  }

  return static_cast<DWORD64>(
      ((value - min) / (max - min) * static_cast<double>(range)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq 0xc8(%rdi), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x94a27(%rip), %xmm0    # 0xc1010
movsd %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %esi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x2c3d0
movsd -0x10(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x2c62b
movsd -0x28(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
movsd 0x95abc(%rip), %xmm2    # 0xc20d8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x2c65c
movsd -0x10(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2c65a
movsd -0x20(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
movsd 0x95a83(%rip), %xmm2    # 0xc20d0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x2c65c
movsd -0x10(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
cvtsi2sdl -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::BitToDouble(long, CommunicateSystem::CodecType)
double CommunicateSystem::BitToDouble(DWORD64 bits,
                                      CommunicateSystem::CodecType type) {
  int range = static_cast<int>((*mpCodecMask)[type]); // [0, range]
  DWORD64 mask = (*mpCodecMask)[type];

  double min = 0.0, max = 1.0;
  GetCodecRange(type, min, max);

  return static_cast<double>(bits & mask) / static_cast<double>(range) *
             (max - min) +
         min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq 0xc8(%rdi), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x18(%rbp)
movq 0xc8(%rdi), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x94936(%rip), %xmm0    # 0xc1010
movsd %xmm0, -0x30(%rbp)
movl -0x14(%rbp), %esi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x2c3d0
movq -0x10(%rbp), %rax
andq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm0
cvtsi2sdl -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd -0x30(%rbp), %xmm2
subsd -0x28(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::Encode(long, unsigned char*, bool)
void CommunicateSystem::Encode(DWORD64 bits, unsigned char *msg,
                               bool is_coach) {
  int i = 0, rem;

  while (bits != 0 || (is_coach && i < MAX_MSG_SIZE)) {
    rem = bits % CODE_SIZE;
    bits = (bits - rem) / CODE_SIZE;
    if (i >= MAX_MSG_SIZE) {
      PRINT_ERROR("codec msg size greater than " << MAX_MSG_SIZE);
      break;
    }
    msg[i++] = CODE[rem];
  }
  msg[i] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x25(%rbp)
jne 0x2c779
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x26(%rbp)
je 0x2c773
cmpl $0xa, -0x20(%rbp)
setl %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x2c785
jmp 0x2c84c
movq -0x10(%rbp), %rax
movl $0x49, %ecx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
subq %rcx, %rax
movl $0x49, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
cmpl $0xa, -0x20(%rbp)
jl 0x2c824
jmp 0x2c7b9
movq 0xd1830(%rip), %rdi     # 0xfdff0
leaq 0x95993(%rip), %rsi     # 0xc215a
callq 0xa5a0
movq %rax, %rdi
leaq 0x98a7b(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0xcc, %esi
callq 0xaa40
movq %rax, %rdi
leaq 0x96d6d(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x95989(%rip), %rsi     # 0xc218a
callq 0xa5a0
movq %rax, %rdi
movl $0xa, %esi
callq 0xaa40
movq %rax, %rdi
movq 0xd1793(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x2c84c
movq 0xd1dfd(%rip), %rax     # 0xfe628
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x2c752
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::Decode(unsigned char const*, long&, bool)
void CommunicateSystem::Decode(const unsigned char *msg, DWORD64 &bits,
                               bool is_coach) {
  int n = is_coach ? MAX_MSG_SIZE : strlen((const char *)msg);
  bits = 0;
  DWORD64 plus = 1;
  for (int i = 0; i < n; ++i) {
    bits += CODE_TO_INT[msg[i]] * plus;
    plus *= CODE_SIZE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x2c88c
movl $0xa, %eax
movq %rax, -0x38(%rbp)
jmp 0x2c899
movq -0x10(%rbp), %rdi
callq 0xa260
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x1, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x2c8fe
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xd83a9(%rip), %rax     # 0x104c80
movslq (%rax,%rcx,4), %rcx
imulq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
imulq $0x49, -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2c8ba
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::PrintBits(long)
void CommunicateSystem::PrintBits(DWORD64 bits) {
  UDWORD64 mask = 1;
  mask <<= 63;

  while (mask != 0) {
    if (bits & mask)
      cerr << '1';
    else
      cerr << '0';
    mask >>= 1;
  }
  cerr << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x3f, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c97a
movq -0x10(%rbp), %rax
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x2c95c
movq 0xd16a0(%rip), %rdi     # 0xfdff0
movl $0x31, %esi
callq 0xa6e0
jmp 0x2c96d
movq 0xd168d(%rip), %rdi     # 0xfdff0
movl $0x30, %esi
callq 0xa6e0
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x18(%rbp)
jmp 0x2c934
movq 0xd166f(%rip), %rdi     # 0xfdff0
movq 0xd1628(%rip), %rsi     # 0xfdfb0
callq 0xa630
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::Update()
void CommunicateSystem::Update() {
  // some reset work
  mCommuBits = 0;
  mBitsUsed = 0;
  mBallSended = false;

  mTeammateSended.bzero();
  mOpponentSended.bzero();

  mCommuType = FREE_FORM;
  SetCommunicateType(FREE_FORM);

  // our coach say
  if (mpObserver->Audio().IsOurCoachSayValid()) {
    ;
  }

  // teammate say
  if (mpObserver->Audio().IsTeammateSayValid()) {
    ParseReceivedTeammateMsg(
        (unsigned char *)(mpObserver->Audio().GetTeammateSayContent().c_str()));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, 0x18(%rdi)
movl $0x0, 0x20(%rdi)
movb $0x0, 0x24(%rdi)
addq $0x25, %rdi
callq 0x2e620
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x2e620
movq -0x10(%rbp), %rdi
movl $0x0, 0x3c(%rdi)
xorl %esi, %esi
callq 0x2e640
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2e690
movq %rax, %rdi
callq 0x2e6b0
testb $0x1, (%rax)
je 0x2ca0b
jmp 0x2ca0b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2e690
movq %rax, %rdi
callq 0x2e6c0
testb $0x1, (%rax)
je 0x2ca4e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2e690
movq %rax, %rdi
callq 0x2e6e0
movq %rax, %rdi
callq 0xa240
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x2ca60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::ParseReceivedTeammateMsg(unsigned char*)
void CommunicateSystem::ParseReceivedTeammateMsg(unsigned char *msg) {
  DWORD64 bits;
  // cerr << mpObserver->CurrentTime() << " (h) " << msg << endl;

  Decode(msg, bits);

  DWORD64 mask = 1;
  mask <<= (MAX_BITS_USED + mCommuFlagBitCount);
  mask -= 1;
  bits += ~mask; //高三位补1

  CommuType type = static_cast<CommuType>(bits & mCommuFlagMask);
  bits >>= mCommuFlagBitCount;

  if (type == FREE_FORM) {
    Logger::instance().GetTextLogger("receive") << "freeform" << endl;
    RecvFreeForm(bits);
  } else {
    Logger::instance().GetTextLogger("receive") << "???" << endl;
    PRINT_ERROR(msg);
    // TODO: 其他信息
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2c860
movq -0x30(%rbp), %rax
movq $0x1, -0x20(%rbp)
movl 0xd1b97(%rip), %ecx     # 0xfe630
addl 0x40(%rax), %ecx
movq -0x20(%rbp), %rdx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorq $-0x1, %rcx
addq -0x18(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
andq 0x48(%rax), %rcx
movl %ecx, -0x24(%rbp)
movl 0x40(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
sarq %cl, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x2cb2d
callq 0x5add0
movq %rax, %rdi
leaq 0x95748(%rip), %rsi     # 0xc2240
callq 0x5b110
movq %rax, %rdi
leaq 0x956b8(%rip), %rsi     # 0xc21bf
callq 0x2e970
movq %rax, %rdi
movq 0xd149a(%rip), %rsi     # 0xfdfb0
callq 0x1a7c0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2dd00
jmp 0x2cbba
callq 0x5add0
movq %rax, %rdi
leaq 0x95704(%rip), %rsi     # 0xc2240
callq 0x5b110
movq %rax, %rdi
leaq 0x9519f(%rip), %rsi     # 0xc1cea
callq 0x2e9c0
movq %rax, %rdi
movq 0xd1456(%rip), %rsi     # 0xfdfb0
callq 0x1a7c0
movq 0xd148a(%rip), %rdi     # 0xfdff0
leaq 0x955ed(%rip), %rsi     # 0xc215a
callq 0xa5a0
movq %rax, %rdi
leaq 0x986d5(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x258, %esi            # imm = 0x258
callq 0xaa40
movq %rax, %rdi
leaq 0x969c7(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xa5f0
movq %rax, %rdi
movq 0xd13fd(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x2cbba
addq $0x30, %rsp
popq %rbp
retq
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::AddDataToCommuBits(double, CommunicateSystem::CodecType)
bool CommunicateSystem::AddDataToCommuBits(double value, CodecType type) {
  if (mBitsUsed + (*mpCodecBitCount)[type] > MAX_BITS_USED) {
    PRINT_ERROR("bits used greater then " << MAX_BITS_USED);
    return false;
  } else {
    mCommuBits <<= (*mpCodecBitCount)[type];
    mCommuBits += DoubleToBit(value, type);
    mBitsUsed += (*mpCodecBitCount)[type];

    return true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl 0x20(%rcx), %eax
movq 0xc0(%rcx), %rcx
movl -0x1c(%rbp), %edx
addl (%rcx,%rdx,4), %eax
cmpl 0xd1a3e(%rip), %eax     # 0xfe630
jle 0x2cc66
jmp 0x2cbf6
movq 0xd13f3(%rip), %rdi     # 0xfdff0
leaq 0x95556(%rip), %rsi     # 0xc215a
callq 0xa5a0
movq %rax, %rdi
leaq 0x9863e(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x107, %esi            # imm = 0x107
callq 0xaa40
movq %rax, %rdi
leaq 0x96930(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x95569(%rip), %rsi     # 0xc21a7
callq 0xa5a0
movq %rax, %rdi
movl 0xd19e4(%rip), %esi     # 0xfe630
callq 0xaa40
movq %rax, %rdi
movq 0xd1355(%rip), %rsi     # 0xfdfb0
callq 0xa630
movb $0x0, -0x1(%rbp)
jmp 0x2ccb7
movq -0x28(%rbp), %rdi
movq 0xc0(%rdi), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %ecx
movq 0x18(%rdi), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, 0x18(%rdi)
movsd -0x18(%rbp), %xmm0
movl -0x1c(%rbp), %esi
callq 0x2c5b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0xc0(%rax), %rcx
movl -0x1c(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%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/CommunicateSystem.cpp
// Function: CommunicateSystem::AddFreeFormFlagToCommuBits(CommunicateSystem::FreeFormType)
bool CommunicateSystem::AddFreeFormFlagToCommuBits(FreeFormType type) {
  if (mBitsUsed + mFreeFormFlagBitCount > MAX_BITS_USED) {
    PRINT_ERROR("bits used greater then " << MAX_BITS_USED);
    return false;
  } else {
    mCommuBits <<= mFreeFormFlagBitCount;
    mCommuBits += static_cast<DWORD64>(type);
    mBitsUsed += mFreeFormFlagBitCount;

    return true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x20(%rcx), %eax
addl 0x50(%rcx), %eax
cmpl 0xd193d(%rip), %eax     # 0xfe630
jle 0x2cd67
jmp 0x2ccf7
movq 0xd12f2(%rip), %rdi     # 0xfdff0
leaq 0x95455(%rip), %rsi     # 0xc215a
callq 0xa5a0
movq %rax, %rdi
leaq 0x9853d(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x114, %esi            # imm = 0x114
callq 0xaa40
movq %rax, %rdi
leaq 0x9682f(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x95468(%rip), %rsi     # 0xc21a7
callq 0xa5a0
movq %rax, %rdi
movl 0xd18e3(%rip), %esi     # 0xfe630
callq 0xaa40
movq %rax, %rdi
movq 0xd1254(%rip), %rsi     # 0xfdfb0
callq 0xa630
movb $0x0, -0x1(%rbp)
jmp 0x2cd96
movq -0x20(%rbp), %rax
movl 0x50(%rax), %ecx
movq 0x18(%rax), %rdx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %ecx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movl 0x50(%rax), %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%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/CommunicateSystem.cpp
// Function: CommunicateSystem::AddCommuFlagToCommuBits(CommunicateSystem::CommuType)
bool CommunicateSystem::AddCommuFlagToCommuBits(CommuType type) {
  mCommuBits <<= mCommuFlagBitCount;
  mCommuBits += static_cast<DWORD64>(type);
  mBitsUsed += mCommuFlagBitCount;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
movq 0x18(%rax), %rdx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movl 0x40(%rax), %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::AddUnumToCommuBits(int)
bool CommunicateSystem::AddUnumToCommuBits(Unum num) {
  if (mBitsUsed + mUnumBitCount > MAX_BITS_USED) {
    PRINT_ERROR("bits used greater then " << MAX_BITS_USED);
    return false;
  } else {
    mCommuBits <<= mUnumBitCount;
    mCommuBits += static_cast<DWORD64>(num);
    mBitsUsed += mUnumBitCount;

    return true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x20(%rcx), %eax
addl 0x70(%rcx), %eax
cmpl 0xd181d(%rip), %eax     # 0xfe630
jle 0x2ce87
jmp 0x2ce17
movq 0xd11d2(%rip), %rdi     # 0xfdff0
leaq 0x95335(%rip), %rsi     # 0xc215a
callq 0xa5a0
movq %rax, %rdi
leaq 0x9841d(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x129, %esi            # imm = 0x129
callq 0xaa40
movq %rax, %rdi
leaq 0x9670f(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x95348(%rip), %rsi     # 0xc21a7
callq 0xa5a0
movq %rax, %rdi
movl 0xd17c3(%rip), %esi     # 0xfe630
callq 0xaa40
movq %rax, %rdi
movq 0xd1134(%rip), %rsi     # 0xfdfb0
callq 0xa630
movb $0x0, -0x1(%rbp)
jmp 0x2ceb7
movq -0x20(%rbp), %rax
movl 0x70(%rax), %ecx
movq 0x18(%rax), %rdx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, 0x18(%rax)
movslq -0x14(%rbp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movl 0x70(%rax), %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%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/CommunicateSystem.cpp
// Function: CommunicateSystem::Decision()
void CommunicateSystem::Decision() {
  DoCommunication();

  if (mBitsUsed != 0) {
    unsigned char msg[11]; // MAX_MSG_SIZE == 10

    AddCommuFlagToCommuBits(mCommuType);

    DWORD64 mask = 1;
    mask <<= mBitsUsed;
    mask -= 1;
    mCommuBits += ~mask; //左边补1
    mask = 1;
    mask <<= (MAX_BITS_USED + mCommuFlagBitCount);
    mask -= 1;
    mCommuBits &= mask; //去掉高三位

    Encode(mCommuBits, msg);

    if (strlen((const char *)msg) > 0) {
      mpAgent->Say(string((const char *)msg));
    } else {
      PRINT_ERROR("bug here?");
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2d9f0
movq -0x60(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x2d9d5
movq -0x60(%rbp), %rdi
movl 0x3c(%rdi), %esi
callq 0x2cdb0
movq -0x60(%rbp), %rdi
movq $0x1, -0x20(%rbp)
movl 0x20(%rdi), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
xorq $-0x1, %rax
addq 0x18(%rdi), %rax
movq %rax, 0x18(%rdi)
movq $0x1, -0x20(%rbp)
movl 0xd0d87(%rip), %ecx     # 0xfe630
addl 0x40(%rdi), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq 0x18(%rdi), %rax
movq %rax, 0x18(%rdi)
movq 0x18(%rdi), %rsi
leaq -0x13(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2c730
leaq -0x13(%rbp), %rdi
callq 0xa260
cmpq $0x0, %rax
jbe 0x2d973
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xaa70
movq -0x68(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq -0x13(%rbp), %rsi
callq 0x1a540
jmp 0x2d91f
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2e8f0
jmp 0x2d92e
leaq -0x40(%rbp), %rdi
callq 0xa370
leaq -0x41(%rbp), %rdi
callq 0xa650
jmp 0x2d9d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2d968
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa370
leaq -0x41(%rbp), %rdi
callq 0xa650
jmp 0x2d9db
jmp 0x2d975
movq 0xd0674(%rip), %rdi     # 0xfdff0
leaq 0x947d7(%rip), %rsi     # 0xc215a
callq 0xa5a0
movq %rax, %rdi
leaq 0x978bf(%rip), %rsi     # 0xc5251
callq 0xa5a0
movq %rax, %rdi
movl $0x1eb, %esi            # imm = 0x1EB
callq 0xaa40
movq %rax, %rdi
leaq 0x95bb1(%rip), %rsi     # 0xc355f
callq 0xa5a0
movq %rax, %rdi
leaq 0x94840(%rip), %rsi     # 0xc21fd
callq 0xa5a0
movq %rax, %rdi
movq 0xd05e4(%rip), %rsi     # 0xfdfb0
callq 0xa630
jmp 0x2d9d3
jmp 0x2d9d5
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xaa60
nopw %cs:(%rax,%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::ExtractDataFromBits(long&, CommunicateSystem::CodecType, int&)
double CommunicateSystem::ExtractDataFromBits(DWORD64 &bits, CodecType type,
                                              int &bit_left) {
  double res;

  res = BitToDouble(bits, type);
  bits >>= (*mpCodecBitCount)[type];
  bit_left -= (*mpCodecBitCount)[type];

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x2c690
movq -0x38(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq 0xc0(%rax), %rcx
movl -0x14(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
movq -0x10(%rbp), %rdx
movq %rdx, -0x30(%rbp)
movq (%rdx), %rdx
movl %ecx, %ecx
sarq %cl, %rdx
movq -0x30(%rbp), %rcx
movq %rdx, (%rcx)
movq 0xc0(%rax), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movsd -0x28(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)