LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::Parser(Observer*)
Parser::Parser(Observer *p_observer) {
  mpObserver = p_observer;

  mConnectServerOk = false;
  mHalfTime = 0;
  mClangOk = false;
  mSynchOk = false;
  mEyeOnOk = false;
  mEarOnOk = false;

  mLastServerPlayMode = SPM_Null;

  ServerPlayModeMap::instance();

  if (PlayerParam::instance().isCoach()) {
    UDPSocket::instance().Initial(ServerParam::instance().serverHost().c_str(),
                                  ServerParam::instance().onlineCoachPort());
  } else if (PlayerParam::instance().isTrainer()) {
    UDPSocket::instance().Initial(ServerParam::instance().serverHost().c_str(),
                                  ServerParam::instance().offlineCoachPort());
  } else {
    UDPSocket::instance().Initial(ServerParam::instance().serverHost().c_str(),
                                  ServerParam::instance().playerPort());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4801d(%rip), %rax     # 0x869f0
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x4f670
xorl %eax, %eax
movl %eax, 0x58(%r15)
movq %rax, 0x51(%r15)
movq %r14, 0x10(%r15)
movl %eax, 0x18(%r15)
movq %rax, 0x48(%r15)
movb $0x0, 0x50(%r15)
callq 0x55f0c
callq 0x450ba
cmpb $0x1, 0x31a5(%rax)
jne 0x3ea31
callq 0x55830
movq %rax, %r14
callq 0x4a75c
movq 0x31e8(%rax), %r15
callq 0x4a75c
addq $0x320c, %rax           # imm = 0x320C
jmp 0x3ea7f
callq 0x450ba
cmpb $0x1, 0x31a6(%rax)
jne 0x3ea60
callq 0x55830
movq %rax, %r14
callq 0x4a75c
movq 0x31e8(%rax), %r15
callq 0x4a75c
addq $0x3208, %rax           # imm = 0x3208
jmp 0x3ea7f
callq 0x55830
movq %rax, %r14
callq 0x4a75c
movq 0x31e8(%rax), %r15
callq 0x4a75c
addq $0x31e0, %rax           # imm = 0x31E0
movl (%rax), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5584e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4f67c
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::StartRoutine()
void Parser::StartRoutine() {
  ConnectToServer();

  while (true) {
    if (UDPSocket::instance().Receive(mBuf) > 0) {
      NetworkTest::instance().AddParserBegin();

      DynamicDebug::instance().AddMessage(mBuf,
                                          MT_Parse); // 动态调试记录Parser信息

      mpObserver->Lock(); // parse时禁止WorldState更新
      Parse(mBuf);
      mpObserver->UnLock();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3eb82
leaq 0x317c35(%rip), %r14    # 0x356740
movl $0x3548, %r15d          # imm = 0x3548
callq 0x55830
movq %rax, %rdi
movq %r14, %rsi
callq 0x55ad0
testl %eax, %eax
jle 0x3eb11
callq 0x3974e
movq %rax, %rdi
callq 0x3a1d2
callq 0x23390
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x2371a
movq 0x10(%rbx), %rdi
addq %r15, %rdi
callq 0x4f686
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ec1a
movq 0x10(%rbx), %rdi
addq %r15, %rdi
callq 0x4f6a2
callq 0x3974e
movq 0x10(%rbx), %rcx
movq 0xc(%rcx), %rsi
movq %rax, %rdi
callq 0x3a204
jmp 0x3eb11
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ConnectToServer()
void Parser::ConnectToServer() {
  mOkMutex.Lock();
  mConnectServerOk = false;
  mOkMutex.UnLock();

  SendInitialLizeMsg();
  do {
    UDPSocket::instance().Receive(mBuf);
  } while (!ParseInitializeMsg(mBuf));

  mOkMutex.Lock();
  mConnectServerOk = true;
  mOkMutex.UnLock();

  DynamicDebug::instance().Initial(
      mpObserver); // 动态调试的初始化，知道自己是哪边了才能初始化，位置不能动
  DynamicDebug::instance().AddMessage(mBuf, MT_Parse); // 动态调试记录Parse信息

  // Logger::instance().GetTextLogger("msg-text") << mBuf << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x4f686
movb $0x0, 0x4c(%rbx)
movq %r14, %rdi
callq 0x4f6a2
callq 0x3efc6
leaq 0x317b8d(%rip), %r15    # 0x356740
callq 0x55830
movq %rax, %rdi
movq %r15, %rsi
callq 0x55ad0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f2da
testb %al, %al
je 0x3ebb3
movq %r14, %rdi
callq 0x4f686
movb $0x1, 0x4c(%rbx)
movq %r14, %rdi
callq 0x4f6a2
callq 0x23390
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x2340a
callq 0x23390
leaq 0x317b3d(%rip), %rsi    # 0x356740
movq %rax, %rdi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2371a
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseForTrainer(char*)
bool Parser::ParseForTrainer(char *msg) {
  char *end;
  int n;
  static char buffer[MAX_MESSAGE];

  if (msg[6] == 'r') // 跳过括号和hear，referee
  {
    ParseTime(msg, &msg, true);
    parser::get_word(&msg);
    end = msg;
    while (*end != ')')
      end++;
    n = end - msg;
    strncpy(buffer, msg, n * sizeof(char));
    buffer[n] = '\0';

    ParseRefereeMsg(buffer);
    return true;
  } else
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, -0x28(%rbp)
movb 0x6(%rsi), %r12b
cmpb $0x72, %r12b
jne 0x40fa7
movq %rdi, %rbx
leaq -0x28(%rbp), %r14
movq %r14, %rdx
movl $0x1, %ecx
callq 0x3f462
movq (%r14), %r15
movsbl (%r15), %r14d
movl %r14d, %edi
callq 0x97c0
testl %r14d, %r14d
je 0x40f5a
testl %eax, %eax
jne 0x40f5a
movsbl 0x1(%r15), %r14d
incq %r15
movl %r14d, %edi
callq 0x97c0
testl %r14d, %r14d
je 0x40f56
testl %eax, %eax
je 0x40f3d
movq %r15, -0x28(%rbp)
movabsq $-0x100000000, %r14     # imm = 0xFFFFFFFF00000000
movq -0x28(%rbp), %rsi
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rsi, %rcx
addq %rax, %r14
cmpb $0x29, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x40f75
sarq $0x20, %r14
leaq 0x31b7c4(%rip), %r15    # 0x35c750
movq %r15, %rdi
movq %r14, %rdx
callq 0x9270
movb $0x0, (%r14,%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4456c
cmpb $0x72, %r12b
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParsePlayerParam(char*)
void Parser::ParsePlayerParam(char *msg) {
  Logger::instance().InitSightLogger(PlayerParam_Msg, msg);

  msg += 13; // 去掉"(player_param"
  PlayerParam::instance().ParseFromServerMsg(msg);
  PlayerParam::instance().MaintainConsistency();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x35b4a
movq %rax, %rdi
movl $0x7, %esi
movq %rbx, %rdx
callq 0x35e96
addq $0xd, %rbx
callq 0x450ba
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3e19c
callq 0x450ba
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x453b4
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseServerParam(char*)
void Parser::ParseServerParam(char *msg) {
  Logger::instance().InitSightLogger(ServerParam_Msg, msg);

  msg += 13; // 去掉"(server_param"
  ServerParam::instance().ParseFromServerMsg(msg);
  ServerParam::instance().MaintainConsistency();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x35b4a
movq %rax, %rdi
movl $0x6, %esi
movq %rbx, %rdx
callq 0x35e96
addq $0xd, %rbx
callq 0x4a75c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3e19c
callq 0x4a75c
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4a8c6
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseChangePlayerType(char*)
void Parser::ParseChangePlayerType(char *msg) {
  int player = parser::get_int(&msg);
  if (*msg != ')') {
    int type = parser::get_int(msg);
    mpObserver->SetTeammateType(player, type);
  } else {
    mpObserver->AddOpponentTypeChangedCount(player);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, -0x28(%rbp)
movb (%rsi), %al
movsbl %al, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jb 0x42204
movq -0x28(%rbp), %rdx
movabsq $0x680000000001, %rcx   # imm = 0x680000000001
cmpb $0x2e, %al
ja 0x421ec
movzbl %al, %eax
btq %rax, %rcx
jb 0x42200
movb 0x1(%rsi), %al
incq %rsi
movsbl %al, %edi
addl $-0x30, %edi
movq %rsi, %rdx
cmpl $0xa, %edi
jae 0x421df
movq %rdx, -0x28(%rbp)
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
leaq -0x28(%rbp), %r15
movq %rsi, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x9680
movq %rax, %r14
movq (%r15), %rdi
movb (%rdi), %al
cmpb $0x29, %al
jne 0x42247
movq 0x10(%rbx), %rax
shlq $0x20, %r14
addq %r12, %r14
sarq $0x1e, %r14
incl 0x94(%rax,%r14)
jmp 0x42272
movsbl %al, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jae 0x4227f
xorl %esi, %esi
movl $0xa, %edx
callq 0x9680
movq 0x10(%rbx), %rcx
shlq $0x20, %r14
addq %r12, %r14
sarq $0x1e, %r14
movl %eax, 0x3c(%rcx,%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x680000000001, %rcx   # imm = 0x680000000001
cmpb $0x2e, %al
ja 0x42296
movzbl %al, %eax
btq %rax, %rcx
jb 0x42252
movb 0x1(%rdi), %al
incq %rdi
movsbl %al, %edx
addl $-0x30, %edx
cmpl $0xa, %edx
jae 0x42289
jmp 0x42252
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParsePlayerType(char*)
void Parser::ParsePlayerType(char *msg) {
  Logger::instance().InitSightLogger(PlayerType_Msg, msg);

  char *p = msg;
  while (!isspace(*p))
    p++;
  while (isspace(*p))
    p++;
  char *line = p;
  while (!isspace(*p))
    p++;
  int type = parser::get_int(p);
  PlayerParam::instance().AddPlayerType(type, line);

  if (type >= PlayerParam::instance().playerTypes() - 1) {
    mIsPlayerTypesReady = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
callq 0x35b4a
movq %rax, %rdi
movl $0xa, %esi
movq %rbx, %rdx
callq 0x35e96
addq $-0x3, %rbx
movsbl 0x3(%rbx), %edi
callq 0x90c0
incq %rbx
testl %eax, %eax
je 0x422d1
movsbl 0x2(%rbx), %edi
callq 0x90c0
incq %rbx
testl %eax, %eax
jne 0x422e1
leaq 0x1(%rbx), %r14
movb 0x1(%rbx), %r12b
incq %rbx
movsbl %r12b, %r15d
movl %r15d, %edi
callq 0x90c0
testl %eax, %eax
je 0x422f5
addl $-0x30, %r15d
cmpl $0xa, %r15d
jae 0x4235b
movq %rbx, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x9680
movq %rax, %rbx
callq 0x450ba
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x462ce
callq 0x450ba
movl 0x3008(%rax), %eax
decl %eax
cmpl %ebx, %eax
jg 0x42352
movb $0x1, 0x3163ee(%rip)    # 0x358740
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x680000000001, %rax   # imm = 0x680000000001
cmpb $0x2e, %r12b
ja 0x42375
movzbl %r12b, %ecx
btq %rcx, %rax
jb 0x42316
movb 0x1(%rbx), %r12b
incq %rbx
movsbl %r12b, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jae 0x42365
jmp 0x42316
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseObjType_Fullstate(char*)
Parser::ObjType Parser::ParseObjType_Fullstate(char *msg) {
  switch (*msg) {
  case 'p':
  case 'P':
    return ParsePlayer_Fullstate(msg);
  case 'b':
  case 'B':
    return ParseBall(msg);
  default:
    PARSE_ERROR("unknown object");
    break;
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rdx), %eax
cmpl $0x61, %eax
jg 0x42ec9
cmpl $0x42, %eax
je 0x42edd
cmpl $0x50, %eax
je 0x42ed3
movabsq $0x3800000005, %rax     # imm = 0x3800000005
movq %rax, (%rbx)
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x42efd
cmpl $0x62, %eax
je 0x42edd
cmpl $0x70, %eax
jne 0x42ea7
movq %rbx, %rdi
callq 0x438de
jmp 0x42efd
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
movabsq $0x3800000001, %rax     # imm = 0x3800000001
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseObjType(char*)
Parser::ObjType Parser::ParseObjType(char *msg) {
  switch (*msg) {
  case 'g':
  case 'G':
    return ParseGoal(msg);
  case 'f':
  case 'F':
    return ParseMarker(msg);
  case 'l':
    return ParseLine(msg);
  case 'p':
  case 'P':
    return ParsePlayer(msg);
  case 'b':
  case 'B':
    return ParseBall(msg);
  default:
    PARSE_ERROR("unknown object");
    break;
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rdx), %eax
cmpl $0x61, %eax
jle 0x43459
cmpl $0x66, %eax
jle 0x4347e
cmpl $0x70, %eax
je 0x43474
cmpl $0x6c, %eax
je 0x434be
cmpl $0x67, %eax
je 0x434b4
jmp 0x434c8
cmpl $0x46, %eax
jg 0x4346a
cmpl $0x42, %eax
je 0x43492
cmpl $0x46, %eax
je 0x43488
jmp 0x434c8
cmpl $0x47, %eax
je 0x434b4
cmpl $0x50, %eax
jne 0x434c8
movq %rbx, %rdi
callq 0x44000
jmp 0x434e8
cmpl $0x62, %eax
je 0x43492
cmpl $0x66, %eax
jne 0x434c8
movq %rbx, %rdi
callq 0x43a80
jmp 0x434e8
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
movabsq $0x3800000001, %rax     # imm = 0x3800000001
movq %rax, (%rbx)
jmp 0x434e8
movq %rbx, %rdi
callq 0x43a1e
jmp 0x434e8
movq %rbx, %rdi
callq 0x43fb0
jmp 0x434e8
movabsq $0x3800000005, %rax     # imm = 0x3800000005
movq %rax, (%rbx)
movl $0x5, 0x8(%rbx)
movb $0x3f, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParsePlayer_Fullstate(char*)
Parser::ObjType Parser::ParsePlayer_Fullstate(char *msg) {
  //((p l 1 g 8) -47.5 0 0 0 -66.8915 -80 (stamina 8000 0.829636 1 130600))
  //((p r 11 14) 0.385 -7.01275e-12 -1.15337e-23 -8.33192e-24 46.129 0 (stamina
  //8000 0.933173 1 124249)))

  ObjType result;

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

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

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

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
movl $0x5, 0x8(%rdi)
movb $0x3f, 0xc(%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x3800000004, %rax     # imm = 0x3800000004
movq %rax, (%rdi)
leaq 0x2(%rdx), %rdi
movq %rdi, -0x30(%rbp)
movb 0x2(%rdx), %r13b
movb %r13b, 0xc(%rbx)
movsbl %r13b, %eax
addl $-0x30, %eax
movabsq $0x680000000001, %r12   # imm = 0x680000000001
cmpl $0xa, %eax
jb 0x43969
movq -0x30(%rbp), %rax
movl %r13d, %ecx
cmpb $0x2e, %cl
ja 0x43951
movzbl %cl, %ecx
btq %rcx, %r12
jb 0x43965
movb 0x1(%rdi), %cl
incq %rdi
movsbl %cl, %edx
addl $-0x30, %edx
movq %rdi, %rax
cmpl $0xa, %edx
jae 0x43943
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %r15
movq %r15, %rsi
movl $0xa, %edx
callq 0x9680
movl %eax, 0x10(%rbx)
movq (%r15), %rcx
leaq 0x1(%rcx), %rdi
movq %rdi, (%r15)
cmpb $0x67, 0x1(%rcx)
jne 0x4399a
movq 0x10(%r14), %rcx
cmpb 0x28(%rcx), %r13b
je 0x4399a
movl %eax, 0x30(%rcx)
movb (%rdi), %al
movsbl %al, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jb 0x439d0
movq -0x30(%rbp), %rcx
cmpb $0x2e, %al
ja 0x439b8
movzbl %al, %eax
btq %rax, %r12
jb 0x439cc
movb 0x1(%rdi), %al
incq %rdi
movsbl %al, %edx
addl $-0x30, %edx
movq %rdi, %rcx
cmpl $0xa, %edx
jae 0x439ab
movq %rcx, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x9680
movl %eax, 0x14(%rbx)
movq %rbx, %rax
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/Parser.cpp
// Function: Parser::ParseBall(char*)
Parser::ObjType Parser::ParseBall(char *msg) {
  (void)msg;
  ObjType result;
  result.type = OBJ_Ball;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl $0x5, 0x8(%rdi)
movb $0x3f, 0xc(%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x3800000001, %rcx     # imm = 0x3800000001
movq %rcx, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseGoal(char*)
Parser::ObjType Parser::ParseGoal(char *msg) {
  ObjType result;
  if (*msg == 'g') { // goal
    result.type = OBJ_Marker;
    msg += 2; // 'g '
    if (*msg == 'r') {
      result.marker = Goal_R;
    } else if (*msg == 'l') {
      result.marker = Goal_L;
    } else {
      PARSE_ERROR("goal ?");
    }
  } else if (*msg == 'G') { // goal behind
    result.type = OBJ_Marker_Behind;
    // result.marker = _pMem->ClosestGoal(); TODO: how to process?
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movabsq $0x3800000005, %rcx     # imm = 0x3800000005
movq %rcx, (%rdi)
movl $0x5, 0x8(%rdi)
movb $0x3f, 0xc(%rdi)
movq $0x0, 0x10(%rdi)
movzbl (%rdx), %ecx
cmpl $0x47, %ecx
je 0x43a6f
cmpl $0x67, %ecx
jne 0x43a7e
movl $0x2, (%rax)
movzbl 0x2(%rdx), %ecx
cmpl $0x6c, %ecx
je 0x43a77
cmpl $0x72, %ecx
jne 0x43a7e
movl $0x1, 0x4(%rax)
jmp 0x43a7e
movl $0x3, (%rax)
jmp 0x43a7e
movl $0x0, 0x4(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseLine(char*)
Parser::ObjType Parser::ParseLine(char *msg) {
  ObjType result;
  result.type = OBJ_Line;
  msg += 2; // 'l'
  if (*msg == 'r') {
    result.line = SL_Right;
  } else if (*msg == 'l') {
    result.line = SL_Left;
  } else if (*msg == 't') {
    result.line = SL_Top;
  } else if (*msg == 'b') {
    result.line = SL_Bottom;
  } else {
    PARSE_ERROR("line ?");
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl $0x5, 0x8(%rdi)
movb $0x3f, 0xc(%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x3800000000, %rcx     # imm = 0x3800000000
movq %rcx, (%rdi)
movb 0x2(%rdx), %cl
addb $-0x62, %cl
rorb %cl
cmpb $0x9, %cl
ja 0x43ffe
movzbl %cl, %ecx
movl $0x321, %edx            # imm = 0x321
btl %ecx, %edx
jae 0x43ffe
leaq 0x29360(%rip), %rdx     # 0x6d358
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseRefereeMsg(char*)
void Parser::ParseRefereeMsg(char *msg) {
  if (msg[0] == 'y' || msg[0] == 'r')
    ParseCard(msg);
  else
    ParsePlayMode(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl (%rsi), %eax
cmpl $0x79, %eax
je 0x4457d
cmpl $0x72, %eax
jne 0x44583
popq %rbp
jmp 0x4458a
popq %rbp
jmp 0x4280a
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Parser.cpp
// Function: Parser::ParseCard(char*)
void Parser::ParseCard(char *msg) {
  CardType card_type;
  switch (msg[0]) {
  case 'y':
    card_type = CR_Yellow;
    break;
  case 'r':
    card_type = CR_Red;
    break;
  default:
    card_type = CR_None;
    break;
  }
  Unum player;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, -0x20(%rbp)
movb (%rsi), %cl
movsbl %cl, %edx
addl $-0x30, %edx
cmpb $0x64, 0x7(%rsi)
movq 0x10(%rdi), %rsi
movb 0x28(%rsi), %sil
jne 0x4460e
cmpb %sil, 0x9(%rax)
jne 0x44668
movl $0xc0, %r14d
cmpl $0xa, %edx
jb 0x446f8
movq -0x20(%rbp), %rsi
movabsq $0x680000000001, %rdx   # imm = 0x680000000001
movl %ecx, %edi
cmpb $0x2e, %dil
ja 0x445f1
movzbl %dil, %edi
btq %rdi, %rdx
jb 0x446f4
movb 0x1(%rax), %dil
incq %rax
movsbl %dil, %r8d
addl $-0x30, %r8d
movq %rax, %rsi
cmpl $0xa, %r8d
jae 0x445dd
jmp 0x446f4
cmpb %sil, 0xc(%rax)
jne 0x446b1
movl $0xc0, %r14d
cmpl $0xa, %edx
jb 0x446f8
movq -0x20(%rbp), %rsi
movabsq $0x680000000001, %rdx   # imm = 0x680000000001
movl %ecx, %edi
cmpb $0x2e, %dil
ja 0x4464b
movzbl %dil, %edi
btq %rdi, %rdx
jb 0x446f4
movb 0x1(%rax), %dil
incq %rax
movsbl %dil, %r8d
addl $-0x30, %r8d
movq %rax, %rsi
cmpl $0xa, %r8d
jae 0x44637
jmp 0x446f4
movl $0xec, %r14d
cmpl $0xa, %edx
jb 0x446f8
movq -0x20(%rbp), %rsi
movabsq $0x680000000001, %rdx   # imm = 0x680000000001
movl %ecx, %edi
cmpb $0x2e, %dil
ja 0x44697
movzbl %dil, %edi
btq %rdi, %rdx
jb 0x446f4
movb 0x1(%rax), %dil
incq %rax
movsbl %dil, %r8d
addl $-0x30, %r8d
movq %rax, %rsi
cmpl $0xa, %r8d
jae 0x44687
jmp 0x446f4
movl $0xec, %r14d
cmpl $0xa, %edx
jb 0x446f8
movq -0x20(%rbp), %rsi
movabsq $0x680000000001, %rdx   # imm = 0x680000000001
movl %ecx, %edi
cmpb $0x2e, %dil
ja 0x446dc
movzbl %dil, %edi
btq %rdi, %rdx
jb 0x446f4
movb 0x1(%rax), %dil
incq %rax
movsbl %dil, %r8d
addl $-0x30, %r8d
movq %rax, %rsi
cmpl $0xa, %r8d
jae 0x446cc
movq %rsi, -0x20(%rbp)
xorl %edx, %edx
cmpb $0x72, %cl
sete %dl
addl %edx, %edx
cmpb $0x79, %cl
movl $0x1, %r15d
cmovnel %edx, %r15d
leaq -0x20(%rbp), %rsi
movq %rax, %rdi
movl $0xa, %edx
callq 0x9680
addq 0x10(%rbx), %r14
shlq $0x20, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
sarq $0x1e, %rcx
movl %r15d, (%rcx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Player.cpp
// Function: Player::SendOptionToServer()
void Player::SendOptionToServer() {
  while (!mpParser->IsClangOk()) {
    mpAgent->CheckCommands(mpObserver);
    mpAgent->Clang(7, 8);
    mpObserver->SetCommandSend();
    WaitFor(200);
  }

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

  mpAgent->CheckCommands(mpObserver);
  mpAgent->EarOff(false);
  mpObserver->SetCommandSend();
  WaitFor(200);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r15
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x4f686
movb 0x4d(%r15), %r15b
movq %r14, %rdi
callq 0x4f6a2
testb %r15b, %r15b
jne 0x448e3
movq 0x8(%rbx), %r14
movq 0x18(%rbx), %rdi
movb 0x3382(%r14), %al
movb %al, 0x28(%rdi)
movq 0x1838(%r14), %rax
movq %rax, 0x2c(%rdi)
callq 0xef28
movq %rax, %rdi
movq %r14, %rsi
callq 0xd71a
movq 0x18(%rbx), %rdi
callq 0xef28
movq %rax, %rdi
movl $0x7, %esi
movl $0x8, %edx
callq 0xc95a
movq 0x8(%rbx), %rdi
callq 0x3d2b6
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x9690
movq 0x20(%rbx), %r15
jmp 0x44865
movq 0x20(%rbx), %r15
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x4f686
movb 0x4e(%r15), %r15b
movq %r14, %rdi
callq 0x4f6a2
testb %r15b, %r15b
jne 0x44977
movq 0x8(%rbx), %r14
movq 0x18(%rbx), %rdi
movb 0x3382(%r14), %al
movb %al, 0x28(%rdi)
movq 0x1838(%r14), %rax
movq %rax, 0x2c(%rdi)
callq 0xef28
movq %rax, %rdi
movq %r14, %rsi
callq 0xd71a
movq 0x18(%rbx), %rdi
callq 0xef28
movq %rax, %rdi
callq 0xca4a
movq 0x8(%rbx), %rdi
callq 0x3d2b6
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x9690
movq 0x20(%rbx), %r15
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x4f686
movb 0x4e(%r15), %r15b
movq %r14, %rdi
callq 0x4f6a2
cmpb $0x1, %r15b
jne 0x44904
movq 0x8(%rbx), %r14
movq 0x18(%rbx), %rdi
movb 0x3382(%r14), %al
movb %al, 0x28(%rdi)
movq 0x1838(%r14), %rax
movq %rax, 0x2c(%rdi)
callq 0xef28
movq %rax, %rdi
movq %r14, %rsi
callq 0xd71a
movq 0x18(%rbx), %rdi
callq 0xef28
movq %rax, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0xc9f0
movq 0x8(%rbx), %rdi
callq 0x3d2b6
movl $0x30d40, %edi          # imm = 0x30D40
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9690
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Player.cpp
// Function: Player::Run()
void Player::Run() {
  // TIMETEST("Run");

  static Time last_time = Time(-100, 0);

  mpObserver->Lock();

  /** 下面几个更新顺序不能变 */
  Formation::instance.SetTeammateFormations();
  CommunicateSystem::instance().Update(); //在这里解析hear信息，必须首先更新
  mpAgent->CheckCommands(mpObserver);
  mpWorldModel->Update(mpObserver);

  mpObserver->UnLock();

  const Time &time = mpAgent->GetWorldState().CurrentTime();

  if (last_time.T() >= 0) {
    if (time != Time(last_time.T() + 1, 0) &&
        time != Time(last_time.T(), last_time.S() + 1)) {
      if (time == last_time) {
        mpAgent->World().SetCurrentTime(
            Time(last_time.T(), last_time.S() + 1)); //否则决策数据更新会出问题
      }
    }
  }

  last_time = time;

  Formation::instance
      .UpdateOpponentRole(); // TODO:
                             // 暂时放在这里，教练未发来对手阵型信息时自己先计算

  VisualSystem::instance().ResetVisualRequest();
  mpDecisionTree->Decision(*mpAgent);

  VisualSystem::instance().Decision();
  CommunicateSystem::instance().Decision();

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

  mpAgent->SetHistoryActiveBehaviors();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x319d73(%rip), %al     # 0x35e760
testb %al, %al
je 0x44b43
movl $0x3548, %r14d          # imm = 0x3548
movq 0x8(%rbx), %rdi
addq %r14, %rdi
callq 0x4f686
leaq 0x49662(%rip), %rdi     # 0x8e070
callq 0x27c22
callq 0x1d3cc
movq %rax, %rdi
callq 0x1d8f8
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
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
movslq 0x319ce3(%rip), %rcx    # 0x35e758
testq %rcx, %rcx
js 0x44ab9
leal 0x1(%rcx), %edi
movl 0x10(%rax), %edx
movl 0x14(%rax), %esi
xorl %edx, %edi
orl %esi, %edi
je 0x44ab9
movl 0x319ccc(%rip), %r8d    # 0x35e75c
leal 0x1(%r8), %edi
movl %esi, %r9d
xorl %edi, %r9d
movl %edx, %r10d
xorl %ecx, %r10d
orl %r9d, %r10d
je 0x44ab9
xorl %r8d, %esi
xorl %ecx, %edx
orl %esi, %edx
jne 0x44ab9
shlq $0x20, %rdi
orq %rcx, %rdi
movq %rdi, 0x10(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x319c94(%rip)    # 0x35e758
leaq 0x495a5(%rip), %rdi     # 0x8e070
callq 0x27ca6
callq 0x57e2a
movq %rax, %rdi
callq 0x57ede
movq 0x18(%rbx), %rsi
movq 0x30(%rbx), %rdi
callq 0x2297c
callq 0x57e2a
movq %rax, %rdi
callq 0x5808c
callq 0x1d3cc
movq %rax, %rdi
callq 0x1e724
callq 0x4a75c
cmpb $0x1, 0x32c9(%rax)
jne 0x44b23
movq 0x18(%rbx), %rdi
callq 0xef28
movq %rax, %rdi
callq 0xc908
movq 0x18(%rbx), %rdi
callq 0xf310
callq 0x35b4a
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35f2c
callq 0xa0c0
jmp 0x449f5
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/ParamEngine.h
// Function: void ParamEngine::AddParam<int>(char const*, int*, int)
void AddParam(const char *name, T *address, T value) {
    if (address) {
      // assign default value
      *address = value;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
testq %rdx, %rdx
je 0x463cc
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, (%rdx)
leaq -0x58(%rbp), %r12
leaq -0x21(%rbp), %rdx
movq %r12, %rdi
callq 0x24892
movq %r15, 0x20(%r12)
movl $0x1, 0x28(%r12)
testq %r14, %r14
je 0x46378
movsbl (%r14), %edx
movb 0x1(%r14), %cl
testb %cl, %cl
je 0x4637f
addq $0x2, %r14
movl %edx, %eax
movsbl %cl, %ecx
shll $0x5, %eax
subl %edx, %eax
addl %ecx, %eax
movb (%r14), %cl
incq %r14
movl %eax, %edx
testb %cl, %cl
jne 0x46360
jmp 0x46381
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x46386
movl %edx, %eax
andl $0x1ff, %eax            # imm = 0x1FF
testl %eax, %eax
js 0x463b3
movl %eax, %eax
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,8), %rbx
addq $0x8, %rbx
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x467ae
movq %rax, %rdi
movq %rbx, %rsi
callq 0x90b0
incq 0x10(%rbx)
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x463cc
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x94e0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x463f5
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::PlayerState()
PlayerState::PlayerState()
    : MobileState(ServerParam::instance().playerDecay(),
                  PlayerParam::instance().HeteroPlayer(0).effectiveSpeedMax()) {
  mBallCatchable = false;
  mCatchBan = 0;
  mCollideWithBall = false;
  mCollideWithPlayer = false;
  mCollideWithPost = false;
  mIsAlive = false;
  mIsGoalie = false;
  mIsSensed = false;
  mIsKicked = false;
  mIsPointing = false;
  mKickRate = 0.0;
  mIsKickable = false;
  mMaxTurnAngle = 0.0;
  mPlayerType = 0;

  mStamina = ServerParam::instance().staminaMax();
  mEffort = ServerParam::instance().effortInit();
  mCapacity = ServerParam::instance().staminaCapacity();
  mRecovery = ServerParam::instance().recoverInit();

  mTackleBan = 0;
  mUnderDangerousTackleCondition = false;

  mFoulChargedCycle = 0;

  mUnum = 0;

  mViewWidth = VW_Normal;
  mIsTired = false;
  mMinStamina = PlayerParam::instance().MinStamina();

  mCardType = CR_None;
  mIsBodyDirMayChanged = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x4a75c
movsd 0x3020(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x450ba
movq 0x5c38(%rax), %rax
movsd 0x3098(%rax), %xmm1
movq %rbx, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x3d736
leaq 0x3f570(%rip), %rax     # 0x85dc8
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x98(%rbx)
movl $0x270f, %ecx           # imm = 0x270F
movl %ecx, 0xa0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%rbx)
movl %ecx, 0xb8(%rbx)
movq %rax, 0xc0(%rbx)
movups %xmm0, 0xd0(%rbx)
movq %rax, 0xe0(%rbx)
movl %ecx, 0xe8(%rbx)
movq %rax, 0xf0(%rbx)
movb $0x3f, 0xf8(%rbx)
movabsq $0x270f00000000, %rcx   # imm = 0x270F00000000
movq %rcx, 0xfc(%rbx)
movups %xmm0, 0x140(%rbx)
movb %al, 0x138(%rbx)
movl %eax, 0xcc(%rbx)
movw %ax, 0x120(%rbx)
movb %al, 0x122(%rbx)
movw %ax, 0x175(%rbx)
movq %rax, 0x130(%rbx)
movb %al, 0x128(%rbx)
movq %rax, 0x158(%rbx)
movl %eax, 0x114(%rbx)
movl %eax, 0x10f(%rbx)
movq %rax, 0x108(%rbx)
callq 0x4a75c
movsd 0x3048(%rax), %xmm0
movsd %xmm0, 0x78(%rbx)
callq 0x4a75c
movsd 0x3078(%rax), %xmm0
movsd %xmm0, 0x80(%rbx)
callq 0x4a75c
movsd 0x3390(%rax), %xmm0
movsd %xmm0, 0x88(%rbx)
callq 0x4a75c
movsd 0x3058(%rax), %xmm0
movsd %xmm0, 0x90(%rbx)
xorl %eax, %eax
movl %eax, 0xc8(%rbx)
movb %al, 0x150(%rbx)
movl %eax, 0x124(%rbx)
movq $0x2, 0x118(%rbx)
movb %al, 0x160(%rbx)
callq 0x450ba
movsd 0x5c60(%rax), %xmm0
movsd %xmm0, 0x168(%rbx)
movl $0x0, 0x170(%rbx)
movb $0x1, 0x174(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x3e8fa(%rip), %rax     # 0x852b0
movq %rax, (%rbx)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x469cc
movl $0x670, %esi            # imm = 0x670
callq 0x94e0
movq %r14, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::IsKickable(BallState const&, double const&) const
bool PlayerState::IsKickable(const BallState &ball_state,
                             const double &buffer) const {
  if (ball_state.GetPosConf() < FLOAT_EPS || GetPosConf() < FLOAT_EPS)
    return false;
  double dis2self = GetPos().Dist(ball_state.GetPos());
  return (dis2self <= GetKickableArea() - buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
movsd 0x24657(%rip), %xmm0    # 0x6b040
ucomisd 0x20(%rsi), %xmm0
ja 0x46a52
movq %rdi, %r14
ucomisd 0x20(%rdi), %xmm0
ja 0x46a52
movq %rdx, %rbx
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
subsd 0x8(%rsi), %xmm0
subsd 0x10(%rsi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x46a2f
sqrtsd %xmm0, %xmm0
jmp 0x46a34
callq 0x93c0
movsd %xmm0, -0x18(%rbp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movsd (%rax), %xmm0
subsd (%rbx), %xmm0
ucomisd -0x18(%rbp), %xmm0
setae %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetPredictedPosWithDash(int, double, double) const
Vector PlayerState::GetPredictedPosWithDash(int steps, double dash_power,
                                            AngleDeg dash_dir) const {
  Simulator::Player self(*this);
  int dash_dir_idx = Dasher::GetDashDirIdx(dash_dir);

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

  return self.mPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, -0x20(%rbp)
movl %esi, %ebx
leaq -0x68(%rbp), %rax
movsd %xmm1, (%rax)
movups 0x8(%rdi), %xmm0
movaps %xmm0, -0x60(%rbp)
movups 0x30(%rdi), %xmm0
movaps %xmm0, -0x50(%rbp)
movsd 0xb0(%rdi), %xmm0
movsd %xmm0, -0x40(%rbp)
cvttsd2si 0x78(%rdi), %ecx
movl %ecx, -0x38(%rbp)
movsd 0x80(%rdi), %xmm0
movsd %xmm0, -0x30(%rbp)
movl 0x114(%rdi), %ecx
movl %ecx, -0x28(%rbp)
movq %rax, %rdi
callq 0x226e8
testl %ebx, %ebx
jle 0x47038
movl %eax, %r14d
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movsd -0x20(%rbp), %xmm0
movl %r14d, %esi
callq 0x4c1bc
decl %ebx
jne 0x47024
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetPredictedVelWithDash(int, double, double) const
Vector PlayerState::GetPredictedVelWithDash(int steps, double dash_power,
                                            AngleDeg dash_dir) const {
  Simulator::Player self(*this);
  int dash_dir_idx = Dasher::GetDashDirIdx(dash_dir);

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

  return self.mVel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, -0x20(%rbp)
movl %esi, %ebx
leaq -0x68(%rbp), %rax
movsd %xmm1, (%rax)
movups 0x8(%rdi), %xmm0
movaps %xmm0, -0x60(%rbp)
movups 0x30(%rdi), %xmm0
movaps %xmm0, -0x50(%rbp)
movsd 0xb0(%rdi), %xmm0
movsd %xmm0, -0x40(%rbp)
cvttsd2si 0x78(%rdi), %ecx
movl %ecx, -0x38(%rbp)
movsd 0x80(%rdi), %xmm0
movsd %xmm0, -0x30(%rbp)
movl 0x114(%rdi), %ecx
movl %ecx, -0x28(%rbp)
movq %rax, %rdi
callq 0x226e8
testl %ebx, %ebx
jle 0x470cc
movl %eax, %r14d
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movsd -0x20(%rbp), %xmm0
movl %r14d, %esi
callq 0x4c1bc
decl %ebx
jne 0x470b8
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::CorrectDashPowerForStamina(double) const
double PlayerState::CorrectDashPowerForStamina(double dash_power) const {
  double stamina = GetStamina();

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

  double new_power;

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

    new_power = -new_power;
  }

  return new_power;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movaps %xmm0, -0x10(%rbp)
movsd 0x78(%rdi), %xmm0
movsd 0x88(%rdi), %xmm1
movapd %xmm0, -0x30(%rbp)
addsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
callq 0x450ba
movsd 0x5c60(%rax), %xmm0
addsd 0x23f22(%rip), %xmm0    # 0x6b040
ucomisd -0x18(%rbp), %xmm0
jbe 0x4712f
movapd -0x10(%rbp), %xmm0
jmp 0x471be
xorpd %xmm1, %xmm1
movapd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x47199
xorpd 0x23eda(%rip), %xmm0    # 0x6b020
movapd %xmm0, -0x10(%rbp)
callq 0x450ba
movapd -0x30(%rbp), %xmm1
subsd 0x5c60(%rax), %xmm1
mulsd 0x24713(%rip), %xmm1    # 0x6b878
minsd -0x10(%rbp), %xmm1
movapd 0x23eae(%rip), %xmm0    # 0x6b020
xorpd %xmm1, %xmm0
cmpltsd %xmm0, %xmm1
movapd %xmm0, %xmm2
movsd 0x25e09(%rip), %xmm0    # 0x6cf90
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x471be
callq 0x450ba
movapd -0x30(%rbp), %xmm0
subsd 0x5c60(%rax), %xmm0
minsd -0x10(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x471be
xorpd %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetControlBallProb(Vector const&) const
double PlayerState::GetControlBallProb(const Vector &ball_pos) const {
  const double dist = GetPos().Dist(ball_pos);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x8(%rdi), %xmm0
movsd 0x10(%rdi), %xmm1
subsd (%rsi), %xmm0
subsd 0x8(%rsi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x474dc
sqrtsd %xmm0, %xmm0
jmp 0x474e1
callq 0x93c0
movsd %xmm0, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movsd (%rax), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x47509
movsd 0x23b51(%rip), %xmm0    # 0x6b058
jmp 0x47566
leaq 0x8(%rbx), %r15
cmpb $0x1, 0x175(%rbx)
jne 0x4754a
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x47572
movsd %xmm0, -0x28(%rbp)
addq $0xb0, %rbx
leaq -0x1a(%rbp), %rcx
movb $0x0, (%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4774d
maxsd -0x28(%rbp), %xmm0
jmp 0x47566
addq $0xb0, %rbx
leaq -0x19(%rbp), %rcx
movb $0x0, (%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4774d
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PlayerState.cpp
// Function: PlayerState::GetCatchProb(double const&) const
double PlayerState::GetCatchProb(const double &dist) const {
  if (dist < GetMinCatchArea()) {
    return ServerParam::instance().catchProb();
  } else {
    double min_length = ServerParam::instance().catchAreaLength() *
                        (2.0 - GetCatchAreaLStretch());
    double max_length =
        ServerParam::instance().catchAreaLength() * GetCatchAreaLStretch();
    if (max_length < min_length + FLOAT_EPS)
      return 0.0;
    double delt =
        Sqrt(dist * dist - ServerParam::instance().catchAreaWidth() *
                               ServerParam::instance().catchAreaWidth() / 4);
    if (delt > max_length)
      return 0.0;
    double dx = delt - min_length;
    return MinMax(0.0,
                  ServerParam::instance().catchProb() -
                      ServerParam::instance().catchProb() * dx /
                          (max_length - min_length),
                  ServerParam::instance().catchProb());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rsi), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x450ba
movq 0x5c38(%rax), %rax
movslq 0x114(%r14), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd 0x3088(%rax,%rcx), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x4a75c
movsd -0x28(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x475d2
movsd 0x31c0(%rax), %xmm1
jmp 0x47740
movsd 0x31b0(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x450ba
movq 0x5c38(%rax), %rax
movslq 0x114(%r14), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd 0x2417f(%rip), %xmm0    # 0x6b780
subsd 0x3070(%rax,%rcx), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x4a75c
movsd 0x31b0(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x450ba
movq 0x5c38(%rax), %rax
movslq 0x114(%r14), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd -0x18(%rbp), %xmm2
mulsd 0x3070(%rax,%rcx), %xmm2
movsd 0x239ea(%rip), %xmm0    # 0x6b040
addsd -0x28(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm0
ja 0x47740
movsd %xmm2, -0x18(%rbp)
movsd (%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x4a75c
movsd 0x31b8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x4a75c
movsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd 0x31b8(%rax), %xmm1
mulsd 0x266b0(%rip), %xmm1    # 0x6dd58
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x476c0
sqrtsd %xmm0, %xmm0
jmp 0x476c9
callq 0x93c0
xorpd %xmm1, %xmm1
movsd -0x18(%rbp), %xmm2
ucomisd %xmm2, %xmm0
ja 0x47740
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x4a75c
movsd 0x31c0(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x4a75c
movsd -0x30(%rbp), %xmm0
mulsd 0x31c0(%rax), %xmm0
movsd -0x18(%rbp), %xmm1
subsd -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
movapd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x4a75c
movsd 0x31c0(%rax), %xmm1
xorpd %xmm0, %xmm0
movsd -0x20(%rbp), %xmm2
maxsd %xmm0, %xmm2
minsd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Plotter.cpp
// Function: Plotter::Init()
void Plotter::Init() {
#ifndef WIN32
  mIsDisplayOk = getenv("DISPLAY") != 0;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x263f2(%rip), %rdi     # 0x6dd60
callq 0x95e0
testq %rax, %rax
setne 0x8(%rbx)
callq 0x450ba
cmpb $0x1, 0x5c46(%rax)
jne 0x4799f
leaq 0x263d9(%rip), %rdi     # 0x6dd68
leaq 0x26b05(%rip), %rsi     # 0x6e49b
callq 0x91b0
movq %rax, 0x10(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x479c3
cmpb $0x1, 0x8(%rbx)
jne 0x479c3
leaq 0x263bd(%rip), %rsi     # 0x6dd70
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x47ac6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Plotter.cpp
// Function: Plotter::GnuplotExecute(char const*, ...)
void Plotter::GnuplotExecute(const char *cmd, ...) {
#ifndef WIN32
  if (!mpGnupolot)
    return;

  va_list ap;
  char local_cmd[GP_CMD_SIZE];

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

  strcat(local_cmd, "\n");

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x8d0, %rsp            # imm = 0x8D0
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x47b08
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
cmpq $0x0, 0x10(%rdi)
je 0x47b81
movq %rdi, %rbx
movabsq $0x3000000010, %rax     # imm = 0x3000000010
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
leaq -0xe0(%rbp), %rax
movq %rax, 0x10(%rdx)
leaq -0x8e0(%rbp), %r14
movq %r14, %rdi
callq 0x9220
movq %r14, %rdi
callq 0x9200
movw $0xa, -0x8e0(%rbp,%rax)
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x9540
movq 0x10(%rbx), %rdi
callq 0x9590
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::UpdateRoutine()
void PositionInfo::UpdateRoutine() {
  UpdateDistMatrix();
  UpdateOffsideLine();
  UpdateOppGoalInfo();

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x47dfa
movq %rbx, %rdi
callq 0x48116
movq %rbx, %rdi
callq 0x48372
movq 0x10d8(%rbx), %rax
cmpq %rax, 0x10e0(%rbx)
je 0x47d4f
movq %rax, 0x10e0(%rbx)
movq 0x10f0(%rbx), %rax
cmpq %rax, 0x10f8(%rbx)
je 0x47d66
movq %rax, 0x10f8(%rbx)
movq 0x1108(%rbx), %rax
cmpq %rax, 0x1110(%rbx)
je 0x47d7d
movq %rax, 0x1110(%rbx)
movq $-0x228, %rax           # imm = 0xFDD8
movq 0x1348(%rbx,%rax), %rcx
cmpq %rcx, 0x1350(%rbx,%rax)
je 0x47d9e
movq %rcx, 0x1350(%rbx,%rax)
movq 0x1570(%rbx,%rax), %rcx
cmpq %rcx, 0x1578(%rbx,%rax)
je 0x47db8
movq %rcx, 0x1578(%rbx,%rax)
movq 0x1798(%rbx,%rax), %rcx
cmpq %rcx, 0x17a0(%rbx,%rax)
je 0x47dd2
movq %rcx, 0x17a0(%rbx,%rax)
addq $0x18, %rax
jne 0x47d84
leaq 0x10a8(%rbx), %rdi
callq 0x49608
addq $0x10c0, %rbx           # imm = 0x10C0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x49608
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/PositionInfo.cpp
// Function: PositionInfo::UpdateOppGoalInfo()
void PositionInfo::UpdateOppGoalInfo() {
  mOppGoal2Ball = Vector(ServerParam::instance().PITCH_LENGTH / 2.0, 0.0) -
                  mpWorldState->GetBall().GetPos();
  mOppLeftPost2Ball = ServerParam::instance().oppLeftGoalPost() -
                      mpWorldState->GetBall().GetPos();
  mOppRightPost2Ball = ServerParam::instance().oppRightGoalPost() -
                       mpWorldState->GetBall().GetPos();
  mOppGoal2BallAngle = mOppGoal2Ball.Dir();
  mOppLeftPost2BallAngle = mOppLeftPost2Ball.Dir();
  mOppRightPost2BallAngle = mOppRightPost2Ball.Dir();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x4a75c
leaq 0x25b8c(%rip), %rax     # 0x6df18
movsd (%rax), %xmm0
mulsd 0x234e0(%rip), %xmm0    # 0x6b878
movq 0x10(%rbx), %rax
subsd 0x38(%rax), %xmm0
xorpd %xmm1, %xmm1
subsd 0x40(%rax), %xmm1
leaq 0x18a8(%rbx), %r14
movsd %xmm0, 0x18a8(%rbx)
movsd %xmm1, 0x18b0(%rbx)
callq 0x4a75c
movq 0x10(%rbx), %rcx
movsd 0x3930(%rax), %xmm0
movsd 0x3938(%rax), %xmm1
subsd 0x38(%rcx), %xmm0
subsd 0x40(%rcx), %xmm1
leaq 0x18b8(%rbx), %r15
movsd %xmm0, 0x18b8(%rbx)
movsd %xmm1, 0x18c0(%rbx)
callq 0x4a75c
movq 0x10(%rbx), %rcx
movsd 0x3940(%rax), %xmm0
movsd 0x3948(%rax), %xmm1
subsd 0x38(%rcx), %xmm0
subsd 0x40(%rcx), %xmm1
leaq 0x18c8(%rbx), %r12
movsd %xmm0, 0x18c8(%rbx)
movsd %xmm1, 0x18d0(%rbx)
movq %r14, %rdi
callq 0xe804
movsd %xmm0, 0x18d8(%rbx)
movq %r15, %rdi
callq 0xe804
movsd %xmm0, 0x18e0(%rbx)
movq %r12, %rdi
callq 0xe804
movsd %xmm0, 0x18e8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq