KeSetActualBasePriorityThread

__int64 __fastcall KeSetActualBasePriorityThread(__int64 a1, int a2){
  unsigned __int8 CurrentIrql; 
  struct _KPRCB *CurrentPrcb; 
  __int64 v5; 
  unsigned int v6; 
  unsigned int v7; 
  _KPRCB *v8; 
  char v9; 
  UINT64 updated; 
  UINT64 v11; 
  unsigned int v12; 
  char v13; 
  int v14; 
  int v15; 
  _KPRCB *v16; 
  __int64 v17; 
  bool v18; 
  _KTHREAD *v19; 
  _ETHREAD *v20; 
  char v21; 
  __int64 v22; 
  volatile INT32 *v23; 
  struct _KPRCB *v25; 
  int *v26; 
  _QWORD *v27; 
  _QWORD *v28; 
  UINT64 v29; 
  char v30; 
  char v31; 
  __int64 v32; 
  INT64 v33; 
  bool v34; 
  _KTHREAD *v35; 
  _ETHREAD *v36; 
  char v37; 
  char v38; 
  __int64 v39; 
  __int64 v40; 
  INT64 v41; 
  bool v42; 
  int v43; 
  int v44; 
  __int64 v45; 
  _KPRCB *v46; 
  __int64 v47; 
  unsigned __int8 v48; 
  _KSHARED_READY_QUEUE *ControlReadyQueue; 
  _SINGLE_LIST_ENTRY ReadyList; 
  _QWORD *v51; 
  unsigned int v52; 
  UINT64 SpinCount; 
  _KPRCB *ControlPrcb; 
  if( *(__int64 **)(a1 + 544) == KiInitialProcess )
    return 1i64;
  ReadyList.Next = 0i64;
  CurrentIrql = KeGetCurrentIrql();
  v48 = CurrentIrql;
  __writecr8(2ui64);
  CurrentPrcb = KeGetCurrentPrcb();
  LODWORD(SpinCount) = 0;
  v5 = *((_QWORD *)CurrentPrcb + 1);
  while( _interlockedbittestandset64((volatile signed __int32 *)(a1 + 64), 0i64) )
  {
    do
      KeYieldProcessorEx(&SpinCount);
    while( *(_QWORD *)(a1 + 64) );
    v39 = *((_QWORD *)CurrentPrcb + 4247);
    if( v39 && *((_BYTE *)CurrentPrcb + 32) <= 1u )
      ++*(_DWORD *)(v39 + 24);
  }
  v6 = *(char *)(a1 + 563);
  *(_BYTE *)(a1 + 645) = 0;
  v7 = v6;
  v8 = KeGetCurrentPrcb();
  v52 = v6;
  if( (char)a2 < (char)v6 )
  {
    if( *(_BYTE *)(a1 + 871) )
    {
      v27 = (_QWORD *)(a1 + 816);
      if( *(_QWORD *)(a1 + 816) == 1i64 )
      {
        v28 = (_QWORD *)((char *)v8 + 34672);
        if( v8 != (_KPRCB *)-34672i64 )
        {
          *v27 = *v28;
          *v28 = v27;
          _InterlockedIncrement16((volatile signed __int16 *)(a1 + 868));
          KiAbQueueAutoBoostDpc(v8);
        }
      }
    }
  }
  *(_BYTE *)(a1 + 563) = a2;
  v9 = *(_BYTE *)(a1 + 564);
  if( v9 )
  {
    if( (v9 & 0xF) != 0 )
      *(_DWORD *)(a1 + 872) = KUSER_SHARED_DATA.TickCount.LowPart;
    *(_BYTE *)(a1 + 564) = 0;
  }
  if( a2 != *(char *)(a1 + 195) )
  {
    if( a1 != v5 || *((_BYTE *)CurrentPrcb + 32) )
    {
      updated = *(_QWORD *)(a1 + 72);
    }
    else
    {
      _disable();
      updated = KiUpdateTotalCyclesCurrentThread((__int64)CurrentPrcb, a1, 0i64);
      _enable();
    }
    v11 = updated + KiCyclesPerClockQuantum * (unsigned int)*(unsigned __int8 *)(a1 + 651);
    if( (*(_DWORD *)(a1 + 120) & 0x20) != 0 )
      _interlockedbittestandreset((volatile signed __int32 *)(a1 + 120), 5u);
    *(_QWORD *)(a1 + 32) = v11;
    ControlPrcb = 0i64;
    ControlReadyQueue = 0i64;
    v12 = (char)KiComputePriorityFloor(a1, a2);
    if( *(char *)(a1 + 195) != v12 )
    {
      KiAcquireThreadStateLock((_ETHREAD *)a1, &ControlPrcb, &ControlReadyQueue);
      v14 = 0;
      v15 = *(char *)(a1 + 195);
      switch( v13 )
      {
        case 2:
          v16 = ControlPrcb;
          v17 = *((_QWORD *)ControlPrcb + 2);
          v51 = (_QWORD *)((char *)ControlPrcb + 16);
          KiUpdateThreadPriority(ControlPrcb, (_KTHREAD *)a1, v12, v17 == 0);
          v18 = (int)v12 <= v15;
          if( (int)v12 < v15 )
          {
            if( !v17 )
            {
              v16 = ControlPrcb;
              if( *(_BYTE *)(a1 + 388) != 2 )
              {
                v7 = v52;
                if( *((_DWORD *)ControlPrcb + 7942) >> (v12 + 1) )
                  *(_BYTE *)(a1 + 112) |= 0x10u;
                goto LABEL_19;
              }
              v19 = (_ETHREAD *)KiSelectReadyThreadEx(ControlPrcb, (_KTHREAD *)a1, 0);
              v20 = v19;
              if( v19 )
              {
                if( (*((_BYTE *)v19 + 2) & 4) != 0 )
                {
                  KiIsThreadRankNonZero(v19, v16);
                  v30 = 1;
                  if( !v31 )
                    v30 = *((_BYTE *)v20 + 195);
                }
                else
                {
                  v30 = *((_BYTE *)v19 + 195);
                }
                **((_BYTE **)v16 + 7) = v30;
                v32 = *((_QWORD *)v16 + 4247);
                if( v32 )
                {
                  if( v20 == *((_ETHREAD **)v16 + 3) )
                    v33 = (unsigned int)KiVpThreadSystemWorkPriority;
                  else
                    v33 = (unsigned int)v30;
                  KiSetSchedulerAssistPriority((volatile INT32 *)v32, v33, 0);
                  v32 = *((_QWORD *)v16 + 4247);
                }
                v34 = v20 == *((_ETHREAD **)v16 + 3);
                *v51 = v20;
                if( v32 )
                  *(_BYTE *)(v32 + 16) = v34;
                if( *((_BYTE *)v20 + 388) == 1 )
                  *((_DWORD *)v20 + 33) = *((_DWORD *)v20 + 33)
                                        - *((_DWORD *)v20 + 109)
                                        + KUSER_SHARED_DATA.TickCount.LowPart;
                v16 = ControlPrcb;
                v7 = v52;
                *((_BYTE *)v20 + 388) = 3;
                v21 = 1;
                goto LABEL_20;
              }
              goto LABEL_18;
            }
            v18 = (int)v12 <= v15;
          }
          if( v18 || v17 )
          {
LABEL_18:
            v7 = v52;
LABEL_19:
            v21 = 0;
LABEL_20:
            KiUpdateSharedReadyQueueAffinityThread(0i64, (_KTHREAD *)a1);
            KiReleaseThreadStateLock(v22, (__int64)v16, (volatile signed __int64 *)ControlReadyQueue);
            if( v21 )
            {
              v29 = *((unsigned int *)ControlPrcb + 9);
              if( *((_DWORD *)KeGetPcr() + 105) != (_DWORD)v29 )
                KiSendSoftwareInterrupt(v29, 2u);
            }
            if( v14 > 0 )
            {
              v25 = KeGetCurrentPrcb();
              if( (KiVelocityFlags & 2) != 0 )
              {
                v26 = (int *)*((_QWORD *)ControlPrcb + 4247);
                if( v26 )
                {
                  if( *((_QWORD *)v25 + 4247) )
                  {
                    if( v25 != ControlPrcb && v14 >= 8 )
                    {
                      v43 = *v26;
                      v44 = *v26 & 0x40000;
                      if( (v43 & 0x100000) != 0 || v44 && (unsigned __int8)v43 < v14 )
                      {
                        v34 = HvlpVirtualProcessorsIdentityMapped == 0;
                        v45 = *((_QWORD *)v25 + 4247);
                        v46 = ControlPrcb;
                        *(_DWORD *)(v45 + 12) = 2;
                        v47 = *((unsigned int *)v46 + 9);
                        if( v34 )
                          LODWORD(v47) = (unsigned __int8)HvlpVirtualProcessorMapping[2 * (unsigned int)v47 + 1] | ((unsigned __int8)HvlpVirtualProcessorMapping[2 * v47] << 6);
                        *(_DWORD *)(v45 + 8) = v47;
                        __writemsr(0x400000C2u, (unsigned int)v47);
                      }
                    }
                  }
                }
              }
            }
            CurrentIrql = v48;
            goto LABEL_23;
          }
          v16 = ControlPrcb;
          v7 = v52;
          if( *(_BYTE *)(a1 + 388) != 2 )
            goto LABEL_19;
          break;
        case 1:
          v16 = ControlPrcb;
          KiRemoveThreadFromAnyReadyQueue(ControlPrcb, ControlReadyQueue, (_KTHREAD *)a1, (unsigned int)v15);
          KiUpdateThreadPriority(0i64, (_KTHREAD *)a1, v12, 0);
          KiPrepareReadyThreadForRescheduling((_KTHREAD *)a1, v12, &ReadyList);
          goto LABEL_19;
        case 3:
          v16 = ControlPrcb;
          KiUpdateThreadPriority(ControlPrcb, (_KTHREAD *)a1, v12, 1u);
          if( (int)v12 < v15 )
          {
            v35 = (_ETHREAD *)KiSelectReadyThreadEx(v16, (_KTHREAD *)a1, 0);
            v36 = v35;
            if( v35 )
            {
              if( (*((_BYTE *)v35 + 2) & 4) != 0 )
              {
                KiIsThreadRankNonZero(v35, v16);
                v37 = 1;
                if( !v38 )
                  v37 = *((_BYTE *)v36 + 195);
              }
              else
              {
                v37 = *((_BYTE *)v35 + 195);
              }
              **((_BYTE **)v16 + 7) = v37;
              v40 = *((_QWORD *)v16 + 4247);
              if( v40 )
              {
                v41 = (unsigned int)KiVpThreadSystemWorkPriority;
                if( v36 != *((_ETHREAD **)v16 + 3) )
                  v41 = (unsigned int)v37;
                KiSetSchedulerAssistPriority(*((volatile INT32 **)v16 + 4247), v41, 0);
                v40 = *((_QWORD *)v16 + 4247);
              }
              v42 = v36 == *((_ETHREAD **)v16 + 3);
              *((_QWORD *)v16 + 2) = v36;
              if( v40 )
                *(_BYTE *)(v40 + 16) = v42;
              if( *((_BYTE *)v36 + 388) == 1 )
                *((_DWORD *)v36 + 33) = *((_DWORD *)v36 + 33)
                                      - *((_DWORD *)v36 + 109)
                                      + KUSER_SHARED_DATA.TickCount.LowPart;
              *((_BYTE *)v36 + 388) = 3;
              KiInsertDeferredReadyList((INT64)&ReadyList, a1);
              v16 = ControlPrcb;
            }
            goto LABEL_19;
          }
          break;
        default:
          KiUpdateThreadPriority(0i64, (_KTHREAD *)a1, v12, 0);
          v16 = ControlPrcb;
          goto LABEL_19;
      }
      v14 = v12;
      goto LABEL_19;
    }
  }
LABEL_23:
  v23 = *(volatile INT32 **)(a1 + 232);
  if( v23 && (*(_BYTE *)v23 & 0x7F) == 21 )
    KiPriQueueThreadPriorityChanged(v23, a1);
  else
    *(_QWORD *)(a1 + 64) = 0i64;
  KiProcessDeferredReadyList((__int64)CurrentPrcb, &ReadyList, CurrentIrql);
  return v7;
}

Referenced by: