LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/TimeTest.cpp
// Function: TimeTest::End(int)
void TimeTest::End(int event_id) {
  if (PlayerParam::instance().TimeTest()) {
    RealTime end_time = GetRealTime();
    long cost_time = end_time.Sub(mRecordQueue[event_id].mBeginTime);
    long last_num = mRecordQueue[event_id].mEachTime.mNum;
    double last_ave_cost = mRecordQueue[event_id].mEachTime.mAveCost;
    if (cost_time > mRecordQueue[event_id].mEachTime.mMaxCost) {
      mRecordQueue[event_id].mEachTime.mMaxCost = cost_time;
      mRecordQueue[event_id].mEachTime.mMaxTime = mUpdateTime;
    }
    if (cost_time < mRecordQueue[event_id].mEachTime.mMinCost) {
      mRecordQueue[event_id].mEachTime.mMinCost = cost_time;
      mRecordQueue[event_id].mEachTime.mMinTime = mUpdateTime;
    }

    mRecordQueue[event_id].mEachTime.mAveCost =
        (last_ave_cost * last_num + cost_time) / (last_num + 1);
    ++mRecordQueue[event_id].mEachTime.mNum;
    mRecordQueue[event_id].mCycleTimeCost += cost_time;
    mIsExecute[event_id] = true;
    mIsBegin[event_id] = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x450ba
cmpb $0x1, 0x5c48(%rax)
jne 0x50304
callq 0x55bd8
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movslq %r14d, %r14
movq 0x18(%rbx), %rax
imulq $0x78, %r14, %r15
leaq (%rax,%r15), %rsi
addq $0x60, %rsi
callq 0x55e10
movq 0x18(%rbx), %rdx
cmpq 0x48(%rdx,%r15), %rax
jle 0x5024b
leaq (%rdx,%r15), %rcx
movq %rax, 0x48(%rcx)
movq 0x80(%rbx), %rsi
movq %rsi, 0x40(%rcx)
movq 0x30(%rdx,%r15), %rcx
movsd 0x38(%rdx,%r15), %xmm0
movq 0x18(%rbx), %rdx
cmpq 0x58(%rdx,%r15), %rax
jge 0x50274
addq %r15, %rdx
movq %rax, 0x58(%rdx)
movq 0x80(%rbx), %rsi
movq %rsi, 0x50(%rdx)
cvtsi2sd %rcx, %xmm1
mulsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
addsd %xmm0, %xmm1
incq %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
divsd %xmm0, %xmm1
movq 0x18(%rbx), %rcx
movsd %xmm1, 0x38(%rcx,%r15)
incq 0x30(%rcx,%r15)
addq %rax, 0x70(%rcx,%r15)
leaq 0x3f(%r14), %rax
testq %r14, %r14
cmovnsq %r14, %rax
sarq $0x6, %rax
shlq $0x3, %rax
movq 0x30(%rbx), %rdx
addq %rax, %rdx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
leaq 0x3f(%rcx), %rsi
andq %r14, %rsi
xorl %edi, %edi
cmpq %rcx, %rsi
setbe %dil
movl $0x1, %esi
movl %r14d, %ecx
shlq %cl, %rsi
orq %rsi, -0x8(%rdx,%rdi,8)
addq 0x58(%rbx), %rax
movq $-0x2, %rdx
rolq %cl, %rdx
andq %rdx, -0x8(%rax,%rdi,8)
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/Trainer.cpp
// Function: Trainer::PlayerState::PlayerState(int, Vector, Vector, double, int)
Trainer::PlayerState::PlayerState(Unum num, Vector pos, Vector vel,
                                  AngleDeg dir, int type) {
  mUnum = num;
  mPos = pos;
  mVel = vel;
  mBodyDir = dir;
  mPlayerType = type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm5, %xmm5
movups %xmm5, 0x8(%rdi)
movups %xmm5, 0x18(%rdi)
movl %esi, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
movsd %xmm3, 0x20(%rdi)
movsd %xmm4, 0x28(%rdi)
movl %edx, 0x30(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Trainer()
Trainer::Trainer() {
  mTrainTime = 0;
  mTrainCount = 0;
  mInitialized = false;
  mConverse = false;
  mPrepared = false;
  mHaveRcg = 0;
  mpEndCondition = new Trainer::Condition(this, ET_Null, 0, 0, 0x0, mConverse);
  mLastStopTime = 0;
  mpObserver->SetSelfUnum(TRAINER_UNUM);
  mInitialTime = 0;
  mPlayerStatesList.clear();
  mBallStateList.clear();
  mNeedOpponentList.clear();
  if (!PlayerParam::instance().ForcePenaltyMode()) {
    ReadConfigFile();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1bd3c
leaq 0x36243(%rip), %rax     # 0x86c80
movq %rax, (%rbx)
leaq 0x120(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x120(%rbx)
xorl %r13d, %r13d
movq %r13, 0x130(%rbx)
leaq 0x140(%rbx), %r15
movups %xmm0, 0x140(%rbx)
movq %r13, 0x150(%rbx)
leaq 0x160(%rbx), %r12
movq %r13, 0x98(%rbx)
movl $0x0, 0x30(%rbx)
movups %xmm0, 0x160(%rbx)
movups %xmm0, 0x170(%rbx)
movups %xmm0, 0x180(%rbx)
movl $0x58, %edi
callq 0x94c0
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movq %rbx, 0x38(%rax)
movl %r13d, (%rax)
movabsq $0x177000000000, %rcx   # imm = 0x177000000000
movq %rcx, 0x40(%rax)
movups %xmm0, 0x8(%rax)
movq %r13, 0x48(%rax)
movq %r13, 0x4d(%rax)
movq %rax, 0x158(%rbx)
movl %r13d, 0x194(%rbx)
movq 0x8(%rbx), %rax
movl $0xc, 0x2c(%rax)
movl %r13d, 0x138(%rbx)
movq 0x120(%rbx), %rsi
movq %r14, %rdi
callq 0x54d52
movq 0x160(%rbx), %rax
cmpq %rax, 0x168(%rbx)
je 0x50b16
movq %rax, 0x168(%rbx)
movq 0x140(%rbx), %rax
cmpq %rax, 0x148(%rbx)
je 0x50b2d
movq %rax, 0x148(%rbx)
callq 0x450ba
cmpb $0x0, 0x5c41(%rax)
jne 0x50b43
movq %rbx, %rdi
callq 0x50b96
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq 0x178(%rbx), %rdi
testq %rdi, %rdi
je 0x50b70
movq 0x188(%rbx), %rsi
subq %rdi, %rsi
callq 0x94e0
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xa3ee
movq %r14, %rdi
callq 0x5443c
movq %rbx, %rdi
callq 0x1be90
movq %r13, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Record()
void Trainer::Record() {
  //记录统计信息
  ofstream os;
  os.open("./train/train.report");
  if (mConverse)
    os << "Converse Train!!" << endl;
  os << "Total Train Count:" << mTrainCount << endl;
  mpEndCondition->Report(os);
  os.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq -0x210(%rbp), %r14
movq %r14, %rdi
callq 0x9870
leaq 0x1e22f(%rip), %rsi     # 0x6f1c4
movq %r14, %rdi
movl $0x10, %edx
callq 0x9090
cmpb $0x1, 0x33(%rbx)
jne 0x50feb
leaq 0x1e22a(%rip), %rsi     # 0x6f1d9
movl $0x10, %edx
movq %r14, %rdi
callq 0x9560
movq -0x210(%rbp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
leaq -0x210(%rbp), %rdi
callq 0x9070
movq %rax, %rdi
callq 0x9330
leaq 0x1e1f8(%rip), %rsi     # 0x6f1ea
leaq -0x210(%rbp), %rdi
movl $0x12, %edx
callq 0x9560
movl 0x9c(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x9320
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
movq 0x158(%rbx), %rdi
leaq -0x210(%rbp), %rsi
callq 0x54028
leaq -0x210(%rbp), %rdi
callq 0x96c0
movq 0x35f4b(%rip), %rax     # 0x86fb0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x9400
leaq -0x118(%rbp), %rdi
callq 0x91c0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x9700
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::SendOptionToServer()
void Trainer::SendOptionToServer() {
  while (!mpParser->IsEyeOnOk()) {
    UDPSocket::instance().Send("(eye on)");
    WaitFor(200);
  }

  while (!mpParser->IsEarOnOk()) {
    cout << "Send (ear on)" << endl;
    UDPSocket::instance().Send("(ear on)");
    WaitFor(200);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r15
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x4f686
movb 0x4f(%r15), %r15b
movq %r14, %rdi
callq 0x4f6a2
testb %r15b, %r15b
jne 0x51150
leaq 0x1afa5(%rip), %r14     # 0x6c0b8
callq 0x55830
movq %rax, %rdi
movq %r14, %rsi
callq 0x55b22
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x9690
movq 0x20(%rbx), %r12
leaq 0x20(%r12), %r15
movq %r15, %rdi
callq 0x4f686
movb 0x4f(%r12), %r12b
movq %r15, %rdi
callq 0x4f6a2
testb %r12b, %r12b
je 0x51113
movq 0x20(%rbx), %r15
leaq 0x20(%r15), %r14
movq %r14, %rdi
callq 0x4f686
movb 0x50(%r15), %r15b
movq %r14, %rdi
callq 0x4f6a2
testb %r15b, %r15b
jne 0x511fa
movq 0x35e44(%rip), %r14     # 0x86fc0
leaq 0x1dc7e(%rip), %r12     # 0x6ee01
movl $0xd, %edx
movq %r14, %rdi
leaq 0x1dc6a(%rip), %rsi     # 0x6edfc
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
callq 0x55830
movq %rax, %rdi
movq %r12, %rsi
callq 0x55b22
movl $0x30d40, %edi          # imm = 0x30D40
callq 0x9690
movq 0x20(%rbx), %r15
leaq 0x20(%r15), %r13
movq %r13, %rdi
callq 0x4f686
movb 0x50(%r15), %r15b
movq %r13, %rdi
callq 0x4f6a2
cmpb $0x1, %r15b
jne 0x51183
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/Trainer.cpp
// Function: Trainer::Run()
void Trainer::Run() {
  // TIMETEST("coach_run");

  mpObserver->Lock();

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

  mpObserver->UnLock();

  DoDecisionMaking();

  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
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 %rbx, %rdi
callq 0x5128e
callq 0x35b4a
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35f2c
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::DoDecisionMaking()
void Trainer::DoDecisionMaking() {
  switch (mpAgent->World().GetPlayMode()) {
  case PM_Our_Penalty:
  case PM_Opp_Penalty:
  case PM_Penalty_On_Our_Field:
  case PM_Penalty_On_Opp_Field:
  case PM_Our_Penalty_Setup:
  case PM_Our_Penalty_Ready:
  case PM_Our_Penalty_Taken:
  case PM_Our_Penalty_Score:
  case PM_Our_Penalty_Miss:
  case PM_Our_Penalty_Foul:
  case PM_Our_Penalty_Winner:
  case PM_Opp_Penalty_Setup:
  case PM_Opp_Penalty_Ready:
  case PM_Opp_Penalty_Taken:
  case PM_Opp_Penalty_Score:
  case PM_Opp_Penalty_Miss:
  case PM_Opp_Penalty_Foul:
  case PM_Opp_Penalty_Winner:
    return;
  default:
    break;
  }

  if (PlayerParam::instance()
          .ForcePenaltyMode()) //普通比赛，临近结束时强制进行点球
  {
    if (mpAgent->World().GetPlayMode() == PM_Before_Kick_Off &&
        mpAgent->World().GetLastPlayMode() == PM_Play_On)
      mPrepared = false;

    if (mpAgent->World().GetTeammateScore() !=
            mpAgent->World().GetOpponentScore() &&
        !mPrepared)

      mpAgent->World().GetTeammateScore() < mpAgent->World().GetOpponentScore()
          ? Score(true)
          : Score(false);
  } else if (CheckOpponent()) {
    if (!mInitialized) {
      InitializeStadium();
    }
    if (mpEndCondition->CheckState(mpAgent->World()) ||
        mpAgent->World().GetPlayMode() == PM_Before_Kick_Off) {
      mPrepared = false;
    }
    if (!mPrepared && mInitialized) {
      PrepareForTrain();
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %eax
cmpq $0x37, %rax
ja 0x512bf
movabsq $0xfe0000079fc000, %rcx # imm = 0xFE0000079FC000
btq %rax, %rcx
jae 0x512bf
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x450ba
cmpb $0x1, 0x5c41(%rax)
jne 0x51309
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
cmpl $0x16, 0x1c(%rax)
jne 0x512e5
cmpl $0x1, 0x20(%rax)
jne 0x512e5
movb $0x0, 0x31(%rbx)
movl 0x2118(%rax), %ecx
movl 0x211c(%rax), %eax
cmpl %eax, %ecx
je 0x512b8
cmpb $0x0, 0x31(%rbx)
jne 0x512b8
movq %rbx, %rdi
cmpl %eax, %ecx
jge 0x5136f
movl $0x1, %esi
jmp 0x51371
movq %rbx, %rdi
callq 0x51484
testb %al, %al
je 0x512b8
cmpb $0x0, 0x30(%rbx)
jne 0x51323
movq %rbx, %rdi
callq 0x514ec
movq 0x18(%rbx), %rax
movq 0x158(%rbx), %rdi
movq 0x18(%rax), %rsi
callq 0x51596
testb %al, %al
jne 0x51349
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
cmpl $0x16, 0x1c(%rax)
jne 0x5134d
movb $0x0, 0x31(%rbx)
cmpb $0x0, 0x31(%rbx)
jne 0x512b8
cmpb $0x1, 0x30(%rbx)
jne 0x512b8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x51b8e
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5137c
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Score(bool)
void Trainer::Score(bool isLeft) {
  if (mpAgent->World().GetPlayMode() != PM_Play_On) {
    ChangePlayMode(PM_Play_On);
  }
  Vector tmp = FindValidPoint(isLeft) - mpAgent->World().Ball().GetVel();
  if (isLeft) {
    tmp.SetX(Min(tmp.X(), ServerParam::instance().PITCH_LENGTH / 2 - 3.1));
  } else {
    tmp.SetX(Max(tmp.X(), -ServerParam::instance().PITCH_LENGTH / 2 + 3.1));
  }
  MoveBall(tmp, Vector(isLeft ? ServerParam::instance().ballSpeedMax()
                              : -ServerParam::instance().ballSpeedMax(),
                       0));
  mPrepared = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %rax
cmpl $0x1, 0x1c(%rax)
je 0x513af
callq 0xef28
movq %rax, %rdi
movl $0x3, %esi
callq 0xcbac
movzbl %r14b, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5427a
movsd %xmm1, -0x28(%rbp)
movq 0x18(%rbx), %rax
movq 0x18(%rax), %rax
subsd 0x60(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x68(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x4a75c
leaq 0x1cb2d(%rip), %rax     # 0x6df18
movsd (%rax), %xmm1
mulsd 0x1a481(%rip), %xmm1    # 0x6b878
testb %r15b, %r15b
je 0x51410
addsd 0x1d86c(%rip), %xmm1    # 0x6ec70
minsd -0x20(%rbp), %xmm1
movsd %xmm1, -0x20(%rbp)
jmp 0x51426
movsd 0x1d850(%rip), %xmm0    # 0x6ec68
subsd %xmm1, %xmm0
maxsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x4a75c
movsd 0x30f8(%rax), %xmm0
testb %r14b, %r14b
jne 0x5143f
xorps 0x19be1(%rip), %xmm0    # 0x6b020
movaps %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq 0x18(%rbx), %rdi
callq 0xef28
xorps %xmm3, %xmm3
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movaps -0x40(%rbp), %xmm2
callq 0xccb8
movb $0x1, 0x31(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::CheckOpponent() const
bool Trainer::CheckOpponent() const {
  WorldState &world = mpAgent->World();
  if (world.CurrentTime().T() > 1) {
    return true; //已经开场之后，如果有人不齐的话，估计就是死了……
  }
  for (std::vector<Unum>::const_iterator it = mNeedOpponentList.begin();
       it != mNeedOpponentList.end(); it++) {
    if (!world.GetOpponent(*it).IsAlive())
      return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movq 0x18(%rax), %rcx
movb $0x1, %al
cmpl $0x1, 0x10(%rcx)
jg 0x514ea
movq 0x140(%rdi), %rdx
movq 0x148(%rdi), %rsi
cmpq %rsi, %rdx
sete %al
je 0x514ea
movslq (%rdx), %rdi
imulq $0x178, %rdi, %rdi      # imm = 0x178
cmpb $0x1, 0x106a(%rdi,%rcx)
jne 0x514ea
addq $0x10d0, %rcx           # imm = 0x10D0
addq $0x4, %rdx
cmpq %rsi, %rdx
sete %al
je 0x514ea
movslq (%rdx), %rdi
addq $0x4, %rdx
imulq $0x178, %rdi, %rdi      # imm = 0x178
cmpb $0x0, -0x66(%rdi,%rcx)
jne 0x514cd
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::InitializeStadium()
void Trainer::InitializeStadium() {
  for (std::vector<Trainer::PlayerState>::const_iterator it =
           mPlayerStatesList[0].begin();
       it != mPlayerStatesList[0].end(); it++) {
    //		ChangePlayerType(it->mUnum,
    //it->mPlayerType);让教练自己选择异构吧
  }

  for (vector<vector<Trainer::PlayerState>>::iterator it =
           mPlayerStatesList.begin();
       it != mPlayerStatesList.end(); it++) {
    for (std::vector<Trainer::PlayerState>::iterator it2 = it->begin();
         it2 != it->end(); it2++) {
      it2->mVel /=
          PlayerParam::instance().HeteroPlayer(it2->mPlayerType).playerDecay();
      it2->mPos -= it2->mVel;
    }
  }
  mInitialized = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x120(%rdi), %r14
cmpq 0x128(%rdi), %r14
je 0x51586
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x51579
callq 0x450ba
movq 0x5c38(%rax), %rax
movslq 0x30(%r15), %rcx
imulq $0x3700, %rcx, %rcx     # imm = 0x3700
movsd 0x18(%r15), %xmm0
divsd 0x3020(%rax,%rcx), %xmm0
movsd %xmm0, 0x18(%r15)
movsd 0x20(%r15), %xmm1
divsd 0x3020(%rax,%rcx), %xmm1
movsd %xmm1, 0x20(%r15)
movsd 0x8(%r15), %xmm2
movsd 0x10(%r15), %xmm3
subsd %xmm0, %xmm2
movsd %xmm2, 0x8(%r15)
subsd %xmm1, %xmm3
movsd %xmm3, 0x10(%r15)
addq $0x38, %r15
jmp 0x5150c
addq $0x18, %r14
cmpq 0x128(%rbx), %r14
jne 0x51509
movb $0x1, 0x30(%rbx)
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/Trainer.cpp
// Function: Trainer::MovePlayer(int, Vector, Vector, double)
void Trainer::MovePlayer(Unum num, Vector pos, Vector vel, AngleDeg dir) {
  if (num > 0) {
    mpAgent->MovePlayer(PlayerParam::instance().teamName(), num, pos, vel, dir);
  } else {
    mpAgent->MovePlayer(PlayerParam::instance().opponentTeamName(), -num, pos,
                        vel, dir);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movsd %xmm4, -0x48(%rbp)
movsd %xmm3, -0x40(%rbp)
movsd %xmm2, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %esi, %ebx
movq 0x18(%rdi), %r14
callq 0x450ba
testl %ebx, %ebx
jle 0x5239f
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x3138(%rax), %rsi
movq 0x3140(%rax), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0xf0e0
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
movsd -0x48(%rbp), %xmm4
callq 0x54498
movq -0x88(%rbp), %rdi
jmp 0x523f1
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x3160(%rax), %rsi
movq 0x3168(%rax), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0xf0e0
negl %ebx
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
movsd -0x48(%rbp), %xmm4
callq 0x54498
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x52402
movq (%r12), %rsi
incq %rsi
callq 0x94e0
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
jmp 0x52422
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x52433
movq (%r12), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::ChangePlayerType(int, int)
void Trainer::ChangePlayerType(Unum num, int player_type) {
  if (num > 0) {
    mpAgent->ChangePlayerType(PlayerParam::instance().teamName(), num,
                              player_type);
    mpObserver->SetTeammateType(num, player_type);
  } else {
    mpAgent->ChangePlayerType(PlayerParam::instance().opponentTeamName(), -num,
                              player_type);
    mpObserver->SetOpponentType(-num, player_type);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, -0x30(%rbp)
movq 0x18(%rdi), %r12
callq 0x450ba
testl %r14d, %r14d
jle 0x5255f
leaq -0x60(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x3138(%rax), %rsi
movq 0x3140(%rax), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %r13
movq %r13, %rdi
callq 0xf0e0
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movl %r15d, %ecx
callq 0x54558
movq -0x70(%rbp), %rdi
cmpq %rbx, %rdi
je 0x5254e
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x94e0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x3c, %rax
decl %r14d
jmp 0x525bb
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x3160(%rax), %rsi
movq 0x3168(%rax), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r13
movq %r13, %rdi
callq 0xf0e0
movl %r14d, %edx
negl %edx
movq %r12, %rdi
movq %r13, %rsi
movl %r15d, %ecx
callq 0x54558
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x525ac
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x94e0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x68, %rax
notl %r14d
movslq %r14d, %rcx
movl %r15d, (%rax,%rcx,4)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
jmp 0x525e1
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %rbx, %rdi
je 0x525f1
movq (%rbx), %rsi
incq %rsi
callq 0x94e0
movq %r14, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::Condition::OptimizeConditionTree()
void Trainer::Condition::OptimizeConditionTree() {
  for (std::vector<Trainer::Condition>::iterator it = mSubCondition.begin();
       it != mSubCondition.end();) {
    if (it->mType == ET_Null && it->mSubCondition.empty()) //删除其空子条件
    {
      it = mSubCondition.erase(it);
    } else {
      it->OptimizeConditionTree();
      it++;
    }
  }
  if (mType == ET_Null) {
    if (mSubCondition.size() == 1) //子条件仅有1个时，提升
    {
      Trainer::Condition &sc = mSubCondition[0];
      mType = sc.mType;
      mArg1 = sc.mArg1;
      mArg2 = sc.mArg2;
      mSubCondition = sc.mSubCondition;
    } else {
      PRINT_ERROR("error condition relationship");
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %rax
cmpq %rax, %r15
je 0x5373e
cmpl $0x0, (%r15)
jne 0x5371c
movq 0x18(%r15), %rax
cmpq 0x20(%r15), %rax
je 0x5372e
movq %r15, %rdi
callq 0x536ee
addq $0x58, %r15
movq 0x20(%r14), %rax
jmp 0x53707
movq %rbx, %rdi
movq %r15, %rsi
callq 0x554ca
movq %rax, %r15
jmp 0x53728
cmpl $0x0, (%r14)
je 0x5374f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rsi
subq %rsi, %rax
cmpq $0x58, %rax
jne 0x5378c
movl (%rsi), %eax
movl %eax, (%r14)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%r14)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%r14)
addq $0x18, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5462c
movq 0x3385d(%rip), %rbx     # 0x86ff0
leaq 0x1b670(%rip), %rsi     # 0x6ee0a
movl $0x12, %edx
movq %rbx, %rdi
callq 0x9560
leaq 0x1ba14(%rip), %rsi     # 0x6f1c2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9560
movq %rbx, %rdi
movl $0x283, %esi            # imm = 0x283
callq 0x9880
movq %rax, %rbx
leaq 0x19cad(%rip), %rsi     # 0x6d47f
movl $0x3, %edx
movq %rax, %rdi
callq 0x9560
leaq 0x1b830(%rip), %rsi     # 0x6f016
movl $0x1c, %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 %r14
popq %r15
popq %rbp
jmp 0x9330
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::ReadConverseConf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Trainer::ReadConverseConf(const std::string &str) {
  stringstream sin;
  sin.str(str);
  int i = 1;
  for (; i <= TEAMSIZE && sin >> mTm2Opp[i]; mOpp2Tm[mTm2Opp[i]] = i, ++i)
    ;

  if (i == TEAMSIZE + 1) {
    mConverse = true;
    cout << "Conversely train!!" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x9350
leaq -0x198(%rbp), %rdi
movq %r14, %rsi
callq 0x9730
leaq 0x38(%rbx), %r12
movl $0x1, %r15d
xorl %r13d, %r13d
leaq -0x1b0(%rbp), %r14
leaq (%r12,%r13), %rsi
movq %r14, %rdi
callq 0x92e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x538a4
movslq 0x38(%rbx,%r13), %rax
movl %r15d, 0x64(%rbx,%rax,4)
incl %r15d
addq $0x4, %r13
cmpq $0x2c, %r13
jne 0x5386d
movl $0xc, %r15d
cmpl $0xc, %r15d
jne 0x538f4
movb $0x1, 0x33(%rbx)
movq 0x3370b(%rip), %rbx     # 0x86fc0
leaq 0x1b979(%rip), %rsi     # 0x6f235
movl $0x12, %edx
movq %rbx, %rdi
callq 0x9560
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x9480
movsbl %al, %esi
movq 0x336d9(%rip), %rdi     # 0x86fc0
callq 0x9070
movq %rax, %rdi
callq 0x9330
movq 0x3369d(%rip), %rsi     # 0x86f98
leaq -0x1b0(%rbp), %rdi
callq 0x9370
leaq -0x130(%rbp), %rdi
callq 0x91c0
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53929
jmp 0x53929
movq %rax, %rbx
movq 0x33665(%rip), %rsi     # 0x86f98
leaq -0x1b0(%rbp), %rdi
callq 0x9370
leaq -0x130(%rbp), %rdi
callq 0x91c0
movq %rbx, %rdi
callq 0x98b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Trainer.cpp
// Function: Trainer::FindValidPoint(bool)
Vector Trainer::FindValidPoint(bool isLeft) {
  Vector tmp;
  tmp.SetX(isLeft ? ServerParam::instance().PITCH_LENGTH / 2 - 0.1
                  : -ServerParam::instance().PITCH_LENGTH / 2 + 0.1);
  do {
    for (double y = -6.5; y < 6.5; y += 0.1) {
      tmp.SetY(y);
      if (mpAgent->GetWorldState()
              .GetPlayer(mpAgent->Info()
                             .GetPositionInfo()
                             .GetClosePlayerToPoint(tmp)
                             .front())
              .GetPos()
              .Dist(tmp) > 1.0) {
        return tmp;
      }
    }
    tmp.SetX(tmp.X() + 0.5);
  } while (1);
  Assert(0);
  return Vector(0.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
callq 0x4a75c
leaq 0x19c74(%rip), %rax     # 0x6df18
movsd (%rax), %xmm0
mulsd 0x175c8(%rip), %xmm0    # 0x6b878
movsd 0x18318(%rip), %xmm1    # 0x6c5d0
testl %r14d, %r14d
jne 0x542c7
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x542cf
addsd 0x18309(%rip), %xmm0    # 0x6c5d8
leaq -0x44(%rbp), %r12
movl $0xa8, %r13d
movsd %xmm0, -0x40(%rbp)
xorl %r14d, %r14d
movsd 0x1a98f(%rip), %xmm1    # 0x6ec78
movsd %xmm1, -0x68(%rbp)
movsd %xmm1, -0x38(%rbp)
movq 0x18(%rbx), %rax
movq 0x18(%rax), %r15
movq 0x20(%rax), %rdi
callq 0x2adf8
movl $0x0, -0x44(%rbp)
leaq -0x80(%rbp), %rdi
movq %rax, %rsi
leaq -0x40(%rbp), %rdx
movq %r12, %rcx
callq 0x48b8c
movq -0x80(%rbp), %rax
movl (%rax), %eax
leal -0x1(%rax), %ecx
testl %eax, %eax
notl %eax
cmovgl %ecx, %eax
movl $0x10d0, %ecx           # imm = 0x10D0
cmovgq %r13, %rcx
addq %r15, %rcx
cltq
imulq $0x178, %rax, %rax      # imm = 0x178
movsd 0x8(%rax,%rcx), %xmm0
subsd -0x40(%rbp), %xmm0
movsd 0x10(%rax,%rcx), %xmm1
subsd -0x38(%rbp), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd 0x16d23(%rip), %xmm0    # 0x6b090
jb 0x54375
sqrtsd %xmm0, %xmm0
jmp 0x5437a
callq 0x93c0
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x54399
movq -0x70(%rbp), %rsi
subq %rdi, %rsi
movsd %xmm0, -0x60(%rbp)
callq 0x94e0
movsd -0x60(%rbp), %xmm0
ucomisd 0x16cb7(%rip), %xmm0    # 0x6b058
ja 0x543cc
movsd 0x18225(%rip), %xmm0    # 0x6c5d0
movsd -0x68(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd 0x1a8c4(%rip), %xmm0    # 0x6ec80
ucomisd %xmm1, %xmm0
setbe %r14b
ja 0x542e9
jmp 0x543e0
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
testb $0x1, %r14b
je 0x543f8
movsd -0x40(%rbp), %xmm0
addsd 0x17485(%rip), %xmm0    # 0x6b878
jmp 0x542d9
movsd -0x58(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
addq $0x58, %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/UDPSocket.cpp
// Function: UDPSocket::Receive(char*)
int UDPSocket::Receive(char *msg) {
#ifdef WIN32
  int servlen;
#else
  socklen_t servlen;
#endif

  sockaddr_in serv_addr;
  servlen = sizeof(serv_addr);
  int n =
      recvfrom(mSockfd, msg, MAX_MESSAGE, 0, (sockaddr *)&serv_addr, &servlen);
  if (n > 0) {
    msg[n] = '\0'; // rccparser will crash if msg has no end
    mAddress.sin_port = serv_addr.sin_port;
  }

  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x14(%rbp), %r9
movl $0x10, (%r9)
movl 0x14(%rdi), %edi
leaq -0x24(%rbp), %r8
movl $0x2000, %edx           # imm = 0x2000
xorl %ecx, %ecx
callq 0x9390
testl %eax, %eax
jle 0x55b18
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movb $0x0, (%r14,%rcx)
movzwl -0x22(%rbp), %ecx
movw %cx, 0x6(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/UDPSocket.cpp
// Function: UDPSocket::Send(char const*)
int UDPSocket::Send(const char *msg) {
  if (mIsInitialOK == true) {
    int n = std::strlen(msg);
    n = sendto(mSockfd, msg, n + 1, 0, (sockaddr *)&mAddress, sizeof(mAddress));
    return n;
  }

  std::cout << msg << std::endl;
  return std::strlen(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpb $0x1, (%rdi)
jne 0x55b5e
movq %rdi, %r14
movq %rbx, %rdi
callq 0x9200
movl 0x14(%r14), %edi
incl %eax
movslq %eax, %rdx
addq $0x4, %r14
movq %rbx, %rsi
xorl %ecx, %ecx
movq %r14, %r8
movl $0x10, %r9d
callq 0x90a0
jmp 0x55bd3
testq %rbx, %rbx
je 0x55b7f
movq %rbx, %rdi
callq 0x9200
movq 0x3144e(%rip), %rdi     # 0x86fc0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x9560
jmp 0x55b9d
movq 0x3143a(%rip), %rax     # 0x86fc0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x9860
movq 0x3141c(%rip), %r14     # 0x86fc0
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
movq %rbx, %rdi
callq 0x9200
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: GetRealTimeParser()
timeval GetRealTimeParser() {
  if (PlayerParam::instance().DynamicDebugMode() == true) {
    return DynamicDebug::instance().GetTimeParser();
  }

  timeval time_val = GetRealTime();
  DynamicDebug::instance().AddTimeParser(time_val);
  return time_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
callq 0x450ba
cmpb $0x1, 0x5c40(%rax)
jne 0x55c2b
callq 0x23390
movq %rax, %rdi
callq 0x245d8
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
jmp 0x55c53
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x97e0
movups (%rbx), %xmm0
leaq -0x18(%rbp), %rbx
movups %xmm0, (%rbx)
callq 0x23390
movq %rax, %rdi
movq %rbx, %rsi
callq 0x23886
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: GetRealTimeDecision()
timeval GetRealTimeDecision() {
  if (PlayerParam::instance().DynamicDebugMode() == true) {
    return DynamicDebug::instance().GetTimeDecision();
  }

  timeval time_val = GetRealTime();
  DynamicDebug::instance().AddTimeDecision(time_val);
  return time_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
callq 0x450ba
cmpb $0x1, 0x5c40(%rax)
jne 0x55c90
callq 0x23390
movq %rax, %rdi
callq 0x24606
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
jmp 0x55cb8
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x97e0
movups (%rbx), %xmm0
leaq -0x18(%rbp), %rbx
movups %xmm0, (%rbx)
callq 0x23390
movq %rax, %rdi
movq %rbx, %rsi
callq 0x238e0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: GetRealTimeCommandSend()
timeval GetRealTimeCommandSend() {
  if (PlayerParam::instance().DynamicDebugMode() == true) {
    return DynamicDebug::instance().GetTimeCommandSend();
  }

  timeval time_val = GetRealTime();
  DynamicDebug::instance().AddTimeCommandSend(time_val);
  return time_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
callq 0x450ba
cmpb $0x1, 0x5c40(%rax)
jne 0x55cf5
callq 0x23390
movq %rax, %rdi
callq 0x24634
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
jmp 0x55d1d
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x97e0
movups (%rbx), %xmm0
leaq -0x18(%rbp), %rbx
movups %xmm0, (%rbx)
callq 0x23390
movq %rax, %rdi
movq %rbx, %rsi
callq 0x23942
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: RealTime::operator+(int) const
RealTime RealTime::operator+(int msec) const {
  int usec = GetUsec() + msec * 1000;
  if (usec >= ONE_MILLION) {
    return RealTime(GetSec() + usec / ONE_MILLION, usec % ONE_MILLION);
  } else {
    return RealTime(GetSec(), usec);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
imull $0x3e8, %esi, %eax      # imm = 0x3E8
addl 0x8(%rdi), %eax
movslq %eax, %rcx
movq (%rdi), %rsi
cmpl $0xf4240, %ecx          # imm = 0xF4240
jl 0x55d98
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
movq %rcx, %rax
mulq %rdx
shrq $0x12, %rdx
addq %rdx, %rsi
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
subq %rax, %rcx
movq %rsi, %rax
movq %rcx, %rdx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: RealTime::operator-(int) const
RealTime RealTime::operator-(int msec) const {
  int usec = GetUsec() - msec * 1000;
  if (usec < 0) {
    usec = -usec;
    return RealTime(GetSec() - usec / ONE_MILLION - 1,
                    ONE_MILLION - usec % ONE_MILLION);
  } else {
    return RealTime(GetSec(), usec);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
imull $0xfffffc18, %esi, %ecx # imm = 0xFFFFFC18
addl 0x8(%rdi), %ecx
js 0x55db6
movq (%rdi), %rax
movl %ecx, %edx
jmp 0x55de2
negl %ecx
movabsq $0x10c6f7a0b5ee, %rdx   # imm = 0x10C6F7A0B5EE
movq %rcx, %rax
mulq %rdx
movq %rdx, %rax
imulq $0xf4240, %rdx, %rdx    # imm = 0xF4240
notq %rax
addq (%rdi), %rax
subq %rcx, %rdx
addq $0xf4240, %rdx          # imm = 0xF4240
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: RealTime::operator<(RealTime const&) const
bool RealTime::operator<(const RealTime &t) const {
  if (GetSec() < t.GetSec())
    return true;
  if (GetSec() == t.GetSec() && GetUsec() < t.GetUsec())
    return true;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rcx
movb $0x1, %al
cmpq %rcx, (%rdi)
jl 0x55e48
jne 0x55e46
movq 0x8(%rdi), %rcx
cmpq 0x8(%rsi), %rcx
jl 0x55e48
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: Time::operator-(int) const
Time Time::operator-(const int a) const {
  int news = S() - a;
  if (news >= 0) {
    return Time(T(), news);
  }
  return Time(T() + news, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x4(%rdi), %eax
xorl %ecx, %ecx
subl %esi, %eax
movl $0x0, %edx
cmovnsl %eax, %edx
cmovnsl %ecx, %eax
addl (%rdi), %eax
shlq $0x20, %rdx
orq %rdx, %rax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: Time::operator-(Time const&) const
int Time::operator-(const Time &a) const {
  if (mT == a.T()) {
    return mS - a.S();
  } else {
    return mT - a.T() + mS; //实际可能差更多,不准
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
subl (%rsi), %eax
jne 0x55f06
movl 0x4(%rdi), %eax
subl 0x4(%rsi), %eax
jmp 0x55f09
addl 0x4(%rdi), %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: ServerPlayModeMap::Bind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ServerPlayMode)
void ServerPlayModeMap::Bind(const std::string &str, ServerPlayMode spm) {
  Assert(mString2Enum.count(str) == 0);
  Assert(mEnum2String.count(spm) == 0);

  mString2Enum[str] = spm;
  mEnum2String[spm] = str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x24(%rbp), %r12
movl %edx, (%r12)
callq 0x5733a
movl %ebx, (%rax)
addq $0x30, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x573ba
movq %rax, %rdi
movq %r14, %rsi
callq 0x92a0
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/Utilities.cpp
// Function: ServerPlayModeMap::GetServerPlayMode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ServerPlayMode ServerPlayModeMap::GetServerPlayMode(const std::string &str) {
  // special case: server 发过来的是 goal_[lr]_[[:digit:]]
  if (strncmp(str.c_str(), "goal_l", strlen("goal_l")) == 0) {
    return mString2Enum["goal_l"];
  } else if (strncmp(str.c_str(), "goal_r", strlen("goal_r")) == 0) {
    return mString2Enum["goal_r"];
  } else if (mString2Enum.count(str)) {
    return mString2Enum[str];
  } else {
    Assert(!"server playmode error");
    return SPM_Null;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
leaq 0x175e3(%rip), %rsi     # 0x6e798
movl $0x6, %edx
movq %r15, %rdi
callq 0x9230
testl %eax, %eax
je 0x57205
leaq 0x175d8(%rip), %rsi     # 0x6e7a5
movl $0x6, %edx
movq %r15, %rdi
callq 0x9230
testl %eax, %eax
je 0x57232
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57c50
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x57276
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5733a
movl (%rax), %ebx
jmp 0x57278
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x17584(%rip), %rsi     # 0x6e798
leaq 0x17583(%rip), %rdx     # 0x6e79e
leaq -0x38(%rbp), %rdi
callq 0x13766
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x57422
jmp 0x5725d
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x17564(%rip), %rsi     # 0x6e7a5
leaq 0x17563(%rip), %rdx     # 0x6e7ab
leaq -0x38(%rbp), %rdi
callq 0x13766
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x57422
movl (%rax), %ebx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x57278
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x57278
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x57289
jmp 0x572a3
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x572a6
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x94e0
jmp 0x572a6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/Utilities.cpp
// Function: ServerPlayModeMap::GetPlayModeString(ServerPlayMode)
const char *ServerPlayModeMap::GetPlayModeString(ServerPlayMode spm) {
  if (mEnum2String.count(spm)) {
    return mEnum2String[spm].c_str();
  } else {
    return "";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %esi, -0x4(%rbp)
movq 0x40(%rdi), %rdx
leaq 0x38(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x572e4
movq %rax, %rcx
xorl %r8d, %r8d
cmpl %esi, 0x20(%rdx)
setl %r8b
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%r8,8), %rdx
testq %rdx, %rdx
jne 0x572cc
movq %rax, %rdx
cmpq %rax, %rcx
je 0x572f6
cmpl %esi, 0x20(%rcx)
cmovgq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x5730d
addq $0x30, %rdi
leaq -0x4(%rbp), %rsi
callq 0x573ba
movq (%rax), %rax
jmp 0x57314
leaq 0x1548c(%rip), %rax     # 0x6c7a0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::VisualSystem()
VisualSystem::VisualSystem() {
  mCanForceChangeViewWidth = false;
  mIsSearching = false;
  mIsCritical = false;
  mForbidden = false;
  mForceToSeeObject.bzero();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2efc7(%rip), %rax     # 0x86cc8
movq %rax, (%rdi)
movl $0x60, %eax
movabsq $0x412e848000000000, %rcx # imm = 0x412E848000000000
xorps %xmm0, %xmm0
movabsq $0x4059000000000000, %rdx # imm = 0x4059000000000000
movq %rcx, -0x30(%rbx,%rax)
movq %rcx, -0x28(%rbx,%rax)
movl $0x0, -0x1c(%rbx,%rax)
movups %xmm0, -0x10(%rbx,%rax)
movq $0x0, (%rbx,%rax)
movb $0x0, -0x20(%rbx,%rax)
movq %rdx, -0x18(%rbx,%rax)
addq $0x40, %rax
cmpq $0x620, %rax            # imm = 0x620
jne 0x57d20
leaq 0x610(%rbx), %rax
xorl %r14d, %r14d
movl %r14d, 0x610(%rbx)
movq %r14, 0x618(%rbx)
movq %rax, 0x620(%rbx)
movq %rax, 0x628(%rbx)
movq %r14, 0x630(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x650(%rbx)
movups %xmm0, 0x660(%rbx)
movq %r14, 0x670(%rbx)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x678(%rbx)
leaq 0x680(%rbx), %rdi
movl $0xb48, %edx            # imm = 0xB48
xorl %esi, %esi
callq 0x92b0
xorps %xmm0, %xmm0
movups %xmm0, 0x5f0(%rbx)
movq %r14, 0x5ff(%rbx)
movl %r14d, 0x638(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::Initial(Agent*)
void VisualSystem::Initial(Agent *agent) {
  mpAgent = agent;
  mpWorldState = &(agent->World());
  mpInfoState = &(agent->Info());
  mpBallState = &(agent->World().Ball());
  mpSelfState = &(agent->Self());

  mVisualRequest.GetOfBall().mpObject = mpBallState;
  mVisualRequest.GetOfBall().mUnum = 0;

  for (Unum i = 1; i <= TEAMSIZE; ++i) {
    mVisualRequest.GetOfTeammate(i).mpObject = &(mpWorldState->GetTeammate(i));
    mVisualRequest.GetOfOpponent(i).mpObject = &(mpWorldState->GetOpponent(i));
    mVisualRequest.GetOfTeammate(i).mUnum = i;
    mVisualRequest.GetOfOpponent(i).mUnum = -i;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movq 0x18(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x20(%rsi), %rcx
movq %rcx, 0x28(%rdi)
addq $0x30, %rax
movq %rax, 0x18(%rdi)
movq %rsi, %rdi
callq 0x134ce
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
movq %rax, 0x60(%rbx)
movl $0x0, 0x68(%rbx)
movl $0x10d0, %eax           # imm = 0x10D0
addq 0x10(%rbx), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq $-0x2c0, %rdx           # imm = 0xFD40
movl $0x1, %esi
leaq -0x1028(%rax), %rdi
movq %rdi, 0x360(%rbx,%rdx)
movq %rax, 0x620(%rbx,%rdx)
movl %esi, 0x368(%rbx,%rdx)
movl %ecx, 0x628(%rbx,%rdx)
decl %ecx
addq $0x178, %rax            # imm = 0x178
incl %esi
addq $0x40, %rdx
jne 0x57ea2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::ResetVisualRequest()
void VisualSystem::ResetVisualRequest() {
  mCanTurn = false;
  mSenseBallCycle = 0;

  if (mpAgent->IsNewSight()) { //有新视觉才重置，否则维持上周期的结果
    mCanForceChangeViewWidth = false;
    mIsSearching = false;
    mIsCritical = false;
    mForbidden = false;

    for (Unum i = -TEAMSIZE; i <= TEAMSIZE; ++i) {
      mVisualRequest[i].Clear();
    }

    mHighPriorityPlayerSet.clear();
    mForceToSeeObject.bzero();
  }

  if (mpSelfState->GetPosConf() < FLOAT_EPS) {
    mIsCritical = true;
    mCanForceChangeViewWidth = false;
  }
  if (mpBallState->GetPosConf() < FLOAT_EPS) {
    RaiseForgotObject(0);
  }

  ViewModeDecision();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x63c(%rdi)
movl $0x0, 0x11c8(%rdi)
movq 0x8(%rdi), %rax
cmpb $0x1, 0x28(%rax)
jne 0x57f77
movl $0x0, 0x638(%rbx)
leaq -0x290(%rbx), %rax
leaq 0x5b0(%rbx), %rcx
movq $-0xb, %rdx
movabsq $0x4059000000000000, %rsi # imm = 0x4059000000000000
testq %rdx, %rdx
movq %rax, %rdi
cmovsq %rcx, %rdi
movb $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
incq %rdx
addq $0x40, %rax
addq $-0x40, %rcx
cmpq $0xc, %rdx
jne 0x57f2b
leaq 0x608(%rbx), %rdi
callq 0x5b61e
xorps %xmm0, %xmm0
movups %xmm0, 0x5f0(%rbx)
movq $0x0, 0x5ff(%rbx)
movq 0x20(%rbx), %rax
movsd 0x130bd(%rip), %xmm0    # 0x6b040
ucomisd 0x20(%rax), %xmm0
jbe 0x57f93
movw $0x1, 0x638(%rbx)
movq 0x18(%rbx), %rax
ucomisd 0x20(%rax), %xmm0
jbe 0x57fac
movb $0x1, %al
movb %al, 0x63a(%rbx)
movb %al, 0x5f0(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x58010
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::RaiseForgotObject(int)
void VisualSystem::RaiseForgotObject(ObjectIndex unum) {
  mIsSearching = true;

  if (unum == 0) {
    mForceToSeeObject.GetOfBall() = true;
  } else {
    mHighPriorityPlayerSet.insert(GetVisualRequest(unum));
  }
}

// Assembly:
movb $0x1, 0x63a(%rdi)
testl %esi, %esi
je 0x58008
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x608(%rdi), %rax
movslq %esi, %rcx
movl $0xb, %edx
subl %esi, %edx
movslq %edx, %rdx
testl %esi, %esi
cmovnsq %rcx, %rdx
shlq $0x6, %rdx
leaq (%rdi,%rdx), %rcx
addq $0x30, %rcx
leaq -0x8(%rbp), %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
callq 0x5b782
addq $0x10, %rsp
popq %rbp
retq
movb $0x1, 0x5f0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::ViewModeDecision()
void VisualSystem::ViewModeDecision() {
  ChangeViewWidth(mpSelfState->GetViewWidth());

  if (mpAgent->IsNewSight() == false) {
    ChangeViewWidth(mpSelfState->GetViewWidth());
    return;
  }

  if (mpWorldState->GetPlayMode() != PM_Before_Kick_Off) {
    double balldis = mpInfoState->GetPositionInfo().GetBallDistToTeammate(
        mpSelfState->GetUnum());
    if (balldis > 60.0) {
      ChangeViewWidth(VW_Wide);
    } else if (balldis > 40.0) {
      ChangeViewWidth(VW_Normal);
    } else {
      ChangeViewWidth(VW_Narrow);
    }
  } else {
    ChangeViewWidth(VW_Narrow);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %rax
movl 0x118(%rax), %eax
movl %eax, 0x640(%rdi)
cmpb $0x1, 0x28(%rcx)
jne 0x5807f
movq 0x10(%rbx), %rcx
movl $0x1, %eax
cmpl $0x16, 0x1c(%rcx)
je 0x5807f
movq 0x28(%rbx), %rdi
callq 0x2adf8
movq 0x20(%rbx), %rcx
movl 0x11c(%rcx), %esi
movq %rax, %rdi
callq 0x4846e
movsd (%rax), %xmm0
movl $0x3, %eax
ucomisd 0x15df2(%rip), %xmm0    # 0x6de60
ja 0x5807f
xorl %eax, %eax
ucomisd 0x14f1e(%rip), %xmm0    # 0x6cf98
seta %al
incl %eax
movl %eax, 0x640(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wrighteagle2d[P]wrighteaglebase/Debug/../src/VisualSystem.cpp
// Function: VisualSystem::Decision()
void VisualSystem::Decision() {
  if (mpAgent->GetActionEffector().IsTurnNeck())
    return; //其他地方已经产生了转脖子动作
  if (mForbidden)
    return;

  if (!DealWithSetPlayMode()) {
    DoDecision();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xef28
cmpb $0x0, 0xe93(%rax)
jne 0x580bc
cmpb $0x0, 0x63b(%rbx)
jne 0x580bc
movq %rbx, %rdi
callq 0x580d2
testb %al, %al
je 0x580c3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5830a
nop