LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rsi, %rbx
movq %rdi, %r14
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x1bc6a
movsd 0x4f407(%rip), %xmm0    # 0x6b058
addsd -0x18(%rbp), %xmm0
movq 0x10(%r14), %rcx
xorl %esi, %esi
subl 0x2114(%rcx), %esi
movq %rax, %rdi
callq 0x58f34
callq 0x57e2a
movsd -0x18(%rbp), %xmm0
addsd 0x4fb04(%rip), %xmm0    # 0x6b780
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x1bca0
xorl %esi, %esi
subl 0x88(%rbx), %esi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x58f34
callq 0x57e2a
movq 0x8(%rax), %rcx
cmpq 0x8(%r14), %rcx
je 0x1bcb8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %esi, %esi
subl 0x78(%rbx), %esi
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x58f34
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Client.cpp
// Function: Client::Client()
Client::Client() {
  srand(time(0)); // global srand once
  srand48(time(0));

  /** Observer and World Model */
  mpAgent = 0;
  mpObserver = new Observer;
  mpWorldModel = new WorldModel;

  // instance放在这里创建以节省后面的运行效率，部分instance不能放在这里，需要时创建

  /** Assistant instance */

  TimeTest::instance();
  NetworkTest::instance();
  DynamicDebug::instance();
  Logger::instance().Initial(mpObserver, &(mpWorldModel->World(false)));
  Plotter::instance();

  /** Param */
  ServerParam::instance();
  PlayerParam::instance();

  /** Base Model */
  InterceptModel::instance();

  /** Smart Action */
  Dasher::instance();
  Tackler::instance();
  Kicker::instance();

  /** Other Useful instance */
  BehaviorFactory::instance();
  UDPSocket::instance();
  VisualSystem::instance();
  CommunicateSystem::instance();

  /** Parser thread and CommandSend thread */
  mpCommandSender = new CommandSender(mpObserver);

  // ServerPlayModeMap::instance();

  mpParser = new Parser(mpObserver);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6a848(%rip), %rax     # 0x86598
movq %rax, (%rdi)
xorl %edi, %edi
callq 0x9440
movl %eax, %edi
callq 0x9470
xorl %edi, %edi
callq 0x9440
movq %rax, %rdi
callq 0x9830
movq $0x0, 0x18(%rbx)
movl $0x56d0, %edi           # imm = 0x56D0
callq 0x94c0
movq %rax, %r14
movq %rax, %rdi
callq 0x3b374
movq %r14, 0x8(%rbx)
movl $0x28, %edi
callq 0x94c0
movq %rax, %r14
movq %rax, %rdi
callq 0x5b83c
movq %r14, 0x10(%rbx)
callq 0x4fec4
callq 0x3974e
callq 0x23390
callq 0x35b4a
movq %rax, %r14
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0x5ba2c
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x35bc4
callq 0x47a2a
callq 0x4a75c
callq 0x450ba
callq 0x2c15e
callq 0x1f5e8
callq 0x4df3a
callq 0x2ddfa
callq 0x13210
callq 0x55830
callq 0x57e2a
callq 0x1d3cc
movl $0x20, %edi
callq 0x94c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x1cfdc
movq %r14, 0x28(%rbx)
movl $0x60, %edi
callq 0x94c0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3e9bc
movq %r14, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x60, %esi
jmp 0x1be80
movq %rax, %rbx
movl $0x20, %esi
jmp 0x1be80
movq %rax, %rbx
movl $0x28, %esi
jmp 0x1be80
movq %rax, %rbx
movl $0x56d0, %esi           # imm = 0x56D0
movq %r14, %rdi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6a6f8(%rip), %rax     # 0x86598
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1beb2
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1bec1
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1bed0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1bedf
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1bef4
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x23390
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x2340a
callq 0x23390
leaq 0x6dbc4(%rip), %r14     # 0x89af0
movq %rax, %rdi
movq %r14, %rsi
callq 0x239a4
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x3f2da
movq %rbx, %rdi
callq 0x1bfc8
movb $0x1, %r15b
callq 0x23390
movq %rax, %rdi
movq %r14, %rsi
callq 0x239a4
cmpl $0x2, %eax
jne 0x1bf86
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
callq 0x35b4a
movq %rax, %rdi
callq 0x35cc6
movq 0x8(%rbx), %rax
movb $0x1, 0x3385(%rax)
jmp 0x1bf4e
cmpl $0x3, %eax
je 0x1bfb0
cmpl $0x1, %eax
jne 0x1bfbd
testb $0x1, %r15b
je 0x1bfa2
movq 0x8(%rbx), %rdi
callq 0x3b85e
xorl %r15d, %r15d
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x3ec1a
jmp 0x1bf4e
movq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x1d0aa
jmp 0x1bf4b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Client.cpp
// Function: Client::ConstructAgent()
void Client::ConstructAgent() {
  Assert(mpAgent == 0);
  if (mpObserver->SelfUnum() > 0 && mpObserver->SelfUnum() < TRAINER_UNUM) {
    mpWorldModel->World(false)
        .Teammate(mpObserver->SelfUnum())
        .SetIsAlive(true);
    std::cout << "WrightEagle 2012: constructing agent for player "
              << mpObserver->SelfUnum() << "..." << std::endl;
  } else if (mpObserver->SelfUnum() == TRAINER_UNUM) {
    std::cout << "WrightEagle 2012: constructing agent for trainer... "
              << std::endl;
  } else {
    std::cout << "WrightEagle 2012: constructing agent for coach..."
              << std::endl;
  }
  mpAgent = new Agent(mpObserver->SelfUnum(), mpWorldModel,
                      false); //要知道号码才能初始化

  Formation::instance.AssignWith(mpAgent);
  mpCommandSender->RegisterAgent(mpAgent);
  CommunicateSystem::instance().Initial(mpObserver,
                                        mpAgent); // init communicate system
  VisualSystem::instance().Initial(mpAgent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl 0x2c(%rax), %eax
leal -0x1(%rax), %ecx
cmpl $0xa, %ecx
ja 0x1c03e
movq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0x5ba2c
movq 0x8(%rbx), %rcx
movslq 0x2c(%rcx), %rcx
imulq $0x178, %rcx, %rcx      # imm = 0x178
movb $0x1, 0x42(%rax,%rcx)
movq 0x6afb9(%rip), %r14     # 0x86fc0
leaq 0x50008(%rip), %rsi     # 0x6c016
movl $0x30, %edx
movq %r14, %rdi
callq 0x9560
movq 0x8(%rbx), %rax
movl 0x2c(%rax), %esi
movq %r14, %rdi
callq 0x9880
movq %rax, %r14
leaq 0x5040f(%rip), %rsi     # 0x6c443
movl $0x3, %edx
movq %rax, %rdi
jmp 0x1c067
movq 0x6af7b(%rip), %r14     # 0x86fc0
cmpl $0xc, %eax
jne 0x1c058
leaq 0x4fff6(%rip), %rsi     # 0x6c047
movl $0x34, %edx
jmp 0x1c064
leaq 0x5001d(%rip), %rsi     # 0x6c07c
movl $0x31, %edx
movq %r14, %rdi
callq 0x9560
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movl $0x128, %edi            # imm = 0x128
callq 0x94c0
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdx
movl 0x2c(%rax), %esi
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xf1e8
movq %r14, 0x18(%rbx)
leaq 0x71fb0(%rip), %rdi     # 0x8e070
movq %r14, %rsi
callq 0x27c86
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rax, 0x18(%rcx)
callq 0x1d3cc
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq %rax, %rdi
callq 0x1d42c
callq 0x57e2a
movq 0x18(%rbx), %rsi
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x57e48
movq %rax, %rbx
movl $0x128, %esi            # imm = 0x128
movq %r14, %rdi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x4f6cc
callq 0x35b4a
movq %rax, %rdi
callq 0x4f6cc
movq 0x20(%rbx), %rdi
callq 0x4f6cc
movl $0x15, %r15d
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x9690
decl %r15d
je 0x1c210
movq 0x20(%rbx), %r12
leaq 0x20(%r12), %r14
movq %r14, %rdi
callq 0x4f686
movb 0x4c(%r12), %r12b
movq %r14, %rdi
callq 0x4f6a2
cmpb $0x1, %r12b
jne 0x1c149
movq %rbx, %rdi
callq 0x1bfc8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x1c286
movq 0x8(%rbx), %rax
imull $0x186a0, 0x2c(%rax), %edi # imm = 0x186A0
callq 0x9690
movq 0x8(%rbx), %rax
movl 0x2c(%rax), %r15d
callq 0x450ba
movq 0x3138(%rax), %rsi
movq 0x3140(%rax), %rdx
movq 0x6adf5(%rip), %rdi     # 0x86fc0
callq 0x9560
movq %rax, %r14
testl %r15d, %r15d
je 0x1c275
leaq 0x52a11(%rip), %rsi     # 0x6ebf4
movl $0x1, %edx
movq %r14, %rdi
callq 0x9560
movq 0x8(%rbx), %rax
movl 0x2c(%rax), %esi
movq %r14, %rdi
callq 0x9880
movq %rax, %r14
leaq 0x4fe03(%rip), %rsi     # 0x6c00c
movl $0x9, %edx
jmp 0x1c23e
callq 0x450ba
movq 0x3138(%rax), %rsi
movq 0x3140(%rax), %rdx
movq 0x6ad96(%rip), %rdi     # 0x86fc0
callq 0x9560
movq %rax, %r14
leaq 0x4fdb2(%rip), %rsi     # 0x6bfeb
movl $0x1a, %edx
movq %rax, %rdi
callq 0x9560
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9070
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9330
leaq 0x4fd8a(%rip), %rsi     # 0x6c006
movl $0xf, %edx
movq %r14, %rdi
jmp 0x1c241
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3cf5a
testb %al, %al
je 0x1c31c
leaq 0x4fe07(%rip), %r14     # 0x6c0ae
callq 0x3974e
movq %rax, %rdi
callq 0x3a2b0
movq 0x8(%rbx), %r15
cmpl $0x1d, 0x1c(%r15)
je 0x1c327
callq 0x23390
movq %rax, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x2371a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%rbx), %rdi
movb $0x1, 0x3385(%rdi)
callq 0x3d2b6
callq 0x35b4a
movq %rax, %rdi
callq 0x35e4a
callq 0x3974e
movq 0x8(%rbx), %rcx
movq 0xc(%rcx), %rsi
movq %rax, %rdi
callq 0x3a2e2
movq 0x8(%rbx), %rdi
callq 0x3cf5a
testb %al, %al
jne 0x1c2a7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rbx), %rdi
movb 0x3382(%r15), %al
movb %al, 0x28(%rdi)
movq 0x1838(%r15), %rax
movq %rax, 0x2c(%rdi)
callq 0xef28
movq %rax, %rdi
movq %r15, %rsi
callq 0xd71a
movq 0x18(%rbx), %rdi
callq 0xef28
movq %rax, %rdi
callq 0xc8b6
movq 0x8(%rbx), %rdi
movb $0x1, 0x3385(%rdi)
callq 0x3d2b6
callq 0x35b4a
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35e4a
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x3548, %r14d          # imm = 0x3548
movq 0x8(%rdi), %rdi
addq %r14, %rdi
callq 0x4f686
leaq 0x71756(%rip), %rdi     # 0x8e070
callq 0x27c22
movq 0x8(%rbx), %r15
movq 0x18(%rbx), %rdi
movb 0x3382(%r15), %al
movb %al, 0x28(%rdi)
movq 0x1838(%r15), %rax
movq %rax, 0x2c(%rdi)
callq 0xef28
movq %rax, %rdi
movq %r15, %rsi
callq 0xd71a
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
callq 0x5b9da
addq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x4f6a2
callq 0x4a75c
cmpb $0x1, 0x32c9(%rax)
jne 0x1c984
movq 0x18(%rbx), %rdi
callq 0xef28
movq %rax, %rdi
callq 0xc908
callq 0x35b4a
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35f2c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3d1d8
testb %al, %al
je 0x1d0a1
movabsq $0x203a646d635f64, %r15 # imm = 0x203A646D635F64
movabsq $0x635f64726f636572, %r12 # imm = 0x635F64726F636572
leaq 0x6eacc(%rip), %r14     # 0x8bb10
callq 0x3974e
movq %rax, %rdi
callq 0x3a38e
movq %r15, 0x6eabd(%rip)     # 0x8bb15
movq %r12, 0x6eab1(%rip)     # 0x8bb10
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d0aa
callq 0x23390
movq %rax, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x2371a
callq 0x3974e
movq 0x10(%rbx), %rcx
movq 0xc(%rcx), %rsi
movq %rax, %rdi
callq 0x3a3c0
movq 0x10(%rbx), %rdi
callq 0x3d1d8
testb %al, %al
jne 0x1d044
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1d0d2
movq %rsi, %rbx
callq 0xef28
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe428
movq 0x69f17(%rip), %rbx     # 0x86ff0
leaq 0x4f00f(%rip), %rsi     # 0x6c0ef
movl $0x18, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x520ce(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x3e, %esi
callq 0x9880
movq %rax, %rbx
leaq 0x50367(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x4efdc(%rip), %rsi     # 0x6c108
movl $0xa, %edx
movq %rbx, %rdi
callq 0x9560
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, -0x18(%rbp)
leaq -0x28(%rbp), %rbx
movq $0x0, (%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1d43a
movsd (%r14), %xmm0
subsd (%rbx), %xmm0
divsd -0x18(%rbp), %xmm0
callq 0x93d0
divsd 0x4ed8c(%rip), %xmm0    # 0x6c130
callq 0x9100
cvttsd2si %xmm0, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x4, %esi
ja 0x1d501
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %eax
leaq 0x4eceb(%rip), %rcx     # 0x6c148
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x4a75c
leaq 0x50aa6(%rip), %rax     # 0x6df18
jmp 0x1d4c8
movabsq $-0x3f99800000000000, %rax # imm = 0xC066800000000000
movq %rax, (%r14)
movabsq $0x4066800000000000, %rax # imm = 0x4066800000000000
movq %rax, (%rbx)
jmp 0x1d4f8
movq $0x0, (%r14)
callq 0x4a75c
movsd 0x30f8(%rax), %xmm0
jmp 0x1d4f4
movq $0x0, (%r14)
callq 0x4a75c
movsd 0x3038(%rax), %xmm0
jmp 0x1d4f4
callq 0x4a75c
leaq 0x50a58(%rip), %rax     # 0x6df20
movsd (%rax), %xmm1
movsd %xmm1, -0x18(%rbp)
movsd 0x4dbaf(%rip), %xmm0    # 0x6b088
mulsd %xmm1, %xmm0
movsd %xmm0, (%r14)
callq 0x4a75c
movsd -0x18(%rbp), %xmm0
mulsd 0x4e384(%rip), %xmm0    # 0x6b878
movsd %xmm0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x69ae8(%rip), %rbx     # 0x86ff0
leaq 0x4ecc7(%rip), %rsi     # 0x6c1d6
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x51c9f(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0xa0, %esi
callq 0x9880
movq %rax, %rbx
leaq 0x4ff38(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x4ec98(%rip), %rsi     # 0x6c1f3
movl $0x12, %edx
movq %rbx, %rdi
callq 0x9560
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, -0x20(%rbp)
movq 0xc8(%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %r14
leaq -0x18(%rbp), %rdx
movq $0x0, (%rdx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq -0x28(%rbp), %rbx
movq %rax, (%rbx)
movq %rbx, %rcx
callq 0x1d43a
movsd -0x20(%rbp), %xmm2
movsd (%rbx), %xmm0
ucomisd %xmm0, %xmm2
jbe 0x1d5fa
movsd 0x4eb50(%rip), %xmm2    # 0x6c140
mulsd %xmm0, %xmm2
addsd %xmm0, %xmm2
jmp 0x1d615
movsd -0x18(%rbp), %xmm1
ucomisd %xmm2, %xmm1
jbe 0x1d615
movsd 0x4eb2b(%rip), %xmm2    # 0x6c138
mulsd %xmm1, %xmm2
addsd %xmm1, %xmm2
movsd -0x18(%rbp), %xmm1
subsd %xmm1, %xmm2
subsd %xmm1, %xmm0
divsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd %xmm2, %xmm0
cvttsd2si %xmm0, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0xc8(%rdi), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %r12
leaq -0x30(%rbp), %r14
movq $0x0, (%r14)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq -0x28(%rbp), %r15
movq %rax, (%r15)
movl %edx, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1d43a
andq %r12, %rbx
cvtsi2sd %rbx, %xmm1
cvtsi2sd %r12d, %xmm0
divsd %xmm0, %xmm1
movsd (%r15), %xmm0
movsd (%r14), %xmm2
subsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %ecx, %eax
xorb $0x1, %al
testq %rsi, %rsi
sete %dl
testb %al, %dl
jne 0x1d746
xorl %r8d, %r8d
movabsq $0x70381c0e070381c1, %rdi # imm = 0x70381C0E070381C1
cmpq $0xa, %r8
je 0x1d74d
movq %rsi, %rax
imulq %rdi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x5, %rdx
addq %rax, %rdx
leaq (%rdx,%rdx,8), %rax
leaq (%rdx,%rax,8), %rax
movq %rsi, %r9
subq %rax, %r9
movq 0x69df8(%rip), %rax     # 0x87508
movb (%rax,%r9), %r9b
leaq 0x1(%r8), %rax
movb %r9b, (%rbx,%r8)
addq $-0x49, %rsi
cmpq $-0x91, %rsi
setb %sil
cmpq $0x9, %r8
setne %r8b
andb %cl, %r8b
orb %sil, %r8b
movq %rax, %r8
movq %rdx, %rsi
jne 0x1d6e1
jmp 0x1d7f0
xorl %eax, %eax
jmp 0x1d7f0
movq 0x6989c(%rip), %r14     # 0x86ff0
leaq 0x4ea7b(%rip), %rsi     # 0x6c1d6
movl $0x1c, %edx
movq %r14, %rdi
callq 0x9560
leaq 0x51a53(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %r14, %rdi
callq 0x9560
movq %r14, %rdi
movl $0xcc, %esi
callq 0x9880
movq %rax, %r14
leaq 0x4fcec(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x4ea5f(%rip), %rsi     # 0x6c206
movl $0x1c, %edx
movq %r14, %rdi
callq 0x9560
movq %r14, %rdi
movl $0xa, %esi
callq 0x9880
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %r14, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
movl $0xa, %eax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl $0xa, %eax
testl %ecx, %ecx
jne 0x1d818
movq %r14, %rdi
callq 0x9200
movq $0x0, (%rbx)
testl %eax, %eax
jle 0x1d858
movl %eax, %eax
movl $0x1, %ecx
xorl %edx, %edx
leaq 0x702ed(%rip), %rsi     # 0x8db20
xorl %edi, %edi
movzbl (%r14,%rdx), %r8d
movslq (%rsi,%r8,4), %r8
imulq %rcx, %r8
addq %r8, %rdi
movq %rdi, (%rbx)
leaq (%rcx,%rcx,8), %r8
leaq (%rcx,%r8,8), %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x1d835
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
movq 0x69770(%rip), %rbx     # 0x86ff0
leaq -0x2a(%rbp), %r15
leaq -0x29(%rbp), %r12
testq %r14, %r13
je 0x1d89e
movb $0x31, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x1d8ad
movb $0x30, -0x2a(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9560
movq %r13, %rax
shrq %rax
cmpq $0x1, %r13
movq %rax, %r13
ja 0x1d888
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xc0(%rdi), %rax
movl %esi, %r12d
movl (%rax,%r12,4), %ecx
movl 0x20(%rdi), %r14d
addl %ecx, %r14d
movl 0x6997d(%rip), %r15d    # 0x87510
cmpl %r15d, %r14d
jg 0x1dbbb
movq %rdi, %rbx
shlq %cl, 0x18(%rdi)
callq 0x1d598
addq %rax, 0x18(%rbx)
movq 0xc0(%rbx), %rax
movl (%rax,%r12,4), %eax
addl %eax, 0x20(%rbx)
jmp 0x1dc5a
movq 0x6942e(%rip), %rbx     # 0x86ff0
leaq 0x4e60d(%rip), %rsi     # 0x6c1d6
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x515e5(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x107, %esi            # imm = 0x107
callq 0x9880
movq %rax, %rbx
leaq 0x4f87e(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x4e60e(%rip), %rsi     # 0x6c223
movl $0x17, %edx
movq %rbx, %rdi
callq 0x9560
movl 0x698e8(%rip), %esi     # 0x87510
movq %rbx, %rdi
callq 0x9880
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
cmpl %r15d, %r14d
setle %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x50(%rdi), %ecx
movl 0x20(%rdi), %r14d
addl %ecx, %r14d
movl 0x6988b(%rip), %r15d    # 0x87510
cmpl %r15d, %r14d
jg 0x1dca3
movq 0x18(%rdi), %rax
shlq %cl, %rax
movl %esi, %ecx
addq %rax, %rcx
movq %rcx, 0x18(%rdi)
movl %r14d, 0x20(%rdi)
jmp 0x1dd42
movq 0x69346(%rip), %rbx     # 0x86ff0
leaq 0x4e525(%rip), %rsi     # 0x6c1d6
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x514fd(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x114, %esi            # imm = 0x114
callq 0x9880
movq %rax, %rbx
leaq 0x4f796(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x4e526(%rip), %rsi     # 0x6c223
movl $0x17, %edx
movq %rbx, %rdi
callq 0x9560
movl 0x69800(%rip), %esi     # 0x87510
movq %rbx, %rdi
callq 0x9880
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
cmpl %r15d, %r14d
setle %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x40(%rdi), %ecx
movq 0x18(%rdi), %rax
shlq %cl, %rax
movl %esi, %edx
addq %rax, %rdx
movq %rdx, 0x18(%rdi)
addl %ecx, 0x20(%rdi)
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x70(%rdi), %ecx
movl 0x20(%rdi), %r14d
addl %ecx, %r14d
movl 0x69783(%rip), %r15d    # 0x87510
cmpl %r15d, %r14d
jg 0x1ddac
movq 0x18(%rdi), %rax
shlq %cl, %rax
movslq %esi, %rcx
addq %rax, %rcx
movq %rcx, 0x18(%rdi)
movl %r14d, 0x20(%rdi)
jmp 0x1de4b
movq 0x6923d(%rip), %rbx     # 0x86ff0
leaq 0x4e41c(%rip), %rsi     # 0x6c1d6
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x513f4(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x129, %esi            # imm = 0x129
callq 0x9880
movq %rax, %rbx
leaq 0x4f68d(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x4e41d(%rip), %rsi     # 0x6c223
movl $0x17, %edx
movq %rbx, %rdi
callq 0x9560
movl 0x696f7(%rip), %esi     # 0x87510
movq %rbx, %rdi
callq 0x9880
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
cmpl %r15d, %r14d
setle %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x1e8b0
movl 0x20(%rbx), %eax
testl %eax, %eax
je 0x1e883
movl 0x3c(%rbx), %esi
movl 0x40(%rbx), %edx
movq 0x18(%rbx), %rdi
movl %edx, %ecx
shlq %cl, %rdi
addq %rsi, %rdi
addl %edx, %eax
movl %eax, 0x20(%rbx)
movq $-0x1, %rsi
movq $-0x1, %r8
movl %eax, %ecx
shlq %cl, %r8
addq %rdi, %r8
movq %r8, 0x18(%rbx)
addl 0x68d93(%rip), %edx     # 0x87510
movl %edx, %ecx
shlq %cl, %rsi
notq %rsi
andq %r8, %rsi
movq %rsi, 0x18(%rbx)
leaq -0x2b(%rbp), %r14
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1d6bc
cmpb $0x0, (%r14)
je 0x1e7f5
movq 0x10(%rbx), %rbx
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdi
callq 0x9200
leaq (%rax,%rbp), %rdx
addq $-0x2b, %rdx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x13766
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f384
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x1e883
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x1e883
movq 0x687f4(%rip), %rbx     # 0x86ff0
leaq 0x4d9d3(%rip), %rsi     # 0x6c1d6
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x509ab(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x1eb, %esi            # imm = 0x1EB
callq 0x9880
movq %rax, %rbx
leaq 0x4ec44(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x4da2a(%rip), %rsi     # 0x6c279
movl $0x9, %edx
movq %rbx, %rdi
callq 0x9560
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x1e8a8
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/CommunicateSystem.cpp
// Function: CommunicateSystem::DoCommunication()
void CommunicateSystem::DoCommunication() {
  if (!mpAgent)
    return;

  PositionInfo &position_info = mpAgent->GetInfoState().GetPositionInfo();
  const Unum closest_tm = position_info.GetClosestTeammateToBall();

  if (closest_tm == mpAgent->GetSelfUnum()) {
    mpAgent->AttentiontoOff();
  } else if (closest_tm) {
    if (closest_tm != mpAgent->GetSelf().GetFocusOnUnum()) {
      mpAgent->Attentionto(closest_tm);
    }
  }

  SendBallStatus(mpAgent->GetWorldState().GetBall());
  SendTeammateStatus(&mpAgent->GetWorldState(), mpAgent->GetSelfUnum());

  const vector<Unum> &o2b =
      mpAgent->GetInfoState().GetPositionInfo().GetCloseOpponentToTeammate(
          mpAgent->GetSelfUnum());
  const vector<Unum> &t2b =
      mpAgent->GetInfoState().GetPositionInfo().GetCloseTeammateToTeammate(
          mpAgent->GetSelfUnum());

  for (uint i = 0; i < TEAMSIZE; ++i) {
    if (i < o2b.size()) {
      SendOpponentStatus(&mpAgent->GetWorldState(), o2b[i]);
    }
    if (i < t2b.size()) {
      SendTeammateStatus(&mpAgent->GetWorldState(), t2b[i]);
    }
  }
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1e9ec
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rax), %rdi
callq 0x2adf8
movq %rax, %rdi
callq 0x13c00
movq 0x10(%rbx), %rdi
cmpl 0x8(%rdi), %eax
jne 0x1e8f4
callq 0xef28
movq %rax, %rdi
callq 0xc2e6
jmp 0x1e91d
movl %eax, %r14d
testl %eax, %eax
je 0x1e91d
callq 0xe85a
cmpl 0xfc(%rax), %r14d
je 0x1e91d
movq 0x10(%rbx), %rdi
callq 0xef28
movq %rax, %rdi
movl %r14d, %esi
callq 0xc260
movq 0x10(%rbx), %rax
movq 0x18(%rax), %rsi
addq $0x30, %rsi
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1de5c
movq 0x10(%rbx), %rax
movq 0x18(%rax), %rsi
movl 0x8(%rax), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1e34c
movq 0x10(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x2adf8
movq 0x10(%rbx), %rcx
movl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0x490c4
movq %rax, %r14
movq 0x10(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x2adf8
movq 0x10(%rbx), %rcx
movl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0x49042
movq %rax, %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x1e9b2
movq 0x10(%rbx), %rcx
movq 0x18(%rcx), %rsi
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1e536
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x1e9db
movq 0x10(%rbx), %rcx
movq 0x18(%rcx), %rsi
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1e34c
incq %r12
cmpq $0xb, %r12
jne 0x1e989
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rsi
callq 0x1d640
movq 0xc0(%r12), %rax
movl %r14d, %ecx
movl (%rax,%rcx,4), %ecx
sarq %cl, (%r15)
subl %ecx, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 (%rsi), %r8
movl 0x78(%rdi), %eax
andl %r8d, %eax
movl 0x70(%rdi), %ecx
sarq %cl, %r8
movq %r8, (%rsi)
subl %ecx, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %ebx, %ebx
leaq 0x6e8f4(%rip), %r14     # 0x8de18
leaq 0x6e94d(%rip), %r15     # 0x8de78
callq 0x4a75c
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x33a8(%rax), %xmm0
movsd 0x4bb19(%rip), %xmm1    # 0x6b060
ucomisd %xmm0, %xmm1
jbe 0x1f561
movsd 0x4bb1b(%rip), %xmm2    # 0x6b070
addsd %xmm2, %xmm0
ucomisd %xmm0, %xmm1
ja 0x1f555
jmp 0x1f581
movsd 0x4badf(%rip), %xmm1    # 0x6b048
ucomisd %xmm1, %xmm0
jb 0x1f581
movsd 0x4baf1(%rip), %xmm2    # 0x6b068
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jae 0x1f577
movsd %xmm0, (%r14,%rbx,8)
callq 0xe8f9
movsd %xmm0, (%r15,%rbx,8)
incq %rbx
cmpq $0x8, %rbx
jne 0x1f52b
xorl %r15d, %r15d
leaq -0x28(%rbp), %rbx
leaq 0x6e8af(%rip), %r12     # 0x8de58
movsd (%r14), %xmm0
addsd 0x4ba92(%rip), %xmm0    # 0x6b048
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
callq 0x226e8
movl %eax, (%r15,%r12)
addq $0x4, %r15
addq $0x8, %r14
cmpq $0x20, %r15
jne 0x1f5a9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebx
movl %edx, %r15d
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %r13
leaq -0x78(%rbp), %r12
movb $0x0, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%r12)
movups %xmm0, 0x14(%r12)
movups %xmm0, 0x20(%r12)
addq $0x38, %rsi
movq %r14, %rdi
callq 0xf5c4
movq %rax, %rdi
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
callq 0x4db56
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movsd -0x40(%rbp), %xmm2
movsd -0x48(%rbp), %xmm3
movl %r15d, %ecx
movl %ebx, %r8d
callq 0x1f640
movq %r12, %rdi
movq %r14, %rsi
callq 0xb38c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movaps %xmm0, -0x20(%rbp)
movq %rdx, %r14
movq %rdi, %rbx
movb $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movups %xmm0, 0x14(%rdi)
movups %xmm0, 0x20(%rdi)
movl $0x1, 0x4(%rdi)
movq %rdx, %rdi
callq 0xe85a
movapd -0x20(%rbp), %xmm2
subsd 0xb0(%rax), %xmm2
movsd 0x497e9(%rip), %xmm0    # 0x6b060
ucomisd %xmm2, %xmm0
jbe 0x21891
movsd 0x497eb(%rip), %xmm1    # 0x6b070
addsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
ja 0x21885
jmp 0x218b5
ucomisd 0x497af(%rip), %xmm2    # 0x6b048
jb 0x218b5
movsd 0x497c5(%rip), %xmm0    # 0x6b068
movsd 0x4979d(%rip), %xmm1    # 0x6b048
addsd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
jae 0x218ab
movapd %xmm2, -0x20(%rbp)
movapd 0x4974e(%rip), %xmm0    # 0x6b010
andpd %xmm2, %xmm0
movapd %xmm0, -0x30(%rbp)
movq %r14, %rdi
callq 0xe85a
movsd 0x158(%rax), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x218ec
movb $0x1, (%rbx)
movapd -0x20(%rbp), %xmm2
jmp 0x21921
movb $0x0, (%rbx)
movq %r14, %rdi
callq 0xe85a
movsd 0x158(%rax), %xmm0
movapd 0x49719(%rip), %xmm1    # 0x6b020
xorpd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmplesd -0x20(%rbp), %xmm2
andpd %xmm2, %xmm0
andnpd %xmm1, %xmm2
orpd %xmm0, %xmm2
movsd %xmm2, 0x18(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %r8d, %r9d
movl %ecx, %r8d
movl %edx, %ecx
movq %rsi, %rbx
leaq -0x40(%rbp), %r14
movb $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%r14)
movups %xmm0, 0x14(%r14)
movups %xmm0, 0x20(%r14)
movq %r14, %rdx
callq 0x21b16
cmpb $0x1, (%r14)
jne 0x21d72
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0xb38c
jmp 0x21d74
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop