Kernel11 kernel decompilation, complete with labels and comments

k11_latest_n3ds.cpp

/* This file was generated by the Hex-Rays decompiler.
   Copyright (c) 2007-2020 Hex-Rays <info@hex-rays.com>

   Detected compiler: GNU C++
*/

#include <defs.h>


//-------------------------------------------------------------------------
// Function declarations

void crt0::Cpu0GetInitSpValues();
void crt0::Cpu1GetInitSpValues();
void crt0::Cpu2GetInitSpValues();
void crt0::Cpu3GetInitSpValues();
void __noreturn _start(void);
void __fastcall crt0::CoreSync(s32 coreId);
void crt0::SetVfpAccessibleToUser(void);
void __fastcall crt0::WaitCycles(u32 numCycles);
void crt0::SetArm11ControlRegs(void);
void __noreturn crt0::Core23Ep(void);
void __fastcall crt0::PrepareTranslationTables(s32 coreId);
u8 *crt0::FetchArm9Info(void);
void __fastcall crt0::memmove(void *dst, const void *src, u32 size);
void _libc_init_array(void);
void _sti___27_KCacheMaintenanceHelper_cpp(void);
void _sti___15_KDmaChannel_cpp(void);
void _sti___10_KDebug_cpp(void);
void _sti___10_KEvent_cpp(void);
void _sti___11_KTimer_cpp(void);
void _sti___10_Kernel_cpp(void);
void _sti___11_KThread_cpp(void);
void _sti___26_KVfpRegisterDumpHelper_cpp(void);
void _sti___12_KProcess_cpp(void);
void _sti___15_KLinkedList_cpp(void);
void _sti___31_KPerformanceCounterManager_cpp(void);
void _sti___9_Sleep_cpp(void);
void _sti___15_KDmaManager_cpp(void);
void _sti___27_KObjectAllocatorAdapter_cpp(void);
int __fastcall _aeabi_atexit_veneer(void *object, void (__fastcall *destroyer)(void *), void *dso_handle);
int __fastcall _cxa_guard_release_veneer(int *guard);
void *__fastcall _aeabi_vec_ctor_nocookie_nodtor_from_arm(void *user_array, void *(__fastcall *constructor)(void *), u32 element_size, u32 element_count);
KObjectContainer *__fastcall KObjectContainer::KObjectContainer(KObjectContainer *this);
void _sti___21_KPxiBufferManager_cpp(void);
void _sti___14_KFiqHelper_cpp(void);
void _sti___20_KSlabHeapAdapter_cpp(void);
void _sti___29_KPerformanceControlHelper_cpp(void);
void crt0::CopyAndJumpToCore0Stub(void);
// void __usercall __noreturn crt0::Core0StubData();
void __noreturn crt0::CopyAndJumpToCore1Stub(void);
// void __usercall __noreturn crt0::Core1StubData(s32 coreId@<R2>);
void __fastcall crt0::CopyFinalStub(const void *start, const void *end, void *dst);
void __fastcall crt0::StopExtraCoresAndJump(s32 coreId);
// void __usercall __noreturn crt0::Core0Stub();
// void __usercall __noreturn crt0::Core1FinalStub(s32 coreId@<R2>);
int __fastcall _aeabi_vec_dtor(int, void (__fastcall *)(int), int, int);
void __noreturn HandleFiqException();
Result __fastcall KScheduler::Intialize(KScheduler *this, s32 coreId, KThread *idleThread);
void __fastcall KScheduler::Enable(KScheduler *this);
void CreateKernelDiagnosticTable(void);
void InitSharedKernelConfigPage(void);
void __fastcall KCoreLocalContext::InitializeCurrent(s32 coreId);
void AllocateSharedConfigPages(void);
void __fastcall KLevel2TranslationTableAllocator::Initialize(u32 cpuId);
void __fastcall KHardwareTimer::Initialize(KHardwareTimer *this, s32 coreId);
Result KDebug::InitializeScheduledInOutState(void);
void __fastcall KThread::SetIdlePriority(KThread *this);
void __fastcall __noreturn HandlePrefetchAbortException(int a1, int a2, int a3, int a4, int a5);
void __fastcall HandleDataAbortException(int, int, int, int, int);
char *__fastcall HandleIrqException(int a1, int a2, int *a3, int a4, int a5);
void __fastcall __noreturn HandleSvcException(int, int, int, int, int, int, __int16);
int __fastcall HandleUndefinedInstructionException(int result, int, int, int, _DWORD *);
KScheduler *__fastcall KScheduler::KScheduler(KScheduler *this);
void __fastcall __noreturn KWorkerTaskManager::ThreadFunction(KWorkerTaskManager *this);
void __fastcall __noreturn KInterruptTaskManager::ThreadFunction(KInterruptTaskManager *this);
Result __fastcall KThread::InitializeCriticalKernelThread(KThread *this, void *ep, void *arg);
void KDmaController::Initialize(void);
void __fastcall KDmaController::EnableInterrupt(s8 channelId);
Result __fastcall KVfpRegisterDumpHelper::BindInterrupt(s32 coreId);
Result __fastcall KTlbMaintenanceHelper::BindInterrupt(s32 coreId);
Result __fastcall KPerformanceCounterControlHelper::BindInterrupt(s32 coreId);
void __fastcall KPageTable::InvalidateEntireInstructionCacheLocal();
u32 __fastcall InitialProcess::GetCxiSize(InitialProcess *this);
void __fastcall AtomicBoolStore(AtomicBool *this, bool value);
void __fastcall __noreturn DispatchKernelExceptionWithRegdump(int, int, int, int, int);
void __fastcall LzssDecompress(u8 *fileEnd);
Result __fastcall SvcAcceptSession(int, Handle);
Result __fastcall SvcConnectToPort(int a1, const char *a2);
Result __fastcall SvcControlMemory(u8 op, u32, u32, u32);
Result __fastcall SvcControlProcessMemory(Handle a1, u32 a2, u32 a3, u32 a4);
Result SvcCreateAddressArbiter();
Result __fastcall SvcCreateCodeSet(u32 dataPtr, CodeSetInfo *, u32, u32);
Result __fastcall SvcCreateEvent(int a1, ResetType a2);
Result __fastcall SvcCreateMemoryBlock(u32 othersPerms, u32, u32, u32);
Result __fastcall SvcCreateMutex(int a1, BOOL a2);
Result __fastcall SvcCreatePort(int, int, const char *, s32);
Result __fastcall SvcCreateProcess(int, Handle, u32 *, s32);
Result SvcCreateResourceLimit();
Result SvcCreateSession();
Result __fastcall SvcCreateSessionToPort(int, Handle);
Result __fastcall SvcDebugActiveProcess(int a1, u32 a2);
Result __fastcall SvcDuplicateHandle(int a1, Handle a2);
Result __fastcall SvcGetDebugThreadParam(DebugThreadParameter param, int a2, Handle a3, u32 a4);
Result __fastcall SvcGetHandleInfo(int, Handle, s32);
Result __fastcall SvcGetProcessId(int a1, Handle a2);
Result __fastcall SvcGetProcessIdOfThread(int a1, Handle a2);
Result __fastcall SvcGetProcessIdealProcessor(int a1, Handle a2);
Result __fastcall SvcGetProcessInfo(int, Handle, s32);
Result __fastcall SvcGetProcessList(int a1, u32 *a2, s32 a3);
Result __fastcall SvcGetResourceLimit(int a1, Handle a2);
Result __fastcall SvcGetSystemInfo(int a1, s32 a2, s32 a3);
Result __fastcall SvcGetThreadIdealProcessor(int a1, Handle a2);
Result __fastcall SvcGetThreadInfo(int a1, Handle a2, s32 a3);
Result __fastcall SvcGetThreadList(int a1, u32 *a2, s32 a3, Handle a4);
Result __fastcall SvcGetThreadPriority(int a1, Handle a2);
Result Svc0x74_CodeSetRelated_stubbed();
Result __fastcall SvcOpenProcess(int, u32);
Result __fastcall SvcOpenThread(int a1, Handle a2, u32 a3);
Result __fastcall SvcQueryDebugProcessMemory(int a1, int a2, Handle a3, u32 a4);
Result __fastcall SvcQueryMemory(int a1, int a2, u32 a3);
Result __fastcall SvcQueryProcessMemory(int a1, int a2, Handle a3, u32 a4);
Result __fastcall SvcReplyAndReceive(int a1, Handle *a2, s32 a3, Handle a4);
Result __fastcall SvcReplyAndReceive1(int a1, Handle *a2, s32 a3, Handle a4);
Result __fastcall SvcReplyAndReceive2(int a1, Handle *a2, s32 a3, Handle a4);
Result __fastcall SvcReplyAndReceive3(int a1, Handle *a2, s32 a3, Handle a4);
Result __fastcall SvcReplyAndReceive4(int a1, Handle *a2, s32 a3, Handle a4);
Result __fastcall SvcSignalAndWait(bool waitAll, Handle a2, Handle *a3, s32 a4);
KThreadIntrusiveList *__fastcall KThreadIntrusiveList::KThreadIntrusiveList(KThreadIntrusiveList *this);
void __fastcall KAffinityMask::Normalize(KAffinityMask *dstAffMask, KAffinityMask *this, u8 numCores);
void PostSvcDpcHandler(void);
Result __fastcall SvcClearEvent(Handle eventHandle);
void __noreturn SvcExitThread(void);
Result __fastcall SvcCloseHandle(Handle handle);
s64 SvcGetSystemTick(void);
int __fastcall SvcSetWifiEnabled(bool a1);
Result __fastcall SvcMapMemoryBlock(Handle sharedMemHandle, u32 addr, u32 myPerms, u32 othersPerms);
Result __fastcall SvcSendSyncRequest(Handle clientSessionHandle);
void __fastcall SvcStopPointOrInvalidId(u32 svcId);
Result __fastcall SvcGetThreadContext(ThreadContext *ctx, Handle threadHandle);
Result __fastcall SvcFlushCodeSegment(u32 addr, u32 size);
Result __fastcall SvcSendSyncRequest1(Handle clientSessionHandle);
Result __fastcall SvcSendSyncRequest2(Handle clientSessionHandle);
Result __fastcall SvcSendSyncRequest3(Handle clientSessionHandle);
Result __fastcall SvcSendSyncRequest4(Handle clientSessionHandle);
Result __fastcall SvcTerminateProcess(Handle processHandle);
Result __fastcall SvcUnmapMemoryBlock(Handle handle, u32 addr);
Result __fastcall SvcUnmapProcessMemory(Handle processHandle, u32 addr, u32 size);
Result __fastcall SvcBreakDebugProcess(Handle debugHandle);
Result __fastcall SvcOutputDebugString(u32 addr, u32 size);
Result __fastcall SvcReadDebugProcessMemory(u32 dstAddr, Handle debugHandle, u32 addr, u32 size);
Result __fastcall SvcContinueDebugEvent(Handle debugHandle, DebugFlags debugFlags);
Result __fastcall SvcWriteDebugProcessMemory(Handle debugHandle, u32 addr, u32 dstAddr, u32 size);
Result __fastcall SvcSetProcessResourceLimits(Handle processHandle, Handle resLimitHandle);
Result __fastcall SvcGetProcessDebugEvent(DebugEventInfo *outDebugEventInfo, Handle debugHandle);
Result __fastcall SvcWaitSynchronization1(Handle handle, s64 timeout);
Result __fastcall SvcSetGpuProt(bool allowSystem);
Result __fastcall SvcGetDebugThreadContext(ThreadContext *outThreadContext, Handle debugHandle, u32 tid, ThreadContextControlFlags flags);
Result __fastcall SvcGetThreadAffinityMask(u8 *outAffinityMask, Handle threadHandle, s32 processorCount);
Result __fastcall SvcSetDebugThreadContext(Handle debugHandle, u32 tid, const ThreadContext *threadContext, ThreadContextControlFlags flags);
Result __fastcall SvcSetHardwareBreakPoint(s32 regId, u32 cr, u32 vr);
Result __fastcall SvcSetThreadAffinityMask(Handle threadHandle, u8 *affinityMask, s32 processorCount);
Result __fastcall SvcStoreProcessDataCache(Handle a1, u32 a2, u32 a3);
Result __fastcall SvcTerminateDebugProcess(Handle debugHandle);
Result __fastcall SvcGetProcessAffinityMask(u8 *outAffMask, Handle processHandle, s32 coreCount);
Result __fastcall SvcSetProcessAffinityMask(Handle processHandle, const u8 *affinityMask, s32 numCores);
Result __fastcall SvcSetThreadIdealProcessor(Handle threadHandle, s32 idealProcessor);
Result __fastcall SvcSetProcessIdealProcessor(Handle processHandle, s32 idealProcessor);
s32 SvcGetCurrentProcessorNumber(void);
Result __fastcall SvcInvalidateProcessDataCache(Handle, u32, u32);
Result __fastcall SvcGetResourceLimitLimitValues(s64 *outLimitValues, Handle reslimitHandle, const ResourceLimitType *names, s32 nameCount);
Result __fastcall SvcSetResourceLimitLimitValues(Handle reslimitHandle, const ResourceLimitType *names, const s64 *values, s32 count);
Result __fastcall SvcGetResourceLimitCurrentValues(s64 *outCurrentValues, Handle reslimitHandle, const ResourceLimitType *names, s32 nameCount);
Result __fastcall SvcBreak(UserBreakType breakReason, u32 croInfoAddr, u32 croInfoSize);
void __fastcall IrqHandlerImpl(BOOL user);
void __fastcall DumpVfpSprsForUserDispatch(ERRF_ExceptionInfo *info);
void __fastcall KScheduler::TrySwitchingToInterruptTaskMgrThread(KScheduler *this);
KHandleTable *__fastcall KHandleTable::KHandleTable(KHandleTable *this);
Result __fastcall KSharedMemory::Map(KSharedMemory *this, KProcessPageTable *dstPgTable, u32 dstAddr, KProcess *dstProcess, KMemoryPermission myPerms, KMemoryPermission othersPerms);
Result __fastcall KSharedMemory::Unmap(KSharedMemory *this, KProcessPageTable *dstPgTable, u32 addr, KProcess *dstProcess);
Result __fastcall KClientSession::SendSyncRequest(KClientSession *this, KThread *thread);
Result __fastcall KSynchronization::WaitSynchronization1(KSynchronization *this, KThread *thread, KSynchronizationObject *obj, s64 timeout);
void __fastcall KThread::EnableExclusiveVfp(KThread *this);
void __fastcall KVfpRegisterDumpHelper::DumpAndDisableVfpRegsForThread(KThread *thread, s32 coreId);
void __fastcall SetWifiEnabled(bool enable);
void __fastcall SetGpuProt(BOOL allowSystem);
Result __fastcall CreatePort(Handle *outSessionPortHandle, Handle *outClientPortHandle, const char *name, s32 maxSessionCount);
Result __fastcall OpenThread(Handle *outThreadHandle, Handle processHandle, u32 threadId);
Result __fastcall CreateEvent(Handle *outEventHandle, ResetType resetType);
Result __fastcall CreateMutex(Handle *outMutexHandle, BOOL initiallyLocked);
Result Svc0x74Impl_CodeSetRelated_Stubbed(Handle *codesetHandleMaybe, ...);
Result __fastcall OpenProcess(Handle *outProcessHandle, u32 pid);
Result __fastcall QueryMemory(MemoryInfo *outMemInfo, u32 *outPgInfo, u32 addr);
Result __fastcall CreateThread(Handle *outThreadHandle, u32 ep, u32 arg, u32 stackTop, s32 priority, s32 processorId);
Result __fastcall GetProcessId(u32 *outPid, Handle processHandle);
Result __fastcall AcceptSession(Handle *outServerSessionHandle, Handle serverPortHandle);
Result __fastcall ConnectToPort(Handle *outClientSessionHandle, const char *name);
Result __fastcall ControlMemory(u32 *outAddr, u32 addr0, u32 addr1, u32 size, u8 op, u32 perms);
Result __fastcall CreateCodeSet(Handle *outHandle, CodeSetInfo *codeSetInfo, u32 textPtr, u32 rodataPtr, u32 dataPtr);
Result __fastcall CreateProcess(Handle *outProcessHandle, Handle codeSetHandle, u32 *kernelCaps, s32 numKernelCaps);
Result __fastcall CreateSession(Handle *outServerSessionHandle, Handle *outClientSessionHandle);
Result __fastcall GetHandleInfo(s64 *out, Handle handle, s32 type);
Result __fastcall GetSystemInfo(s64 *out, s32 type, s32 subType);
Result __fastcall GetThreadInfo(s64 *outValue, Handle threadHandle, s32 type);
Result __fastcall GetThreadList(s32 *outNumThreads, u32 *outTids, s32 maxNumThreads, Handle processHandle);
Result __fastcall SignalAndWait(s32 *idx, Handle signal, Handle *handles, s32 numHandles, bool waitAll, s64 timeout);
Result __fastcall GetProcessInfo(s64 *outValue, Handle processHandle, s32 type);
Result __fastcall GetProcessList(s32 *outNumProcesses, u32 *outPids, s32 maxNumProcesses);
Result __fastcall DuplicateHandle(Handle *outHandle, Handle handle);
Result __fastcall ReplyAndReceive(s32 *outIdx, Handle *handles, s32 numHandles, Handle replyTargetHandle);
Result __fastcall GetResourceLimit(Handle *outReslimit, Handle processHandle);
Result __fastcall ReplyAndReceive1(s32 *outIdx, Handle *handles, s32 numHandles, Handle replyTargetHandle);
Result __fastcall ReplyAndReceive2(s32 *outIdx, Handle *handles, s32 numHandles, Handle replyTargetHandle);
Result __fastcall ReplyAndReceive3(s32 *outIdx, Handle *handles, s32 numHandles, Handle replyTargetHandle);
Result __fastcall ReplyAndReceive4(s32 *outIdx, Handle *handles, s32 numHandles, Handle replyTargetHandle);
Result __fastcall CreateMemoryBlock(Handle *outSharedMemHandle, u32 addr, u32 size, u32 ownerPerms, u32 othersPerms);
Result __fastcall GetThreadPriority(s32 *outPriority, Handle threadHandle);
Result __fastcall DebugActiveProcess(Handle *outHandle, u32 pid);
Result __fastcall QueryProcessMemory(MemoryInfo *outMemInfo, u32 *outPgInfo, Handle processHandle, u32 addr);
Result __fastcall CreateResourceLimit(Handle *outReslimitHandle);
Result __fastcall CreateSessionToPort(Handle *outClientSessionHandle, Handle clientPortHandle);
Result __fastcall GetDebugThreadParam(s64 *out1, s32 *out2, Handle debugHandle, u32 tid, DebugThreadParameter param);
Result __fastcall CreateAddressArbiter(Handle *outArbiterHandle);
Result __fastcall GetProcessIdOfThread(u32 *outPid, Handle threadHandle);
Result __fastcall GetThreadIdealProcessor(s32 *outIdealProcessor, Handle threadHandle);
Result __fastcall QueryDebugProcessMemory(MemoryInfo *outMemInfo, u32 *outPgInfo, Handle debugHandle, u32 addr);
Result __fastcall ControlProcessMemory(Handle processHandle, u32 addr0, u32 addr1, u32 size, u32 op, u32 perms);
Result __fastcall GetProcessIdealProcessor(s32 *outIdealProcessor, Handle processHandle);
Result __fastcall KCacheOperator::OperateOnProcessCache(KCacheOperator *this, Handle processHandle, u32 addr, u32 size);
Result __fastcall KProcessPageTable::UnmapProcessMemory(KProcessPageTable *this, u32 addr, u32 numPages);
void __fastcall SetResourceLimitLimitValues(SetResourceLimitLimitValuesArgs *args, ResourceLimitKvPair *pairs);
Result __fastcall Run(Handle processHandle, const StartupInfo *info);
Result __fastcall KEvent::Clear(KEvent *this);
Result __fastcall KMutex::Unlock(KMutex *this, KThread *thread);
bool __fastcall KInterruptManager::HandleIncomingInterrupt(KInterruptManager *this);
Result __fastcall SetHardwareBreakpoint(s32 regId, u32 cr, u32 vr);
Result __fastcall KDebug::ReadProcessMemory(KDebug *this, u32 dstAddr, u32 addr, u32 size);
Result __fastcall KDebug::WriteProcessMemory(KDebug *this, u32 addr, u32 dstAddr, u32 size);
Result __fastcall KDebug::BreakProcess(KDebug *this);
Result __fastcall KDebug::Continue(KDebug *this, DebugFlags debugFlags);
Result __fastcall KDebug::EraseFirstEventInfoToFetchNode(KDebug *this);
Result __fastcall KDebug::GetPausedThreadContextById(KDebug *this, ThreadContext *outThreadContext, u32 tid, ThreadContextControlFlags flags);
BOOL __fastcall KDebug::NeedsContinue(KDebug *this);
Result __fastcall KDebug::SetPausedThreadContextById(KDebug *this, ThreadContext *threadContext, u32 tid, ThreadContextControlFlags flags);
Result __fastcall KDebug::TerminateProcess(KDebug *this);
Result __fastcall BreakImpl(UserBreakType breakReason, u32 croInfoAddr, u32 croInfoSize);
void __fastcall KDebug::ProcessEventInfo(KDebug *this, DebugEventType type, KEventInfo *info);
KEventInfo *__fastcall KDebug::GetFirstEventInfoToFetch(KDebug *this);
KCodeSet *__fastcall KCodeSet::KCodeSet(KCodeSet *this);
Result __fastcall KProcess::UnbindUserInterruptEventChecked(KProcess *this, KInterruptEvent *interruptEvent, u32 interruptId);
BOOL __fastcall KProcess::IsDebugged(KProcess *this);
Result __fastcall KProcess::SetResourceLimits(KProcess *this, KResourceLimit *reslimit);
Result __fastcall KProcess::Run(KProcess *this, u32 mainThreadPrio, u32 mainThreadStackSize);
void __fastcall KDebug::DoWorkerTask(KWorkerTask *__shifted(KDebug,0x14) this);
Result __fastcall KProcess::TerminateOtherProcess(KProcess *this);
void __fastcall SetEightBytesTo1(bool *statusArray, bool isFree);
KFiqState __fastcall KFiqState::CompareExchangeStrong(KFiqState *this, KFiqState oldVal, KFiqState newVal);
void __fastcall KFiqState::Set(KFiqState *this, KFiqState newState);
KInterruptEvent *__fastcall KHandleTable::ConvertToInterruptEvent(KHandleTable *this, Handle handle);
void __fastcall KThreadContext::LoadVfp(KThreadContext *ctx);
bool __fastcall KScheduler::RemoveTerminatingThread(KScheduler *this, KThread *thread);
Result __fastcall KScheduler::ChangeAppPreemptionMode(u32 newMode);
void __fastcall KScheduler::YieldCurrentThread(KScheduler *this);
void __fastcall KScheduler::InitializeNewThread(KScheduler *this, KThread *thread);
void __fastcall KSemaphore::Initialize(KSemaphore *this, KProcess *ownerProcess, s32 initialCount, s32 maxCount);
Result __fastcall KClientPort::CreateSession(KClientPort *this, KClientSession **outClientSessionPtr);
void __fastcall KDmaManager::AbortAll(KDmaManager *this);
KAutoObject *__fastcall KObjectName::FindObject(const char *name);
Result __fastcall KObjectName::RegisterObject(KAutoObject *obj, const char *name);
KServerSession *__fastcall KServerPort::AcceptSession(KServerPort *this);
void __fastcall KCodeSegment::EnsureCacheCoherencyForCode(KCodeSegment *this);
KCodeSegment *__fastcall KCodeSegment::KCodeSegment(KCodeSegment *this);
void __fastcall KProcess::ChangeAffinityMask(u8 *newAffMask, u8 affMask, bool add);
void __fastcall KAffinityMask::MakeAllCoresMask(KAffinityMask *result);
Result __fastcall KSharedMemory::Initialize(KSharedMemory *this, KProcess *ownerProcess, u32 addr, u32 size, u32 ownerPerms, u32 othersPerms);
KSharedMemory *__fastcall KSharedMemory::KSharedMemory(KSharedMemory *__hidden this);
s32 __fastcall KResourceLimit::GetCurrentValue(KResourceLimit *this, ResourceLimitType type);
KCpuTimeLimit *__fastcall KResourceLimit::GetTimeLimit(KResourceLimit *this);
Result __fastcall KServerSession::SendSyncRequest(KServerSession *this, KThread *thread);
void __fastcall KAddressArbiter::Initialize(KAddressArbiter *this, KProcess *owner);
Result __fastcall KInterruptEvent::ReenableInterrupt(KInterruptEvent *this);
void __fastcall KInterruptTaskManager::EnqueueTask(KInterruptTaskManager *this, KInterruptTask *task);
Result __fastcall KThread::InitializeUserThread(KThread *this, u32 ep, u32 arg, u32 stackTop, s32 priority, s32 idealCore, KProcess *parentProcess);
Result __fastcall KProcess::GetQtmStaticMappedSize(s32 *out, KProcess *this);
Result __fastcall KProcess::GetQtmStaticMappedBase(s32 *out, KProcess *this);
Result __fastcall KProcess::GetQtmStaticMappedConversionOffset(s32 *out, KProcess *this);
u32 __fastcall KMemoryManager::ConvertSharedMemPaLinearWithAppMemType(u32 pa);
void __fastcall ReplyAndReceiveImpl(ReplyAndReceiveArgs *args, KSynchronizationObject **syncObjects);
void __fastcall GetThreadListImpl(GetThreadListArgs *args, u32 *tidBuffer);
void __fastcall GetProcessListImpl(GetProcessListArgs *args, u32 *pidBuffer);
Result __fastcall KDmaChannel::Restart(KDmaChannel *this, u32 dstAddr, u32 srcAddr, u32 size, DmaRestartFlags restartFlags);
KPort *__fastcall KPort::KPort(KPort *this);
void __fastcall KEvent::Initialize(KEvent *this, KProcess *ownerProcess, ResetType resetType);
Result __fastcall KMutex::Initialize(KMutex *this, KProcess *owner, BOOL initiallyLocked);
void __fastcall KMutex::ForceUnlock(KMutex *this, KThread *thread);
Result __fastcall KProcessPageTable::Initialize(KProcessPageTable *this, u32 pid, bool onlyUseSmallPages);
Result __fastcall KProcessPageTable::ControlMemory(KProcessPageTable *this, u32 *outAddr, u32 addr0, u32 addr1, u32 size, u32 op, u32 perms);
Result __fastcall KProcessPageTable::MapSharedConfigPages(KProcessPageTable *this, bool canWriteSharedUserPage);
Result __fastcall KPageTable::CheckAndUpdateAddrRangeMaskedStateAndPerms(KPageTable *this, u32 addr, u32 numPages, KMemoryState stateMask, KMemoryState expectedState, KMemoryPermission minPerms, KMemoryState newState, KMemoryPermission newPerms);
Result __fastcall KInterruptManager::UnbindUserInterruptEventChecked(KInterruptManager *this, KInterruptEvent *interruptEvent, s32 irqId);
void __fastcall KMemoryBlockManager::Initialize(KMemoryBlockManager *this, u32 addrSpaceStart, u32 addrSpaceEnd);
void __fastcall KInterruptController::EnableWithPriority(s32 irqId, u8 priority);
u32 KPerformanceCounterManager::GetOverflowFlags(void);
void __fastcall KPerformanceCounterManager::SetVirtualCounterEnabled(KPerformanceCounterManager *this, bool enable);
void __fastcall KPerformanceCounterManager::ResetCounters(KPerformanceCounterManager *this, u32 valueMask, u32 overflowMask);
void KPerformanceCounterManager::Disable(void);
PerformanceCounterEvent __fastcall KPerformanceCounterManager::GetEvent(KPerformanceCounterManager *this, PerformanceCounterName name);
u64 __fastcall KPerformanceCounterManager::GetCounterValue(KPerformanceCounterManager *this, PerformanceCounterName name);
void __fastcall KPerformanceCounterManager::SetEvent(KPerformanceCounterManager *this, PerformanceCounterName name, PerformanceCounterEvent event);
void __fastcall KPerformanceCounterManager::SetCounterValue(KPerformanceCounterManager *this, PerformanceCounterName name, u64 value);
void __fastcall KPageTable::InvalidateEntireInstructionCache();
Result __fastcall KProcessPageTable::CopyMemoryForDebug(KProcessPageTable *this, u32 dstAddr, KProcessPageTable *srcPgTbl, u32 srcAddr, u32 size);
void __fastcall KDebug::Intialize(KDebug *this, KProcess *process);
Result __fastcall KThread::AttachNewToDebug(KThread *this);
Result __fastcall KThread::SignalExitToDebug(KThread *this);
Result __fastcall KProcess::SetDebugExitedNormallyFlag(KProcess *this);
Result __fastcall KThread::SetDebugPauseOnInit(KThread *this);
Result __fastcall KProcess::SetDebugTerminatedFlag(KProcess *this);
Result __fastcall KDebug::BreakNoRo(KDebug *this, UserBreakType breakReason);
Result __fastcall KDebug::GetThreadContext(KDebug *this, ThreadContext *outThreadContext, KThread *thread, ThreadContextControlFlags flags);
Result __fastcall KDebug::SetThreadContext(KDebug *this, ThreadContext *threadContext, KThread *thread, ThreadContextControlFlags flags);
Result __fastcall KDebug::Attach(KDebug *this, KProcess *process);
Result __fastcall KDebug::QueryProcessMemory(KDebug *this, MemoryInfo *outMemInfo, u32 *pgInfo, u32 addr);
KThread *__fastcall KThread::FindById(u32 id);
void __fastcall KThread::SetSleepPriority(KThread *this, s32 priority);
void __fastcall KThread::RestorePriorityAfterSleep(KThread *this);
void __fastcall KThread::Exit(KThread *this);
Result __fastcall KCodeSet::Initialize(KCodeSet *this, const CodeSetInfo *codeSetInfo, KProcessPageTable *pgTable, u32 textPtr, u32 rodataPtr, u32 dataPtr);
bool __fastcall KProcess::IsTerminated(KProcess *this);
Result __fastcall KProcess::DumpThreadIds(KProcess *this, s32 *outNumThreads, u32 *threadIdList, s32 threadIdListSize);
bool __fastcall KProcess::TerminateImpl1(KProcess *this);
KProcess *__fastcall KProcess::OpenById(u32 pid);
bool __fastcall KProcess::ReserveResource(KProcess *this, ResourceLimitType type, s32 amount);
BOOL __fastcall KProcess::CheckThreadPriority(KProcess *this, s32 priority);
void __fastcall KProcess::IncrementThreadCount(KProcess *this);
Result *__fastcall MakeResultCode(Result *result, u8 level, u8 summary, u8 module, u16 description);
u32 __fastcall KHandleTable::GetTotalAllocatedSize(KHandleTable *this);
s64 __fastcall KMemoryBlockManger::GetTotalPrivateMemSize(KMemoryBlockManager *this);
s64 __fastcall KMemoryBlockManager::GetTotalCommittedMemory(KMemoryBlockManager *this);
s64 __fastcall KMemoryBlockManger::GetTotalPrivateOrSharedMemSize(KMemoryBlockManager *this);
u32 __fastcall KThread::GetProcessId(KThread *this);
void __fastcall __noreturn KThread::UserThreadStarter(int, int, int, int, int);
int KThread::SupervisorThreadStarter(); // weak
void __fastcall CallFuncWithStackAllocImpl(void *args, u32 stackAllocSize, FuncWithStackAlloc func);
void __fastcall memset(void *, size_t, unsigned __int8);
char *__fastcall strncpy(char *dstStr, const char *srcStr, u32 count);
void __fastcall KResourceLimit::Initialize(KResourceLimit *this);
void __fastcall KPort::Initialize(KPort *this, s32 maxSessionCount);
Result __fastcall KDmaManager::InitializeChannel(KDmaManager *this, Handle *outDmaObjectHandle, KDmaChannel **outDmaChannel, s8 channelId, u8 cfgFlags);
void *__fastcall _aeabi_vec_ctor_nocookie_nodtor(void *user_array, void *(__fastcall *constructor)(void *), u32 element_size, u32 element_count);
s32 __fastcall Ncch::ConvertSize(s32 size, u32 unused, s32 unitSize);
void __fastcall __noreturn DispatchExceptionWithRegdump(int, int, int, int, int);
Result __fastcall DispatchDebugEventFromException(DebugEventType type, u32 param1, u32 param2);
Result __fastcall KDebug::CheckMemoryAddressRange(KDebug *this, u32 addr, u32 size, bool isDstProcess, bool write);
void __fastcall KProcess::TerminateCurrentProcess(KProcess *this);
u32 __fastcall KPageHeap::GetTotalNumPages(KPageHeap *this);
bool __fastcall CallFuncWithStackAlloc(FuncWithStackAlloc func, void *args, u32 stackAllocSize);
KThread *__fastcall KHandleTable::ConvertToThreadAllowPseudoHandle(KHandleTable *this, Handle handle);
KDebug *__fastcall KHandleTable::ConvertCurProcHandleToDebug(Handle debugHandle);
BOOL __fastcall KDebug::IsProcessTerminated(KDebug *this);
KResourceLimit *__fastcall KHandleTable::ConvertToResourceLimit(KHandleTable *this, Handle reslimitHandle);
KProcess *__fastcall KHandleTable::ConvertToProcessAllowPseudoHandle(KHandleTable *this, Handle handle);
void __fastcall KDebug::UnpauseAllThreads(KDebug *this, BOOL checkBreak);
u32 __fastcall KProcess::GetLinearAddrRangeBase(KProcess *this);
u32 __fastcall KObjectAllocator::CountObjectsOwnedByProcess(KObjectAllocator *this, KProcess *process);
void __fastcall KThread::PrepareToRun(KThread *this);
Result __fastcall KThread::Initialize(KThread *this, u32 ep, u32 arg, u32 kernelStackTop, u32 stackTop, s32 priority, s32 idealCore, KProcess *parentProcess, KThreadType threadType);
void __fastcall _aeabi_memclr4(void *, size_t); // idb
void __fastcall _aeabi_memset4(void *data, u8 value, u32 size);
BOOL __fastcall CopyBytesFromUser(void *dst, const void *src, u32 size);
BOOL __fastcall CopyWordsFromUser(void *dst, const void *src, u32 size);
BOOL __fastcall CopyWordFromUser(void *dst, const void *src);
int __fastcall CopyStringFromUser(char *dstStr, const char *srcStr, u32 size);
BOOL __fastcall CopyBytesToUser(void *dst, const void *src, u32 size);
BOOL __fastcall CopyWordsToUser(void *dst, const void *src, u32 dataSize);
BOOL __fastcall CopyWordToUser(void *dst, const void *src);
int __fastcall CopyStringToUser(char *dstStr, const char *srcStr, u32 size);
BOOL __fastcall ClearUserBytes(void *userBuffer, u32 size);
BOOL __fastcall ClearUserWords(void *userBuffer, u32 size);
BOOL __fastcall ClearUserWord(void *userBuffer);
bool __fastcall KDmaAddress::ResetAddress(KDmaAddress *this, u32 newAddr);
KAutoObject *__fastcall KAutoObject::KAutoObject(KAutoObject *this);
Result __fastcall KProcessPageTable::MapStaticOrIo(KProcessPageTable *this, u32 addr, u32 size, BOOL isIo, KMemoryPermission userPerms);
Result __fastcall KDebug::SetThreadVfpContext(KDebug *this, ThreadContext *threadContext, KThread *thread, ThreadContextControlFlags flags);
bool __fastcall KResourceLimit::Reserve(KResourceLimit *this, ResourceLimitType category, s32 amount);
bool __fastcall KDmaAddress::CheckBufferRangeValid(KDmaAddress *this, s32 minOffset, s32 maxOffset);
bool __fastcall KDmaAddress::CheckVirtualAddressBlockUsable(KDmaAddress *this, s32 minOffset, s32 maxOffset, BOOL writePerms);
KSynchronizationObject *__fastcall KSynchronizationObject::KSynchronizationObject(KSynchronizationObject *__hidden this);
Result __fastcall KObjectAllocator::Register(KObjectAllocator *this, KAutoObject *obj);
void __fastcall KPageGroup::IncrefPages(KPageGroup *this);
Result __fastcall KPageTable::CheckAndMapPageGroup(KProcessPageTable *this, u32 addr, KPageGroup *pgGroup, KMemoryState state, KMemoryPermission perms);
void __fastcall KPageHeap::FreeBlock(KPageHeap *this, u32 addr, u32 numPages);
Result __fastcall ControlSystem(SystemOperation op, u32 arg1, u64 arg2);
void __fastcall KDmaAddress::Initialize(KDmaAddress *this, u32 dstAddr, bool isDevice, KProcess *process);
void __fastcall KDmaBufferSize::ComputeFromConfig(KDmaBufferSize *this, s32 size, DmaDeviceConfig *cfg);
bool __fastcall KDmaAddress::CheckPhysicalMemContiguous(KDmaAddress *this, s32 minOffset, s32 maxOffset);
Result __fastcall KPageTable::CheckMemoryBlockAttributes(KPageTable *this, u32 addr, u32 size, KMemoryState state, KMemoryPermission perms);
Result __fastcall KPageTable::MapL2Entries(KPageTable *this, u32 va, u32 pa, u32 numPages_reused, u32 *attribsPtr, bool isLarge);
void __fastcall KSystemControl::StopExtraCoresAndJumpImpl(s32 coreId);
Result __fastcall KPageTable::MapL1Entries(KPageTable *this, u32 va, u32 pa, u32 numPages, u32 *attribsPtr, bool isLarge);
Result __fastcall KPageTable::MergeContiguousEntries(KPageTable *this, u32 va);
Result __fastcall KPageTable::MapContiguousPhysicalAddressRange(KPageTable *this, u32 va, u32 pa, u32 numPages, u32 *mmuAttribs);
KPageHeapBlock *__fastcall KPageHeap::AllocateBackwards(KPageHeap *this, u32 size);
Result __fastcall KMemoryBlockManager::MutateRange(KMemoryBlockManager *this, u32 va, u32 numPages, KMemoryState state, KMemoryPermission perms, u32 tag);
void __fastcall KInterruptController::DisableInterrupt(u32 irqId);
void __fastcall KMemoryBlock::ShrinkBlock(KMemoryBlock *this, u32 va, u32 numPages);
Result __fastcall KInterruptManager::UnbindKernelInterruptForCore(KInterruptManager *this, s32 irqId, s32 coreId);
Result __fastcall KInterruptManager::BindInterrupt(KInterruptManager *this, KInterruptHandler *handler, u32 irqId, s32 coreId, s32 priority, bool autoDisable, bool levelSensitive);
Result __fastcall KDebug::DispatchEvent(KDebug *this, DebugEventType type, u32 param1, u32 param2);
void __fastcall KScheduler::TrySwitchingThread(KScheduler *this);
Result __fastcall KDebug::BuildOrderedListOfThreads(KDebug *this);
Result __fastcall KDebug::RequestPause(KDebug *this, KThread *thread);
Result __fastcall KDebug::GetThreadVfpContext(KDebug *this, ThreadContext *outThreadContext, KThread *thread, ThreadContextControlFlags flags);
Result __fastcall KAutoObject::Initialize(KAutoObject *this);
KMemoryBlock *__fastcall KMemoryBlockManager::GetMemoryBlockContainingAddr(KMemoryBlockManager *this, u32 addr);
void __fastcall KMemoryBlockManager::DumpInfoMaybe_stubbed(KMemoryBlockManager *this);
void __fastcall KScheduler::RemoveThread(KScheduler *this, KThread *thread, s32 prio);
void __fastcall KScheduler::TriggerSgi(KScheduler *this);
KDmaBlockBase *__fastcall KDmaBlockBase::KDmaBlockBase(KDmaBlockBase *this);
void SignalNewThreadEntry(void);
Result __fastcall DispatchDebugEvent(DebugEventType type, u32 param1, u32 param2);
void __fastcall KAutoObject::IncrementRefcount(KAutoObject *this);
KAutoObject *__fastcall KHandleTable::ConvertToAutoObject(KHandleTable *this, Handle handle);
Result __fastcall KHandleTable::Add(KHandleTable *this, Handle *outHandle, KAutoObject *obj, u8 typeId);
Result __fastcall KPageTable::CheckAddrRangeMaskedStateAndPerms(KPageTable *this, u32 addr, u32 size, KMemoryState stateMask, KMemoryState expectedState, KMemoryPermission minPerms);
bool KDmaController::IsManagerFaulting(void);
bool __fastcall KDmaController::IsChannelFaulting(s8 channelId);
u32 __fastcall KDmaController::GetChannelStatus(s8 channelId);
Result __fastcall KPageTable::OperateOnGroup(KPageTable *this, u32 addr, KPageGroup *pgGroup, KMemoryState state, KMemoryPermission perms, KMemoryUpdateFlags updateFlags);
u32 __fastcall KMemoryManager::AllocateContiguous(KMemoryManager *this, u32 numPages, u32 pageAlignment, MemoryOperation op);
void *__fastcall KPageHeap::AllocateContiguous(KPageHeap *this, u32 size, u32 pageAlignment);
void __fastcall KPageManager::IncrefPages(KPageManager *this, u32 addr, u32 numPages);
Result __fastcall KPageTable::SplitContiguousEntries(KPageTable *this, u32 va, u32 size);
void __fastcall KPageTable::InvalidateAllTlbEntries(KPageTable *this);
KMemoryInfo *__fastcall KMemoryBlock::GetInfo(KMemoryInfo *__return_ptr result, KMemoryBlock *this);
void __fastcall KVfpRegisterDumpHelper::DumpAndDisableVfpRegsForCore(s32 coreId);
void __fastcall KDebug::RequestReschedulingForDebugger(KDebug *this, s32 coreId);
Result __fastcall KDebug::EmplaceAysncEventInfo(KDebug *this, DebugEventType type, BOOL needsToBeContinued, u32 param1, u32 param2, u32 param3, u32 param4, u32 param5, u32 param6);
Result __fastcall KDebug::BreakCurrentProcess(KDebug *this, KThread *thread);
Result __fastcall KDebug::UnbreakCurrentProcess(KDebug *this);
Result __fastcall KThread::SetPriority(KThread *this, s32 priority);
s32 __fastcall KResourceLimit::GetLimitValue(KResourceLimit *this, ResourceLimitType type);
s32 __fastcall KDmaAddress::GetPhysicalChunkSize(KDmaAddress *this, s32 size);
void __fastcall KPageGroup::AddRange(KPageGroup *this, u32 addr, u32 numPages);
Result __fastcall KPageTable::QueryInfo(KPageTable *this, KMemoryInfo *outMemoryInfo, u32 *pageInfo, u32 addr);
void __fastcall KScheduler::AddThread(KScheduler *this, KThread *thread);
void __fastcall KScheduler::RescheduleByForce(KScheduler *this, KThread *forcedThread);
void __fastcall KScheduler::SwitchThread(KScheduler *this, KThread *forcedThread);
Result __fastcall KPageTable::CopyMemoryInterprocessForIpc(KPageTable *this, u32 dstAddr, KPageTable *srcPgTbl, u32 srcAddr, u32 size);
void *__fastcall memcpy(void *dst, const void *src, u32 size);
void __fastcall KCacheMaintenanceHelper::RequestOtherCoresCacheMaintenanceByMva(bool *outAsync, KCacheMaintenanceOperation op, u32 addr, u32 size);
void __fastcall KScheduler::AdjustThreadPriorityChanged(KScheduler *this, KThread *thread, s32 newPrio);
void __fastcall KPageHeap::ValidateBlock(KPageHeap *this, KPageHeapBlock *block);
void __fastcall KPageHeap::UpdateBlockMac(KPageHeap *this, KPageHeapBlock *block);
void __fastcall KPageHeap::SetLastBlock(KPageHeap *this, KPageHeapBlock *block);
s64 __fastcall KHardwareTimer::GetSystemTick(KHardwareTimer *this);
bool __fastcall KDmaController::IsInterruptActive(s8 channelId);
void __fastcall _aeabi_memclr(void *data, u32 size);
void __fastcall _aeabi_memset(void *data, u32 size, u32 value);
KPageGroup *__fastcall KPageGroup::KPageGroup(KPageGroup *this);
Result __fastcall KPageTable::AnalyzeRange(KPageTable *this, KPageGroup *pgGrp, u32 addr, u32 numPages);
Result __fastcall KPageTable::CheckAndChangeGroupStateAndPerms(KPageTable *this, u32 addr, KPageGroup *pgGroup, KMemoryState stateMask, KMemoryState expectedState, KMemoryPermission minPerms, KMemoryState newState, KMemoryPermission newPerms);
u32 __fastcall KPageGroup::GetTotalNumPages(KPageGroup *this);
void __fastcall KPageGroup::EraseAll(KPageGroup *this);
KDmaBlockBase *__fastcall KDmaBlockBase::GetChildBlock(KDmaBlockBase *this);
void __fastcall KDmaBlockBase::ResetInfo(KDmaBlockBase *this);
s32 __fastcall KDmaAddress::CalculateMinimumAlignment(u32 addr);
s32 __fastcall KDmaBurstConfig::Calculate(KDmaBurstConfig *this, s32 dataSize, s32 alignment, DmaDeviceConfig *dmaDeviceCfg);
void KThreadContext::EnableCurrentThreadVfp(void);
void __fastcall KThreadContext::StoreVfpRegsAndDisable(KThreadContext *this);
int __fastcall KInterruptController::EndOfInterrupt(s32 irqId, s32 coreId);
void __fastcall KInterruptController::ClearInterruptPendingStatus(s32 irqId);
void __fastcall KInterruptController::EnableWithPriorityAndTarget(s32 irqId, s32 coreId, u8 priority);
void __fastcall KInterruptController::AcknowledgeIrq(KIrqAcknowledgmentInfo *this);
void L2C::Disable(void);
void __fastcall InitialProcess::InitialProcess(InitialProcess *this, Cxi *cxi);
void *__fastcall _aeabi_memcpy4(void *dst, const void *src, u32 size);
void __fastcall KWorkerTaskManager::AddTask(KWorkerType type, KWorkerTask *task);
void __fastcall KDmaInstructionFactory::ResetCodeBuffer(KDmaInstructionFactory *this);
KDmaAddress *__fastcall KDmaAddress::KDmaAddress(KDmaAddress *this);
void __fastcall KSynchronizationObject::GetWaitersListBeginIt(KThreadLinkedListNode **firstNode, KSynchronizationObject *this);
void __fastcall KSynchronizationObject::GetWaitersListEndIt(KThreadLinkedListLink **endLink, KSynchronizationObject *this);
void __fastcall KThread::RelinquishMutex(KThread *this, KMutex *mutex);
void __fastcall KThread::AcquireMutex(KThread *this, KMutex *mutex);
BOOL __fastcall KHardwareTimer::RegisterTask(KHardwareTimer *this, KTimerTask *task, s64 timepoint);
void __fastcall KTranslationTableIterator::CreateFromEntry(u32 **L1TablePtr, KTranslationTableIterator *ttblIterator, KTranslationTableTraversalContext *traversalContext, u32 va);
void __fastcall KTranslationTableIterator::Advance(u32 **L1TablePtr, KTranslationTableIterator *ttblIterator, KTranslationTableTraversalContext *traversalContext);
void __fastcall KPageManager::FreeContiguous(KPageManager *this, u32 data, u32 numPages, MemoryOperation op);
void __fastcall KHardwareTimer::SetHardwareTimer(KHardwareTimer *this);
void __fastcall KHardwareTimer::Sanitize(KHardwareTimer *this);
void __fastcall KSchedulerLock::UnlockSingleCoreResched(KSchedulerLock *this);
void KPageTable::CleanInvalidateEntireDataCacheLocal(void);
void __fastcall KPageGroup::~KPageGroup(KPageGroup *this);
void __fastcall KLinkedList::~KLinkedList(KLinkedList *this);
void __fastcall KInterruptController::SetInterruptPriority(s32 irqId, u8 priority);
bool KSystemControl::IsLgr2Capable(void);
void __fastcall KCacheMaintenanceHelperTask::DoTask(KCacheMaintenanceHelperTask *this);
void __fastcall KThread::SetSchedulingState(KThread *this, KThreadSchedulingState state);
void cpu::SynchronizeAllCores(void);
void __fastcall KCacheMaintenanceHelper::RequestOtherCoresEntireCacheMaintenance(bool *outAsync, KCacheMaintenanceOperation op);
void __fastcall KCacheMaintenanceHelper::Join(bool *async);
void __fastcall L2C::InvalidateRange(u32 addrBegin, u32 addrEnd);
void L2C::InvalidateAll(void);
void __fastcall KThread::SetDebugPauseState(KThread *this, BOOL pause);
bool __fastcall KHardwareTimer::CancelTask(KHardwareTimer *this, KTimerTask *task);
void __fastcall KThread::RemoveVfpUsageFromCurrentContext(KThread *this);
void *__fastcall KSlabHeap::Allocate(KSlabHeap *this);
void __fastcall KLinkedList::InsertAfter(KLinkedList *this, KLinkedListLink *it, KLinkedListNode *node);
void __fastcall KSlabHeap::Free(KSlabHeap *this, void *obj);
void __noreturn kernelpanic(void);
void __fastcall KProcess::ReleaseResource(KProcess *this, ResourceLimitType type, s32 amount);
void __fastcall KLinkedList::EraseNode(KLinkedList *this, KLinkedListLink **linkPtr);
Result __fastcall KPageTable::Operate(KPageTable *this, u32 va, u32 numPages, u32 pa, KMemoryState state, KMemoryPermission perms, KMemoryUpdateFlags updateFlags, u32 region);
bool __fastcall KResourceLimit::Release(KResourceLimit *this, ResourceLimitType category, s32 amount);
u32 __fastcall KPageTable::ConvertVaToPa(u32 **L1TablePtr, u32 va);
void __fastcall KDmaInstructionFactory::EmitMov(KDmaInstructionFactory *this, CoreLinkDma330InstructionFlags flags, u32 addr);
u8 __fastcall KDmaController::MakeSwapRegValue(s32 endianSwapSize);
KDmaBufferSize *__fastcall KDmaBufferSize::operator+(KDmaBufferSize *__return_ptr __struct_ptr retstr, const KDmaBufferSize *this, s32 rhs);
KDmaBufferSize *__fastcall KDmaBufferSize::operator*(KDmaBufferSize *__return_ptr __struct_ptr retstr, const KDmaBufferSize *this, s32 rhs);
KDmaBufferSize *__fastcall KDmaBufferSize::operator+(KDmaBufferSize *__return_ptr __struct_ptr retstr, const KDmaBufferSize *this, const KDmaBufferSize *rhs);
KDmaBufferSize *__fastcall KDmaBufferSize::operator+=(KDmaBufferSize *this, s32 rhs);
void __fastcall KDmaInstructionFactory::EmitWfp(KDmaInstructionFactory *this, u8 flags, s8 deviceId);
s32 __fastcall KDmaController::CalculateLoopCountForDepth(s32 numIter, s32 counterId);
KDmaBufferSize *__fastcall KDmaBufferSize::operator+=(KDmaBufferSize *this, const KDmaBufferSize *rhs);
void __fastcall KDmaBufferSize::operator=(KDmaBufferSize *this, s32 size);
KDmaBufferSize *__fastcall KDmaBufferSize::operator*=(KDmaBufferSize *this, s32 rhs);
void __fastcall KDmaBufferSize::operator=(KDmaBufferSize *lhs, const KDmaBufferSize *rhs);
void __fastcall KDmaDataUnitBlock::EmitMovCcr(KDmaDataUnitBlock *this, KDmaInstructionFactory *instFactory, bool isNotMain);
int divby0();
void __fastcall KLightMutex::LockImpl(KLightMutex *this);
void __fastcall KLightMutex::UnlockImpl(KLightMutex *this);
void __fastcall KSchedulerLock::Lock(KSchedulerLock *this);
void __fastcall KScheduler::AdjustThreadScheduling(KScheduler *this, KThread *thread, u8 oldSchedMask);
void __fastcall KSchedulerLock::Unlock(KSchedulerLock *this);
void __fastcall KSemaphore::DoTask(KInterruptTask *__shifted(KSemaphore,0x14) this);
void __fastcall KSynchronizationObject::NotifyWaiters(KSynchronizationObject *this, BOOL pulse);
void __fastcall KCleanInvalidateDataCacheOperator::DoRangeOperation(KCleanInvalidateDataCacheOperator *this, u32 addr, u32 size);
void __fastcall KPageTable::CleanInvalidateDataCacheRange(u32 addr, u32 size);
bool L2C::IsEnabled(void);
void __fastcall KProcess::CleanInvalidateDataCacheRange(KProcess *this, u32 dstAddr, u32 dstSize);
void __fastcall KPageTable::CleanInvalidateEntireDataCache();
void __fastcall KCleanDataCacheOperator::DoRangeOperation(KCleanDataCacheOperator *this, u32 addr, u32 size);
void __fastcall KPageTable::CleanDataCacheRange(u32 addr, u32 size);
void __fastcall KObjectAllocator::Deregister(KObjectAllocator *this, KAutoObject *obj);
void __fastcall KLightMutex::Unlock(KLightMutex *this);
void __fastcall KServerPort::Connect(KServerPort *this, KServerSession *serverSession);
Result __fastcall KCodeSegment::Initialize(KCodeSegment *this, CodeSegmentInfo *a2, KProcessPageTable *pageTable, u32 srcAddr);
Result __fastcall KHandleTable::Destroy(KHandleTable *this);
void __fastcall KMemoryManager::FreeContiguousLocked(KMemoryManager *this, u32 addr, u32 numPages);
KPageHeapBlock *__fastcall KMemoryManager::AllocateContiguousBackwards(KMemoryManager *this, u32 numPages, MemoryOperation region);
void __fastcall KResourceLimit::SetLimitValue(KResourceLimit *this, ResourceLimitType name, s32 value);
Result __fastcall KServerSession::ReceiveSyncRequest(KServerSession *this, KThread *thread);
KLightMutex **__fastcall KLightMutex::Lock(KLightMutex **pLightMutex, KLightMutex *this);
void KDmaController::KillManagerThread(void);
u32 __fastcall KDmaController::GetLoopCounter(s8 channelId, s32 regId);
void KDmaController::ClearAllInterrupts(void);
u32 __fastcall KDmaController::GetDestinationAddress(s8 channelId);
u32 __fastcall KDmaController::GetSourceAddress(s8 channelId);
void __fastcall KDmaInstructionFactory::ReplaceFlushPByNop(KDmaInstructionFactory *this);
void __fastcall KDmaInstructionFactory::MutateMovDarMovSarInsts(KDmaInstructionFactory *this, u32 dstAddr, u32 srcAddr);
void __fastcall KDmaChannel::AbortTransferForPowerStateChange(KDmaChannel *this);
void __fastcall KDmaChannel::AbortTransfer(KDmaChannel *this);
Result __fastcall KPageTable::CheckAddressRangeSizeAndState(KPageTable *this, u32 addr, u32 size, KMemoryState state);
Result __fastcall KPageTable::CheckAddressRangeSizeAndStateFlags(KPageTable *this, u32 addr, u32 size, KMemoryState stateMask, KMemoryState expectedStateFlags);
Result __fastcall KPageTable::ChangePageAttributes(KPageTable *this, u32 addr, u32 size, u32 *mmuAttribs);
Result __fastcall KPageTable::CheckAndUnmapPageGroup(KPageTable *this, u32 addr, KPageGroup *pgGroup);
Result __fastcall KPageTable::MapNewlyAllocatedPhysicalAddressRange(KPageTable *this, u32 va, u32 pa, u32 numPages, u32 *mmuAttrbis);
Result __fastcall KPageTable::OperateOnAnyFreeBlockInRegionWithGuardPage(KPageTable *this, u32 *outAddr, u32 blockNumPages, u32 regionStart, u32 regionNumPages, u32 pa, KMemoryState state, KMemoryPermission perms, KMemoryUpdateFlags updateFlags, u32 region);
Result __fastcall KPageTable::CreateAlias(KPageTable *this, u32 srcAddr, u32 dstAddr, u32 numPages, KMemoryState expectedStateSrc, KMemoryPermission expectedMinPermsSrc, KMemoryState newStateSrc, KMemoryPermission newPermsSrc, KMemoryState newStateDst, KMemoryPermission newPermsDst);
Result __fastcall KPageTable::DestroyAlias(KPageTable *this, u32 srcAddr, u32 dstAddr, u32 numPages, KMemoryState expectedStateSrc, KMemoryPermission expectedMinPermsSrc, KMemoryState expectedStateDst, KMemoryPermission expectedMinPermsDst, KMemoryState newStateSrc, KMemoryPermission newPermsSrc, KMemoryUpdateFlags additionalMemUpdateFlags);
void __fastcall KPageTable::Unmap(KPageTable *this, u32 addr, u32 numPages);
void __fastcall KPageTable::InitizalizeL1Table(u32 **outL1TablePtr, u32 *L1Table);
Result __fastcall KInterruptManager::ReenablePublicInterruptOrFiq(KInterruptManager *this, s32 irqId);
void __fastcall KInterruptManager::UnbindUserInterruptEvent(KInterruptManager *this, s32 irqId);
void __fastcall KPerformanceCounterManager::BindInterrupts(KPerformanceCounterManager *this);
void __fastcall KPageTable::CleanInvalidateInstructionCacheRange(u32 addr, u32 size);
Result __fastcall KDebug::PauseSignalingThread(KDebug *this, KThread *thread);
Result __fastcall KDebug::AttachNewThread(KDebug *this, KThread *thread);
Result __fastcall KDebug::DetachThread(KDebug *this, KThread *thread);
Result __fastcall KDebug::IntializeDebugThreads(KDebug *this);
Result __fastcall KDebug::PauseProcess(KDebug *this, KThread **outCurrentThreads);
Result __fastcall KDebug::EmplaceSyncEventInfo(KDebug *this);
Result __fastcall KDebug::GetThreadContextInSvc(KDebug *this, ThreadContext *outThreadContext, KThread *thread, ThreadContextControlFlags flags);
Result __fastcall KDebug::ProcessAsyncEventAndEmplaceInfo(KDebug *this, DebugEventType type, u32 param1);
Result __fastcall KThread::Sleep(KThread *this, s64 timeout);
Result __fastcall KProcess::GetProcessList(s32 *outNumProcesses, u32 *pidBuffer, s32 maxNumProcesses);
void __fastcall KSession::Initialize(KSession *this, KClientPort *clientPort);
KPageHeapBlock *__fastcall KPageHeap::SplitBlock(KPageHeap *this, KPageHeapBlock *curBlk, u32 newBlockSize);
BOOL __fastcall KAffinityMask::CheckCoreAllowed(KAffinityMask *this, u8 coreId);
KMemoryBlock *__fastcall KMemoryBlockManager::FindFreeBlockInRegion(KMemoryBlockManager *this, u32 regionStart, u32 regionNumPages, u32 blockNumPages);
Result __fastcall KProcessPageTable::UnmapStaticOrIoByPa(KProcessPageTable *this, u32 dstPa, KProcessPageTable *srcPgTbl, u32 srcPa, u32 size);
void __fastcall KThreadContext::Load(KThreadContext *ctx);
KThreadContext *__fastcall KScheduler::Reschedule(KScheduler *this, _DWORD reused_variable);
void __fastcall KCpuTimeLimit::ConfigureTimeLimit(s32 cpuTime);
KThread *__fastcall KScheduler::GetNextQueuedThread(KScheduler *this, KThread *thread);
s8 __fastcall KDmaManager::TryLockChannel(KDmaManager *this, s8 channelId);
Result __fastcall KDmaManager::CheckDeviceConfig(s32 *outMinAlignment, DmaDeviceConfig *deviceCfg, s8 endianSwapSize, bool isDevice);
BOOL __fastcall KHandleTable::CloseHandle(KHandleTable *this, Handle handle);
void __fastcall KMemoryBlock::GrowBlock(KMemoryBlock *this, u32 va, u32 numPages);
Result __fastcall KServerSession::ReplyOrAbortRequest(KServerSession *this, KThread *srcThread, bool reply);
Result __fastcall KSynchronization::WaitSynchronizationN(KSynchronization *this, s32 *outIdx, KThread *thread, KSynchronizationObject **objs, s32 numHandles, bool waitAll, s64 timeout);
KDmaProgram *__fastcall KDmaProgram::KDmaProgram(KDmaProgram *this);
bool __fastcall KSynchronizationObject::AddWaiter(KSynchronizationObject *this, KThread *thread);
bool __fastcall KSynchronizationObject::RemoveWaiter(KSynchronizationObject *this, KThread *thread);
void __fastcall KDmaController::KillChannelThread(s8 channelId);
void __fastcall KDmaInstructionFactory::SetCodeBuffer(KDmaInstructionFactory *this, u8 *codeBuffer, s32 size);
void __fastcall KThreadContext::SetVfpGprs(KThreadContext *this, f64 *d);
Result KFiqHelper::ReenableInterrupt(void);
void __fastcall KServerSession::TranslateOutputIpcParameters(u32 *reqCmdbuf, u32 *srcCmdbuf, KThread *reqThread, KThread *srcThread, u32 reqThreadTls, u32 normalSize, u32 translateSize);
Result __fastcall KServerSession::TranslateInputIpcParameters(u32 *dstCmdbuf, u32 *srcCmdbuf, KThread *dstThread, KThread *srcThread, u32 dstTlsVa, u32 normalSize, u32 translateSize);
void __fastcall KDmaChannel::Initialize(KDmaChannel *this, KDmaChannelEventHandler *chEvHandler, KDmaObject *dmaObject);
void __fastcall KDmaChannel::FinalizeTransfer(KDmaChannel *this);
void __fastcall KDmaChannel::StartExecutingCode(KDmaChannel *this, BOOL waitForWfpState);
void __fastcall KDmaChannel::BuildProgramAndRun(KDmaChannel *this, BOOL flushPeripheral);
void __fastcall KMutex::RecalculatePriority(KMutex *this);
Result __fastcall KPageTable::RemapMemoryInterprocess(KPageTable *dstPgTbl, KPageTable *srcPgTbl, u32 dstAddr, u32 srcAddr, u32 numPages, KMemoryState dstMemState, KMemoryPermission dstMemPerms);
void __fastcall KPageTable::InvalidateTlbEntryByMva(KPageTable *this, u32 addr);
void __fastcall KPageTable::UnmapEntries(KPageTable *this, u32 currentVa, u32 numPages, KPageGroup *outPgGroupUnmapped);
Result __fastcall KInterruptManager::ReenablePublicInterrupt(KInterruptManager *this, s32 irqId);
void __fastcall KMemoryBlockManager::CoalesceBlocks(KMemoryBlockManager *this);
void __fastcall KInterruptController::DisablePeripheralInterrupt(s32 irqId);
void __fastcall KInterruptController::ConfigureInterrupt(s32 irqId, bool levelSensitive);
void __fastcall KPageTable::CleanInvalidateDataCacheRangeLocal(u32 addr, u32 size);
Result __fastcall KDebug::InitializeSyncEventInfo(KDebug *this, KEventInfo *info);
Result __fastcall KDebug::InitalizeAsyncEventInfo(KDebug *this, DebugEventType type, KEventInfo *eventInfo, u32 param1, u32 param2, u32 param3, u32 param4, u32 param5, u32 param6);
void __fastcall KThread::ForceToTerminate(KThread *this);
bool __fastcall KPageGroup::IsEqualRange(KPageGroup *lhs, KPageGroup *rhs);
bool __fastcall KDmaAddress::CheckAlignment(KDmaAddress *this, s32 alignment);
BOOL __fastcall KMemoryBlock::IncludesRange(KMemoryBlock *this, u32 va, u32 numPages);
bool __fastcall KMemoryBlock::Contains(KMemoryBlock *this, u32 addr);
void KThreadContext::DisableCurrentThreadVfp(void);
void __fastcall KScheduler::UpdateQueue(KScheduler *this);
u32 __fastcall KDmaAddress::Advance(KDmaAddress *this, s32 offset);
void __fastcall KSynchronization::Cancel(KSynchronization *this, KThread *thread, Result cancelResult);
void __fastcall KDmaController::ClearInterrupt(s8 channelId);
u32 __fastcall KDmaController::GetChannelProgramCounter(s8 channelId);
void __fastcall KDmaController::StartExecutingChannelCode(s8 channelId, u32 codeBufferPa, bool nonSecure);
void __fastcall KDmaInstructionFactory::EmitFlushP(KDmaInstructionFactory *this, s8 deviceId);
void __fastcall KDmaInstructionFactory::EmitFinalSequence(KDmaInstructionFactory *this, s8 channelId);
Result __fastcall KProcessPageTable::MapMemoryForIpc(u32 *outAddr, KPageTable *this, KPageTable *srcPgTbl, u32 srcAddr, u32 size);
void __fastcall KProcessPageTable::SwitchContext(KProcessPageTable *this);
u32 __fastcall KTranslationTableTraversalContext::InitFromEntry(u32 *outPa, u32 **outL2Entry, u32 entryValue, u32 va);
void __fastcall KInterruptController::EnableInterrupt(s32 irqId);
void __fastcall KInvalidateDataCacheOperator::DoRangeOperation(KInvalidateDataCacheOperator *this, u32 addr, u32 size);
void __fastcall KPageTable::InvalidateDataCacheRange(u32 addr, u32 size);
Result __fastcall KDebug::InitializeExceptionDebugEventInfo(KDebug *this, KEventInfo *info);
BOOL __fastcall KPageHeap::TryInsert(KPageHeap *this, u32 freedAddr, u32 freedNumPages, KPageHeapBlock *prevBlock, KPageHeapBlock *nextBlock);
bool __fastcall AtomicBool::CompareExchangeStrong(AtomicBool *this, bool oldVal, bool newVal);
void __fastcall KSynchronizationObject::EraseWaiterNode(KThreadLinkedListLink *outLink, KSynchronizationObject *this, KThreadLinkedListNode **it);
int __fastcall ll_udiv_donemoving(unsigned __int64 a1, unsigned int a2, int a3);
int __fastcall _aeabi_ldiv0(_DWORD, _DWORD); // weak
void _aeabi_idiv0();
void __noreturn KSystemControl::LaunchFirm(void);
void __fastcall DestroyDmaChannelInstances();
void HorizonKernelFinalize(void);
bool __fastcall KDmaObject::IsSignaled(KDmaObject *this, KThread *thread);
bool __fastcall KDmaObject::TryAcquire(KDmaObject *this, KThread *thread);
void __fastcall KPageGroup::FreeMemory(KPageGroup *this);
void __fastcall KScheduler::Disable(KScheduler *this);
KInterruptTask *__fastcall KScheduler::OnInterrupt(KScheduler *this, s32 irqId);
void __fastcall KCpuTimeLimiterMode1::OnTimeout(KCpuTimeLimiterMode1 *this);
bool __fastcall KSemaphore::IsSignaled(KSemaphore *this, KThread *thread);
void __fastcall KSemaphore::Finalize(KSemaphore *this);
bool __fastcall KSemaphore::TryAcquire(KSemaphore *this, KThread *thread);
bool __fastcall KTimerTask::IsValidTimerTask(KTimerTask *this);
void __fastcall KAutoObject::DecrementReferenceCount(KAutoObject *this);
bool __fastcall KClientPort::IsSignaled(KClientPort *this, KThread *thread);
void __fastcall KClientPort::DecrementSessionCount(KClientPort *this);
bool __fastcall KClientPort::TryAcquire(KClientPort *this, KThread *thread);
KInterruptTask *__fastcall KDmaManager::OnInterrupt(KDmaManager *this, s32 irqId);
void __fastcall KDmaManger::DoTask(KDmaManager *this);
void __fastcall KDmaManager::Finalize(KDmaManager *this);
void __fastcall KThreadLinkedList::~KThreadLinkedList(KThreadLinkedList *this);
bool __fastcall KServerPort::IsSignaled(KServerPort *this, KThread *thread);
void __fastcall KServerPort::OnAbort(KServerPort *this);
bool __fastcall KServerPort::TryAcquire(KServerPort *this, KThread *thread);
void __fastcall KCodeSet::Finalize(KCodeSet *this);
Result __fastcall KCodeSegment::Finalize(KCodeSegment *this);
void __fastcall KDmaDataUnitBlock::SetInfo(KDmaDataUnitBlock *this, s8 *outLoopDepth, KDmaTransferInfo *dmaTransferInfo);
KDmaBlockBase **__fastcall KDmaBlockBase::CalculateSizes(KDmaBlockBase **pThis);
void __fastcall KDmaProgram::SetInfo(KDmaProgram *this, s8 *outLoopDepth, KDmaTransferInfo *dmaTransferInfo);
void __fastcall KDmaBlockBase::SetInfo(KDmaBlockBase *this, s8 *outLoopDepth, KDmaTransferInfo *dmaTransferInfo);
void __fastcall KSharedMemory::Finalize(KSharedMemory *this);
bool __fastcall KClientSession::IsSignaled(KClientSession *this, KThread *thread);
bool __fastcall KClientSession::TryAcquire(KClientSession *this, KThread *thread);
void __fastcall KDmaSmallerTransferBlock::Configure(KDmaSmallerTransferBlock *this, KDmaConfig *dmaCfg, KDmaBlockConfig *dmaBlkCfg, KDmaBlockType type);
bool __fastcall KServerSession::IsSignaled(KServerSession *this, KThread *thread);
void __fastcall KServerSession::AbortAllRequests(KServerSession *this);
void __fastcall KServerSession::NotifyClientClosed(KServerSession *this);
bool __fastcall KServerSession::TryAcquire(KServerSession *this, KThread *thread);
void __fastcall KSlabHeap::~KSlabHeap(KSlabHeap *this);
void __fastcall KAddressArbiter::Finalize(KAddressArbiter *this);
KInterruptTask *__fastcall `covariant return thunk to'KInterruptEvent::OnInterrupt(KInterruptEvent *this, s32 irqId);
KObjectContainer *__fastcall KObjectContainer::KObjectContainer(KObjectContainer *this);
void __fastcall KSynchronization::AbortSynchronization(KSynchronization *this, KSynchronizationObject *obj, Result rescode);
void __fastcall KDmaProgram::CalculateLargeSmallBlockSplit(KDmaBlockConfig *largerBlkCfg, KDmaBlockConfig *smallerBlkCfg, s32 dstSize, s32 srcSize, s32 dstStride, s32 srcStride);
void __fastcall KDmaProgram::SetTreeStructure(KDmaProgram *this, KDmaTransferInfo *info);
void __fastcall KDmaProgram::Configure(KDmaProgram *this, KDmaConfig *dmaCfg, KDmaBlockConfig *dmaBlkCfg, KDmaBlockType type);
void __fastcall KDmaLargerTransferBlock::Configure(KDmaLargerTransferBlock *this, KDmaConfig *dmaCfg, KDmaBlockConfig *dmaBlkCfg, KDmaBlockType type);
void __fastcall KCpuTimeLimiterMode0::OnTimeout(KCpuTimeLimiterMode0 *this);
Result __fastcall KProcess::FreeKernelStackOfThread(KProcess *this, u32 stackAddr);
void __fastcall KSynchronizationObject::AbortSynchronization(KSynchronizationObject *this, Result result);
void __fastcall KThread::Finalize(KThread *this);
void __fastcall KSynchronizationObject::Finalize(KSynchronizationObject *this);
s32 __fastcall KDmaController::CalculateLoopDepthFromNumIter(s32 numIterations);
bool __fastcall KDmaController::IsEventActive(s8 channelId);
u32 KDmaController::GetInterruptStatusRegister(void);
void __fastcall KDmaInstructionFactory::SetCurrentInstruction(KDmaInstructionFactory *this, u32 index);
void __fastcall KDmaInstructionFactory::EmitAddh(KDmaInstructionFactory *this, u8 flags, s8 deviceId);
void __fastcall KDmaInstructionFactory::EmitLdp(KDmaInstructionFactory *this, u8 flags, s8 deviceId);
void __fastcall KDmaInstructionFactory::EmitStp(KDmaInstructionFactory *this, u8 flags, s8 deviceId);
void __fastcall KDmaInstructionFactory::EmitRmb(KDmaInstructionFactory *this);
void __fastcall KDmaInstructionFactory::EmitWmb(KDmaInstructionFactory *this);
void __fastcall KDmaInstructionFactory::EmitMovCcr(KDmaInstructionFactory *this, u32 endianSwapSize, u32 dstCacheCtrl, u32 dstProtCtrl, u32 dstBurstLen, u32 dstBurstSize, u32 dstInc, u32 srcCacheCtrl, u32 srcProtCtrl, u32 srcBurstLen, u32 srcBurstSize, u32 srcInc);
void __fastcall KDmaInstructionFactory::EmitLd(KDmaInstructionFactory *this, u8 flags);
void __fastcall KDmaInstructionFactory::EmitLp(KDmaInstructionFactory *this, s32 numIterations);
void __fastcall KDmaInstructionFactory::EmitSt(KDmaInstructionFactory *this, u8 flags);
void __fastcall KDmaInstructionFactory::EmitLpEnd(KDmaInstructionFactory *this, u8 flags);
KDmaInstructionFactory *__fastcall KDmaInstructionFactory::KDmaInstructionFactory(KDmaInstructionFactory *this);
KInterruptTask *__fastcall KVfpRegisterDumpHelperImpl::OnInterrupt(KVfpRegisterDumpHelperImpl *this, s32 irqId);
KVfpRegisterDumpHelperImpl *__fastcall KVfpRegisterDumpHelperImpl::KVfpRegisterDumpHelperImpl(KVfpRegisterDumpHelperImpl *this);
KInterruptTask *__fastcall KSystemControlHelper::OnInterrupt(KSystemControlHelper *this, s32 irqId);
u32 KSystemControl::NotifyProcess9AndFinalize(void);
void __noreturn KSystemControl::StopExtraCoresAndJump(void);
KInterruptTask *__fastcall KSleepEntrySchedHelperImpl::OnInterrupt(KSleepEntrySchedHelperImpl *this, s32 coreId);
void __fastcall KSleepEntrySchedHelperImpl::DoTask(KSleepEntrySchedHelper *this);
KSleepEntrySchedHelperImpl *__fastcall KSleepEntrySchedHelperImpl::KSleepEntrySchedHelperImpl(KSleepEntrySchedHelperImpl *this);
KInterruptTask *__fastcall KSleepExitSchedHelperImpl::OnInterrupt(KSleepExitSchedHelperImpl *this, s32 coreId);
void __fastcall KSleepExitSchedHelperImpl::DoTask(KSleepExitSchedHelper *this);
KSleepExitSchedHelperImpl *__fastcall KSleepExitSchedHelperImpl::KSleepExitSchedHelperImpl(KSleepExitSchedHelperImpl *this);
KInterruptTask *__fastcall KFiqHelper::OnInterrupt(KFiqHelper *this, s32 irqId);
void __fastcall KFiqHelper::DoTask(KFiqHelper *this);
KInterruptTask *__fastcall KDmaChannel::OnInterrupt(KDmaChannel *this, s32 irqId);
void __fastcall KDmaChannel::DoTask(KDmaChannel *this);
void __fastcall `non-virtual thunk to'KDmaChannel::DoWorkerTask(KWorkerTask *__shifted(KDmaChannel,8) this);
void __fastcall KDmaChannel::DoWorkerTask(KDmaChannel *this);
KDmaChannel *__fastcall KDmaChannel::KDmaChannel(KDmaChannel *this);
void __fastcall KDmaChannel::~KDmaChannel(KDmaChannel *this);
void __fastcall KClientPort::Destroy(KClientPort *this);
void __fastcall KServerPort::Destroy(KServerPort *this);
bool __fastcall KEvent::IsSignaled(KEvent *this, KThread *thread);
void __fastcall KEvent::OnPulse(KEvent *this);
bool __fastcall KMutex::IsSignaled(KMutex *this, KThread *thread);
void __fastcall KMutex::OnAbort(KMutex *this);
void __fastcall KMutex::Finalize(KMutex *this);
void __fastcall KMutex::OnWaiterRemoved(KMutex *this, KThread *thread);
void __fastcall KMutex::OnWaiterAdded(KMutex *this, KThread *thread);
bool __fastcall KMutex::TryAcquire(KMutex *this, KThread *thread);
void __fastcall KTimer::OnAbort(KTimer *this);
void __fastcall `non-virtual thunk to'KTimer::OnTimeout(KTimerTask *__shifted(KTimer,0x14) this);
void __fastcall KTimer::OnTimeout(KTimer *this);
void __fastcall KTimer::Finalize(KTimer *this);
bool __fastcall KTimer::TryAcquire(KTimer *this, KThread *thread);
Result __fastcall KProcessPageTable::Finalize(KProcessPageTable *this, s32 *outTotalMemoryComitted);
KInterruptTask *__fastcall KHardwareTimer::OnInterrupt(KHardwareTimer *this, s32 irqId);
void __fastcall KHardwareTimer::SetPrescaler(KHardwareTimer *this, u32 prescaler);
void __fastcall KHardwareTimer::DoTask(KHardwareTimer *this);
void __fastcall KHardwareTimer::Finalize(KHardwareTimer *this, s32 coreId);
void __fastcall KSupervisorPageTable::Finalize(KSupervisorPageTable *this, s32 coreId);
void __fastcall KSupervisorPageTable::~KSupervisorPageTable(KSupervisorPageTable *this);
Result __fastcall KInterruptManager::ReenableInterruptOnCore(KInterruptManager *this, s32 interruptId, s32 coreId);
void __fastcall KInterruptManager::~KInterruptManager(KInterruptManager *this);
void __fastcall KMemoryBlockManager::Finalize(KMemoryBlockManager *this);
void __fastcall KInterruptController::EnableAndRestoreShared(KInterruptControllerState *this);
void __fastcall KInterruptController::DumpAndDisableShared(KInterruptControllerState *state);
void __fastcall KInterruptController::EnableAndRestoreLocal(KInterruptControllerState *this);
void __fastcall KInterruptController::DumpAndDisableLocal(KInterruptControllerState *state);
void __fastcall KInterruptManager::Finalize(KInterruptManager *this, s32 coreId);
KInterruptTask *__fastcall KPerformanceCounterManager::OnInterrupt(KPerformanceCounterManager *this, s32 irqId);
void __fastcall KPerformanceCounterManager::~KPerformanceCounterManager(KPerformanceCounterManager *this);
KInterruptTask *__fastcall KCacheMaintenanceHelperTask::OnInterrupt(KCacheMaintenanceHelperTask *this, s32 irqId);
KCacheMaintenanceHelperTask *__fastcall KCacheMaintenanceHelperTask::KCacheMaintenanceHelperTask(KCacheMaintenanceHelperTask *this);
void __fastcall KCacheMaintenanceHelper::~KCacheMaintenanceHelper(KCacheMaintenanceHelper *this);
KInterruptTask *__fastcall KTerminationHelper::OnInterrupt(KTerminationHelper *this, s32 coreId);
KInterruptTask *__fastcall KTlbMaintenanceHelperImpl::OnInterrupt(KTlbMaintenanceHelperImpl *this, s32 irqId);
KTlbMaintenanceHelperImpl *__fastcall KTlbMaintenanceHelperImpl::KTlbMaintenanceHelperImpl(KTlbMaintenanceHelperImpl *this);
void __fastcall KLevel2TranslationTableAllocator::~KLevel2TranslationTableAllocator(KLevel2TranslationTableAllocator *this);
void L2C::Enable(void);
void __fastcall KCleanDataCacheOperator::DoEntireOperation(KCleanDataCacheOperator *this);
void __fastcall KPageTable::InvalidateDataCacheRangeLocal(u32 addr, u32 size);
bool __fastcall KDebug::IsSignaled(KDebug *this, KThread *thread);
Result __fastcall KDebug::DestroyDebugThreadList(KDebug *this);
Result __fastcall KProcess::SignalExitToDebugNoPause(KProcess *this);
void __fastcall KDebug::OnAbort(KDebug *this);
bool __fastcall KDebug::TryAcquire(KDebug *this, KThread *thread);
bool __fastcall KThread::IsSignaled(KThread *this);
void __fastcall `non-virtual thunk to'KThread::DoTask(KInterruptTask *__shifted(KThread,0x2C) this);
void __fastcall KThread::DoTask(KThread *this);
void __fastcall KThread::AddTryingToAcquireMutex(KThread *this, KMutex *mutex);
void __fastcall KThread::RemoveTryingToAcquireMutex(KThread *this, KMutex *mutex);
bool __fastcall KThread::TryAcquire(KThread *this);
bool __fastcall KProcess::IsSignaled(KProcess *this);
void __fastcall KProcess::DecrementThreadCount(KProcess *this);
Result __fastcall KProcess::FreeTls(KProcess *this, u32 tlsUserAddr);
void __fastcall KProcess::Finalize(KProcess *this);
bool __fastcall KProcess::TryAcquire(KProcess *this);
void __fastcall KClientSession::Destroy(KClientSession *this);
void __fastcall KServerSession::Destroy(KServerSession *this);
void __fastcall KSession::Finalize(KSession *this);
void __fastcall KDmaObject::GetTypeObj(KTypeObj *outTypeObj, KDmaObject *this);
void __fastcall KSemaphore::GetTypeObj(KTypeObj *outTypeObj, KSemaphore *this);
KProcess *__fastcall KSemaphore::GetOwnerProcess(KSemaphore *this);
void __fastcall KAutoObject::GetTypeObj(KTypeObj *outTypeObj, KSynchronizationObject *this);
KProcess *__fastcall KAutoObject::GetOwnerProcess(KAutoObject *this);
void __fastcall KClientPort::GetTypeObj(KTypeObj *outTypeObj, KClientPort *this);
u32 __fastcall KDmaAddress::GetAdvancedAddrPa(KDmaAddress *this, s32 offset);
void __fastcall KServerPort::GetTypeObj(KTypeObj *outTypeObj, KServerPort *this);
void __fastcall KDmaDataUnitBlock::EmitInstructions(KDmaDataUnitBlock *this, KDmaSize *outDmaTransferSize, KDmaSize *transferredDmaSize, KDmaInstructionFactory *instFactory, KDmaDirection wfpDirection, KDmaTailInfo *parentDmaTailInfo);
s32 __fastcall KDmaBlockBase::ComputeNumberOfBlocks(KDmaBlockBase *this, KDmaSize *dmaSize);
BOOL __fastcall KDmaBlockBase::UpdateInfo(KDmaBlockBase *this, KDmaTransferInfo *transferInfo, KDmaBlockBase *block, s32 numBlocks, KDmaTailInfo *tailInfo);
void __fastcall KDmaBlockBase::EmitInstructions(KDmaBlockBase *this, KDmaSize *outDmaTransferSize_local, KDmaSize *transferredDmaSize, KDmaInstructionFactory *instFactory, KDmaDirection wfpDirection, KDmaTailInfo *parentDmaTailInfo);
void __fastcall KSharedMemory::GetTypeObj(KTypeObj *outTypeObj, KSharedMemory *this);
KProcess *__fastcall KSharedMemory::GetOwnerProcess(KSharedMemory *this);
void __fastcall KClientSession::GetTypeObj(KTypeObj *outTypeObj, KClientSession *this);
bool __fastcall KDmaBufferSize::operator<=(const KDmaBufferSize *this, const KDmaBufferSize *rhs);
void __fastcall KResourceLimit::GetTypeObj(KTypeObj *outTypeObj, KResourceLimit *this);
void __fastcall KServerSession::GetTypeObj(KTypeObj *outTypeObj, KServerSession *this);
void __fastcall KAddressArbiter::GetTypeObj(KTypeObj *outTypeObj, KAddressArbiter *this);
KProcess *__fastcall KAddressArbiter::GetOwnerProcess(KAddressArbiter *this);
void __fastcall KDmaProgram::EmitInstructions(KDmaProgram *this, KDmaSize *outDmaTransferSize, KDmaSize *transferredDmaSize, KDmaInstructionFactory *instFactory, KDmaDirection wfpDirection, KDmaTailInfo *parentDmaTailInfo);
void __fastcall KSynchronizationObject::GetTypeObj(KTypeObj *outTypeObj, KSynchronizationObject *this);
void __fastcall KPort::GetTypeObj(KTypeObj *outTypeObj, KPort *this);
void __fastcall KEvent::GetTypeObj(KTypeObj *outTypeObj, KEvent *this);
KProcess *__fastcall KEvent::GetOwnerProcess(KEvent *this);
void __fastcall KMutex::GetTypeObj(KTypeObj *outTypeObj, KMutex *this);
KProcess *__fastcall KMutex::GetOwnerProcess(KMutex *this);
void __fastcall KTimer::GetTypeObj(KTypeObj *outTypeObj, KTimer *this);
KProcess *__fastcall KTimer::GetOwnerProcess(KTimer *this);
void __fastcall KDebug::GetTypeObj(KTypeObj *outTypeObj, KDebug *this);
void __fastcall KThread::GetTypeObj(KTypeObj *outTypeObj, KThread *this);
void __fastcall KCodeSet::GetTypeObj(KTypeObj *outTypeObj, KCodeSet *this);
s32 __fastcall KDmaSize::operator/(KDmaSize *this, const KDmaSize *rhs);
void __fastcall KProcess::GetTypeObj(KTypeObj *outTypeObj, KProcess *this);
void __fastcall KSession::GetTypeObj(KTypeObj *outTypeObj, KSession *this);
void __fastcall KEvent::DoTask(KInterruptTask *__shifted(KEvent,0x14) this);
bool __fastcall KTimer::IsValidTimerTask(KTimerTask *__shifted(KTimer,0x14) this);
void __fastcall KThread::OnTimeout(KTimerTask *__shifted(KThread,0x14) this);
void __fastcall KThread::DoWorkerTask(KWorkerTask *__shifted(KThread,0x24) this);
KInterruptTask *__fastcall KThread::OnInterrupt(KInterruptTask *this, s32 irqId);
void __fastcall KDmaManager::OnChannelUnlocked(KDmaManager *__shifted(KDmaManager,8) this, s8 channelId);
u32 __fastcall KInvalidateDataCacheOperator::GetThreshold(KInvalidateDataCacheOperator *this);
u32 __fastcall KCleanInvalidateDataCacheOperator::GetThreshold(KCleanInvalidateDataCacheOperator *this);
u32 __fastcall KCleanDataCacheOperator::GetThreshold(KCleanDataCacheOperator *this);
AtomicBool *__fastcall AtomicBool::AtomicBool(AtomicBool *this);
void __fastcall KDmaObject::Destroy(KDmaObject *this);
void __fastcall KSemaphore::Destroy(KSemaphore *this);
void __fastcall KSharedMemory::Destroy(KSharedMemory *this);
void __fastcall KResourceLimit::Destroy(KResourceLimit *this);
void __fastcall KAddressArbiter::Destroy(KAddressArbiter *this);
void __fastcall KPort::Destroy(KPort *this);
void __fastcall KEvent::Destroy(KEvent *this);
void __fastcall KMutex::Destroy(KMutex *this);
void __fastcall KTimer::Destroy(KTimer *this);
void __fastcall KDebug::Destroy(KDebug *this);
void __fastcall KThread::Destroy(KThread *this);
void __fastcall KCodeSet::Destroy(KCodeSet *this);
void __fastcall KProcess::Destroy(KProcess *this);
void __fastcall KSession::Destroy(KSession *this);
void __noreturn WaitForeverAndAckSgis(void);
void __noreturn HandleResetException();
BOOL __fastcall DispatchExceptionToUser(ExceptionDispatchContext *ctx, ERRF_ExceptionInfo *excInfo);
void __fastcall DispatchDataAbortException(ExceptionDispatchContext *ctx);
void __fastcall DispatchPrefetchAbortException(ExceptionDispatchContext *ctx);
void __fastcall DispatchVfpException(ExceptionDispatchContext *ctx);
void __fastcall cpu::WaitCycles(u32 numCycles);
void __fastcall ExecuteOnExceptionStackInAxiWram(u32 arg, void (__fastcall *func)(s32 arg));
void EnableVfpAfterException(void);
void __fastcall __noreturn KSystemControl::HardwareResetImpl(s32 srcCoreId);
void __fastcall KSystemControl::HardwareReset(s32 srcCoreId);
void KSystemControl::PowerVramDown(void);
void KSystemControl::MakeFcramFinalRead(void);
void KSystemControl::SetFcramInSelfRefreshMode(void);
void KSystemControl::SetFcramInNormalMode(void);
void __fastcall KSystemControl::SleepSystemImpl(s32 srcCoreId);
void __fastcall KSystemControl::SleepSystem(s32 srcCoreId);
BOOL __fastcall KInterruptController::IsInterruptPending(s32 irqId);

//-------------------------------------------------------------------------
// Data declarations

volatile Config11Registers PA_CONFIG11;
volatile PdnRegisters PA_PDN;
volatile PxiRegisters PA_PXI;
volatile Mp11PrivateMemRegion PA_MPCORE;
u32 *crt0::L1TableAddresses[4] = { (u32 *)0x1FFF8000, (u32 *)0x1FFFC000, (u32 *)0x1F3F8000, (u32 *)0x1F3FC000 };
u32 *crt0::L2TableAddresses_FFF[4] = { (u32 *)0x1FFF7000, (u32 *)0x1FFF7400, (u32 *)0x1FFF7800, (u32 *)0x1FFF7C00 };
u32 crt0::idleThreadStacks[4] = { 536813568u, 524230656u, 524234752u, 524238848u };
u32 crt0::coreCtxAddrs[4] = { 536817664u, 524242944u, 524247040u, 524251136u };
_UNKNOWN unk_1FFB0414; // weak
int (*SHT__INIT_ARRAY__Base)() = (int (*)())0x320; // weak
void *off_1FFF4A64 = (void *)0x17E00100; // weak
void *off_1FFF4A68 = (void *)0x17E01000; // weak
void *off_1FFF4A6C = (void *)0x17E01280; // weak
void *off_1FFF4A70 = (void *)0x1FFFFFDC; // weak
char *off_1FFF4A74 = &crt0::core1ReadyForFirmlaunch; // weak
volatile bool crt0::core1ReadyForFirmlaunch = false;
volatile Arm11SysRv SYSRV;
int _dso_handle = 1198540656; // idb
void *svcTable[126] =
{
  NULL,
  &SvcControlMemory,
  &SvcQueryMemory,
  &SvcExitProcess,
  &SvcGetProcessAffinityMask,
  &SvcSetProcessAffinityMask,
  &SvcGetProcessIdealProcessor,
  &SvcSetProcessIdealProcessor,
  &SvcCreateThread,
  &SvcExitThread,
  &SvcSleepThread,
  &SvcGetThreadPriority,
  &SvcSetThreadPriority,
  &SvcGetThreadAffinityMask,
  &SvcSetThreadAffinityMask,
  &SvcGetThreadIdealProcessor,
  &SvcSetThreadIdealProcessor,
  &SvcGetCurrentProcessorNumber,
  &SvcRun,
  &SvcCreateMutex,
  &SvcReleaseMutex,
  &SvcCreateSemaphore,
  &SvcReleaseSemaphore,
  &SvcCreateEvent,
  &SvcSignalEvent,
  &SvcClearEvent,
  &SvcCreateTimer,
  &SvcSetTimer,
  &SvcCancelTimer,
  &SvcClearTimer,
  &SvcCreateMemoryBlock,
  &SvcMapMemoryBlock,
  &SvcUnmapMemoryBlock,
  &SvcCreateAddressArbiter,
  &SvcArbitrateAddress,
  &SvcCloseHandle,
  &SvcWaitSynchronization1,
  &SvcWaitSynchronizationN,
  &SvcSignalAndWait,
  &SvcDuplicateHandle,
  &SvcGetSystemTick,
  &SvcGetHandleInfo,
  &SvcGetSystemInfo,
  &SvcGetProcessInfo,
  &SvcGetThreadInfo,
  &SvcConnectToPort,
  &SvcSendSyncRequest1,
  &SvcSendSyncRequest2,
  &SvcSendSyncRequest3,
  &SvcSendSyncRequest4,
  &SvcSendSyncRequest,
  &SvcOpenProcess,
  &SvcOpenThread,
  &SvcGetProcessId,
  &SvcGetProcessIdOfThread,
  &SvcGetThreadId,
  &SvcGetResourceLimit,
  &SvcGetResourceLimitLimitValues,
  &SvcGetResourceLimitCurrentValues,
  &SvcGetThreadContext,
  &SvcBreak,
  &SvcOutputDebugString,
  &SvcControlPerformanceCounter,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  &SvcCreatePort,
  &SvcCreateSessionToPort,
  &SvcCreateSession,
  &SvcAcceptSession,
  &SvcReplyAndReceive1,
  &SvcReplyAndReceive2,
  &SvcReplyAndReceive3,
  &SvcReplyAndReceive4,
  &SvcReplyAndReceive,
  &SvcBindInterrupt,
  &SvcUnbindInterrupt,
  &SvcInvalidateProcessDataCache,
  &SvcStoreProcessDataCache,
  &SvcFlushProcessDataCache,
  &SvcStartInterProcessDma,
  &SvcStopDma,
  &SvcGetDmaState,
  &SvcRestartDma,
  &SvcSetGpuProt,
  &SvcSetWifiEnabled,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  &SvcDebugActiveProcess,
  &SvcBreakDebugProcess,
  &SvcTerminateDebugProcess,
  &SvcGetProcessDebugEvent,
  &SvcContinueDebugEvent,
  &SvcGetProcessList,
  &SvcGetThreadList,
  &SvcGetDebugThreadContext,
  &SvcSetDebugThreadContext,
  &SvcQueryDebugProcessMemory,
  &SvcReadDebugProcessMemory,
  &SvcWriteDebugProcessMemory,
  &SvcSetHardwareBreakPoint,
  &SvcGetDebugThreadParam,
  NULL,
  NULL,
  &SvcControlProcessMemory,
  &SvcMapProcessMemory,
  &SvcUnmapProcessMemory,
  &SvcCreateCodeSet,
  &Svc0x74_CodeSetRelated_stubbed,
  &SvcCreateProcess,
  &SvcTerminateProcess,
  &SvcSetProcessResourceLimits,
  &SvcCreateResourceLimit,
  &SvcSetResourceLimitLimitValues,
  &SvcFlushCodeSegment,
  NULL,
  &SvcControlSystem,
  &SvcQueryProcessMemory
}; // weak
_UNKNOWN loc_FFF1FFFC; // weak
_UNKNOWN loc_FFF20000; // weak
_DWORD dword_FFF26E70[16] =
{
  -252645136,
  -477218589,
  -678152731,
  -858993460,
  -1022611261,
  -1171354718,
  -1307163960,
  -1431655766,
  -1546188227,
  -1651910499,
  -1749801491,
  -1840700270,
  -1925330168,
  -2004318072,
  -2078209982,
  2147483648
}; // weak
int dword_FFF2E000 = 22534; // weak
KInterruptTask_vtbl KSleepEntrySchedHelperImpl::vt =
{
  &KSleepEntrySchedHelperImpl::OnInterrupt,
  &KSleepEntrySchedHelperImpl::DoTask
};
KInterruptTask_vtbl KSleepExitSchedHelperImpl::vt = { &KSleepExitSchedHelperImpl::OnInterrupt, &KSleepExitSchedHelperImpl::DoTask };
KInterruptTask_vtbl KCacheMaintenanceHelperTask::vt =
{
  &KCacheMaintenanceHelperTask::OnInterrupt,
  &KCacheMaintenanceHelperTask::DoTask
};
KInterruptHandler_vtbl KCacheMaintenanceHelper::vt = { &KCacheMaintenanceHelper::OnInterrupt };
u32 g_permsToMmuAttribLut[16] = { 0u, 0u, 0u, 0u, 528u, 560u, 0u, 0u, 0u, 0u, 0u, 0u, 16u, 32u, 0u, 48u };
KInterruptHandler_vtbl KTlbMaintenanceHelperImpl::vt = { &KTlbMaintenanceHelperImpl::OnInterrupt };
KInterruptHandler_vtbl KPerformanceCounterControlHelper::vt = { &KPerformanceCounterControlHelper::OnInterrupt };
int off_FFF2E15C = -857691; // weak
KCacheOperator_vtbl KCleanDataCacheOperator::vt =
{
  &KCleanDataCacheOperator::DoRangeOperation,
  &KCleanDataCacheOperator::DoEntireOperation,
  &KCleanDataCacheOperator::GetThreshold
};
KCacheOperator_vtbl KInvalidateDataCacheOperator::vt =
{
  &KInvalidateDataCacheOperator::DoRangeOperation,
  &KInvalidateDataCacheOperator::DoEntireOperation_actuallyCleanInv,
  &KInvalidateDataCacheOperator::GetThreshold
};
KInterruptTask_vtbl KFiqHelper::vt = { &KFiqHelper::OnInterrupt, &KFiqHelper::DoTask };
KSynchronizationObject_vtbl KDmaObject::vt =
{
  NULL,
  NULL,
  &KDmaObject::Destroy,
  &KSynchronizationObject::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KDmaObject::GetTypeObj,
  0u,
  &KSynchronizationObject::OnWaiterAdded,
  &KSynchronizationObject::OnWaiterRemoved,
  &KDmaObject::OnAbort,
  &KDmaObject::IsSignaled,
  &KDmaObject::TryAcquire,
  &KSynchronizationObject::OnPulse
};
KInterruptTask_vtbl KScheduler::vt = { &KScheduler::OnInterrupt, &KScheduler::DoTask };
KAutoObject_vtbl KAutoObject::vt =
{
  NULL,
  NULL,
  &KAutoObject::Destroy,
  &KAutoObject::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KAutoObject::GetTypeObj
};
KSynchronizationObject_vtbl KClientPort::vt =
{
  NULL,
  NULL,
  &KClientPort::Destroy,
  &KSynchronizationObject::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KClientPort::GetTypeObj,
  0u,
  &KSynchronizationObject::OnWaiterAdded,
  &KSynchronizationObject::OnWaiterRemoved,
  &KSynchronizationObject::OnAbort,
  &KClientPort::IsSignaled,
  &KClientPort::TryAcquire,
  &KSynchronizationObject::OnPulse
};
KInterruptTask_vtbl KDmaManager::vt = { &KDmaManager::OnInterrupt, &KDmaManger::DoTask };
KDmaChannelEventHandler_vt KDmaManager::vt_KDmaChannelEventHandler = { &KDmaManager::OnChannelTransferFinished, &KDmaManager::OnChannelUnlocked };
KSynchronizationObject_vtbl KServerPort::vt =
{
  NULL,
  NULL,
  &KServerPort::Destroy,
  &KSynchronizationObject::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KServerPort::GetTypeObj,
  0u,
  &KSynchronizationObject::OnWaiterAdded,
  &KSynchronizationObject::OnWaiterRemoved,
  &KServerPort::OnAbort,
  &KServerPort::IsSignaled,
  &KServerPort::TryAcquire,
  &KSynchronizationObject::OnPulse
};
KDmaBlockBase_vtbl KDmaBlockBase::vt = { NULL, NULL, NULL, &KDmaBlockBase::SetInfo, &KDmaBlockBase::EmitInstructions };
KAutoObject_vtbl KSharedMemory::vt =
{
  NULL,
  NULL,
  &KSharedMemory::Destroy,
  &KSharedMemory::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KSharedMemory::GetOwnerProcess,
  &KSharedMemory::GetTypeObj
};
KSynchronizationObject_vtbl KClientSession::vt =
{
  NULL,
  NULL,
  &KClientSession::Destroy,
  &KSynchronizationObject::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KClientSession::GetTypeObj,
  0u,
  &KSynchronizationObject::OnWaiterAdded,
  &KSynchronizationObject::OnWaiterRemoved,
  &KSynchronizationObject::OnAbort,
  &KClientSession::IsSignaled,
  &KClientSession::TryAcquire,
  &KSynchronizationObject::OnPulse
};
KAutoObject_vtbl KResourceLimit::vt =
{
  NULL,
  NULL,
  &KResourceLimit::Destroy,
  &KResourceLimit::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KResourceLimit::GetTypeObj
};
KSynchronizationObject_vtbl KServerSession::vt =
{
  NULL,
  NULL,
  &KServerSession::Destroy,
  &KSynchronizationObject::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KServerSession::GetTypeObj,
  0u,
  &KSynchronizationObject::OnWaiterAdded,
  &KSynchronizationObject::OnWaiterRemoved,
  &KSynchronizationObject::OnAbort,
  &KServerSession::IsSignaled,
  &KServerSession::TryAcquire,
  &KSynchronizationObject::OnPulse
};
KAutoObject_vtbl KAddressArbiter::vt =
{
  NULL,
  NULL,
  &KAddressArbiter::Destroy,
  &KAddressArbiter::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAddressArbiter::GetOwnerProcess,
  &KAddressArbiter::GetTypeObj
};
KSynchronizationObject_vtbl KSynchronizationObject::vt =
{
  NULL,
  NULL,
  &KAutoObject::Destroy,
  &KSynchronizationObject::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KSynchronizationObject::GetTypeObj,
  0u,
  &KSynchronizationObject::OnWaiterAdded,
  &KSynchronizationObject::OnWaiterRemoved,
  &KSynchronizationObject::OnAbort,
  &KSynchronizationObject::IsSignaled,
  &KSynchronizationObject::IsSignaled,
  &KSynchronizationObject::OnPulse
};
KInterruptHandler_vtbl KVfpRegisterDumpHelperImpl::vt = { &KVfpRegisterDumpHelperImpl::OnInterrupt };
KInterruptTask_vtbl KDmaChannel::vt = { &KDmaChannel::OnInterrupt, &KDmaChannel::DoTask };
KWorkerTask_vtbl KDmaChannel::vt_WorkerTask = { &`non-virtual thunk to'KDmaChannel::DoWorkerTask };
KAutoObject_vtbl KPort::vt =
{
  NULL,
  NULL,
  &KPort::Destroy,
  &KAutoObject::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KPort::GetTypeObj
};
KInterruptEvent_vtbl KEvent::vt =
{
  NULL,
  NULL,
  &KEvent::Destroy,
  &KEvent::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KEvent::GetOwnerProcess,
  &KEvent::GetTypeObj,
  0u,
  &KSynchronizationObject::OnWaiterAdded,
  &KSynchronizationObject::OnWaiterRemoved,
  &KSynchronizationObject::OnAbort,
  &KEvent::IsSignaled,
  &KEvent::TryAcquire,
  &KEvent::OnPulse,
  &`covariant return thunk to'KInterruptEvent::OnInterrupt
};
KInterruptTask_vtbl KEvent::vt_KInterruptTask = { &KInterruptEvent::OnInterrupt, &KEvent::DoTask };
KSynchronizationObject_vtbl KMutex::vt =
{
  NULL,
  NULL,
  &KMutex::Destroy,
  &KMutex::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KMutex::GetOwnerProcess,
  &KMutex::GetTypeObj,
  0u,
  &KMutex::OnWaiterAdded,
  &KMutex::OnWaiterRemoved,
  &KMutex::OnAbort,
  &KMutex::IsSignaled,
  &KMutex::TryAcquire,
  &KSynchronizationObject::OnPulse
};
KTimerTask_vtbl KDummyTimerTask::vt = { &KDummyTimerTask::OnTimeout, &KTimerTask::IsValidTimerTask };
KInterruptTask_vtbl KHardwareTimer::vt = { &KHardwareTimer::OnInterrupt, &KHardwareTimer::DoTask };
KInterruptHandler_vtbl KPerformanceCounterManager::vt = { &KPerformanceCounterManager::OnInterrupt };
KSynchronizationObject_vtbl KDebug::vt =
{
  NULL,
  NULL,
  &KDebug::Destroy,
  &KSynchronizationObject::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KDebug::GetTypeObj,
  0u,
  &KSynchronizationObject::OnWaiterAdded,
  &KSynchronizationObject::OnWaiterRemoved,
  &KDebug::OnAbort,
  &KDebug::IsSignaled,
  &KDebug::TryAcquire,
  &KSynchronizationObject::OnPulse
};
KWorkerTask_vtbl KDebug::vt_KWorkerTask = { &KDebug::DoWorkerTask };
KSynchronizationObject_vtbl KThread::vt =
{
  NULL,
  NULL,
  &KThread::Destroy,
  &KThread::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KThread::GetTypeObj,
  0u,
  &KSynchronizationObject::OnWaiterAdded,
  &KSynchronizationObject::OnWaiterRemoved,
  &KSynchronizationObject::OnAbort,
  &KThread::IsSignaled,
  &KThread::TryAcquire,
  &KSynchronizationObject::OnPulse
};
KTimerTask_vtbl KThread::vt_KTimerTask = { &KThread::OnTimeout, &KTimerTask::IsValidTimerTask };
KWorkerTask_vtbl KThread::vt_KWorkerTask = { &KThread::DoWorkerTask };
KInterruptTask_vtbl KThread::vt_KInterruptTask = { &KThread::OnInterrupt, &`non-virtual thunk to'KThread::DoTask };
KAutoObject_vtbl KCodeSet::vt =
{
  NULL,
  NULL,
  &KCodeSet::Destroy,
  &KCodeSet::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KCodeSet::GetTypeObj
};
KAutoObject_vtbl KSession::vt =
{
  NULL,
  NULL,
  &KSession::Destroy,
  &KSession::Finalize,
  &KAutoObject::DecrementReferenceCount,
  &KAutoObject::GetOwnerProcess,
  &KSession::GetTypeObj
};
_UNKNOWN unk_FFF2EFFF; // weak
KLightMutex g_dmaManagerLock = { NULL, 0, 0 };
KSystemControl g_systemControl =
{
  { false, false, false },
  true,
  false,
  6u,
  0u,
  0u,
  0u,
  { &PXI, (vu32 *)0xFFFC0004, (vu32 *)0xFFFC0008, (vu32 *)0xFFFC000C },
  &PDN_MPCORE_CLKCNT,
  &HID,
  SYSTEMOP_CONFIGURE_N3DS_CPU_L2C,
  1,
  0u,
  3993444352u,
  0u,
  0uLL,
  { NULL, 0, 0 },
  0uLL
};
bool g_scheduledOut[8] = { false, false, true, false, true, true, true, true }; // weak
u32 g_coreSynchronizationCount = 0u;
KLightMutex g_l2cLock = { NULL, 0, 0 };
u32 g_timerPrescaler = 0u;
u32 g_wdPrescaler = 0u;
KLightMutex g_eventSignalMutex = { NULL, 0, 0 };
KLightMutex g_objectNameListMutex = { NULL, 0, 0 };
u32 g_memoryManagementNonce = 2201152216u;
u32 g_pidCounter = 40u;
bool g_sysmoduleReslimitSet = false;
KCpuTimeLimitCategory g_schedulerCurrentlyAllowedCategoryForMode0 = KCPUTIMELIMIT_CATEGORY_SYSMODULE;
u32 g_schedulerAppPreemptionMode = 0u;
KCpuTimeLimit *g_cpuTimeLimitListHead = &unk_FFF93D6C;
KSchedulerLock g_schedulerLock = { NULL, 0 };
KThreadIntrusiveList g_schedulerPreemptedThreadList = { { NULL, NULL } };
u32 g_threadIdCounter = 223u;
KLightMutex g_timerOpsMutex = { NULL, 0, 0 };
KernelState g_kernelState = KSTATE_RUNNING;
KSynchronization g_synchronization = { 0u };
KernelSharedConfig *g_kernelSharedConfigPagePtr = &g_kernelSharedConfig; // weak
u32 g_userSharedConfigPagePtr = 3993309184u;
_UNKNOWN unk_FFF2F0E0; // weak
_UNKNOWN unk_FFF2F0E8; // weak
u32 g_perfCounterMgrExclusivePid = 4294967295u;
KFiqState g_fiqState = KFIQSTATE_UNBOUND;
int `guard variable for'KObjectContainer<KDmaObject>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KDmaObject>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KSemaphore>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KSemaphore>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KSharedMemory>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KSharedMemory>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KResourceLimit>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KResourceLimit>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KAddressArbiter>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KAddressArbiter>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KPort>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KPort>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KEvent>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KEvent>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KMutex>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KMutex>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KTimer>::KObjectContainer(void)::initialized = 0; // idb
int `guard variable for'KSlabHeap<KTimer>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KDebug>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KDebug>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KThread>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KThread>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KCodeSet>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KCodeSet>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KProcess>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KProcess>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KObjectContainer<KSession>::KObjectContainer(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KSession>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KBlockInfo>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KEventInfo>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KObjectName>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KMemoryBlock>::KSlabHeap(void)::initialized = 0; // weak
int `guard variable for'KSlabHeap<KThreadLocalPage>::KSlabHeap(void)::initialized = 0; // idb
int `guard variable for'KSlabHeap<KDebugThread>::KSlabHeap(void)::initialized = 0; // weak
KVfpRegisterDumpHelper g_vfpRegisterDumpHelper =
{
  {
    { { &KVfpRegisterDumpHelperImpl::vt }, NULL },
    { { &KVfpRegisterDumpHelperImpl::vt }, NULL },
    { { &KVfpRegisterDumpHelperImpl::vt }, NULL },
    { { &KVfpRegisterDumpHelperImpl::vt }, NULL }
  }
};
KSleepEntrySchedHelper g_sleepEntrySchedHelper =
{
  {
    { { { &KSleepEntrySchedHelperImpl::vt }, NULL } },
    { { { &KSleepEntrySchedHelperImpl::vt }, NULL } },
    { { { &KSleepEntrySchedHelperImpl::vt }, NULL } },
    { { { &KSleepEntrySchedHelperImpl::vt }, NULL } }
  }
};
KSleepExitSchedHelper g_sleepExitSchedHelper =
{
  {
    { { { &KSleepExitSchedHelperImpl::vt }, NULL } },
    { { { &KSleepExitSchedHelperImpl::vt }, NULL } },
    { { { &KSleepExitSchedHelperImpl::vt }, NULL } },
    { { { &KSleepExitSchedHelperImpl::vt }, NULL } }
  }
};
KThreadLinkedList g_debuggerThreadLinkedList =
{
  0u,
  { (KThreadLinkedListNode *)0xFFF2F1E4, (KThreadLinkedListNode *)0xFFF2F1E4 }
};
KCacheMaintenanceHelper g_cacheMaintenanceHelper =
{
  { &KCacheMaintenanceHelper::vt },
  KCACHEMAINTOP_CLEANINV_ENTIRE_DCACHE,
  true,
  2u,
  &unk_FFF80A90,
  0u,
  0u,
  { { NULL, NULL } },
  {
    { { { &KCacheMaintenanceHelperTask::vt }, NULL }, &unk_FFF7D180 },
    { { { &KCacheMaintenanceHelperTask::vt }, NULL }, &unk_FFF7D2E0 },
    { { { &KCacheMaintenanceHelperTask::vt }, NULL }, &unk_FFF7D230 },
    { { { &KCacheMaintenanceHelperTask::vt }, &unk_FFF701A4 }, &unk_FFF7D390 }
  }
};
KTlbMaintenanceHelper g_tlbMaintenanceHelper =
{
  { &unk_FFF7BB5C, &unk_FFF78D0C, &unk_FFF75C4C, &unk_FFF7834C },
  {
    { { &KTlbMaintenanceHelperImpl::vt }, NULL, 4282953728u, KTLBMAINTOP_NONE },
    { { &KTlbMaintenanceHelperImpl::vt }, NULL, 0u, KTLBMAINTOP_NONE },
    { { &KTlbMaintenanceHelperImpl::vt }, NULL, 4282953728u, KTLBMAINTOP_NONE },
    { { &KTlbMaintenanceHelperImpl::vt }, NULL, 4282953728u, KTLBMAINTOP_NONE }
  }
};
KAsidManager g_asidManager = { { 4294967295u, 511u, 0u, 0u, 0u, 0u, 0u, 0u }, { NULL, 0, 0 }, 41u };
KLevel2TranslationTableAllocator g_level2TtblAllocator =
{
  (KLevel2TranslationTable *)0xEE124800,
  &unk_EE041000,
  3992977408u,
  33554432u,
  { NULL, 0, 0 },
  2u
};
KPerformanceCounterControlHelper g_perfCounterControlHelper =
{
  { &KPerformanceCounterControlHelper::vt },
  { false, false, false, false },
  0u
};
KDmaChannel g_dmaChannels[8] =
{
  {
    { { &KDmaChannel::vt }, NULL },
    { &KDmaChannel::vt_WorkerTask, NULL },
    NULL,
    NULL,
    NULL,
    NULL,
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    {
      { '\0', '\0', 0, 0, 0, 0 },
      { '\0', '\0', 0, 0, 0, 0 },
      0u,
      0u,
      false,
      false,
      false,
      false,
      false,
      false,
      0u,
      '\0',
      NULL,
      NULL
    },
    { 0u, false, 0u, 0u, NULL },
    { 0u, false, 0u, 0u, NULL },
    NULL,
    0u,
    {
      0,
      NULL,
      NULL,
      NULL,
      { NULL, NULL },
      '\0',
      false,
      NULL,
      NULL,
      NULL,
      { 0u, 0u }
    },
    '\xFF',
    KDMACHANSTATE_STOPPED,
    false,
    false,
    false,
    {
      {
        NULL,
        NULL,
        NULL,
        NULL,
        0,
        0,
        0,
        KDMABLOCKTYPE_PROLOGUE,
        '\0',
        KDMADIRECTION_NONE,
        KDMADIRECTION_NONE,
        '\0',
        '\0',
        '\0',
        '\0',
        { 0, { 0, 0, 0 }, { 0, 0, 0 } },
        0
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      0
    },
    NULL,
    { NULL, 0, 0 }
  },
  {
    { { &KDmaChannel::vt }, NULL },
    { &KDmaChannel::vt_WorkerTask, NULL },
    (KDmaChannelEventHandler *)0xFFF3305C,
    &unk_FFF8C820,
    &unk_FFF79B90,
    &unk_FFF79B90,
    { 128, { 0, 0, 128 }, { 0, 0, 128 } },
    { 128, { 128, 0, 128 }, { 128, 0, 128 } },
    {
      { '\xFF', '\x0F', 128, 0, 128, 0 },
      { '\x04', '\x04', 64, 128, 64, 128 },
      794319040u,
      271720448u,
      false,
      true,
      false,
      true,
      true,
      true,
      0u,
      '\x01',
      (KDmaAddress *)0xFFF300AC,
      (KDmaAddress *)0xFFF300C0
    },
    { 794319040u, false, 268454080u, 268454080u, &unk_FFF79B90 },
    { 271720448u, true, 518135808u, 518135808u, &unk_FFF79B90 },
    (u8 *)0xFFF2F400,
    536794112u,
    {
      256,
      (u8 *)0xFFF2F400,
      (u8 *)0xFFF2F500,
      (u8 *)0xFFF2F42B,
      { (u8 *)0xFFF2F41C, NULL },
      '\0',
      false,
      (u8 *)0xFFF2F408,
      (u8 *)0xFFF2F400,
      (u8 *)0xFFF2F41C,
      { 0u, 0u }
    },
    '\x01',
    KDMACHANSTATE_STOPPED,
    false,
    false,
    true,
    {
      {
        &KDmaProgram::vt,
        (KDmaBlockBase *)0xFFF30440,
        (KDmaBlockBase *)0xFFF30220,
        (KDmaBlockBase *)0xFFF30480,
        128,
        0,
        0,
        KDMABLOCKTYPE_PROGRAM,
        '\x06',
        KDMADIRECTION_BOTH,
        KDMADIRECTION_NONE,
        '\0',
        '\0',
        '\x01',
        '\0',
        { 128, { 128, 0, 128 }, { 128, 0, 128 } },
        1
      },
      {
        {
          &KDmaDataUnitBlock::vt,
          NULL,
          NULL,
          NULL,
          64,
          0,
          0,
          KDMABLOCKTYPE_BODY,
          '\x01',
          KDMADIRECTION_BOTH,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 64, { 64, 0, 64 }, { 64, 0, 64 } },
          0
        },
        { '\x04', '\x10', '\x01', '\xFF' },
        { '\x04', '\x10', '\x01', '\xFF' },
        { '\x04', '\x10', '\x01', '\xFF' },
        { '\x04', '\x10', '\x01', '\xFF' }
      },
      {
        {
          &KDmaSmallerBurstBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF30150,
          NULL,
          64,
          0,
          0,
          KDMABLOCKTYPE_BODY,
          '\x02',
          KDMADIRECTION_SRC,
          KDMADIRECTION_NONE,
          '\0',
          '\x02',
          '\x01',
          '\0',
          { 64, { 64, 0, 64 }, { 64, 0, 64 } },
          1
        }
      },
      {
        {
          &KDmaLargerBurstBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF301A0,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_BODY,
          '\x03',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaSmallerTransferBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF301A0,
          NULL,
          128,
          0,
          0,
          KDMABLOCKTYPE_BODY,
          '\x04',
          KDMADIRECTION_SRC,
          KDMADIRECTION_SRC,
          '\x02',
          '\x02',
          '\x01',
          '\0',
          { 128, { 128, 0, 128 }, { 128, 0, 128 } },
          2
        }
      },
      {
        {
          &KDmaLargerTransferBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF30220,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_BODY,
          '\x05',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaDataUnitBlock::vt,
          NULL,
          NULL,
          NULL,
          64,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\x01',
          KDMADIRECTION_BOTH,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\x04', '\x10', '\x01', '\xFF' },
        { '\x04', '\x10', '\x01', '\xFF' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          &KDmaDataUnitBlock::vt,
          NULL,
          NULL,
          NULL,
          64,
          0,
          0,
          KDMABLOCKTYPE_EPILOGUE,
          '\x01',
          KDMADIRECTION_BOTH,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\x04', '\x10', '\x01', '\xFF' },
        { '\x04', '\x10', '\x01', '\xFF' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          &KDmaSmallerBurstBlock::vt,
          (KDmaBlockBase *)0xFFF302A0,
          (KDmaBlockBase *)0xFFF30150,
          NULL,
          64,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\x02',
          KDMADIRECTION_SRC,
          KDMADIRECTION_NONE,
          '\0',
          '\x02',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaSmallerBurstBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF30150,
          (KDmaBlockBase *)0xFFF302F0,
          64,
          0,
          0,
          KDMABLOCKTYPE_EPILOGUE,
          '\x02',
          KDMADIRECTION_SRC,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaLargerBurstBlock::vt,
          (KDmaBlockBase *)0xFFF30340,
          (KDmaBlockBase *)0xFFF301A0,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\x03',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaLargerBurstBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF301A0,
          (KDmaBlockBase *)0xFFF30380,
          0,
          0,
          0,
          KDMABLOCKTYPE_EPILOGUE,
          '\x03',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaSmallerTransferBlock::vt,
          (KDmaBlockBase *)0xFFF30340,
          (KDmaBlockBase *)0xFFF301A0,
          NULL,
          128,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\x04',
          KDMADIRECTION_SRC,
          KDMADIRECTION_NONE,
          '\x02',
          '\x02',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaSmallerTransferBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF301A0,
          (KDmaBlockBase *)0xFFF30380,
          128,
          0,
          0,
          KDMABLOCKTYPE_EPILOGUE,
          '\x04',
          KDMADIRECTION_SRC,
          KDMADIRECTION_SRC,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaLargerTransferBlock::vt,
          (KDmaBlockBase *)0xFFF30440,
          (KDmaBlockBase *)0xFFF30220,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\x05',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaLargerTransferBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF30220,
          (KDmaBlockBase *)0xFFF30480,
          0,
          0,
          0,
          KDMABLOCKTYPE_EPILOGUE,
          '\x05',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x01',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      128
    },
    (KDmaProgram *)0xFFF30110,
    { NULL, 0, 0 }
  },
  {
    { { &KDmaChannel::vt }, NULL },
    { &KDmaChannel::vt_WorkerTask, NULL },
    (KDmaChannelEventHandler *)0xFFF3305C,
    &unk_FFF8C808,
    &unk_FFF79B90,
    &unk_FFF79B90,
    { 128, { 0, 0, 128 }, { 0, 0, 128 } },
    { 128, { 128, 0, 128 }, { 128, 0, 128 } },
    {
      { '\x04', '\x04', 64, 128, 64, 128 },
      { '\xFF', '\x0F', 128, 0, 128, 0 },
      271720448u,
      794316960u,
      true,
      false,
      true,
      false,
      true,
      true,
      0u,
      '\x02',
      (KDmaAddress *)0xFFF305D4,
      (KDmaAddress *)0xFFF305E8
    },
    { 271720448u, true, 518135808u, 518135808u, &unk_FFF79B90 },
    { 794316960u, false, 268452000u, 268452000u, &unk_FFF79B90 },
    (u8 *)0xFFF2F500,
    536794368u,
    {
      256,
      (u8 *)0xFFF2F500,
      (u8 *)0xFFF2F600,
      (u8 *)0xFFF2F52B,
      { (u8 *)0xFFF2F51C, NULL },
      '\0',
      false,
      (u8 *)0xFFF2F508,
      (u8 *)0xFFF2F500,
      (u8 *)0xFFF2F51C,
      { 0u, 0u }
    },
    '\x02',
    KDMACHANSTATE_STOPPED,
    false,
    false,
    true,
    {
      {
        &KDmaProgram::vt,
        (KDmaBlockBase *)0xFFF30968,
        (KDmaBlockBase *)0xFFF30748,
        (KDmaBlockBase *)0xFFF309A8,
        128,
        0,
        0,
        KDMABLOCKTYPE_PROGRAM,
        '\x06',
        KDMADIRECTION_BOTH,
        KDMADIRECTION_NONE,
        '\0',
        '\0',
        '\x02',
        '\0',
        { 128, { 128, 0, 128 }, { 128, 0, 128 } },
        1
      },
      {
        {
          &KDmaDataUnitBlock::vt,
          NULL,
          NULL,
          NULL,
          64,
          0,
          0,
          KDMABLOCKTYPE_BODY,
          '\x01',
          KDMADIRECTION_BOTH,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 64, { 64, 0, 64 }, { 64, 0, 64 } },
          0
        },
        { '\x04', '\x10', '\x01', '\0' },
        { '\x04', '\x10', '\x01', '\0' },
        { '\x04', '\x10', '\x01', '\0' },
        { '\x04', '\x10', '\x01', '\0' }
      },
      {
        {
          &KDmaSmallerBurstBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF30678,
          NULL,
          64,
          0,
          0,
          KDMABLOCKTYPE_BODY,
          '\x02',
          KDMADIRECTION_DST,
          KDMADIRECTION_NONE,
          '\0',
          '\x01',
          '\x02',
          '\0',
          { 64, { 64, 0, 64 }, { 64, 0, 64 } },
          1
        }
      },
      {
        {
          &KDmaLargerBurstBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF306C8,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_BODY,
          '\x03',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaSmallerTransferBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF306C8,
          NULL,
          128,
          0,
          0,
          KDMABLOCKTYPE_BODY,
          '\x04',
          KDMADIRECTION_DST,
          KDMADIRECTION_DST,
          '\x01',
          '\x01',
          '\x02',
          '\0',
          { 128, { 128, 0, 128 }, { 128, 0, 128 } },
          2
        }
      },
      {
        {
          &KDmaLargerTransferBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF30748,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_BODY,
          '\x05',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaDataUnitBlock::vt,
          NULL,
          NULL,
          NULL,
          64,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\x01',
          KDMADIRECTION_BOTH,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\x04', '\x10', '\x01', '\0' },
        { '\x04', '\x10', '\x01', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          &KDmaDataUnitBlock::vt,
          NULL,
          NULL,
          NULL,
          64,
          0,
          0,
          KDMABLOCKTYPE_EPILOGUE,
          '\x01',
          KDMADIRECTION_BOTH,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\x04', '\x10', '\x01', '\0' },
        { '\x04', '\x10', '\x01', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          &KDmaSmallerBurstBlock::vt,
          (KDmaBlockBase *)0xFFF307C8,
          (KDmaBlockBase *)0xFFF30678,
          NULL,
          64,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\x02',
          KDMADIRECTION_DST,
          KDMADIRECTION_NONE,
          '\0',
          '\x01',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaSmallerBurstBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF30678,
          (KDmaBlockBase *)0xFFF30818,
          64,
          0,
          0,
          KDMABLOCKTYPE_EPILOGUE,
          '\x02',
          KDMADIRECTION_DST,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaLargerBurstBlock::vt,
          (KDmaBlockBase *)0xFFF30868,
          (KDmaBlockBase *)0xFFF306C8,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\x03',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaLargerBurstBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF306C8,
          (KDmaBlockBase *)0xFFF308A8,
          0,
          0,
          0,
          KDMABLOCKTYPE_EPILOGUE,
          '\x03',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaSmallerTransferBlock::vt,
          (KDmaBlockBase *)0xFFF30868,
          (KDmaBlockBase *)0xFFF306C8,
          NULL,
          128,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\x04',
          KDMADIRECTION_DST,
          KDMADIRECTION_NONE,
          '\x01',
          '\x01',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaSmallerTransferBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF306C8,
          (KDmaBlockBase *)0xFFF308A8,
          128,
          0,
          0,
          KDMABLOCKTYPE_EPILOGUE,
          '\x04',
          KDMADIRECTION_DST,
          KDMADIRECTION_DST,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaLargerTransferBlock::vt,
          (KDmaBlockBase *)0xFFF30968,
          (KDmaBlockBase *)0xFFF30748,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\x05',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          &KDmaLargerTransferBlock::vt,
          NULL,
          (KDmaBlockBase *)0xFFF30748,
          (KDmaBlockBase *)0xFFF309A8,
          0,
          0,
          0,
          KDMABLOCKTYPE_EPILOGUE,
          '\x05',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\x02',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      128
    },
    (KDmaProgram *)0xFFF30638,
    { NULL, 0, 0 }
  },
  {
    { { &KDmaChannel::vt }, NULL },
    { &KDmaChannel::vt_WorkerTask, NULL },
    NULL,
    NULL,
    NULL,
    NULL,
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    {
      { '\0', '\0', 0, 0, 0, 0 },
      { '\0', '\0', 0, 0, 0, 0 },
      0u,
      0u,
      false,
      false,
      false,
      false,
      false,
      false,
      0u,
      '\0',
      NULL,
      NULL
    },
    { 0u, false, 0u, 0u, NULL },
    { 0u, false, 0u, 0u, NULL },
    NULL,
    0u,
    {
      0,
      NULL,
      NULL,
      NULL,
      { NULL, NULL },
      '\0',
      false,
      NULL,
      NULL,
      NULL,
      { 0u, 0u }
    },
    '\xFF',
    KDMACHANSTATE_STOPPED,
    false,
    false,
    false,
    {
      {
        NULL,
        NULL,
        NULL,
        NULL,
        0,
        0,
        0,
        KDMABLOCKTYPE_PROLOGUE,
        '\0',
        KDMADIRECTION_NONE,
        KDMADIRECTION_NONE,
        '\0',
        '\0',
        '\0',
        '\0',
        { 0, { 0, 0, 0 }, { 0, 0, 0 } },
        0
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      0
    },
    NULL,
    { NULL, 0, 0 }
  },
  {
    { { &KDmaChannel::vt }, NULL },
    { &KDmaChannel::vt_WorkerTask, NULL },
    NULL,
    NULL,
    NULL,
    NULL,
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    {
      { '\0', '\0', 0, 0, 0, 0 },
      { '\0', '\0', 0, 0, 0, 0 },
      0u,
      0u,
      false,
      false,
      false,
      false,
      false,
      false,
      0u,
      '\0',
      NULL,
      NULL
    },
    { 0u, false, 0u, 0u, NULL },
    { 0u, false, 0u, 0u, NULL },
    NULL,
    0u,
    {
      0,
      NULL,
      NULL,
      NULL,
      { NULL, NULL },
      '\0',
      false,
      NULL,
      NULL,
      NULL,
      { 0u, 0u }
    },
    '\xFF',
    KDMACHANSTATE_STOPPED,
    false,
    false,
    false,
    {
      {
        NULL,
        NULL,
        NULL,
        NULL,
        0,
        0,
        0,
        KDMABLOCKTYPE_PROLOGUE,
        '\0',
        KDMADIRECTION_NONE,
        KDMADIRECTION_NONE,
        '\0',
        '\0',
        '\0',
        '\0',
        { 0, { 0, 0, 0 }, { 0, 0, 0 } },
        0
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      0
    },
    NULL,
    { NULL, 0, 0 }
  },
  {
    { { &KDmaChannel::vt }, NULL },
    { &KDmaChannel::vt_WorkerTask, NULL },
    NULL,
    NULL,
    NULL,
    NULL,
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    {
      { '\0', '\0', 0, 0, 0, 0 },
      { '\0', '\0', 0, 0, 0, 0 },
      0u,
      0u,
      false,
      false,
      false,
      false,
      false,
      false,
      0u,
      '\0',
      NULL,
      NULL
    },
    { 0u, false, 0u, 0u, NULL },
    { 0u, false, 0u, 0u, NULL },
    NULL,
    0u,
    {
      0,
      NULL,
      NULL,
      NULL,
      { NULL, NULL },
      '\0',
      false,
      NULL,
      NULL,
      NULL,
      { 0u, 0u }
    },
    '\xFF',
    KDMACHANSTATE_STOPPED,
    false,
    false,
    false,
    {
      {
        NULL,
        NULL,
        NULL,
        NULL,
        0,
        0,
        0,
        KDMABLOCKTYPE_PROLOGUE,
        '\0',
        KDMADIRECTION_NONE,
        KDMADIRECTION_NONE,
        '\0',
        '\0',
        '\0',
        '\0',
        { 0, { 0, 0, 0 }, { 0, 0, 0 } },
        0
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      0
    },
    NULL,
    { NULL, 0, 0 }
  },
  {
    { { &KDmaChannel::vt }, NULL },
    { &KDmaChannel::vt_WorkerTask, NULL },
    NULL,
    NULL,
    NULL,
    NULL,
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    {
      { '\0', '\0', 0, 0, 0, 0 },
      { '\0', '\0', 0, 0, 0, 0 },
      0u,
      0u,
      false,
      false,
      false,
      false,
      false,
      false,
      0u,
      '\0',
      NULL,
      NULL
    },
    { 0u, false, 0u, 0u, NULL },
    { 0u, false, 0u, 0u, NULL },
    NULL,
    0u,
    {
      0,
      NULL,
      NULL,
      NULL,
      { NULL, NULL },
      '\0',
      false,
      NULL,
      NULL,
      NULL,
      { 0u, 0u }
    },
    '\xFF',
    KDMACHANSTATE_STOPPED,
    false,
    false,
    false,
    {
      {
        NULL,
        NULL,
        NULL,
        NULL,
        0,
        0,
        0,
        KDMABLOCKTYPE_PROLOGUE,
        '\0',
        KDMADIRECTION_NONE,
        KDMADIRECTION_NONE,
        '\0',
        '\0',
        '\0',
        '\0',
        { 0, { 0, 0, 0 }, { 0, 0, 0 } },
        0
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      0
    },
    NULL,
    { NULL, 0, 0 }
  },
  {
    { { &KDmaChannel::vt }, NULL },
    { &KDmaChannel::vt_WorkerTask, NULL },
    NULL,
    NULL,
    NULL,
    NULL,
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    { 0, { 0, 0, 0 }, { 0, 0, 0 } },
    {
      { '\0', '\0', 0, 0, 0, 0 },
      { '\0', '\0', 0, 0, 0, 0 },
      0u,
      0u,
      false,
      false,
      false,
      false,
      false,
      false,
      0u,
      '\0',
      NULL,
      NULL
    },
    { 0u, false, 0u, 0u, NULL },
    { 0u, false, 0u, 0u, NULL },
    NULL,
    0u,
    {
      0,
      NULL,
      NULL,
      NULL,
      { NULL, NULL },
      '\0',
      false,
      NULL,
      NULL,
      NULL,
      { 0u, 0u }
    },
    '\xFF',
    KDMACHANSTATE_STOPPED,
    false,
    false,
    false,
    {
      {
        NULL,
        NULL,
        NULL,
        NULL,
        0,
        0,
        0,
        KDMABLOCKTYPE_PROLOGUE,
        '\0',
        KDMADIRECTION_NONE,
        KDMADIRECTION_NONE,
        '\0',
        '\0',
        '\0',
        '\0',
        { 0, { 0, 0, 0 }, { 0, 0, 0 } },
        0
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' },
        { '\0', '\0', '\0', '\0' }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      {
        {
          NULL,
          NULL,
          NULL,
          NULL,
          0,
          0,
          0,
          KDMABLOCKTYPE_PROLOGUE,
          '\0',
          KDMADIRECTION_NONE,
          KDMADIRECTION_NONE,
          '\0',
          '\0',
          '\0',
          '\0',
          { 0, { 0, 0, 0 }, { 0, 0, 0 } },
          0
        }
      },
      0
    },
    NULL,
    { NULL, 0, 0 }
  }
};
KDmaConfig *g_dmaConfigs[8] =
{
  NULL,
  (KDmaConfig *)0xFFF30080,
  (KDmaConfig *)0xFFF305A8,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL
};
KSlabHeap g_linkedListNodeSlabHeap = { &unk_FFF9967C, &unk_FFF95458, 51280u, 12u };
KObjectNameLinkedList g_objectNameList = { 2u, { &unk_FFF95A64, &unk_FFF97684 } };
bool g_isThreadLocalPageVaFree[126] =
{
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  true,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  false,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true,
  true
};
KCpuTimeLimiterMode0 g_cpuTimeLimiterMode0 =
{
  {
    { &KCpuTimeLimiterMode0::vt, NULL, 0LL },
    (KScheduler *)0xFFFDA0C8,
    0u,
    false
  },
  1LL,
  0u,
  0u,
  0u,
  0u
};
KCpuTimeLimiterMode1 g_cpuTimeLimiterMode1 =
{
  {
    { &KCpuTimeLimiterMode1::vt, NULL, 0LL },
    (KScheduler *)0xFFFDA0C8,
    0u,
    false
  },
  1LL
};
KPxiBufferManager g_pxiBufferManager =
{
  {
    { &unk_FFF7DB20, 134422528u, 300u },
    { NULL, 134259968u, 256u },
    { NULL, 135065600u, 32u },
    { NULL, 134537216u, 72u },
    { NULL, 67125120u, 24u },
    { NULL, 67125064u, 24u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u },
    { NULL, 0u, 0u }
  },
  { NULL, 0, 0 }
};
KSupervisorPageTable g_supervisorPageTable =
{
  {
    { NULL, 0, 0 },
    { 0, 0, 0, 0 },
    { { 335u, { &unk_FFF955F0, &unk_FFF9C2A4 } } },
    0u,
    0u,
    0u,
    0u,
    true,
    false,
    1073741824u,
    4294963200u,
    0u,
    0u,
    12288u,
    (u32 *)0xFFFF2000
  }
};
KMemoryManager g_memoryManager =
{
  {
    { (KPageHeapBlock *)0xE3000000, (KPageHeapBlock *)0xE3000000 },
    3758096384u,
    130023424u,
    { 138367042u, 2224196488u, 1130866005u, 2214765377u }
  },
  {
    { (KPageHeapBlock *)0xE8C52000, (KPageHeapBlock *)0xE8C52000 },
    3888119808u,
    104857600u,
    { 732773267u, 2641404568u, 63272552u, 3895632972u }
  },
  {
    { (KPageHeapBlock *)0xEE125000, (KPageHeapBlock *)0xEF64B000 },
    3992977408u,
    33554432u,
    { 4074765376u, 815189423u, 263563535u, 1438498989u }
  },
  {
    &g_memoryManager,
    3758096384u,
    65536u,
    (u32 *)0xEE000000,
    745472u,
    0u,
    { NULL, 0, 0 }
  }
};
KInterruptManager g_interruptManager =
{
  {
    {
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { &g_perfCounterControlHelper, false, false, 0u },
      { &g_terminationHelper, false, false, 0u },
      { &g_systemControlHelper, false, false, 0u },
      { &g_cacheMaintenanceHelper, false, false, 0u },
      { (KInterruptHandler *)0xFFFD10C8, false, false, 0u },
      { &g_vfpRegisterDumpHelper, false, false, 0u },
      { (KInterruptHandler *)0xFFF2F248, false, false, 0u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u }
    },
    {
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { &g_perfCounterControlHelper, false, false, 0u },
      { &g_terminationHelper, false, false, 0u },
      { &g_systemControlHelper, false, false, 0u },
      { &g_cacheMaintenanceHelper, false, false, 0u },
      { (KInterruptHandler *)0xFFFDA0C8, false, false, 0u },
      { (KInterruptHandler *)0xFFF2F188, false, false, 0u },
      { (KInterruptHandler *)0xFFF2F258, false, false, 0u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { &g_hardwareTimer, true, false, 0u },
      { &g_hardwareTimer, false, false, 0u },
      { NULL, false, false, 15u }
    },
    {
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { &g_perfCounterControlHelper, false, false, 0u },
      { &g_terminationHelper, false, false, 0u },
      { &g_systemControlHelper, false, false, 0u },
      { &g_cacheMaintenanceHelper, false, false, 0u },
      { (KInterruptHandler *)0xFFFE30C8, false, false, 0u },
      { (KInterruptHandler *)0xFFF2F190, false, false, 0u },
      { (KInterruptHandler *)0xFFF2F268, false, false, 0u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u }
    },
    {
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { &g_perfCounterControlHelper, false, false, 0u },
      { &g_terminationHelper, false, false, 0u },
      { &g_systemControlHelper, false, false, 0u },
      { &g_cacheMaintenanceHelper, false, false, 0u },
      { (KInterruptHandler *)0xFFFEC0C8, false, false, 0u },
      { (KInterruptHandler *)0xFFF2F198, false, false, 0u },
      { (KInterruptHandler *)0xFFF2F278, false, false, 0u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u },
      { NULL, false, false, 15u }
    }
  },
  {
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { &unk_FFF70744, true, false, 0u },
    { &unk_FFF7076C, true, false, 0u },
    { &unk_FFF70794, true, false, 0u },
    { &unk_FFF707BC, true, false, 0u },
    { &unk_FFF707E4, true, false, 0u },
    { &unk_FFF7080C, true, true, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { &g_dmaManager, false, false, 0u },
    { &g_dmaManager, true, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { &unk_FFF70B2C, true, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { &unk_FFF7062C, true, false, 0u },
    { &unk_FFF70654, true, false, 0u },
    { &unk_FFF7049C, true, false, 0u },
    { &unk_FFF709C4, true, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { &unk_FFF70064, true, false, 0u },
    { NULL, false, false, 0u },
    { NULL, true, false, 0u },
    { NULL, true, false, 0u },
    { &unk_FFF701A4, true, false, 0u },
    { &unk_FFF701CC, true, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { &unk_FFF70A3C, true, false, 0u },
    { NULL, false, false, 0u },
    { &unk_FFF701F4, true, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { &unk_FFF70474, true, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, true, false, 0u },
    { &unk_FFF70A8C, true, false, 0u },
    { &unk_FFF7044C, true, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { &unk_FFF7008C, true, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u },
    { NULL, false, false, 0u }
  },
  { NULL, 0, 0 }
};
KHardwareTimer g_hardwareTimer =
{
  { { &KHardwareTimer::vt }, &unk_FFF7080C },
  3u,
  3u,
  { &KDummyTimerTask::vt, &unk_FFF74FD8, 0LL },
  { NULL, 0 }
};
KDmaManager g_dmaManager =
{
  { { &KDmaManager::vt }, &unk_FFF70B2C },
  { &KDmaManager::vt_KDmaChannelEventHandler },
  { false, true, true, false, false, false, false, false },
  { false, false, false, false, false, false, false, false }
};
KPerformanceCounterManager g_perfCounterMgr =
{
  { &KPerformanceCounterManager::vt },
  { { 0u, 0u, 0u }, { 0u, 0u, 0u }, { 0u, 0u, 0u }, { 0u, 0u, 0u } },
  { 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u },
  false
};
KWorkerTaskManager g_workerTaskManager[2] =
{
  { KWORKERTYPE_HIGH_PRIO, NULL, NULL, false, &unk_FFF7D440 },
  { KWORKERTYPE_LOW_PRIO, NULL, NULL, false, &unk_FFF7D4F0 }
};
KFiqHelper g_fiqHelper = { { { &KFiqHelper::vt }, NULL }, NULL, false, false };
KObjectAllocator g_dmaObjectAllocator =
{
  { { 2u, { &unk_FFF9CB5C, &unk_FFF9BBCC } }, { NULL, 0, 0 } },
  2,
  { &unk_FFF8C838, &unk_FFF8C808, 384u, 24u }
};
KObjectAllocator g_semaphoreAllocator =
{
  { { 47u, { &unk_FFF95A4C, &unk_FFF9C400 } }, { NULL, 0, 0 } },
  47,
  { &unk_FFF747EC, &unk_FFF73FD8, 3656u, 44u }
};
KObjectAllocator g_sharedMemoryAllocator =
{
  { { 11u, { &unk_FFF9724C, &unk_FFF9B908 } }, { NULL, 0, 0 } },
  12,
  { &unk_FFF8CB40, &unk_FFF8C988, 2520u, 40u }
};
KObjectAllocator g_resourceLimitAllocator =
{
  { { 4u, { &unk_FFF95C68, &unk_FFF95C8C } }, { NULL, 0, 0 } },
  4,
  { &unk_FFF93D80, &unk_FFF93BB0, 584u, 116u }
};
KObjectAllocator g_addressArbiterAllocator =
{
  { { 40u, { &unk_FFF959F8, &unk_FFF9CB50 } }, { NULL, 0, 0 } },
  40,
  { &unk_FFF94118, &unk_FFF93DF8, 1024u, 20u }
};
KObjectAllocator g_portAllocator =
{
  { { 136u, { &unk_FFF95A58, &unk_FFF9C6A0 } }, { NULL, 0, 0 } },
  136,
  { &unk_FFF8C340, &unk_FFF89D00, 11016u, 72u }
};
KObjectAllocator g_eventAllocator =
{
  { { 157u, { &unk_FFF95AAC, &unk_FFF97B1C } }, { NULL, 0, 0 } },
  159,
  { &unk_FFF71860, &_slabheaps_start, 12600u, 40u }
};
KObjectAllocator g_mutexAllocator =
{
  { { 15u, { &unk_FFF95AB8, &unk_FFF9A030 } }, { NULL, 0, 0 } },
  15,
  { &unk_FFF733CC, &unk_FFF73138, 3744u, 44u }
};
KObjectAllocator g_timerAllocator =
{
  { { 15u, { &unk_FFF96D90, &unk_FFF9946C } }, { NULL, 0, 0 } },
  15,
  { &unk_FFF751A4, &unk_FFF74E20, 3600u, 60u }
};
KObjectAllocator g_debugAllocator =
{
  {
    {
      0u,
      {
        (KAutoObjectLinkedListNode *)0xFFF3328C,
        (KAutoObjectLinkedListNode *)0xFFF3328C
      }
    },
    { NULL, 0, 0 }
  },
  0,
  { &unk_FFF8D360, &unk_FFF8D360, 480u, 160u }
};
KObjectAllocator g_threadAllocator =
{
  { { 189u, { &unk_FFF95464, &unk_FFF9BAB8 } }, { NULL, 0, 0 } },
  192,
  { &unk_FFF84870, &unk_FFF7CEC0, 52800u, 176u }
};
KObjectAllocator g_codeSetAllocator =
{
  { { 40u, { &unk_FFF95530, &unk_FFF99AF0 } }, { NULL, 0, 0 } },
  40,
  { &unk_FFF95198, &unk_FFF941F8, 4704u, 100u }
};
KObjectAllocator g_processAllocator =
{
  { { 40u, { &unk_FFF955C0, &unk_FFF9C0AC } }, { NULL, 0, 0 } },
  40,
  { &unk_FFF7BDB0, &unk_FFF75C30, 29328u, 624u }
};
KObjectAllocator g_sessionAllocator =
{
  { { 181u, { &unk_FFF95AA0, &unk_FFF9CC1C } }, { NULL, 0, 0 } },
  197,
  { &unk_FFF90B94, &unk_FFF8D540, 26224u, 76u }
};
KSlabHeap g_blockInfoSlabHeap = { &unk_FFFA21D8, &unk_FFFA1CA8, 4808u, 8u };
KSlabHeap g_eventInfoSlabHeap = { &unk_FFFAC868, &unk_FFFAC868, 3752u, 56u };
KSlabHeap g_objectNameSlabHeap = { &unk_FFFABC30, &unk_FFFABC10, 112u, 16u };
KSlabHeap g_memoryBlockSlabHeap = { &unk_FFFA59DC, &unk_FFFA2F70, 34464u, 20u };
KSlabHeap g_threadLocalPageSlabHeap = { &unk_FFFAB850, &unk_FFFAB610, 1536u, 24u };
KSlabHeap g_debugThreadSlabHeap = { &unk_FFFABC80, &unk_FFFABC80, 3048u, 24u };
_UNKNOWN _slabheaps_start; // weak
volatile CoreLinkL2C310 L2C;
volatile I2cRegisters I2C2;
vu32 GX_VRAM_BANKS_DISABLE;
vu16 PDN_CNT;
vu32 PDN_GPU_CNT;
vu16 PDN_FCRAM_CNT;
volatile PxiRegisters PXI;
volatile HidRegisters HID;
volatile LcdAblRegisters LCD_ABL_TOP;
volatile LcdAblRegisters LCD_ABL_BOT;
volatile Config11Registers CONFIG11;
volatile CoreLinkDma330 CDMA;
KCoreLocalPseudoRegion g_coreLocalRegions[4];
volatile Mp11PrivateMemRegion MPCORE;
KCoreLocalPseudoRegion current;
_UNKNOWN KernStackL2Tables; // weak


//----- (1FFAF000) --------------------------------------------------------
void crt0::Cpu0GetInitSpValues()
{
  ;
}

//----- (1FFAF01C) --------------------------------------------------------
void crt0::Cpu1GetInitSpValues()
{
  ;
}

//----- (1FFAF034) --------------------------------------------------------
void crt0::Cpu2GetInitSpValues()
{
  ;
}

//----- (1FFAF04C) --------------------------------------------------------
void crt0::Cpu3GetInitSpValues()
{
  ;
}

//----- (1FFAF064) --------------------------------------------------------
void __noreturn _start(void)
{
  s32 coreId; // r4

  __asm { CPSID           AIF }
  j_crt0::SetArm11ControlRegs();
  coreId = __mrc(15, 0, 0, 0, 5) & 3;
  crt0::stackSelectors[coreId]();
  __asm
  {
    CPS             #0x1F
    CPS             #0x12
    MSR             SPSR_cxsf, #0
    CPS             #0x11
    MSR             SPSR_cxsf, #0
    CPS             #0x17
    MSR             SPSR_cxsf, #0
    CPS             #0x1B
    MSR             SPSR_cxsf, #0
    CPS             #0x13
    MSR             SPSR_cxsf, #0
  }
  crt0::InitCpu(coreId);
  __asm { CPS             #0x13 }
  crt0::CoreSync(coreId);
  HorizonKernelMain();
}
// 1FFAF148: using guessed type int (*crt0::stackSelectors[4])();

//----- (1FFAF168) --------------------------------------------------------
void __fastcall crt0::CoreSync(s32 coreId)
{
  _DWORD *v2; // r6
  int v3; // r0
  char cfgr; // r1
  char v5; // r0
  int numInterruptLines; // r0
  int v7; // r1
  int v8; // r4
  u32 *v9; // r4
  u32 v10; // r0
  BOOL has4Cores; // r11
  unsigned int i; // r0
  unsigned int v13; // r4
  u8 bootenv; // r0
  __int16 *j; // r0
  __int16 v16; // t1
  int *v17; // r0
  int v18; // t1
  int v19; // r0
  int v20; // r1
  int v21; // r2
  int v22; // r0

  crt0::SetVfpAccessibleToUser();
  __mcr(14, 0, __mrc(14, 0, 0, 1, 0) | 0x1000, 0, 1, 0);// DSCR |= User mode access to comms channel disabled.
  __mcr(14, 7, __mrc(14, 7, 1, 0, 0) & ~3u | 1, 1, 0, 0);// 
                                                // according to DDI01001, this is the
                                                // Jazelle OS Control register. Disable Jazelle.
  v2 = (_DWORD *)((unsigned int)&MPCORE.gicd & 0xFFFFE000);
  MPCORE.gicd.icpendr[0] = 0xFFFFFFFF;
  *(_DWORD *)(((unsigned int)&MPCORE.gicd & 0xFFFFE000) + 0x100) = 1;// activate gicc interface
  if ( coreId )
  {
    *(_DWORD *)(((unsigned int)&MPCORE.gicd & 0xFFFFE000) + 0x1F00) = coreId | 0x10000;// send SGI <coreId> to core0
    do
    {
      __wfi();
      v3 = v2[67];
      v2[68] = v3;
    }
    while ( v3 != (((unsigned __int8)(coreId - 1) << 10) | 4) );// wait for previous core to have booted up
    cfgr = MPCORE.scu.cfgr;
    if ( (cfgr & 3) + 1 > coreId + 1 )          // if there's another core
      *(_DWORD *)(((unsigned int)&MPCORE.gicd & 0xFFFFE000) + 0x1F00) = (1 << (coreId + 1) << 16) | 4;// send SGI 4
                                                // 
                                                // this isn't reached before all cores except 0 have executed the previous section
  }
  else
  {
    numInterruptLines = (MPCORE.gicd.typer & 0x1F) + 1;
    if ( numInterruptLines > 0 )
    {
      v7 = numInterruptLines & 1;
      if ( v7 == 1 )
        MPCORE.gicd.icenabler[0] = 0xFFFFFFFF;
    }
    else
    {
      v7 = 0;
    }
    for ( ; v7 < numInterruptLines; v9[0x61] = 0xFFFFFFFF )// icenabler
    {
      v8 = v7;
      v7 += 2;
      v9 = &MPCORE.gicd.ctlr + v8;
      v9[96] = 0xFFFFFFFF;
    }
    MPCORE.gicd.ctlr = 1;
    v10 = MPCORE.scu.cfgr;
    has4Cores = (~v10 & 3) == 0;
    MPCORE.gicd.sgir = 0x20001;                 // send SGI1 to core1 to wake it up
    if ( (~v10 & 3) == 0 )                      // four cpus
    {
      MPCORE.gicd.sgir = 0x40002;               // send SGI2 to core2 to wake it up
      MPCORE.gicd.sgir = 0x80003;               // send SGI3 to core3 to wake it up
    }
    for ( i = 0; 0x4230u >> 2 > i; ++i )        // bss clear
      (&g_vfpRegisterDumpHelper.impls[0].__vftable)[i] = 0;
    _libc_init_array();
    CONFIG11.gpuprot = 0x550;
    v13 = 0x1FFA0000;
    bootenv = crt0::FetchArm9Info()[2];         // copy deliver (firmlaunch) args to 0x1FFA1000
    if ( (bootenv & 1) != 0 )
    {
      if ( (bootenv & 6) != 0 )
      {
        for ( j = (__int16 *)0xE0000000; (unsigned int)j < 0xE0001000; j += 4 )
        {                                       // We were in legacy mode. Copy 2 bytes with a stride of 8.
          v16 = *j;
          *(_WORD *)v13 = v16;
          v13 += 2;
        }
        for ( ; v13 < 0x1FFA1000; v13 += 4 )
          *(_DWORD *)v13 = 0;
      }
      else
      {
        v17 = (int *)0xE0000000;                // Non-legacy, normal FCRAM layout
        do
        {
          v18 = *v17++;
          *(_DWORD *)v13 = v18;
          v13 += 4;
        }
        while ( v13 < 0x1FFA1000 );
      }
    }
    else
    {
      do
      {
        *(_DWORD *)v13 = 0;
        v13 += 4;
      }
      while ( v13 < 0x1FFA1000 );
    }
    if ( has4Cores )
    {
      v19 = 0;
      do
      {
        __wfi();
        v20 = v2[67];
        v21 = (unsigned __int16)(v20 & 0x1C00) >> 10;
        v2[68] = v20;
        if ( (v20 & 0x3FF) == v21 )
          v19 |= 1 << v21;
      }
      while ( (~v19 & 0xE) != 0 );              // wait for all other cores to have booted up
    }
    else
    {
      do
      {
        __wfi();
        v22 = v2[67];
        v2[68] = v22;
      }
      while ( v22 != 0x401 );
    }
    MPCORE.gicd.sgir = 0x20004;                 // unblock core1, in turn unblocking core2 then core3
  }
  v2[64] = 0;                                   // disable gicc again
  v5 = MPCORE.scu.cfgr;
  if ( (v5 & 3) == coreId )                     // last core (core3 or core1) executes this section
  {
    MPCORE.gicd.ctlr = 0;
    LOBYTE(CONFIG11.cdma_cnt) = 0x10;           // mic, bit0: disabled
                                                // ntrcard, bit1: disabled
                                                // cam0/1, bits2-3: disabled
                                                // wifi, bit4: enabled (new in 11.4)
                                                // sdio3? (sd card), bit5: disabled
  }
}

//----- (1FFAF44C) --------------------------------------------------------
void crt0::SetVfpAccessibleToUser(void)
{
  __mcr(15, 0, 0xF00000u, 1, 0, 2);
  __mcr(15, 0, 0xF00000u, 7, 5, 4);
  _R0 = 0;
  __asm { VMSR            FPEXC, R0 }
}

//----- (1FFAF464) --------------------------------------------------------
void __fastcall crt0::WaitCycles(u32 numCycles)
{
  bool v1; // cc

  do
  {
    v1 = (int)numCycles <= 2;
    numCycles -= 2;
  }
  while ( !v1 );
}

//----- (1FFAF474) --------------------------------------------------------
void crt0::SetArm11ControlRegs(void)
{
  __mcr(15, 0, 0x54078u, 1, 0, 0);
  __mcr(15, 0, 0xFu, 1, 0, 1);
  __mcr(15, 0, 0, 7, 5, 4);
  __mcr(15, 0, 0, 7, 5, 0);
  __mcr(15, 0, 0, 7, 6, 0);
  __mcr(15, 0, 0, 7, 10, 4);
}

//----- (1FFAF4A0) --------------------------------------------------------
void __noreturn crt0::Core23Ep(void)
{
  int v4; // r4
  u32 iar; // r0

  __asm { CPSID           AIF }
  __mcr(15, 0, __mrc(15, 0, 15, 12, 0) | 0xFFFF00D, 15, 12, 0);// enable,
                                                // no count reg reset on write,
                                                // cycle counter reset on write,
                                                // Cycle Counter Register counts every 64th processor clock
                                                //  cycle, evtcount0 = evtcount1 = 0xff (unpredictable)
  PA_MPCORE.gicc.ctlr = 1;
  v4 = __mrc(15, 0, 0, 0, 5) & 3;
  if ( v4 == 3 )
    PA_PDN.lgr_cpu_cnt[3] = 1;                  // clear bit 1
  else
    PA_PDN.lgr_cpu_cnt[2] = 1;
  do
  {
    __wfi();
    iar = PA_MPCORE.gicc.iar;
    PA_MPCORE.gicc.eoir = iar;
  }
  while ( iar != v4 );
  _start();
}

//----- (1FFAF528) --------------------------------------------------------
void __fastcall DoFcramTrainingUnused(u32 *testPatternLocation, u32 initialNumIterations, u32 numIterationsIncrement)
{
  u32 v3; // r6

  *testPatternLocation = 0x1F3D5B79;            // unused function?
  testPatternLocation[1] = 1;
  testPatternLocation[2] = 2;
  testPatternLocation[3] = 3;
  testPatternLocation[4] = 4;
  testPatternLocation[5] = 5;
  testPatternLocation[6] = 6;
  testPatternLocation[7] = 7;
  while ( *testPatternLocation != 0x1F3D5B79 )
  {
    PA_FCRAMCFG.cnt1 = 131075;
    v3 = initialNumIterations;
    do
      --v3;
    while ( v3 );
    PA_FCRAMCFG.cnt1 = 0x20000;
    initialNumIterations += numIterationsIncrement;
  }
}

//----- (1FFAF5A4) --------------------------------------------------------
void __fastcall crt0::PrepareTranslationTables(s32 coreId)
{
  int v1; // r5
  u32 *L1; // r2
  u32 *L2_FFF; // r1
  u32 *v4; // r4
  unsigned int v5; // r5
  int v6; // r7
  int v7; // r4
  unsigned int v8; // r10
  unsigned int v9; // r3
  unsigned int v10; // r4
  int *v11; // r7
  bool v12; // cc
  int v13; // r9
  unsigned int v14; // r3
  unsigned int v15; // r4
  u32 *v16; // r7
  bool v17; // cc
  int v18; // r9
  unsigned int *v19; // r4
  unsigned int v20; // r3
  int v21; // r12
  bool v22; // cc
  unsigned int v23; // r8
  unsigned int v24; // r3
  unsigned int v25; // r12
  int *v26; // r4
  bool v27; // cc
  int v28; // r8
  int *v29; // r6
  unsigned int v30; // r2
  int v31; // r3
  int v32; // r12
  char *v33; // r3
  unsigned int v34; // r9
  unsigned int v35; // r12
  unsigned int v36; // r11
  bool v37; // zf
  u32 *v38; // r9
  bool v39; // cc
  int v40; // lr
  int v41; // r3
  int v42; // r12
  int v43; // r12
  int v44; // r8
  int v45; // r3
  unsigned int v46; // r3
  int v47; // r12
  unsigned int v48; // r3
  unsigned int v49; // r8
  unsigned int v50; // r12
  int *v51; // r9
  bool v52; // cc
  int v53; // r11
  int v54; // r3
  unsigned int v55; // r3
  unsigned int v56; // r2
  int *v57; // r12
  bool v58; // cc
  int v59; // r8
  char *v60; // r2
  unsigned int v61; // r12
  int *v62; // r9
  bool v63; // cc
  int v64; // r10
  KLightMutex *v65; // r11
  int *v66; // r7
  unsigned int v67; // r8
  unsigned int v68; // r6
  int v69; // r10
  unsigned int v70; // r3
  unsigned int v71; // r9
  int *v72; // r10
  bool v73; // cc
  int v74; // lr
  int *v75; // r12
  bool v76; // cc
  int v77; // r9
  int *v78; // r2
  unsigned int v79; // r6
  bool v80; // cc
  u32 *L1Table; // r2
  unsigned int v82; // r3
  u32 *v83; // r12
  bool v84; // cc
  int v85; // r8
  u32 *v86; // r2
  u32 *v87; // r12
  unsigned int v88; // r3
  bool v89; // cc
  unsigned int v90; // r8
  u32 *v91; // r2
  unsigned int v92; // r3
  u32 *v93; // r12
  bool v94; // cc
  int v95; // r8
  u32 *v96; // r2
  u32 *v97; // r12
  unsigned int v98; // r3
  bool v99; // cc
  unsigned int v100; // r8
  unsigned int v101; // r2
  u32 v102; // r6
  u32 v103; // r7
  u32 *v104; // r0
  u32 *v105; // r3
  unsigned int v106; // r9
  bool v107; // cc
  volatile Mp11PrivateMemRegion *v108; // r2
  u32 *v109; // r12
  volatile Mp11PrivateMemRegion *v110; // r3
  bool v111; // cc
  unsigned int v112; // r7
  char *v113; // r0
  u32 *v114; // r1
  bool v115; // cc
  int v116; // r3

  v1 = 2048;
  L1 = crt0::L1TableAddresses[coreId];
  L2_FFF = crt0::L2TableAddresses_FFF[coreId];
  v4 = L1 - 1;
  do
  {
    --v1;
    v4[1] = 0;
    v4[2] = 0;
    v4 += 2;
  }
  while ( v1 );
  v5 = 0x1FFF5000;
  if ( !coreId )
  {
    v6 = 0x600;
    v7 = 0x1FFF4FFC;                            // kernel stacks mapping?
    do
    {
      *(_DWORD *)(v7 + 4) = 0;
      --v6;
      *(_DWORD *)(v7 + 8) = 0;
      v7 += 8;
    }
    while ( v6 );
  }
  v8 = 0x1F3F0000;
  L1[0x1FF] = 0x1FF16406;                       // identity mapping, L1
  L1[0x1F3] = 0x1F316406;
  v9 = 0xD8000000;
  v10 = 0x18000000;
  v11 = (int *)(L1 + 3456);
  do
  {
    v9 += 0x100000;
    v12 = v9 != 0;
    v13 = (v10 >> 20 << 20) | 0x16416;
    if ( v9 )
      v12 = v9 < 0xD85FFFFF;
    v10 += 0x100000;
    *v11++ = v13;
  }
  while ( v12 );
  v14 = 0xDF000000;
  v15 = 0x1F000000;
  v16 = L1 + 0xDF0;
  do
  {
    v14 += 0x100000;
    v17 = v14 != 0;
    v18 = (v15 >> 20 << 20) | 0x16416;
    if ( v14 )
      v17 = v14 < 0xDF3FFFFF;
    v15 += 0x100000;
    *v16++ = v18;
  }
  while ( v17 );
  v19 = L1 + 0xE00;
  L1[0xDFF] = 0x1FF16416;
  v20 = 0xE0000000;                             // FCRAM
  v21 = 0x20000000;
  do
  {
    v20 += 0x100000;
    v22 = v20 != 0;
    v23 = v21 & 0xFF000000 | 0x56416;
    if ( v20 )
      v22 = v20 < 0xEFFFFFFF;
    v21 += 0x100000;
    *v19++ = v23;
  }
  while ( v22 );
  v24 = 0xFF400000;                             // kernel stack area page tables
  v25 = 0x1FFF5000;
  v26 = (int *)(L1 + 0xFF4);
  do
  {
    v24 += 0x100000;
    v27 = v24 != 0;
    v28 = (v25 >> 10 << 10) | 1;
    if ( v24 )
      v27 = v24 < 0xFFBFFFFF;
    v25 += 1024;
    *v26++ = v28;
  }
  while ( v27 );
  L1[0xFFF] = ((unsigned int)L2_FFF >> 10 << 10) | 1;
  v29 = &_dso_handle;
  v30 = -(int)&HID;
  if ( (unsigned int)-(int)&HID >= 0x42000 )
    v31 = 0x42000;
  else
    v31 = -(int)&HID;
  if ( (int)(((unsigned int)(v31 - 0x90000) >> 16 << 16) + 0x90000) > 0 )
  {
    v32 = v30 >= 0x42000 ? 270336 : -(int)&HID;
    v33 = (char *)&_slabheaps_start;            // slabheaps
    v34 = (unsigned int)(v32 + 0xFFF70000) >> 16;
    v35 = 0x1FFA0000;
    v36 = (v34 << 16) - 1;
    v37 = v34 << 16 == 0xFFF70001;
    v38 = L2_FFF + 0x70;
    if ( !v37 && v36 >= 0xFFF70000 )
    {
      do
      {
        v33 += 4096;
        v39 = v33 != 0;
        v40 = (HIWORD(v35) << 16) | 0xE415;
        if ( v33 )
          v39 = v36 > (unsigned int)v33;
        v35 += 4096;
        *v38++ = v40;
      }
      while ( v39 );
    }
  }
  if ( v30 >= 0x42000 )
  {
    v41 = 0x42000;
    v42 = 0x42000;
  }
  else
  {
    v41 = -(int)&HID;
    v42 = -(int)&HID;
  }
  if ( (int)(v41 - ((unsigned int)(v42 + 0xFFF70000) >> 16 << 16) + 0xFFF70000) > 0 )
  {
    v43 = v30 >= -0xFFFBE000 ? -0xFFFBE000 : -(int)&HID;
    v44 = v43 + 0xFFF70000;
    v45 = v30 >= -0xFFFBE000 ? -0xFFFBE000 : -(int)&HID;
    v46 = v45 + 0xFFF70000;
    v47 = v30 >= -0xFFFBE000 ? -0xFFFBE000 : -(int)&HID;
    v48 = HIWORD(v46) << 16;
    v49 = v44 - 1;
    v50 = ((unsigned int)(v47 + 0xFFF70000) >> 16 << 16) - 0xDFFD0000;
    v51 = (int *)((char *)L2_FFF + ((v48 & 0xFF000) >> 10));
    if ( v48 < v49 )
    {
      do
      {
        v48 += 4096;
        v52 = v48 != 0;
        v53 = (v50 >> 12 << 12) | 0x597;        // last <64K of heap
        if ( v48 )
          v52 = v49 > v48;
        v50 += 4096;
        *v51++ = v53;
      }
      while ( v52 );
    }
  }
  if ( v30 >= -0xFFFBE000 )
    v54 = 0x42000;
  else
    v54 = -(int)&HID;
  v55 = v54 + 0xFFF70000;
  if ( v30 >= -0xFFFBE000 )
    v30 = 0x42000;
  v56 = v30 + 0xFFF71FFF;
  v57 = (int *)((char *)L2_FFF + ((v55 & 0xFF000) >> 10));
  if ( v55 < v56 )
  {
    do
    {
      v55 += 4096;
      v58 = v55 != 0;
      v59 = (v8 >> 12 << 12) | 0x597;           // qtm mem
      if ( v55 )
        v58 = v56 > v55;
      v8 += 4096;
      *v57++ = v59;
    }
    while ( v58 );
  }
  v60 = (char *)&loc_FFF20000;
  v61 = 0x1FF80000;                             // .text part1
  v62 = (int *)((char *)L2_FFF + (((unsigned int)&_dso_handle & 0xFF000) >> 10));
  if ( &_dso_handle < (int *)((char *)&loc_FFF1FFFC + 3) )
  {
    do
    {
      v29 += 1024;
      v63 = v29 != 0;
      v64 = (HIWORD(v61) << 16) | 0x6615;
      if ( v29 )
        v63 = (int *)((char *)&loc_FFF1FFFC + 3) > v29;
      v61 += 4096;
      *v62++ = v64;
    }
    while ( v63 );
  }
  v65 = &g_dmaManagerLock;
  v66 = &dword_FFF2E000;
  v67 = 0x1FFED000u;
  v68 = 0x1FFEC000u;
  if ( ((unsigned int)&dword_FFF2E000 & 0xFFFF) != 0 )
  {
    v69 = (unsigned __int16)&dword_FFF2E000;
    v70 = 0x1FFEC000 - v69;
    v71 = 0x1FEA0000 + v69 - 536346625;
    v72 = (int *)((char *)L2_FFF + (((unsigned int)&loc_FFF20000 & 0xFF000) >> 10));
    if ( v71 > (unsigned int)&loc_FFF20000 )
    {
      do
      {
        v60 += 4096;
        v73 = v60 != 0;
        v74 = (v70 >> 12 << 12) | 0x796;        // .text part2
        if ( v60 )
          v73 = v71 > (unsigned int)v60;
        v70 += 4096;
        *v72++ = v74;
      }
      while ( v73 );
    }
  }
  v75 = (int *)((char *)L2_FFF + (((unsigned int)&dword_FFF2E000 & 0xFF000) >> 10));
  if ( &dword_FFF2E000 < (int *)&unk_FFF2EFFF )
  {
    do
    {
      v66 += 1024;
      v76 = v66 != 0;
      v77 = (v68 >> 12 << 12) | 0x797;          // .rodata
      if ( v66 )
        v76 = &unk_FFF2EFFF > (_UNKNOWN *)v66;
      v68 += 4096;
      *v75++ = v77;
    }
    while ( v76 );
  }
  v78 = (int *)((char *)L2_FFF + (((unsigned int)&g_dmaManagerLock & 0xFF000) >> 10));
  if ( (unsigned int)&g_dmaManagerLock < 0xFFF33FFF )
  {
    do
    {
      v65 += 512;
      v79 = v67 >> 12 << 12;
      v80 = v65 != 0;                           // .data and bss
      if ( v65 )
        v80 = (unsigned int)v65 < 0xFFF33FFF;
      v67 += 4096;
      *v78++ = v79 | 0x597;
    }
    while ( v80 );
  }
  L1Table = g_coreLocalRegions[0].L1Table;      // core local regions etc
  v82 = 0x1FFF8000;
  v83 = L2_FFF + 0xCA;
  do
  {
    L1Table += 1024;
    v84 = L1Table != 0;
    v85 = (v82 >> 12 << 12) | 0x597;
    if ( L1Table )
      v84 = (unsigned int)L1Table < 0xFFFCDFFF;
    v82 += 4096;
    *v83++ = v85;
  }
  while ( v84 );
  v86 = g_coreLocalRegions[1].L1Table;
  v87 = L2_FFF + 211;
  L2_FFF[0xCF] = 0x1FFF2597;
  L2_FFF[0xD1] = 0x1FFF3597;
  v88 = 0x1FFFC000;
  do
  {
    v86 += 1024;
    v89 = v86 != 0;
    v90 = v88 >> 12;
    if ( v86 )
      v89 = (unsigned int)v86 < 0xFFFD6FFF;
    v88 += 4096;
    *v87++ = (v90 << 12) | 0x597;
  }
  while ( v89 );
  v91 = g_coreLocalRegions[2].L1Table;
  L2_FFF[0xD8] = 0x1F3F2597;
  L2_FFF[0xDA] = 0x1F3F5597;
  v92 = 524255232;
  v93 = L2_FFF + 0xDC;
  do
  {
    v91 += 1024;
    v94 = v91 != 0;
    v95 = (v92 >> 12 << 12) | 0x597;
    if ( v91 )
      v94 = (unsigned int)v91 < 0xFFFDFFFF;
    v92 += 4096;
    *v93++ = v95;
  }
  while ( v94 );
  v96 = g_coreLocalRegions[3].L1Table;
  v97 = L2_FFF + 0xE5;
  L2_FFF[0xE1] = 0x1F3F3597;
  L2_FFF[0xE3] = 0x1F3F6597;
  v98 = 0x1F3FC000;
  do
  {
    v96 += 1024;
    v99 = v96 != 0;
    v100 = v98 >> 12;
    if ( v96 )
      v99 = (unsigned int)v96 < 0xFFFE8FFF;
    v98 += 4096;
    *v97++ = (v100 << 12) | 0x597;
  }
  while ( v99 );
  L2_FFF[234] = 0x1F3F4597;
  L2_FFF[236] = 0x1F3F7597;
  v101 = (unsigned int)crt0::L1TableAddresses[coreId];
  v102 = crt0::idleThreadStacks[coreId];
  v103 = crt0::coreCtxAddrs[coreId];
  v104 = current.L1Table;
  v105 = L2_FFF + 242;
  do
  {
    v104 += 1024;
    v106 = v101 >> 12 << 12;
    v107 = v104 != 0;
    if ( v104 )
      v107 = (unsigned int)v104 < 0xFFFF5FFF;
    v101 += 4096;
    *v105++ = v106 | 0x597;
  }
  while ( v107 );
  L2_FFF[0xF7] = (v102 >> 12 << 12) | 0x597;
  L2_FFF[0xF9] = (v103 >> 12 << 12) | 0x597;
  L2_FFF[0xB8] = 0x17E10417;
  v108 = &MPCORE;
  v109 = L2_FFF + 0xEE;
  L2_FFF[0xBA] = 0x10144417;                    // io
  L2_FFF[0xBC] = 0x10400417;
  L2_FFF[0xBE] = 0x10141417;
  L2_FFF[0xC0] = 0x10163417;
  L2_FFF[0xC2] = 0x10146417;
  L2_FFF[0xC4] = 0x10202417;
  L2_FFF[0xC6] = 0x10140417;
  L2_FFF[0xC8] = 0x10206417;
  v110 = &PA_MPCORE;
  do
  {
    v108 = (volatile Mp11PrivateMemRegion *)((char *)v108 + 4096);
    v111 = v108 != 0;
    if ( v108 )
      v111 = (unsigned int)v108 < 0xFFFEFFFF;
    v112 = (unsigned int)v110 >> 12;
    v110 = (volatile Mp11PrivateMemRegion *)((char *)v110 + 4096);
    *v109++ = (v112 << 12) | 0x417;
  }
  while ( v111 );
  v113 = (char *)&KernStackL2Tables;
  L2_FFF[0xF0] = 0x1FFF4796;                    // excep page
  v114 = L2_FFF + 251;
  do
  {
    v113 += 4096;
    v115 = v113 != 0;
    v116 = (v5 >> 12 << 12) | 0x597;
    if ( v113 )
      v115 = (unsigned int)v113 < 0xFFFFDFFF;   // 0x1FFF5000, covering the 8 shared tables for 0xFF4.... (plus an extra page?)
    v5 += 4096;
    *v114++ = v116;
  }
  while ( v115 );
}
// FFF2E000: using guessed type int dword_FFF2E000;

//----- (1FFAFC78) --------------------------------------------------------
// write access to const memory has been detected, the output may be wrong!
void __fastcall crt0::InitCpu(s32 coreId)
{
  char socinfo; // r0
  unsigned int v3; // r0
  bool v4; // zf
  char lgr_socmode; // r0
  int socModeHigherClk; // r10
  unsigned int v7; // r0
  u16 v8; // r0
  u8 v9; // r1
  u16 v10; // r0
  u16 v11; // r0
  int syncStatus; // r3
  u8 unitinfo; // r12
  u8 bootenv; // r0
  int i; // r0
  int v16; // r12
  char totalNumCores; // r1
  int prevSocModeBeforeLow; // r0
  unsigned int v19; // r1
  int socModeLowerClk; // r3
  u8 v21; // r12
  u16 v22; // r1
  u16 v23; // r1
  u8 lgr_brom_overlay_cnt; // r10
  u8 v25; // r10
  u8 v26; // r10
  u8 v27; // r10
  u8 v28; // r10
  int v29; // r10
  int v30; // r10
  u8 v31; // r0
  u16 v32; // r0
  u16 v33; // r0
  unsigned int v34; // r1
  u32 ctlr; // r1
  u32 reg1_aux_control; // r1
  u32 reg15_prefetch_ctrl; // r1
  u32 reg15_power_ctrl; // r1
  u32 reg2_int_clear; // r1
  int v40; // r0
  int v41; // r2
  int v42; // r1
  int v43; // t1

  if ( !coreId )
  {
    socinfo = PA_CONFIG11.socinfo;
    if ( (unsigned __int8)(socinfo & 2) >> 1 )
    {
      v3 = PA_CONFIG11.socinfo & 4;
      v4 = v3 >> 2 == 0;
      lgr_socmode = PA_PDN.lgr_socmode;
      if ( v4 )
        socModeHigherClk = 3;
      else
        socModeHigherClk = 5;
      if ( (lgr_socmode & 7) != socModeHigherClk )
      {
        PA_PDN.lgr_cnt |= 1u;
        v7 = PA_CONFIG11.socinfo & 4;
        if ( v7 >> 2 )
        {
          v8 = PA_PDN.lgr_cnt | 0x100;          // if LGR2 is supported, enable the L2C block
          PA_PDN.lgr_cnt = v8;
        }
        crt0::WaitCycles(0x193u);               // approx 1.5usec using the base Arm11 clk speed...
                                                // except the caches aren't yet enabled, so
                                                // SYSCLOCK_SOC (16MHz?) should be used as base instead
                                                // (as the spin code triggers a strongly ordered
                                                // AXIWRAM read at each instr. fetch)
        PA_MPCORE.gicc.ctlr = 1;
        PA_MPCORE.gicd.icpendr[2] = 0x1000000;
        PA_PDN.lgr_socmode = socModeHigherClk & 7 | 0x8000;
        PA_MPCORE.gicd.ipriorityr[KINTNAME_PDN] = 0;
        v9 = PA_MPCORE.gicd.itargetsr[KINTNAME_PDN];
        PA_MPCORE.gicd.itargetsr[KINTNAME_PDN] = v9 | 1;
        PA_MPCORE.gicd.isenabler[2] = 0x1000000;
        do
        {
          __wfi();
          v10 = PA_PDN.lgr_socmode;
        }
        while ( (v10 & 0x8000) == 0 );
        v11 = PA_PDN.lgr_socmode;
        PA_PDN.lgr_socmode = v11;
        PA_MPCORE.gicd.icenabler[2] = 0x1000000;
        PA_CONFIG11.lgr_gpu_cnt = 3;            // n3ds only reg, set bits 0 and 1
      }
      PA_CONFIG11.lgr_cdma_sel = 0x3FFFF;
    }                                           // select new dma for everything
    SYSRV.syncStatus = 1;
    do
      syncStatus = SYSRV.syncStatus;
    while ( syncStatus != 2 );
    SYSRV.syncStatus = 3;
    unitinfo = SYSRV.unitinfo;
    crt0::unitinfo = unitinfo;
    bootenv = SYSRV.bootenv;
    crt0::bootenv = bootenv;
    if ( crt0::unitinfo == 3 )
    {
      for ( i = 0; i < 0x800000; ++i )
        ;
      SYSRV.syncStatus = 1;
      do
        v16 = SYSRV.syncStatus;
      while ( v16 != 2 );
      SYSRV.syncStatus = 3;
    }
    if ( (unsigned __int8)(PA_CONFIG11.socinfo & 2) >> 1 )
    {
      totalNumCores = PA_MPCORE.scu.cfgr;
      if ( (totalNumCores & 3) == 3 )
      {
        PA_MPCORE.scu.statusr &= ~0xF0u;        // Power off mode => Normal mode
        prevSocModeBeforeLow = PA_PDN.lgr_socmode & 7;
        v19 = PA_CONFIG11.socinfo & 4;
        if ( v19 >> 2 )
          socModeLowerClk = 1;
        else
          socModeLowerClk = 2;
        if ( prevSocModeBeforeLow != socModeLowerClk )
        {
          PA_MPCORE.gicc.ctlr = 1;
          PA_MPCORE.gicd.icpendr[2] = 0x1000000;
          PA_PDN.lgr_socmode = socModeLowerClk & 7 | 0x8000;
          PA_MPCORE.gicd.ipriorityr[KINTNAME_PDN] = 0;
          v21 = PA_MPCORE.gicd.itargetsr[88] | 1;
          PA_MPCORE.gicd.itargetsr[KINTNAME_PDN] = v21;
          PA_MPCORE.gicd.isenabler[2] = 0x1000000;
          do
          {
            __wfi();
            v22 = PA_PDN.lgr_socmode;
          }
          while ( (v22 & 0x8000) == 0 );
          v23 = PA_PDN.lgr_socmode;
          PA_PDN.lgr_socmode = v23;
          PA_MPCORE.gicd.icenabler[2] = 0x1000000;
        }
        lgr_brom_overlay_cnt = PA_CONFIG11.lgr_brom_overlay_cnt;
        PA_CONFIG11.lgr_brom_overlay_cnt = lgr_brom_overlay_cnt | 1;
        *(_DWORD *)((unsigned int)&PA_CONFIG11.lgr_brom_overlay_cnt | ((int)&PA_PDN >> 26)) = crt0::Core23Ep;
        v25 = PA_PDN.lgr_cpu_cnt[2];
        if ( (v25 & 0x10) == 0 )
        {
          PA_PDN.lgr_cpu_cnt[2] |= 2u;
          v26 = PA_PDN.lgr_cpu_cnt[2] | 1;
          PA_PDN.lgr_cpu_cnt[2] = v26;
        }
        v27 = PA_PDN.lgr_cpu_cnt[3];
        if ( (v27 & 0x10) == 0 )
        {
          PA_PDN.lgr_cpu_cnt[3] |= 2u;
          v28 = PA_PDN.lgr_cpu_cnt[3] | 1;
          PA_PDN.lgr_cpu_cnt[3] = v28;
        }
        do
          v29 = PA_PDN.lgr_cpu_cnt[2] & 0x12;
        while ( v29 != 16 );
        do
          v30 = PA_PDN.lgr_cpu_cnt[3] & 0x12;
        while ( v30 != 16 );
        PA_CONFIG11.lgr_brom_overlay_cnt &= ~1u;
        if ( prevSocModeBeforeLow != socModeLowerClk )// 
                                                // switch back to higher clock mode
                                                // 
                                                // Could have just... not switched to higher-clock mode at first (early in the func)?
        {
          PA_MPCORE.gicc.ctlr = 1;
          PA_MPCORE.gicd.icpendr[2] = 0x1000000;
          PA_PDN.lgr_socmode = prevSocModeBeforeLow & 7 | 0x8000;
          PA_MPCORE.gicd.ipriorityr[88] = 0;
          v31 = PA_MPCORE.gicd.itargetsr[88];
          PA_MPCORE.gicd.itargetsr[88] = v31 | 1;
          PA_MPCORE.gicd.isenabler[2] = 0x1000000;
          do
          {
            __wfi();
            v32 = PA_PDN.lgr_socmode;
          }
          while ( (v32 & 0x8000) == 0 );
          v33 = PA_PDN.lgr_socmode;
          PA_PDN.lgr_socmode = v33;
          PA_MPCORE.gicd.icenabler[2] = 0x1000000;
        }
      }
    }
    SYSRV.core1Entrypoint = (u32)_start;
  }
  v34 = (unsigned int)crt0::L1TableAddresses[coreId];
  __mcr(15, 0, 0, 8, 7, 0);                     // TLB invalidate all
  __mcr(15, 0, (v34 >> 9 << 9) | 0x12, 2, 0, 0);
  __mcr(15, 0, (v34 >> 14 << 14) | 0x12, 2, 0, 1);
  __mcr(15, 0, 2u, 2, 0, 2);
  __mcr(15, 0, 0, 13, 0, 1);                    // CONTEXTIDR
  __mcr(15, 0, 1u, 3, 0, 0);                    // DACR
  crt0::PrepareTranslationTables(coreId);
  if ( !coreId )
  {
    ctlr = PA_MPCORE.scu.ctlr;
    PA_MPCORE.scu.ctlr = ctlr | 1;              // enable SCU
  }
  __mcr(15, 0, __mrc(15, 0, 1, 0, 1) | 0x2F, 1, 0, 1);// Enables instruction folding, static branch prediction, dynamic branch prediction, and return stack.
                                                // 
                                                // On top of what crt0 initalizes, also signal this CPU is taking part in SMP
  __mcr(15, 0, __mrc(15, 0, 1, 0, 0) | 0xC03805, 1, 0, 0);// From LSB to MSB: Enable the MMU, L1 dcache, flow prediction, L1 icache, high vectors, unaligned access, extended page tables
  __mcr(15, 0, 0, 7, 5, 4);                     //     __isb();
                                                // 
                                                //     __icache_inv_all();
                                                //     __dcache_inv_all();
                                                //     __tlb_inv_all();
                                                //     
                                                //     __dsb();
                                                //     __isb();
  __mcr(15, 0, 0, 7, 5, 0);
  __mcr(15, 0, 0, 7, 6, 0);
  __mcr(15, 0, 0, 8, 7, 0);
  __mcr(15, 0, 0, 7, 10, 5);
  __mcr(15, 0, 0, 7, 5, 4);
  if ( !coreId )
  {
    reg1_aux_control = L2C.reg1_aux_control;
    L2C.reg1_aux_control = reg1_aux_control & ~0x3901400u | 0x2800000;// Set: Force write allocate="force no allocate"
                                                // Disable/unset:
                                                // - High Priority for SO and Dev Reads
                                                // - Exclusive cache configuration
                                                // - Event monitor bus enable
                                                // 
                                                // Enable RR
    reg15_prefetch_ctrl = L2C.reg15_prefetch_ctrl;
    L2C.reg15_prefetch_ctrl = reg15_prefetch_ctrl & ~0x79A0001Fu | 0x70000001;// Enable:
                                                // - Double linefill
                                                // - Instruction prefetch
                                                // - Data prefetch
                                                // - Double linefill on WRAP read (bit 27 unset)
                                                // 
                                                // Disable:
                                                // - Prefetch drop
                                                // - Incr double Linefill
                                                // - Not same ID on exclusive sequence
                                                // 
                                                // Clear prefetch offset
    reg15_power_ctrl = L2C.reg15_power_ctrl;
    L2C.reg15_power_ctrl = reg15_power_ctrl & ~3u;// Disable dynamic clock gating and standby mode
    reg2_int_clear = L2C.reg2_int_clear;
    L2C.reg2_int_clear = reg2_int_clear | 0x1FF;// Clear all interrupts
    L2C.reg7_inv_way = 0xFFFF;                  // Invalidate all
    while ( (L2C.reg7_cache_sync & 1) != 0 )
      ;
    L2C.reg7_cache_sync = 0;
    L2C.reg1_control |= 1u;                     // Enable L2C
    v40 = 0x1FFF3FFC;
    v41 = 0x1FFADFFC;
    v42 = 0x200;                                // copy exception page from 1FFAE000 to 1FFF4000
    do
    {
      --v42;
      *(_DWORD *)(v40 + 4) = *(_DWORD *)(v41 + 4);
      v43 = *(_DWORD *)(v41 + 8);
      v41 += 8;
      *(_DWORD *)(v40 + 8) = v43;
      v40 += 8;
    }
    while ( v42 );
    if ( 0x1FFED000u << 20 )
      __breakpoint(89);
    if ( 0x1FFEC000u << 20 )
      __breakpoint(90);
    crt0::memmove((void *)0x1FFED000, (const void *)0x1FFB3000, 0x180u);// .data
    crt0::memmove((void *)0x1FFEC000, (const void *)0x1FFB2000, 0x1000u);// .rodata
    crt0::memmove(
      (void *)(0x1FFEC000 - (unsigned __int16)&dword_FFF2E000),// remaining of .text
                                                // first chunk of .text is at 0x1FF80000
      (const void *)0x1FFA0000,
      (unsigned __int16)&dword_FFF2E000);
    __mcr(15, 0, 0, 7, 10, 0);
    __mcr(15, 0, 0, 7, 10, 4);
    L2C.reg7_clean_inv_way = 0xFFFF;            // bogus? No L1 clean and L2C doesn't hold dirty lines
    while ( (L2C.reg7_cache_sync & 1) != 0 )
      ;
    L2C.reg7_cache_sync = 0;
  }
  __mcr(15, 0, 0, 7, 14, 0);                    // Clean and Invalidate Entire Data Cache
  __mcr(15, 0, 0, 7, 10, 5);
  __mcr(15, 0, 0, 7, 5, 0);                     // Invalidate entire instruction cache
  __mcr(15, 0, 0, 7, 5, 6);
  __mcr(15, 0, 0, 7, 10, 4);
  __mcr(15, 0, 0, 7, 5, 4);
}
/* Orphan comments:
We NEED to switch to lower clock mode
before powering up cores 2 and 3.
wait for invalidation done
*/
// 1FFAFD98: write access to const memory at 1FFB0415 has been detected
// 1FFAFDA0: write access to const memory at 1FFB0416 has been detected
// 1FFB0415: using guessed type char crt0::unitinfo;
// 1FFB0416: using guessed type char crt0::bootenv;
// FFF2E000: using guessed type int dword_FFF2E000;

//----- (1FFB02D4) --------------------------------------------------------
u8 *crt0::FetchArm9Info(void)
{
  return (u8 *)&unk_1FFB0414;
}

//----- (1FFB02DC) --------------------------------------------------------
void __fastcall crt0::memmove(void *dst, const void *src, u32 size)
{
  u32 v3; // r12
  int v4; // r3
  int v5; // t1
  char *v6; // r1
  char *v7; // r0
  int v8; // t1
  int j; // r2
  int v10; // t1
  char *v11; // r1
  char *v12; // r0
  int v13; // t1
  int v14; // t1
  int i; // r2
  int v16; // t1

  v3 = -3 - size + ((unsigned int)((int)(-3 - size) >> 31) >> 30);
  v4 = (int)(-3 - size) / -4;
  if ( src <= dst )
  {
    v11 = (char *)src + (size & 0xFFFFFFFC);
    v12 = (char *)dst + (size & 0xFFFFFFFC);
    if ( size <= 0x7FFFFFFF )
    {
      if ( v4 > 0 )
      {
        if ( (v3 & 4) != 0 )
        {
          v14 = *((_DWORD *)v11 - 1);
          v11 -= 4;
          *((_DWORD *)v12 - 1) = v14;
          v12 -= 4;
        }
        for ( i = v4 >> 1; i; v12 -= 8 )
        {
          --i;
          *((_DWORD *)v12 - 1) = *((_DWORD *)v11 - 1);
          v16 = *((_DWORD *)v11 - 2);
          v11 -= 8;
          *((_DWORD *)v12 - 2) = v16;
        }
      }
    }
    else
    {
      do
      {
        v13 = *((_DWORD *)v11 - 1);
        v11 -= 4;
        size -= 4;
        *((_DWORD *)v12 - 1) = v13;
        v12 -= 4;
      }
      while ( size );
    }
  }
  else if ( size <= 0x7FFFFFFF )
  {
    if ( v4 > 0 )
    {
      v6 = (char *)src - 4;
      v7 = (char *)dst - 4;
      if ( (v3 & 4) != 0 )
      {
        v8 = *((_DWORD *)v6 + 1);
        v6 += 4;
        *((_DWORD *)v7 + 1) = v8;
        v7 += 4;
      }
      for ( j = v4 >> 1; j; v7 += 8 )
      {
        --j;
        *((_DWORD *)v7 + 1) = *((_DWORD *)v6 + 1);
        v10 = *((_DWORD *)v6 + 2);
        v6 += 8;
        *((_DWORD *)v7 + 2) = v10;
      }
    }
  }
  else
  {
    do
    {
      v5 = *(_DWORD *)src;
      src = (char *)src + 4;
      size -= 4;
      *(_DWORD *)dst = v5;
      dst = (char *)dst + 4;
    }
    while ( size );
  }
}

//----- (1FFB0438) --------------------------------------------------------
void _libc_init_array(void)
{
  void (*i)(void); // r4

  for ( i = (void (*)(void))&SHT__INIT_ARRAY__Base;
        i != _sti___27_KCacheMaintenanceHelper_cpp;
        i = (void (*)(void))((char *)i + 4) )
  {
    ((void (*)(void))((char *)i + *(_DWORD *)i))();
  }
}
// 1FFB045C: using guessed type int (*SHT__INIT_ARRAY__Base)();

//----- (1FFB04B0) --------------------------------------------------------
void _sti___27_KCacheMaintenanceHelper_cpp(void)
{
  g_l2cLock.lockingThread = 0;
  g_l2cLock.numWaiters = 0;
  g_l2cLock.ticketCount = 0;
  g_coreSynchronizationCount = 0;
  g_cacheMaintenanceHelper.__vftable = &KCacheMaintenanceHelper::vt;
  g_cacheMaintenanceHelper.op = KCACHEMAINTOP_NONE;
  g_cacheMaintenanceHelper.numClients = 0;
  g_cacheMaintenanceHelper.firstClientThread = 0;
  g_cacheMaintenanceHelper.waitList.link.prev = 0;
  g_cacheMaintenanceHelper.waitList.link.next = 0;
  __aeabi_atexit_nopped(
    (char *)_aeabi_vec_ctor_nocookie_nodtor_from_arm(
              g_cacheMaintenanceHelper.tasks,
              (void *(__fastcall *)(void *))KCacheMaintenanceHelperTask::KCacheMaintenanceHelperTask,
              0xCu,
              4u)
  - 28,
    (void (__fastcall *)(void *))KCacheMaintenanceHelper::~KCacheMaintenanceHelper,
    &_dso_handle);
  g_systemControlHelper.__vftable = &KSystemControlHelper::vt;
  g_terminationHelper.__vftable = &KTerminationHelper::vt;
}

//----- (1FFB0558) --------------------------------------------------------
void _sti___15_KDmaChannel_cpp(void)
{
  _aeabi_vec_ctor_nocookie_nodtor_from_arm(
    g_dmaChannels,
    (void *(__fastcall *)(void *))KDmaChannel::KDmaChannel,
    0x528u,
    8u);
  _aeabi_atexit_veneer(0, (void (__fastcall *)(void *))DestroyDmaChannelInstances, &_dso_handle);
}

//----- (1FFB0594) --------------------------------------------------------
void _sti___10_KDebug_cpp(void)
{
  g_debuggerThreadLinkedList.link.next = (KThreadLinkedListNode *)&g_debuggerThreadLinkedList.link;
  g_debuggerThreadLinkedList.count = 0;
  g_debuggerThreadLinkedList.link.prev = (KThreadLinkedListNode *)&g_debuggerThreadLinkedList.link;
  _aeabi_atexit_veneer(
    &g_debuggerThreadLinkedList,
    (void (__fastcall *)(void *))KThreadLinkedList::~KThreadLinkedList,
    &_dso_handle);
}

//----- (1FFB05C4) --------------------------------------------------------
void _sti___10_KEvent_cpp(void)
{
  g_eventSignalMutex.lockingThread = 0;
  g_eventSignalMutex.numWaiters = 0;
  g_eventSignalMutex.ticketCount = 0;
}

//----- (1FFB05E0) --------------------------------------------------------
void _sti___11_KTimer_cpp(void)
{
  g_timerOpsMutex.lockingThread = 0;
  g_timerOpsMutex.numWaiters = 0;
  g_timerOpsMutex.ticketCount = 0;
}

//----- (1FFB05FC) --------------------------------------------------------
void _sti___10_Kernel_cpp(void)
{
  KDmaManager *__shifted(KDmaManager,0xC) v0; // r0

  g_supervisorPageTable.mutex.lockingThread = 0;
  g_supervisorPageTable.mutex.numWaiters = 0;
  g_supervisorPageTable.mutex.ticketCount = 0;
  g_supervisorPageTable.memoryBlockMgr.blocks.link.next = (KMemoryBlockLinkedListNode *)&g_supervisorPageTable.memoryBlockMgr.blocks.link;
  g_supervisorPageTable.memoryBlockMgr.blocks.count = 0;
  g_supervisorPageTable.memoryBlockMgr.blocks.link.prev = (KMemoryBlockLinkedListNode *)&g_supervisorPageTable.memoryBlockMgr.blocks.link;
  __aeabi_atexit_nopped(
    &g_supervisorPageTable,
    (void (__fastcall *)(void *))KSupervisorPageTable::~KSupervisorPageTable,
    &_dso_handle);
  g_memoryManager.pgMgr.memoryStartAddr = 0;
  g_memoryManager.pgMgr.numPages = 0;
  g_memoryManager.pgMgr.pageRefcounts = 0;
  g_memoryManager.pgMgr.kernelMemoryUsage = 0;
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  g_memoryManager.pgMgr.mutex.numWaiters = 0;
  g_memoryManager.pgMgr.mutex.ticketCount = 0;
  g_interruptManager.mutex.lockingThread = 0;
  g_interruptManager.mutex.numWaiters = 0;
  g_interruptManager.mutex.ticketCount = 0;
  __aeabi_atexit_nopped(
    &g_interruptManager,
    (void (__fastcall *)(void *))KInterruptManager::~KInterruptManager,
    &_dso_handle);
  g_hardwareTimer.__vftable = &KHardwareTimer::vt;
  g_hardwareTimer.next = 0;
  g_hardwareTimer.innerTask.__vftable = &KDummyTimerTask::vt;
  g_hardwareTimer.innerTask.next = 0;
  g_hardwareTimer.lock.lockingThread = 0;
  g_hardwareTimer.lock.lockCount = 0;
  g_dmaManager.vt = &KDmaManager::vt_KDmaChannelEventHandler;
  g_dmaManager.__vftable = &KDmaManager::vt;
  g_dmaManager.next = 0;
  v0 = (KDmaManager *__shifted(KDmaManager,0xC))_aeabi_vec_ctor_nocookie_nodtor_from_arm(
                                                  g_dmaManager.channelLocked,
                                                  (void *(__fastcall *)(void *))AtomicBool::AtomicBool,
                                                  1u,
                                                  8u);
  _aeabi_vec_ctor_nocookie_nodtor_from_arm(
    ADJ(v0)->interruptTaskEnqueued,
    (void *(__fastcall *)(void *))AtomicBool::AtomicBool,
    1u,
    8u);
  g_perfCounterMgr.__vftable = &KPerformanceCounterManager::vt;
  __aeabi_atexit_nopped(
    &g_perfCounterMgr,
    (void (__fastcall *)(void *))KPerformanceCounterManager::~KPerformanceCounterManager,
    &_dso_handle);
  unk_FFF2F0E0 = 0LL;
  unk_FFF2F0E8 = 0LL;
}

//----- (1FFB0768) --------------------------------------------------------
void _sti___11_KThread_cpp(void)
{
  g_threadIdCounter = 0;
}

//----- (1FFB077C) --------------------------------------------------------
void _sti___26_KVfpRegisterDumpHelper_cpp(void)
{
  _aeabi_vec_ctor_nocookie_nodtor_from_arm(
    &g_vfpRegisterDumpHelper,
    (void *(__fastcall *)(void *))KVfpRegisterDumpHelperImpl::KVfpRegisterDumpHelperImpl,
    8u,
    4u);
}

//----- (1FFB0798) --------------------------------------------------------
void _sti___12_KProcess_cpp(void)
{
  g_pidCounter = 0;
}

//----- (1FFB07AC) --------------------------------------------------------
void _sti___21_KProcessPageTable_cpp(void)
{
  _aeabi_vec_ctor_nocookie_nodtor_from_arm(
    g_tlbMaintenanceHelper.impls,
    (void *(__fastcall *)(void *))KTlbMaintenanceHelperImpl::KTlbMaintenanceHelperImpl,
    0x10u,
    4u);
  g_asidManager.mutex.lockingThread = 0;
  g_asidManager.mutex.numWaiters = 0;
  g_asidManager.mutex.ticketCount = 0;
  g_asidManager.map[1] = 0;
  g_asidManager.map[2] = 0;
  g_asidManager.map[3] = 0;
  g_asidManager.map[4] = 0;
  g_asidManager.map[5] = 0;
  g_asidManager.map[6] = 0;
  g_asidManager.map[7] = 0;
  g_asidManager.index = 0;
  g_asidManager.map[0] = 1;
  g_level2TtblAllocator.rootNode = 0;
  g_level2TtblAllocator.mutex.lockingThread = 0;
  g_level2TtblAllocator.mutex.numWaiters = 0;
  g_level2TtblAllocator.mutex.ticketCount = 0;
  _aeabi_atexit_veneer(
    &g_level2TtblAllocator,
    (void (__fastcall *)(void *))KLevel2TranslationTableAllocator::~KLevel2TranslationTableAllocator,
    &_dso_handle);
}

//----- (1FFB083C) --------------------------------------------------------
void _sti___14_KScheduler_cpp(void)
{
  g_cpuTimeLimiterMode0.next = 0;
  g_cpuTimeLimiterMode0.__vftable = &KCpuTimeLimiterMode0::vt;
  g_cpuTimeLimiterMode1.next = 0;
  g_cpuTimeLimiterMode1.__vftable = &KCpuTimeLimiterMode1::vt;
  g_schedulerLock.lockingThread = 0;
  g_schedulerLock.lockCount = 0;
  g_schedulerPreemptedThreadList.link.prev = 0;
  g_schedulerPreemptedThreadList.link.next = 0;
}

//----- (1FFB088C) --------------------------------------------------------
void _sti___15_KLinkedList_cpp(void)
{
  g_linkedListNodeSlabHeap.currentHead = 0;
  g_linkedListNodeSlabHeap.totalSize = 0;
  _aeabi_atexit_veneer(&g_linkedListNodeSlabHeap, (void (__fastcall *)(void *))KSlabHeap::~KSlabHeap, &_dso_handle);
}

//----- (1FFB08B4) --------------------------------------------------------
void _sti___15_KObjectName_cpp(void)
{
  g_objectNameList.link.next = (KObjectNameLinkedListNode *)&g_objectNameList.link;
  g_objectNameList.count = 0;
  g_objectNameList.link.prev = (KObjectNameLinkedListNode *)&g_objectNameList.link;
  __cxa_atexit_nopped((void (__fastcall *)(void *))&g_objectNameList, KLinkedList::~KLinkedList, &_dso_handle);
  g_objectNameListMutex.lockingThread = 0;
  g_objectNameListMutex.numWaiters = 0;
  g_objectNameListMutex.ticketCount = 0;
}

//----- (1FFB0900) --------------------------------------------------------
void _sti___31_KPerformanceCounterManager_cpp(void)
{
  g_perfCounterMgrExclusivePid = -1;
}

//----- (1FFB0914) --------------------------------------------------------
void _sti___9_Sleep_cpp(void)
{
  g_systemControl.mutex.lockingThread = 0;
  g_systemControl.mutex.numWaiters = 0;
  g_systemControl.mutex.ticketCount = 0;
  _aeabi_vec_ctor_nocookie_nodtor_from_arm(
    &g_sleepEntrySchedHelper,
    (void *(__fastcall *)(void *))KSleepEntrySchedHelperImpl::KSleepEntrySchedHelperImpl,
    8u,
    4u);
  _aeabi_vec_ctor_nocookie_nodtor_from_arm(
    &g_sleepExitSchedHelper,
    (void *(__fastcall *)(void *))KSleepExitSchedHelperImpl::KSleepExitSchedHelperImpl,
    8u,
    4u);
}

//----- (1FFB096C) --------------------------------------------------------
void _sti___15_KDmaManager_cpp(void)
{
  g_dmaManagerLock.lockingThread = 0;
  g_dmaManagerLock.numWaiters = 0;
  g_dmaManagerLock.ticketCount = 0;
}

//----- (1FFB0988) --------------------------------------------------------
void _sti___27_KObjectAllocatorAdapter_cpp(void)
{
  if ( (`guard variable for'KSlabHeap<KDebug>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KDebug>::KSlabHeap(void)::initialized )// nopped __cxa_guard_acquire and atexit calls in each block
                                                // but I CBA to add them
  {
    g_debugAllocator.slabHeap.currentHead = 0;
    g_debugAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KDebug>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KDebug>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_debugAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KThread>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KThread>::KSlabHeap(void)::initialized )
  {
    g_threadAllocator.slabHeap.currentHead = 0;
    g_threadAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KThread>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KThread>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_threadAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KAddressArbiter>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KAddressArbiter>::KSlabHeap(void)::initialized )
  {
    g_addressArbiterAllocator.slabHeap.currentHead = 0;
    g_addressArbiterAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KAddressArbiter>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KAddressArbiter>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_addressArbiterAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KCodeSet>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KCodeSet>::KSlabHeap(void)::initialized )
  {
    g_codeSetAllocator.slabHeap.currentHead = 0;
    g_codeSetAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KCodeSet>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KCodeSet>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_codeSetAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KDmaObject>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KDmaObject>::KSlabHeap(void)::initialized )
  {
    g_dmaObjectAllocator.slabHeap.currentHead = 0;
    g_dmaObjectAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KDmaObject>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KDmaObject>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_dmaObjectAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KEvent>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KEvent>::KSlabHeap(void)::initialized )
  {
    g_eventAllocator.slabHeap.currentHead = 0;
    g_eventAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KEvent>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KEvent>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_eventAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KMutex>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KMutex>::KSlabHeap(void)::initialized )
  {
    g_mutexAllocator.slabHeap.currentHead = 0;
    g_mutexAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KMutex>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KMutex>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_mutexAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KPort>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KPort>::KSlabHeap(void)::initialized )
  {
    g_portAllocator.slabHeap.currentHead = 0;
    g_portAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KPort>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KPort>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_portAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KResourceLimit>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KResourceLimit>::KSlabHeap(void)::initialized )
  {
    g_resourceLimitAllocator.slabHeap.currentHead = 0;
    g_resourceLimitAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KResourceLimit>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KResourceLimit>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_resourceLimitAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KProcess>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KProcess>::KSlabHeap(void)::initialized )
  {
    g_processAllocator.slabHeap.currentHead = 0;
    g_processAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KProcess>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KProcess>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_processAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KSemaphore>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KSemaphore>::KSlabHeap(void)::initialized )
  {
    g_semaphoreAllocator.slabHeap.currentHead = 0;
    g_semaphoreAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KSemaphore>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KSemaphore>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_semaphoreAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KSession>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KSession>::KSlabHeap(void)::initialized )
  {
    g_sessionAllocator.slabHeap.currentHead = 0;
    g_sessionAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KSession>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KSession>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_sessionAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KSharedMemory>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KSharedMemory>::KSlabHeap(void)::initialized )
  {
    g_sharedMemoryAllocator.slabHeap.currentHead = 0;
    g_sharedMemoryAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KSharedMemory>::KObjectContainer(void)::initialized & 1) == 0
    && &`guard variable for'KObjectContainer<KSharedMemory>::KObjectContainer(void)::initialized )
  {
    KObjectContainer::KObjectContainer(&g_sharedMemoryAllocator.container);
  }
  if ( (`guard variable for'KSlabHeap<KTimer>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KTimer>::KSlabHeap(void)::initialized )
  {
    g_timerAllocator.slabHeap.currentHead = 0;
    g_timerAllocator.slabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KObjectContainer<KTimer>::KObjectContainer(void)::initialized & 1) == 0 )
  {
    if ( &`guard variable for'KObjectContainer<KTimer>::KObjectContainer(void)::initialized )
    {
      KObjectContainer::KObjectContainer(&g_timerAllocator.container);
      _cxa_guard_release_veneer(&`guard variable for'KObjectContainer<KTimer>::KObjectContainer(void)::initialized);
    }
  }
}
// FFF2F0F8: using guessed type int `guard variable for'KObjectContainer<KDmaObject>::KObjectContainer(void)::initialized;
// FFF2F0FC: using guessed type int `guard variable for'KSlabHeap<KDmaObject>::KSlabHeap(void)::initialized;
// FFF2F100: using guessed type int `guard variable for'KObjectContainer<KSemaphore>::KObjectContainer(void)::initialized;
// FFF2F104: using guessed type int `guard variable for'KSlabHeap<KSemaphore>::KSlabHeap(void)::initialized;
// FFF2F108: using guessed type int `guard variable for'KObjectContainer<KSharedMemory>::KObjectContainer(void)::initialized;
// FFF2F10C: using guessed type int `guard variable for'KSlabHeap<KSharedMemory>::KSlabHeap(void)::initialized;
// FFF2F110: using guessed type int `guard variable for'KObjectContainer<KResourceLimit>::KObjectContainer(void)::initialized;
// FFF2F114: using guessed type int `guard variable for'KSlabHeap<KResourceLimit>::KSlabHeap(void)::initialized;
// FFF2F118: using guessed type int `guard variable for'KObjectContainer<KAddressArbiter>::KObjectContainer(void)::initialized;
// FFF2F11C: using guessed type int `guard variable for'KSlabHeap<KAddressArbiter>::KSlabHeap(void)::initialized;
// FFF2F120: using guessed type int `guard variable for'KObjectContainer<KPort>::KObjectContainer(void)::initialized;
// FFF2F124: using guessed type int `guard variable for'KSlabHeap<KPort>::KSlabHeap(void)::initialized;
// FFF2F128: using guessed type int `guard variable for'KObjectContainer<KEvent>::KObjectContainer(void)::initialized;
// FFF2F12C: using guessed type int `guard variable for'KSlabHeap<KEvent>::KSlabHeap(void)::initialized;
// FFF2F130: using guessed type int `guard variable for'KObjectContainer<KMutex>::KObjectContainer(void)::initialized;
// FFF2F134: using guessed type int `guard variable for'KSlabHeap<KMutex>::KSlabHeap(void)::initialized;
// FFF2F13C: using guessed type int `guard variable for'KSlabHeap<KTimer>::KSlabHeap(void)::initialized;
// FFF2F140: using guessed type int `guard variable for'KObjectContainer<KDebug>::KObjectContainer(void)::initialized;
// FFF2F144: using guessed type int `guard variable for'KSlabHeap<KDebug>::KSlabHeap(void)::initialized;
// FFF2F148: using guessed type int `guard variable for'KObjectContainer<KThread>::KObjectContainer(void)::initialized;
// FFF2F14C: using guessed type int `guard variable for'KSlabHeap<KThread>::KSlabHeap(void)::initialized;
// FFF2F150: using guessed type int `guard variable for'KObjectContainer<KCodeSet>::KObjectContainer(void)::initialized;
// FFF2F154: using guessed type int `guard variable for'KSlabHeap<KCodeSet>::KSlabHeap(void)::initialized;
// FFF2F158: using guessed type int `guard variable for'KObjectContainer<KProcess>::KObjectContainer(void)::initialized;
// FFF2F15C: using guessed type int `guard variable for'KSlabHeap<KProcess>::KSlabHeap(void)::initialized;
// FFF2F160: using guessed type int `guard variable for'KObjectContainer<KSession>::KObjectContainer(void)::initialized;
// FFF2F164: using guessed type int `guard variable for'KSlabHeap<KSession>::KSlabHeap(void)::initialized;

//----- (1FFB1274) --------------------------------------------------------
void _sti___21_KPxiBufferManager_cpp(void)
{
  int v0; // r2
  int v1; // r1
  int v2; // r12
  int v3; // r2
  int v4; // r4

  g_pxiBufferManager.mutex.lockingThread = 0;
  g_pxiBufferManager.mutex.numWaiters = 0;
  v0 = 0;
  g_pxiBufferManager.mutex.ticketCount = 0;
  v1 = 0;
  do
  {
    v2 = v0;
    v3 = v0 + 1;
    v1 += 2;
    v4 = v3;
    g_pxiBufferManager.ctxs[v2].clientThread = 0;
    v0 = v3 + 1;
    g_pxiBufferManager.ctxs[v4].clientThread = 0;
  }
  while ( v1 < 64 );
}

//----- (1FFB12D8) --------------------------------------------------------
void _sti___14_KFiqHelper_cpp(void)
{
  g_fiqHelper.s.next = 0;
  g_fiqHelper.s.__vftable = &KFiqHelper::vt;
  g_fiqHelper.interruptEvent = 0;
  g_fiqState = KFIQSTATE_UNBOUND;
}

//----- (1FFB1308) --------------------------------------------------------
void _sti___20_KSlabHeapAdapter_cpp(void)
{
  if ( (`guard variable for'KSlabHeap<KEventInfo>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KEventInfo>::KSlabHeap(void)::initialized )// nopped __cxa_guard_acquire and atexit calls in each block
                                                // but I CBA to add them
  {
    g_eventInfoSlabHeap.currentHead = 0;
    g_eventInfoSlabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KSlabHeap<KMemoryBlock>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KMemoryBlock>::KSlabHeap(void)::initialized )
  {
    g_memoryBlockSlabHeap.currentHead = 0;
    g_memoryBlockSlabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KSlabHeap<KObjectName>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KObjectName>::KSlabHeap(void)::initialized )
  {
    g_objectNameSlabHeap.currentHead = 0;
    g_objectNameSlabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KSlabHeap<KBlockInfo>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KBlockInfo>::KSlabHeap(void)::initialized )
  {
    g_blockInfoSlabHeap.currentHead = 0;
    g_blockInfoSlabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KSlabHeap<KDebugThread>::KSlabHeap(void)::initialized & 1) == 0
    && &`guard variable for'KSlabHeap<KDebugThread>::KSlabHeap(void)::initialized )
  {
    g_debugThreadSlabHeap.currentHead = 0;
    g_debugThreadSlabHeap.totalSize = 0;
  }
  if ( (`guard variable for'KSlabHeap<KThreadLocalPage>::KSlabHeap(void)::initialized & 1) == 0 )
  {
    if ( &`guard variable for'KSlabHeap<KThreadLocalPage>::KSlabHeap(void)::initialized )
    {
      g_threadLocalPageSlabHeap.currentHead = 0;
      g_threadLocalPageSlabHeap.totalSize = 0;
      _cxa_guard_release_veneer(&`guard variable for'KSlabHeap<KThreadLocalPage>::KSlabHeap(void)::initialized);
    }
  }
}
// FFF2F168: using guessed type int `guard variable for'KSlabHeap<KBlockInfo>::KSlabHeap(void)::initialized;
// FFF2F16C: using guessed type int `guard variable for'KSlabHeap<KEventInfo>::KSlabHeap(void)::initialized;
// FFF2F170: using guessed type int `guard variable for'KSlabHeap<KObjectName>::KSlabHeap(void)::initialized;
// FFF2F174: using guessed type int `guard variable for'KSlabHeap<KMemoryBlock>::KSlabHeap(void)::initialized;
// FFF2F17C: using guessed type int `guard variable for'KSlabHeap<KDebugThread>::KSlabHeap(void)::initialized;

//----- (1FFB1508) --------------------------------------------------------
void _sti___29_KPerformanceControlHelper_cpp(void)
{
  g_perfCounterControlHelper.__vftable = &KPerformanceCounterControlHelper::vt;
}

//----- (1FFF4994) --------------------------------------------------------
void crt0::CopyAndJumpToCore0Stub(void)
{
  crt0::CopyFinalStub(crt0::Core0StubData, crt0::CopyAndJumpToCore1Stub, crt0::Core0Stub);
  crt0::Core0Stub();
}

//----- (1FFF49AC) --------------------------------------------------------
void __usercall __noreturn crt0::Core0StubData()
{
  void (**v0)(void); // r0

  v0 = (void (**)(void))off_1FFF49D8;
  *(_DWORD *)off_1FFF49D8 = 0;
  *(_DWORD *)off_1FFF49DC = dword_1FFF49E0;
  while ( !*v0 )
    ;
  (*v0)();
}
// 1FFF49D8: using guessed type void *off_1FFF49D8;
// 1FFF49DC: using guessed type void *off_1FFF49DC;
// 1FFF49E0: using guessed type int dword_1FFF49E0;

//----- (1FFF49E4) --------------------------------------------------------
void __noreturn crt0::CopyAndJumpToCore1Stub(void)
{
  crt0::CopyFinalStub(crt0::Core1StubData, crt0::CopyFinalStub, crt0::Core1FinalStub);
  crt0::Core1FinalStub(__mrc(15, 0, 0, 0, 5));
}

//----- (1FFF4A00) --------------------------------------------------------
void __usercall __noreturn crt0::Core1StubData(s32 coreId@<R2>)
{
  _DWORD *v1; // r3
  void (**v2)(void); // lr

  *(_DWORD *)off_1FFF4A64 = 1;
  *(_DWORD *)off_1FFF4A68 = 1;
  v1 = off_1FFF4A6C;
  *(_DWORD *)off_1FFF4A6C = -1;
  v2 = (void (**)(void))off_1FFF4A70;
  *off_1FFF4A74 = 1;
  do
    __wfi();
  while ( (*v1 & (1 << coreId)) == 0 );
  (*v2)();
}
// 1FFF4A64: using guessed type void *off_1FFF4A64;
// 1FFF4A68: using guessed type void *off_1FFF4A68;
// 1FFF4A6C: using guessed type void *off_1FFF4A6C;
// 1FFF4A70: using guessed type void *off_1FFF4A70;
// 1FFF4A74: using guessed type char *off_1FFF4A74;

//----- (1FFF4A78) --------------------------------------------------------
void __fastcall crt0::CopyFinalStub(const void *start, const void *end, void *dst)
{
  int v3; // r3
  char *v4; // r0
  char *v5; // r1
  int v6; // t1
  int i; // r2
  int v8; // t1

  v3 = (_BYTE *)end - (_BYTE *)start;
  if ( ((_BYTE *)end - (_BYTE *)start) >> 2 > 0 )
  {
    v4 = (char *)start - 4;
    v5 = (char *)dst - 4;
    if ( (v3 & 4) != 0 )
    {
      v6 = *((_DWORD *)v4 + 1);
      v4 += 4;
      *(_DWORD *)dst = v6;
      v5 = (char *)dst;
    }
    for ( i = v3 >> 3; i; v5 += 8 )
    {
      --i;
      *((_DWORD *)v5 + 1) = *((_DWORD *)v4 + 1);
      v8 = *((_DWORD *)v4 + 2);
      v4 += 8;
      *((_DWORD *)v5 + 2) = v8;
    }
  }
}

//----- (1FFF4AC4) --------------------------------------------------------
void __fastcall crt0::StopExtraCoresAndJump(s32 coreId)
{
  u32 v5; // r0
  char lgr_socmode; // r12
  u8 v7; // r12
  u8 v8; // r12
  u8 v9; // r5
  u16 v10; // r4
  u16 v11; // r1
  unsigned int v12; // r4
  u32 v13; // r4
  u8 v14; // r0
  u32 iar; // r0

  __mcr(15, 0, 0, 7, 14, 0);                    // cleaninv entire dcache (local)
  __mcr(15, 0, 0, 7, 10, 5);
  __mcr(15, 0, 0xFu, 1, 0, 1);                  // aux control
  __mcr(15, 0, 0x54078u, 1, 0, 0);              // control
  __mcr(15, 0, 0, 2, 0, 0);                     // disable mmu, write 0 to the translation registers
  __mcr(15, 0, 0, 2, 0, 1);
  __mcr(15, 0, 0, 2, 0, 2);
  __mcr(15, 0, 0, 13, 0, 1);
  __mcr(15, 0, 0, 7, 5, 4);                     // flush prefetch buffer
  __asm { CPSID           IF }
  if ( coreId )
  {
    switch ( coreId )
    {
      case 1:
        crt0::CopyAndJumpToCore1Stub();
      case 2:
        v5 = PA_MPCORE.scu.statusr | 0x30;      // set SCU status to indicate the core is about to enter Power Off mode (core 2)
        break;
      case 3:
        do
          v14 = PA_PDN.lgr_cpu_cnt[2];          // wait for core 2 to be off
        while ( (v14 & 0x10) != 0 );
        v5 = PA_MPCORE.scu.statusr | 0xC0;      // set SCU status to indicate the core is about to enter Power Off mode (core 3)
        break;
      default:
        goto LABEL_27;
    }
    PA_MPCORE.scu.statusr = v5;
    while ( 1 )
    {
LABEL_27:
      __wfi();                                  // core 2 and 3: basically, wfi forever
      iar = PA_MPCORE.gicc.iar;
      PA_MPCORE.gicc.eoir = iar;
    }
  }
  lgr_socmode = PA_PDN.lgr_socmode;             // core 0
  if ( (lgr_socmode & 7) != 0 )
  {
    if ( (PA_MPCORE.scu.cfgr & 3) == 3 )
    {
      PA_PDN.lgr_cpu_cnt[2] = 0;                // set Power Off for core 2. Only takes effect when SCU status becomes "Power off"
      do
        v7 = PA_PDN.lgr_cpu_cnt[2];
      while ( (v7 & 0x10) != 0 );
      PA_PDN.lgr_cpu_cnt[3] = 0;
      do
        v8 = PA_PDN.lgr_cpu_cnt[3];             // same for core 3
      while ( (v8 & 0x10) != 0 );
    }
    PA_CONFIG11.lgr_gpu_cnt = 0;                // set SoC mode to CTR
    PA_PDN.lgr_cnt = 0;
    PA_MPCORE.gicc.ctlr = 1;
    PA_MPCORE.gicd.icpendr[2] = 0x1000000;
    PA_PDN.lgr_socmode = 0x8000;
    PA_MPCORE.gicd.ipriorityr[KINTNAME_PDN] = 0;
    v9 = PA_MPCORE.gicd.itargetsr[KINTNAME_PDN];
    PA_MPCORE.gicd.itargetsr[KINTNAME_PDN] = v9 | 1;
    PA_MPCORE.gicd.isenabler[2] = 0x1000000;
    while ( 1 )
    {
      __wfi();
      v10 = PA_PDN.lgr_socmode;
      if ( (v10 & 0x8000) != 0 )
        break;
      v12 = PA_MPCORE.gicc.hppir & 0x3FF;
      if ( v12 <= 0x15 )                        // bug, this is meant to be 15 (decimal)
                                                // 
                                                // throw away all SGIs
      {
        v13 = PA_MPCORE.gicc.iar;
        PA_MPCORE.gicc.eoir = v13;
      }
    }
    v11 = PA_PDN.lgr_socmode;
    PA_PDN.lgr_socmode = v11;
    PA_MPCORE.gicd.icenabler[2] = 0x1000000;
  }
  PA_CONFIG11.lgr_cdma_sel = 0;                 // make all devices use O3DS dma again
  while ( !crt0::core1ReadyForFirmlaunch )      // wait fore core1 to be ready
    ;
  crt0::CopyAndJumpToCore0Stub();
}

//----- (1FFFFC00) --------------------------------------------------------
void __usercall __noreturn crt0::Core0Stub()
{
  SYSRV.core0Entrypoint = 0;
  PA_PXI.send = 0x44846;
  while ( !SYSRV.core0Entrypoint )
    ;
  ((void (__noreturn *)(void))SYSRV.core0Entrypoint)();
}

//----- (1FFFFE00) --------------------------------------------------------
void __usercall __noreturn crt0::Core1FinalStub(s32 coreId@<R2>)
{
  void (*core1Entrypoint)(void); // lr

  PA_MPCORE.gicc.ctlr = 1;
  PA_MPCORE.gicd.ctlr = 1;
  PA_MPCORE.gicd.icpendr[0] = -1;
  crt0::core1ReadyForFirmlaunch = 1;
  do
    __wfi();
  while ( (PA_MPCORE.gicd.icpendr[0] & (1 << coreId)) == 0 );
  core1Entrypoint = (void (*)(void))SYSRV.core1Entrypoint;
  core1Entrypoint();
}

//----- (FFF0000C) --------------------------------------------------------
int __fastcall _aeabi_vec_dtor(int a1, void (__fastcall *a2)(int), int a3, int a4)
{
  int v7; // r4

  if ( a4 )
  {
    v7 = a3 * a4 + a1;
    do
    {
      v7 -= a3;
      a2(v7);
    }
    while ( a1 != v7 );
  }
  return a1 - 8;
}

//----- (FFF00030) --------------------------------------------------------
void __noreturn HorizonKernelMain(void)
{
  s32 coreId; // r5
  KCoreLocalContext *p_clc; // r8
  int v2; // r0
  char *heap; // r4
  FcramLayout stackTop; // [sp+0h] [bp-18h] BYREF

  coreId = __mrc(15, 0, 0, 0, 5) & 3;
  KCoreLocalContext::InitializeCurrent(coreId);
  g_kernelState = KSTATE_INITIALIZING;
  p_clc = &g_coreLocalRegions[coreId].clc;
  KAutoObject::Initialize(&p_clc->idleThread);
  KThread::Initialize(&p_clc->idleThread, 0, 0, 0xFFFF8000, 0, 1, coreId, 0, KTHREAD_TYPE_IDLE);// KTHREAD_TYPE_IDLE.
                                                // It's initialized as the first thread with prio 0, meaning it won't be scheduled out until
                                                // its priority is set to 64.
  current.clc.current.thread = &p_clc->idleThread;
  current.clc.current.process = 0;
  KInterruptManager::InitializeCore(&g_interruptManager, coreId);
  KHardwareTimer::Initialize(&g_hardwareTimer, coreId);
  KScheduler::Intialize(current.clc.current.scheduler, coreId, &p_clc->idleThread);
  cpu::SynchronizeAllCores();
  if ( !coreId )
  {
    ParseDeliverArgs(&stackTop);
    KMemoryManager::Intialize(&g_memoryManager, &stackTop, 0xE0000000, 0x10000000u);
  }
  cpu::SynchronizeAllCores();
  KLevel2TranslationTableAllocator::Initialize(coreId);
  if ( coreId )
  {
    if ( coreId == 1 )
    {
      AllocateSharedConfigPages();
      KDebug::InitializeScheduledInOutState();
      KDmaManager::Initialize(&g_dmaManager);
    }
  }
  else
  {
    SaveDeliverParameters();
    v2 = -(int)&HID;
    if ( (unsigned int)-(int)&HID >= 0x42000 )
      v2 = 0x42000;
    KPageHeap::Initialize(&g_kernelPageHeap, (u32)&_slabheaps_start, v2 + 0x2000);
    heap = (char *)KPageHeap::AllocateContiguous(&g_kernelPageHeap, 0x3Eu, 0);
    if ( !heap )
      kernelpanic();
    KSlabHeap::Initialize(&g_eventAllocator.slabHeap, 0x28u, heap, 0x3138u);
    g_eventAllocator.count = 0;
    KSlabHeap::Initialize(&g_mutexAllocator.slabHeap, 0x2Cu, heap + 12600, 0xEA0u);
    g_mutexAllocator.count = 0;
    KSlabHeap::Initialize(&g_semaphoreAllocator.slabHeap, 0x2Cu, heap + 0x3FD8, 0xE48u);
    g_semaphoreAllocator.count = 0;
    KSlabHeap::Initialize(&g_timerAllocator.slabHeap, 0x3Cu, heap + 20000, 0xE10u);
    g_timerAllocator.count = 0;
    KSlabHeap::Initialize(&g_processAllocator.slabHeap, 0x270u, heap + 23600, 0x7290u);
    g_processAllocator.count = 0;
    KSlabHeap::Initialize(&g_threadAllocator.slabHeap, 0xB0u, heap + 52928, 0xCE40u);
    g_threadAllocator.count = 0;
    KSlabHeap::Initialize(&g_portAllocator.slabHeap, 0x48u, heap + 105728, 0x2B08u);
    g_portAllocator.count = 0;
    KSlabHeap::Initialize(&g_dmaObjectAllocator.slabHeap, 0x18u, heap + 116744, 0x180u);
    g_dmaObjectAllocator.count = 0;
    KSlabHeap::Initialize(&g_sharedMemoryAllocator.slabHeap, 0x28u, heap + 117128, 0x9D8u);
    g_sharedMemoryAllocator.count = 0;
    KSlabHeap::Initialize(&g_debugAllocator.slabHeap, 0xA0u, heap + 119648, 0x1E0u);
    g_debugAllocator.count = 0;
    KSlabHeap::Initialize(&g_sessionAllocator.slabHeap, 0x4Cu, heap + 120128, 0x6670u);
    g_sessionAllocator.count = 0;
    KSlabHeap::Initialize(&g_resourceLimitAllocator.slabHeap, 0x74u, heap + 146352, 0x248u);
    g_resourceLimitAllocator.count = 0;
    KSlabHeap::Initialize(&g_addressArbiterAllocator.slabHeap, 0x14u, heap + 146936, 0x400u);
    g_addressArbiterAllocator.count = 0;
    KSlabHeap::Initialize(&g_codeSetAllocator.slabHeap, 0x64u, heap + 147960, 0x1260u);
    g_codeSetAllocator.count = 0;
    KSlabHeap::Initialize(&g_linkedListNodeSlabHeap, 0xCu, heap + 152664, 0xC850u);
    KSlabHeap::Initialize(&g_blockInfoSlabHeap, 8u, heap + 203944, 0x12C8u);
    KSlabHeap::Initialize(&g_memoryBlockSlabHeap, 0x14u, heap + 208752, 0x86A0u);
    KSlabHeap::Initialize(&g_threadLocalPageSlabHeap, 0x18u, heap + 243216, 0x600u);
    KSlabHeap::Initialize(&g_objectNameSlabHeap, 0x10u, heap + 244752, 0x70u);
    KSlabHeap::Initialize(&g_debugThreadSlabHeap, 0x18u, heap + 244864, 0xBE8u);
    KSlabHeap::Initialize(&g_eventInfoSlabHeap, 0x38u, heap + 247912, 0xEA8u);
  }
  KSupervisorPageTable::UnmapIdentityAndInit(&g_supervisorPageTable, coreId);
  cpu::SynchronizeAllCores();
  BindVariousAllCoreHelperIrqHandlers(coreId);
  KObjectAllocator::Register(&g_threadAllocator, &p_clc->idleThread);
  KInterruptTaskManager::Initialize(&p_clc->interruptTaskManagerInstance);
  __enable_irq();
  KScheduler::Enable(current.clc.current.scheduler);
  InitBindIrqHandlersWithThreads(coreId);
  cpu::SynchronizeAllCores();
  if ( !coreId )
  {
    KWorkerTaskManager::Initialize(g_workerTaskManager, KWORKERTYPE_HIGH_PRIO, 1);
    KWorkerTaskManager::Initialize(&g_workerTaskManager[1], KWORKERTYPE_LOW_PRIO, 16);
    InitSharedKernelConfigPage();
    StartInitialProcesses();
    g_kernelState = KSTATE_RUNNING;
    CreateKernelDiagnosticTable();
  }
  cpu::SynchronizeAllCores();
  KThread::SetIdlePriority(current.clc.current.thread);
  while ( 1 )
    __wfi();
}

//----- (FFF005E0) --------------------------------------------------------
void __noreturn HandleFiqException()
{
  int v0; // lr
  u8 fiq_mask; // r9

  fiq_mask = CONFIG11.fiq_mask;
  CONFIG11.fiq_mask = fiq_mask | 2;
  MPCORE.gicd.sgir = 196623;
  ((void (*)(void))(v0 - 4))();
}
// FFF005FC: variable 'v0' is possibly undefined

//----- (FFF00648) --------------------------------------------------------
Result __fastcall KScheduler::Intialize(KScheduler *this, s32 coreId, KThread *idleThread)
{
  signed __int32 v7; // r1
  char cfgr; // r2

  this->coreId = coreId;
  idleThread->alive = 1;
  v7 = idleThread->coreId;
  idleThread->coreId = this->coreId;
  if ( v7 >= 0 )
  {
    cfgr = MPCORE.scu.cfgr;
    if ( (cfgr & 3) + 1 > v7 )
      KVfpRegisterDumpHelper::DumpAndDisableVfpRegsForThread(idleThread, v7);
  }
  this->idleThread = idleThread;
  KSchedulerLock::Lock(&g_schedulerLock);
  KScheduler::AddThread(this, idleThread);
  KSchedulerLock::Unlock(&g_schedulerLock);
  if ( coreId == 1 )
  {
    g_cpuTimeLimiterMode0.scheduler = this;
    g_cpuTimeLimiterMode0.active = 0;
    g_cpuTimeLimiterMode0.absoluteTimeInQuanta = 1LL;
    g_cpuTimeLimiterMode1.scheduler = this;
    g_cpuTimeLimiterMode1.active = 0;
    g_cpuTimeLimiterMode1.absoluteTimeInQuanta = 1LL;
  }
  return KInterruptManager::BindInterrupt(&g_interruptManager, this, KINTNAME_SGI_SCHEDULER, this->coreId, 0, 0, 0);
}

//----- (FFF00728) --------------------------------------------------------
void __fastcall KScheduler::Enable(KScheduler *this)
{
  unsigned int CPSR; // r4
  unsigned int *p_disableCount; // r2
  unsigned int v3; // r1

  CPSR = __get_CPSR();
  __disable_irq();
  p_disableCount = (unsigned int *)&this->disableCount;
  do
    v3 = __ldrex(p_disableCount);
  while ( __strex(v3 - 1, p_disableCount) );
  if ( this->reschedule )
    KScheduler::SwitchThread(this, 0);
  __set_CPSR(CPSR);
}

//----- (FFF00768) --------------------------------------------------------
Result __fastcall KDmaManager::Initialize(KDmaManager *this)
{
  int chanId; // r4
  int coreId; // r7

  KDmaController::Initialize();
  for ( chanId = 0; chanId < 8; ++chanId )
  {
    AtomicBoolStore(&this->channelLocked[chanId], 0);
    AtomicBoolStore(&this->interruptTaskEnqueued[chanId], 0);
    KDmaController::EnableInterrupt(chanId);
  }
  coreId = __mrc(15, 0, 0, 0, 5) & 3;
  KInterruptManager::BindInterrupt(&g_interruptManager, this, KINTNAME_N3DS_CDMA, coreId, 0, 1, 1);
  return KInterruptManager::BindInterrupt(&g_interruptManager, this, KINTNAME_O3DS_CDMA_ABORT, coreId, 0, 0, 1);// BUG, should be the n3ds version (0x3b)
                                                // This means the interrupt handler is bugged
}

//----- (FFF007FC) --------------------------------------------------------
void CreateKernelDiagnosticTable(void)
{
  KernelDiagnosticTable *diagTable; // r0
  int v1; // [sp+0h] [bp-10h] BYREF

  diagTable = (KernelDiagnosticTable *)((unsigned int)&v1 & ~0xFFFu);
  diagTable->mainKernelRegionStart = 0x1FF80000;
  diagTable->mainKernelRegionSize = 0x80000;
  diagTable->unk_18 = 0;
  diagTable->sizeofKAutoObject = 8;
  diagTable->sizeofKThreadStackParams = 0xC8;
  diagTable->clientPortOffset = 44;
  diagTable->unk_1c = 0;
  diagTable->pageManager = &g_memoryManager.pgMgr;
  diagTable->hardwareTimer = &g_hardwareTimer;
  diagTable->event.heap = g_eventAllocator.slabHeap.first;
  diagTable->event.numElements = 315;
  diagTable->event.elementSize = 40;
  diagTable->event.head = &g_eventAllocator.slabHeap;
  diagTable->mutex.heap = g_mutexAllocator.slabHeap.first;
  diagTable->mutex.numElements = 85;
  diagTable->mutex.elementSize = 44;
  diagTable->mutex.head = &g_mutexAllocator.slabHeap;
  diagTable->semaphore.heap = g_semaphoreAllocator.slabHeap.first;
  diagTable->semaphore.numElements = 83;
  diagTable->semaphore.elementSize = 44;
  diagTable->semaphore.head = &g_semaphoreAllocator.slabHeap;
  diagTable->timer.heap = g_timerAllocator.slabHeap.first;
  diagTable->timer.numElements = 60;
  diagTable->timer.elementSize = 60;
  diagTable->timer.head = &g_timerAllocator.slabHeap;
  diagTable->process.heap = g_processAllocator.slabHeap.first;
  diagTable->process.numElements = 47;
  diagTable->process.elementSize = 624;
  diagTable->process.head = &g_processAllocator.slabHeap;
  diagTable->thread.heap = g_threadAllocator.slabHeap.first;
  diagTable->thread.numElements = 300;
  diagTable->thread.elementSize = 176;
  diagTable->thread.head = &g_threadAllocator.slabHeap;
  diagTable->port.heap = g_portAllocator.slabHeap.first;
  diagTable->port.numElements = 153;
  diagTable->port.elementSize = 72;
  diagTable->port.head = &g_portAllocator.slabHeap;
  diagTable->dmaObject.heap = g_dmaObjectAllocator.slabHeap.first;
  diagTable->dmaObject.numElements = 16;
  diagTable->dmaObject.elementSize = 24;
  diagTable->dmaObject.head = &g_dmaObjectAllocator.slabHeap;
  diagTable->sharedMemory.heap = g_sharedMemoryAllocator.slabHeap.first;
  diagTable->sharedMemory.numElements = 63;
  diagTable->sharedMemory.elementSize = 40;
  diagTable->sharedMemory.head = &g_sharedMemoryAllocator.slabHeap;
  diagTable->session.heap = g_sessionAllocator.slabHeap.first;
  diagTable->session.numElements = 345;
  diagTable->session.elementSize = 76;
  diagTable->session.head = &g_sessionAllocator.slabHeap;
  diagTable->resourceLimit.heap = g_resourceLimitAllocator.slabHeap.first;
  diagTable->resourceLimit.numElements = 5;
  diagTable->resourceLimit.elementSize = 116;
  diagTable->resourceLimit.head = &g_resourceLimitAllocator.slabHeap;
  diagTable->addressArbiter.heap = g_addressArbiterAllocator.slabHeap.first;
  diagTable->addressArbiter.numElements = 51;
  diagTable->addressArbiter.elementSize = 20;
  diagTable->addressArbiter.head = &g_addressArbiterAllocator.slabHeap;
  diagTable->codeSet.heap = g_codeSetAllocator.slabHeap.first;
  diagTable->codeSet.numElements = 47;
  diagTable->codeSet.elementSize = 100;
  diagTable->codeSet.head = &g_codeSetAllocator.slabHeap;
  diagTable->linkedListNode.heap = g_linkedListNodeSlabHeap.first;
  diagTable->linkedListNode.numElements = 4273;
  diagTable->linkedListNode.elementSize = 12;
  diagTable->linkedListNode.head = &g_linkedListNodeSlabHeap;
  diagTable->blockInfo.heap = g_blockInfoSlabHeap.first;
  diagTable->blockInfo.numElements = 601;
  diagTable->blockInfo.elementSize = 8;
  diagTable->blockInfo.head = &g_blockInfoSlabHeap;
  diagTable->memoryBlock.heap = g_memoryBlockSlabHeap.first;
  diagTable->memoryBlock.numElements = 1723;
  diagTable->memoryBlock.elementSize = 20;
  diagTable->memoryBlock.head = &g_memoryBlockSlabHeap;
  diagTable->threadLocalPage.heap = g_threadLocalPageSlabHeap.first;
  diagTable->threadLocalPage.numElements = 64;
  diagTable->threadLocalPage.elementSize = 24;
  diagTable->threadLocalPage.head = &g_threadLocalPageSlabHeap;
  diagTable->objectName.heap = g_objectNameSlabHeap.first;
  diagTable->objectName.numElements = 7;
  diagTable->objectName.elementSize = 16;
  diagTable->objectName.head = &g_objectNameSlabHeap;
}

//----- (FFF00B00) --------------------------------------------------------
void __fastcall KWorkerTaskManager::Initialize(KWorkerTaskManager *this, KWorkerType type, s32 priority)
{
  unsigned int v5; // r2
  bool v6; // zf
  unsigned int v7; // r3
  unsigned int v8; // r1
  unsigned int v9; // r2
  bool v10; // zf
  unsigned int v11; // r3
  KSynchronizationObject *v12; // r0
  KThread *v13; // r7
  KThread *v14; // r0
  void *stack; // r8

  this->type = type;
  this->first = 0;
  this->last = 0;
  this->active = 0;
  v5 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v6 = v5 == 0;
  if ( v5 )
    v7 = __strex(v5, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v7 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v5 )
    v6 = v7 == 0;
  if ( !v6 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  do
    v8 = __ldrex(&g_memoryManager.pgMgr.kernelMemoryUsage);
  while ( __strex(v8 + 4096, &g_memoryManager.pgMgr.kernelMemoryUsage) );
  stack = KPageHeap::AllocateContiguous(&g_memoryManager.baseHeap, 1u, 1u);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  v9 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v10 = v9 == 0;
  if ( v9 )
    v11 = __strex(v9, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v11 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v9 )
    v10 = v11 == 0;
  if ( !v10 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)stack, 1u);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  v12 = (KSynchronizationObject *)KSlabHeap::Allocate(&g_threadAllocator.slabHeap);
  v13 = (KThread *)v12;
  if ( v12 )
  {
    v14 = (KThread *)KSynchronizationObject::KSynchronizationObject(v12);
    v14->KTimerTask::next = 0;
    v14->KWorkerTask::next = 0;
    v14->KInterruptTask::KInterruptHandler::__vftable = &KThread::vt_KInterruptTask;
    v14->KInterruptTask::next = 0;
    v14->KWorkerTask::__vftable = &KThread::vt_KWorkerTask;
    v14->KTimerTask::__vftable = &KThread::vt_KTimerTask;
    v14->KSynchronizationObject::KAutoObject::__vftable = &KThread::vt;
    v14->shallTerminate = 0;
    v14->synchronizationResult = 0xE7E3FFFF;
    v14->wantedLightMutex = 0;
    v14->syncObjectWaitAllList.link.next = (KSynchronizationObjectLinkedListNode *)&v14->syncObjectWaitAllList.link;
    v14->syncObjectWaitAllList.count = 0;
    v14->syncObjectWaitAllList.link.prev = (KSynchronizationObjectLinkedListNode *)&v14->syncObjectWaitAllList.link;
    v14->heldMutexListRootNode = 0;
    v14->mutexTryingToAcquireList.link.next = (KMutexLinkedListNode *)&v14->mutexTryingToAcquireList.link;
    v14->mutexTryingToAcquireList.count = 0;
    v14->mutexTryingToAcquireList.link.prev = (KMutexLinkedListNode *)&v14->mutexTryingToAcquireList.link;
    v14->affinityMask = 0;
    v14->owner = 0;
    v14->context = 0;
    KAutoObject::Initialize(v13);
  }
  this->handlingThread = v13;
  KThread::Initialize(
    v13,
    (u32)KWorkerTaskManager::ThreadFunction,
    (u32)this,
    (u32)stack + 0x1000,
    0,
    priority,
    1,
    0,
    KTHREAD_TYPE_KERNEL);
  KObjectAllocator::Register(&g_threadAllocator, this->handlingThread);
  KThread::PrepareToRun(this->handlingThread);
}
// FFF00B8C: conditional instruction was optimized away because r0.4==300
// FFF00B94: conditional instruction was optimized away because r0.4==300
// FFF00C34: conditional instruction was optimized away because r0.4!=0

//----- (FFF00DBC) --------------------------------------------------------
void __fastcall KInterruptTaskManager::Initialize(KInterruptTaskManager *this)
{
  KSynchronizationObject *v2; // r0
  KThread *v3; // r4
  KThread *v4; // r0

  v2 = (KSynchronizationObject *)KSlabHeap::Allocate(&g_threadAllocator.slabHeap);
  v3 = (KThread *)v2;
  if ( v2 )
  {
    v4 = (KThread *)KSynchronizationObject::KSynchronizationObject(v2);
    v4->KTimerTask::next = 0;
    v4->KWorkerTask::next = 0;
    v4->KInterruptTask::next = 0;
    v4->KWorkerTask::__vftable = &KThread::vt_KWorkerTask;
    v4->KInterruptTask::KInterruptHandler::__vftable = &KThread::vt_KInterruptTask;
    v4->KTimerTask::__vftable = &KThread::vt_KTimerTask;
    v4->KSynchronizationObject::KAutoObject::__vftable = &KThread::vt;
    v4->shallTerminate = 0;
    v4->wantedLightMutex = 0;
    v4->synchronizationResult = 0xE7E3FFFF;
    v4->syncObjectWaitAllList.count = 0;
    v4->syncObjectWaitAllList.link.next = (KSynchronizationObjectLinkedListNode *)&v4->syncObjectWaitAllList.link;
    v4->heldMutexListRootNode = 0;
    v4->syncObjectWaitAllList.link.prev = (KSynchronizationObjectLinkedListNode *)&v4->syncObjectWaitAllList.link;
    v4->mutexTryingToAcquireList.count = 0;
    v4->mutexTryingToAcquireList.link.next = (KMutexLinkedListNode *)&v4->mutexTryingToAcquireList.link;
    v4->mutexTryingToAcquireList.link.prev = (KMutexLinkedListNode *)&v4->mutexTryingToAcquireList.link;
    v4->affinityMask = 0;
    v4->owner = 0;
    v4->context = 0;
    KAutoObject::Initialize(v3);
  }
  this->handlingThread = v3;
  KThread::InitializeCriticalKernelThread(v3, KInterruptTaskManager::ThreadFunction, this);
  KObjectAllocator::Register(&g_threadAllocator, this->handlingThread);
  KThread::PrepareToRun(this->handlingThread);
}
// FFF00DE4: conditional instruction was optimized away because r0.4!=0

//----- (FFF00EA4) --------------------------------------------------------
void __fastcall StartInitialProcesses()
{
  Cxi *currentCxi; // r6
  int v1; // r7
  KCodeSet *v2; // r0
  KCodeSet *v3; // r5
  s32 idealProcessor; // r9
  KSynchronizationObject *v5; // r0
  KProcess *v6; // r4
  KProcess *v7; // r0
  KProcess *p_process; // r0
  char cfgr; // r0
  InitialProcess v10; // [sp+0h] [bp-C0h] BYREF
  u32 mainThreadPrio; // [sp+84h] [bp-3Ch]
  KAffinityMask affinityMask; // [sp+88h] [bp-38h] BYREF
  u32 mainThreadStackSize; // [sp+8Ch] [bp-34h]
  KSynchronizationObject_vtbl *v14; // [sp+90h] [bp-30h]
  KWorkerTask_vtbl *v15; // [sp+94h] [bp-2Ch]

  currentCxi = (Cxi *)0xDFF00000;
  v14 = &KProcess::vt;
  v1 = 0;
  v15 = &KProcess::vt_KWorkerTask;
  do
  {
    if ( (unsigned int)currentCxi >= 0xDFF357FC )
      break;
    v2 = (KCodeSet *)KSlabHeap::Allocate(&g_codeSetAllocator.slabHeap);
    v3 = v2;
    if ( v2 )
    {
      KCodeSet::KCodeSet(v2);
      KAutoObject::Initialize(v3);
    }
    v10.cxi = 0;
    InitialProcess::InitialProcess(&v10, currentCxi);
    InitialProcess::LoadCode(&v10, v3);
    KObjectAllocator::Register(&g_codeSetAllocator, v3);
    affinityMask = v10.affinityMask;
    mainThreadPrio = v10.mainThreadPriority;
    idealProcessor = v10.idealProcessor;
    mainThreadStackSize = v10.mainThreadStackSize;
    v5 = (KSynchronizationObject *)KSlabHeap::Allocate(&g_processAllocator.slabHeap);
    v6 = (KProcess *)v5;
    if ( v5 )
    {
      v7 = (KProcess *)KSynchronizationObject::KSynchronizationObject(v5);
      v7->next = 0;
      v7->KSynchronizationObject::KAutoObject::__vftable = v14;
      v7->KWorkerTask::__vftable = v15;
      v7->pgTable.mutex.lockingThread = 0;
      v7->pgTable.mutex.numWaiters = 0;
      v7->pgTable.mutex.ticketCount = 0;
      v7->pgTable.memoryBlockMgr.blocks.link.next = (KMemoryBlockLinkedListNode *)&v7->pgTable.memoryBlockMgr.blocks.link;
      v7->pgTable.memoryBlockMgr.blocks.count = 0;
      v7->pgTable.memoryBlockMgr.blocks.link.prev = (KMemoryBlockLinkedListNode *)&v7->pgTable.memoryBlockMgr.blocks.link;
      v7->kernAllocatedForProcess = 0;
      v7->threadLocalPages.link.next = (KThreadLocalPageLinkedListNode *)&v7->threadLocalPages.link;
      v7->threadLocalPages.count = 0;
      v7->threadLocalPages.link.prev = (KThreadLocalPageLinkedListNode *)&v7->threadLocalPages.link;
      v7->state = KPROCSTATE_CREATED;
      v7->affinityMask = 0;
      v7->threadCount = 0;
      v7->capability.kernelFlags = 0;
      v7->capability.intendedKernelVersion = 0;
      p_process = CONTAINING_RECORD(KHandleTable::KHandleTable(&v7->handleTable), KProcess, handleTable);
      p_process->unused_234 = 0;
      p_process->unused_238 = 0LL;
      p_process->unused_240 = 0LL;
      p_process->unused_248 = 0LL;
      p_process->unused_250 = 0LL;
      p_process->unused_258 = 0LL;
      p_process->unused_260 = 0LL;
      p_process->unused_268 = 0LL;
      KAutoObject::Initialize(v6);
    }
    KProcess::Initialize(v6, v3, v10.kernelCapsDescriptors, 0x1Cu);
    KObjectAllocator::Register(&g_processAllocator, v6);
    cfgr = MPCORE.scu.cfgr;
    KAffinityMask::Normalize(&v6->affinityMask, &affinityMask, (cfgr & 3) + 1);
    v6->idealProcessor = idealProcessor;
    KProcess::Run(v6, mainThreadPrio, mainThreadStackSize);
    ++v1;
    currentCxi = (Cxi *)((char *)currentCxi + InitialProcess::GetCxiSize(&v10));
  }
  while ( v1 < 5 );
  memset((void *)0xDFF00000, 0, 0x35800u);
}
// FFF00EFC: conditional instruction was optimized away because r0.4!=0
// FFF00F7C: conditional instruction was optimized away because r0.4!=0

//----- (FFF010E0) --------------------------------------------------------
void __fastcall ParseDeliverArgs(FcramLayout *layout)
{
  u8 bootEnv; // r0
  int v3; // r7
  int v4; // r2
  int v5; // r0
  u32 systemSize; // r2
  u32 v7; // r0

  bootEnv = crt0::FetchArm9Info_veneer()[2];
  if ( (bootEnv & 1) != 0 && (bootEnv & 6) == 0 )
  {
    if ( MEMORY[0x1FFA0438] != 0xFFFF
      || (v3 = MEMORY[0x1FFA043C], MEMORY[0x1FFA043C] = 0, crc32((void *)0x1FFA0400, 0x140u, 0xFFFFFFFF) != v3) )
    {
      memset((void *)0x1FFA0000, 0, 0x1000u);
    }
  }
  v4 = 0x7C00000;
  if ( MEMORY[0x1FFA0438] == 0xFFFF )
  {
    v5 = MEMORY[0x1FFA0400];
    if ( MEMORY[0x1FFA0400] == 7 )
    {
      v4 = 0xB200000;
      layout->baseSize = 0x2000000;
      layout->applicationSize = 0xB200000;
    }
    else
    {
      layout->applicationSize = 0x7C00000;
      if ( v5 != 8 )
        LOBYTE(v5) = 6;
      layout->baseSize = 0x2000000;
    }
    layout->systemSize = 0xE000000 - v4;
    g_systemControl.appMemType = v5;
  }
  else
  {
    layout->baseSize = 0x2000000;
    layout->systemSize = 104857600;
    layout->applicationSize = 0x7C00000;
    g_systemControl.appMemType = 6;
  }
  systemSize = layout->systemSize;
  v7 = layout->applicationSize - 0x20000000;
  layout->applicationAddr = 0xE0000000;
  layout->systemAddr = v7;
  layout->baseAddr = v7 + systemSize;
}

//----- (FFF01204) --------------------------------------------------------
void SaveDeliverParameters(void)
{
  unsigned int v0; // r2
  bool v1; // zf
  unsigned int v2; // r3
  unsigned int v3; // r2
  unsigned int v4; // r2
  bool v5; // zf
  unsigned int v6; // r3
  u8 *Arm9Info_veneer; // r0
  void *Contiguous; // r6

  v0 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v1 = v0 == 0;
  if ( v0 )
    v2 = __strex(v0, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v2 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v0 )
    v1 = v2 == 0;
  if ( !v1 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  do
    v3 = __ldrex(&g_memoryManager.pgMgr.kernelMemoryUsage);
  while ( __strex(v3 + 4096, &g_memoryManager.pgMgr.kernelMemoryUsage) );
  Contiguous = KPageHeap::AllocateContiguous(&g_memoryManager.baseHeap, 1u, 0);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  g_systemControl.deliverParamsPage = (u32)Contiguous;
  v4 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v5 = v4 == 0;
  if ( v4 )
    v6 = __strex(v4, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v6 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v4 )
    v5 = v6 == 0;
  if ( !v5 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)Contiguous, 1u);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  qmemcpy((void *)g_systemControl.deliverParamsPage, (const void *)0x1FFA0000, 0x1000u);
  Arm9Info_veneer = crt0::FetchArm9Info_veneer();
  g_systemControl.unitInfo = Arm9Info_veneer[1];
  g_systemControl.bootEnv = Arm9Info_veneer[2];
  g_systemControl.deliverParamsSaved = 1;
}
// FFF01278: conditional instruction was optimized away because r0.4==300
// FFF01280: conditional instruction was optimized away because r0.4==300

//----- (FFF01404) --------------------------------------------------------
void InitSharedKernelConfigPage(void)
{
  int isSafeModeComboPressed; // r12
  KernelSharedConfig *v1; // r0
  bool isDevUnitWithJtag; // zf
  u32 appMemType; // r3
  u32 deliverParamsPage; // r2
  int v5; // r1
  u32 v6; // r6
  u8 kernelRevisionVersion; // r2
  u8 kernelMinorVersion; // r3
  u8 kernelMajorVersion; // r12
  u32 sysCoreVer; // r4
  u32 kernelCtrSdkVersion; // r5

  isSafeModeComboPressed = 0;
  v1 = g_kernelSharedConfigPagePtr;
  if ( (g_systemControl.bootEnv & 1) == 0 && g_systemControl.hid->pad == (u16)~0xF341 )
    isSafeModeComboPressed = 1;
  g_kernelSharedConfigPagePtr->kernelBuildVersion = 0;
  v1->kernelRevisionVersion = 0;
  v1->kernelMinorVersion = 57;
  v1->kernelMajorVersion = 2;
  v1->updateFlag = isSafeModeComboPressed;
  v1->sysCoreVer = 2;
  LODWORD(v1->nsTid) = 0;
  HIDWORD(v1->nsTid) = 0;
  v1->envInfo = 0;
  v1->unitInfo = g_systemControl.unitInfo;
  v1->bootEnv = g_systemControl.bootEnv;
  v1->kernelCtrSdkVersion = 0xF426;             // sdk version
  if ( g_systemControl.unitInfo )
  {
    g_systemControl.targetSystem.isDevUnit = 1;
  }
  else
  {
    g_systemControl.targetSystem.isDevUnit = 0;
    v1->envInfo = 1;
  }
  isDevUnitWithJtag = g_systemControl.unitInfo == 2;
  if ( g_systemControl.unitInfo != 2 )
    isDevUnitWithJtag = g_systemControl.unitInfo == 3;
  if ( isDevUnitWithJtag )
  {
    g_systemControl.targetSystem.userExceptionHandlersEnabled = 1;
    g_systemControl.targetSystem.kernelPanicOnUserBreak = 1;
  }
  else
  {
    g_systemControl.targetSystem.userExceptionHandlersEnabled = 0;
    g_systemControl.targetSystem.kernelPanicOnUserBreak = 0;
  }
  if ( (__mrc(14, 0, 0, 1, 0) & 0x4000) != 0 )  // jtag connected
    v1->envInfo |= 2u;
  v1->nsTid = 0x4013000008002LL;
  appMemType = g_systemControl.appMemType;
  deliverParamsPage = g_systemControl.deliverParamsPage;
  if ( g_systemControl.appMemType == 7 )
    v5 = 0xB200000;
  else
    v5 = 0x7C00000;
  v6 = *(_DWORD *)(g_systemControl.deliverParamsPage + 0x400);
  v1->appMemAlloc = v5;
  v1->sysMemAlloc = 0xE000000 - v5;
  v1->baseMemAlloc = 0x2000000;
  v1->appMemType = appMemType;
  v1->firmlaunchFlags = v6;
  if ( *(_DWORD *)(deliverParamsPage + 0x438) == 0xFFFF && (*(_DWORD *)(deliverParamsPage + 0x400) & 0x100) != 0 )// "FIRM" fields
  {
    v1->firmBuildVersion = *(_BYTE *)(deliverParamsPage + 0x410);
    v1->firmRevisionVersion = *(_BYTE *)(deliverParamsPage + 0x411);
    v1->firmMinorVersion = *(_BYTE *)(deliverParamsPage + 0x412);
    v1->firmMajorVersion = *(_BYTE *)(deliverParamsPage + 0x413);
    v1->firmCtrSdkVersion = *(_DWORD *)(deliverParamsPage + 0x418);
    v1->firmSysCoreVer = *(_DWORD *)(deliverParamsPage + 0x414);
  }
  else
  {
    kernelRevisionVersion = v1->kernelRevisionVersion;
    kernelMinorVersion = v1->kernelMinorVersion;
    kernelMajorVersion = v1->kernelMajorVersion;
    sysCoreVer = v1->sysCoreVer;
    kernelCtrSdkVersion = v1->kernelCtrSdkVersion;
    v1->firmBuildVersion = v1->kernelBuildVersion;
    v1->firmRevisionVersion = kernelRevisionVersion;
    v1->firmMinorVersion = kernelMinorVersion;
    v1->firmMajorVersion = kernelMajorVersion;
    v1->firmSysCoreVer = sysCoreVer;
    v1->firmCtrSdkVersion = kernelCtrSdkVersion;
  }
}
// FFF2F0D4: using guessed type KernelSharedConfig *g_kernelSharedConfigPagePtr;

//----- (FFF015BC) --------------------------------------------------------
void __fastcall KCoreLocalContext::InitializeCurrent(s32 coreId)
{
  KCoreLocalContext *p_clc; // r4
  KThread *__shifted(KCoreLocalContext,0x18) schedThread; // r0
  KScheduler *__shifted(KCoreLocalContext,0xC8) v3; // r0
  unsigned __int64 *unused_300; // r2

  p_clc = &g_coreLocalRegions[coreId].clc;
  if ( p_clc )
  {
    memset(p_clc, 0, 0xB78u);
    p_clc->current.threadWithVfp = 0;
    schedThread = (KThread *__shifted(KCoreLocalContext,0x18))KSynchronizationObject::KSynchronizationObject(&p_clc->idleThread);
    ADJ(schedThread)->idleThread.next = 0;
    ADJ(schedThread)->idleThread.next = 0;
    ADJ(schedThread)->idleThread.__vftable = &KThread::vt_KInterruptTask;
    ADJ(schedThread)->idleThread.next = 0;
    ADJ(schedThread)->idleThread.__vftable = &KThread::vt_KTimerTask;
    ADJ(schedThread)->idleThread.__vftable = &KThread::vt;
    ADJ(schedThread)->idleThread.__vftable = &KThread::vt_KWorkerTask;
    ADJ(schedThread)->idleThread.shallTerminate = 0;
    ADJ(schedThread)->idleThread.synchronizationResult = 0xE7E3FFFF;
    ADJ(schedThread)->idleThread.wantedLightMutex = 0;
    ADJ(schedThread)->idleThread.syncObjectWaitAllList.link.next = (KSynchronizationObjectLinkedListNode *)&ADJ(schedThread)->idleThread.syncObjectWaitAllList.link;
    ADJ(schedThread)->idleThread.syncObjectWaitAllList.count = 0;
    ADJ(schedThread)->idleThread.syncObjectWaitAllList.link.prev = (KSynchronizationObjectLinkedListNode *)&ADJ(schedThread)->idleThread.syncObjectWaitAllList.link;
    ADJ(schedThread)->idleThread.heldMutexListRootNode = 0;
    ADJ(schedThread)->idleThread.mutexTryingToAcquireList.link.next = (KMutexLinkedListNode *)&ADJ(schedThread)->idleThread.mutexTryingToAcquireList.link;
    ADJ(schedThread)->idleThread.mutexTryingToAcquireList.count = 0;
    ADJ(schedThread)->idleThread.mutexTryingToAcquireList.link.prev = (KMutexLinkedListNode *)&ADJ(schedThread)->idleThread.mutexTryingToAcquireList.link;
    ADJ(schedThread)->idleThread.affinityMask = 0;
    ADJ(schedThread)->idleThread.owner = 0;
    ADJ(schedThread)->idleThread.context = 0;
    v3 = KScheduler::KScheduler(&ADJ(schedThread)->schedulerInstance);
    ADJ(v3)->interruptTaskManagerInstance.first = 0;
    ADJ(v3)->interruptTaskManagerInstance.last = 0;
    v3 = (KScheduler *__shifted(KCoreLocalContext,0xC8))((char *)v3 + 0x238);
    ADJ(v3)->schedulerInstance.__vftable = 0;   // unused@0x300
    ADJ(v3)->schedulerInstance.next = 0;
  }
  p_clc->current.thread = 0;
  p_clc->current.process = 0;
  unused_300 = (unsigned __int64 *)p_clc->unused_300;
  p_clc->current.scheduler = &p_clc->schedulerInstance;
  p_clc->current.interruptTaskManager = &p_clc->interruptTaskManagerInstance;
  do
    __ldrexd(unused_300);
  while ( __strexd(0LL, unused_300) );
  *(_DWORD *)&p_clc->unused_300[8] = 0;
  *(_DWORD *)&p_clc->unused_300[12] = 0;
  *(_DWORD *)&p_clc->unused_300[16] = 0;
  *(_DWORD *)&p_clc->unused_300[20] = 0;
  *(_DWORD *)&p_clc->unused_300[24] = 0;
  *(_DWORD *)&p_clc->unused_300[28] = 0;
  *(_DWORD *)&p_clc->unused_300[40] = 0;
  *(_DWORD *)&p_clc->unused_300[44] = 0;
  *(_DWORD *)&p_clc->unused_300[48] = 0;
  *(_DWORD *)&p_clc->unused_300[52] = 0;
  *(_DWORD *)&p_clc->unused_300[56] = 0;
  *(_DWORD *)&p_clc->unused_300[60] = 0;
  *(_DWORD *)&p_clc->unused_300[68] = 0;
  *(_DWORD *)&p_clc->unused_300[96] = 0;
  *(_DWORD *)&p_clc->unused_300[64] = 0;
  *(_DWORD *)&p_clc->unused_300[108] = 0;
  *(_DWORD *)&p_clc->unused_300[100] = 0;
  *(_DWORD *)&p_clc->unused_300[104] = 0;
  *(_DWORD *)&p_clc->unused_300[88] = 0;
  *(_DWORD *)&p_clc->unused_300[92] = 0;
  *(_DWORD *)&p_clc->unused_300[72] = 0;
  *(_DWORD *)&p_clc->unused_300[76] = 0;
  *(_DWORD *)&p_clc->unused_300[80] = 0;
  *(_DWORD *)&p_clc->unused_300[84] = 0;
}

//----- (FFF01764) --------------------------------------------------------
void AllocateSharedConfigPages(void)
{
  KernelSharedConfig *v0; // r9
  unsigned int v1; // r2
  bool v2; // zf
  unsigned int v3; // r3
  u32 v4; // r8
  unsigned int v5; // r2
  bool v6; // zf
  unsigned int v7; // r3

  g_kernelSharedConfigPagePtr = (KernelSharedConfig *)KMemoryManager::AllocateContiguous(
                                                        &g_memoryManager,
                                                        1u,
                                                        0,
                                                        MEMOP_REGION_BASE_KERNEL);
  g_userSharedConfigPagePtr = KMemoryManager::AllocateContiguous(&g_memoryManager, 1u, 0, MEMOP_REGION_BASE_KERNEL);
  v0 = g_kernelSharedConfigPagePtr;
  v1 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v2 = v1 == 0;
  if ( v1 )
    v3 = __strex(v1, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v3 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v1 )
    v2 = v3 == 0;
  if ( !v2 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)v0, 1u);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  v4 = g_userSharedConfigPagePtr;
  v5 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v6 = v5 == 0;
  if ( v5 )
    v7 = __strex(v5, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v7 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v5 )
    v6 = v7 == 0;
  if ( !v6 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::IncrefPages(&g_memoryManager.pgMgr, v4, 1u);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
}
// FFF2F0D4: using guessed type KernelSharedConfig *g_kernelSharedConfigPagePtr;

//----- (FFF01870) --------------------------------------------------------
void __fastcall KLevel2TranslationTableAllocator::Initialize(u32 cpuId)
{
  u32 v1; // r9
  u16 *refcounts; // r7
  int v3; // r0
  unsigned int v4; // r1
  int v5; // r1
  u32 v6; // r0
  u16 *v7; // r2
  int v8; // r1
  u16 *v9; // r2
  u32 Contiguous; // r5
  unsigned int v11; // r1
  bool v12; // zf
  int i; // r7
  KLevel2TranslationTable *v14; // r0
  KLevel2TranslationTable *rootNode; // r1

  if ( !cpuId )
  {
    g_level2TtblAllocator.baseRegionStart = g_memoryManager.baseHeap.regionStart;
    g_level2TtblAllocator.baseRegionSize = g_memoryManager.baseHeap.regionSize;
    v1 = g_memoryManager.baseHeap.regionSize >> 21;
    refcounts = (u16 *)KMemoryManager::AllocateContiguous(
                         &g_memoryManager,
                         g_memoryManager.baseHeap.regionSize >> 21,// BUG: this is not rounded up
                                                // 
                                                // this prevent rosalina from setting BASE to a non-2MB aligned region
                                                // 
                                                // fuck this shit
                         0,
                         MEMOP_REGION_BASE_KERNEL);
    if ( !refcounts )
    {
      v3 = -664795149;
LABEL_36:
      if ( v3 < 0 )
        kernelpanic();
      return;
    }
    v4 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
    if ( v4 )
    {
      __strex(v4, (unsigned int *)&g_memoryManager.pgMgr.mutex);
    }
    else if ( !__strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex) )
    {
      goto LABEL_8;
    }
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
LABEL_8:
    __mcr(15, 0, 0, 7, 10, 5);
    KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)refcounts, v1);
    __mcr(15, 0, 0, 7, 10, 5);
    g_memoryManager.pgMgr.mutex.lockingThread = 0;
    if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
    g_level2TtblAllocator.refcounts = refcounts;
    if ( g_level2TtblAllocator.baseRegionSize >= 0x400 )
    {
      v5 = 0;
      v6 = g_level2TtblAllocator.baseRegionSize << 21 >> 31;
      if ( v6 == 1 )
        *refcounts = 0;
      if ( v6 == 1 )
        v5 = 1;
      for ( ; v6 < g_level2TtblAllocator.baseRegionSize >> 10; *v9 = 0 )
      {
        v6 += 2;
        v7 = &g_level2TtblAllocator.refcounts[v5];
        v8 = v5 + 1;
        *v7 = 0;
        v9 = &g_level2TtblAllocator.refcounts[v8];
        v5 = v8 + 1;
      }
    }
    g_level2TtblAllocator.numAvailable = 0;
    Contiguous = KMemoryManager::AllocateContiguous(&g_memoryManager, 0x20u, 0, MEMOP_REGION_BASE_KERNEL);
    if ( Contiguous )
    {
      v11 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
      v12 = v11 == 0;
      if ( v11 )
        __strex(v11, (unsigned int *)&g_memoryManager.pgMgr.mutex);
      else
        v11 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
      if ( v12 )
        v12 = v11 == 0;
      if ( !v12 )
        KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
      __mcr(15, 0, 0, 7, 10, 5);
      KPageManager::IncrefPages(&g_memoryManager.pgMgr, Contiguous, 0x20u);
      __mcr(15, 0, 0, 7, 10, 5);
      g_memoryManager.pgMgr.mutex.lockingThread = 0;
      if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
        KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
      for ( i = 0; i < 128; ++i )
      {
        v14 = (KLevel2TranslationTable *)(Contiguous + (i << 10));
        if ( v14 )
        {
          v14->next = 0;
          v14->prev = 0;
        }
        rootNode = g_level2TtblAllocator.rootNode;
        if ( g_level2TtblAllocator.rootNode )
        {
          v14->prev = g_level2TtblAllocator.rootNode;
          rootNode->next->prev = v14;
          v14->next = rootNode->next;
          rootNode->next = v14;
        }
        else
        {
          v14->prev = v14;
          v14->next = v14;
        }
        g_level2TtblAllocator.rootNode = v14;
      }
      g_level2TtblAllocator.numAvailable += 128;
    }
    v3 = 0;
    goto LABEL_36;
  }
}

//----- (FFF01A8C) --------------------------------------------------------
void __fastcall KHardwareTimer::Initialize(KHardwareTimer *this, s32 coreId)
{
  int v2; // r8
  char cfgr; // r0
  int v4; // r10
  _DWORD *v5; // r0

  if ( coreId == 1 )
  {
    if ( KSystemControl::IsLgr2Capable() )
    {
      g_timerPrescaler = 2;
      g_wdPrescaler = 2;
    }
    v2 = 0;
    cfgr = MPCORE.scu.cfgr;
    v4 = (cfgr & 3) + 1;
    if ( v4 > 0 )                               // initialize all timer and wdt blocks (but only use the one for core 1)
    {
      do
      {
        v5 = (_DWORD *)((v2 << 8) + 0xFFFEE734);
        *(_DWORD *)((v2 << 8) + 0xFFFEE708) = 0;
        *(_DWORD *)((v2 << 8) + 0xFFFEE700) = 0;
        *(_DWORD *)((v2 << 8) + 0xFFFEE704) = 0;
        *(_DWORD *)((v2 << 8) + 0xFFFEE70C) = 1;// clear event flag (timer)
        *v5 = 0x12345678;                       // disable watchdog mode
        *v5 = 0x87654321;
        *(_DWORD *)((v2 << 8) + 0xFFFEE728) = 0;
        *(_DWORD *)((v2 << 8) + 0xFFFEE720) = 0;
        *(_DWORD *)((v2 << 8) + 0xFFFEE724) = 0;
        *(_DWORD *)((v2 << 8) + 0xFFFEE72C) = 1;// clear event flag (watchdog)
        *(_DWORD *)((v2++ << 8) + 0xFFFEE730) = 0;
      }
      while ( v4 > v2 );
    }
    this->innerTask.next = 0;
    KInterruptManager::BindInterrupt(&g_interruptManager, this, KINTNAME_TIMER, 1, 0, 1, 0);
    KInterruptManager::BindInterrupt(&g_interruptManager, this, KINTNAME_WDT, 1, 0, 0, 0);
    this->counter = 0;
    this->previousCounterOnInterrupt = 0;
    MPCORE.timerWdtN[1].watchdogloadr = 0xFFFFFFFF;
    MPCORE.timerWdtN[1].watchdogcontrolr = (g_wdPrescaler << 8) | 7;// 
                                                // wdt interrupt is always left enable, and we still need to keep track of the time when running KTimerTasks...
                                                // 
                                                // timer interrupt is used for timer tasks
  }
  cpu::SynchronizeAllCores();
}

//----- (FFF01C10) --------------------------------------------------------
void __fastcall KSupervisorPageTable::UnmapIdentityAndInit(KSupervisorPageTable *this, u32 coreId)
{
  current.L1Table[0x1FF] = 0;
  KPageTable::CleanInvalidateEntireDataCacheLocal();
  KPageTable::InvalidateEntireInstructionCacheLocal();
  __mcr(15, 0, 0, 8, 7, 0);
  __mcr(15, 0, 0, 7, 5, 6);
  __mcr(15, 0, 0, 7, 10, 4);
  __mcr(15, 0, 0, 7, 5, 4);
  if ( !coreId )
    KSupervisorPageTable::Initialize(this, current.L1Table, 0x40000000u, 0xFFFFF000);
}

//----- (FFF01C70) --------------------------------------------------------
void __fastcall BindVariousAllCoreHelperIrqHandlers(s32 coreId)
{
  KInterruptManager::BindInterrupt(
    &g_interruptManager,
    &g_systemControlHelper,
    KINTNAME_SGI_CONTROL_SYSTEM,
    coreId,
    0,
    0,
    0);
  KTlbMaintenanceHelper::BindInterrupt(coreId);
  KVfpRegisterDumpHelper::BindInterrupt(coreId);
}

//----- (FFF01CC0) --------------------------------------------------------
void __fastcall InitBindIrqHandlersWithThreads(s32 coreId)
{
  unsigned int v2; // r2
  bool v3; // zf
  unsigned int v4; // r3
  unsigned int v5; // r3
  unsigned int v6; // r2
  bool v7; // zf
  unsigned int v8; // r3
  KSynchronizationObject *v9; // r0
  KThread *v10; // r5
  KThread *v11; // r0
  void *kernStackBottom; // r9

  v2 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v3 = v2 == 0;
  if ( v2 )
    v4 = __strex(v2, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v4 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v2 )
    v3 = v4 == 0;
  if ( !v3 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  do
    v5 = __ldrex(&g_memoryManager.pgMgr.kernelMemoryUsage);
  while ( __strex(v5 + 4096, &g_memoryManager.pgMgr.kernelMemoryUsage) );
  kernStackBottom = KPageHeap::AllocateContiguous(&g_memoryManager.baseHeap, 1u, 1u);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  v6 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v7 = v6 == 0;
  if ( v6 )
    v8 = __strex(v6, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v8 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v6 )
    v7 = v8 == 0;
  if ( !v7 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)kernStackBottom, 1u);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  v9 = (KSynchronizationObject *)KSlabHeap::Allocate(&g_threadAllocator.slabHeap);
  v10 = (KThread *)v9;
  if ( v9 )
  {
    v11 = (KThread *)KSynchronizationObject::KSynchronizationObject(v9);
    v11->KTimerTask::next = 0;
    v11->KWorkerTask::next = 0;
    v11->KInterruptTask::KInterruptHandler::__vftable = &KThread::vt_KInterruptTask;
    v11->KInterruptTask::next = 0;
    v11->KWorkerTask::__vftable = &KThread::vt_KWorkerTask;
    v11->KTimerTask::__vftable = &KThread::vt_KTimerTask;
    v11->KSynchronizationObject::KAutoObject::__vftable = &KThread::vt;
    v11->shallTerminate = 0;
    v11->synchronizationResult = 0xE7E3FFFF;
    v11->wantedLightMutex = 0;
    v11->syncObjectWaitAllList.link.next = (KSynchronizationObjectLinkedListNode *)&v11->syncObjectWaitAllList.link;
    v11->syncObjectWaitAllList.count = 0;
    v11->syncObjectWaitAllList.link.prev = (KSynchronizationObjectLinkedListNode *)&v11->syncObjectWaitAllList.link;
    v11->heldMutexListRootNode = 0;
    v11->mutexTryingToAcquireList.link.next = (KMutexLinkedListNode *)&v11->mutexTryingToAcquireList.link;
    v11->mutexTryingToAcquireList.count = 0;
    v11->mutexTryingToAcquireList.link.prev = (KMutexLinkedListNode *)&v11->mutexTryingToAcquireList.link;
    v11->affinityMask = 0;
    v11->owner = 0;
    v11->context = 0;
    KAutoObject::Initialize(v10);
  }
  KThread::Initialize(
    v10,
    (u32)KCacheMaintenanceHelper::ThreadFunction,
    (u32)&g_cacheMaintenanceHelper,
    (u32)kernStackBottom + 0x1000,
    0,
    12,
    coreId,
    0,
    KTHREAD_TYPE_KERNEL);
  KObjectAllocator::Register(&g_threadAllocator, v10);
  KSchedulerLock::Lock(&g_schedulerLock);
  KThread::PrepareToRun(v10);
  KThread::SetSchedulingState(v10, KTHREADSCHEDSTAT_PAUSED);
  KSchedulerLock::Unlock(&g_schedulerLock);
  g_cacheMaintenanceHelper.tasks[coreId].handlingThread = v10;
  KInterruptManager::BindInterrupt(
    &g_interruptManager,
    &g_cacheMaintenanceHelper,
    KINTNAME_SGI_CACHE_MAINTENANCE,
    coreId,
    0,
    0,
    0);
  KInterruptManager::BindInterrupt(&g_interruptManager, &g_terminationHelper, KINTNAME_SGI_TERMINATION, coreId, 0, 0, 0);
  KPerformanceCounterControlHelper::BindInterrupt(coreId);
}
// FFF01D40: conditional instruction was optimized away because r0.4==300
// FFF01D48: conditional instruction was optimized away because r0.4==300
// FFF01DEC: conditional instruction was optimized away because r0.4!=0

//----- (FFF02000) --------------------------------------------------------
Result KDebug::InitializeScheduledInOutState(void)
{
  SetEightBytesTo1(g_scheduledOut, 1);
  return 0;
}
// FFF2F058: using guessed type bool g_scheduledOut[8];

//----- (FFF0201C) --------------------------------------------------------
void __fastcall KThread::SetIdlePriority(KThread *this)
{
  s32 dynamicPriority; // r2

  KSchedulerLock::Lock(&g_schedulerLock);
  dynamicPriority = this->dynamicPriority;
  this->basePriority = 64;
  this->dynamicPriority = 64;
  KScheduler::AdjustThreadPriorityChanged(current.clc.current.scheduler, this, dynamicPriority);
  KSchedulerLock::Unlock(&g_schedulerLock);
}

//----- (FFF02068) --------------------------------------------------------
void __fastcall __noreturn HandlePrefetchAbortException(int a1, int a2, int a3, int a4, int a5)
{
  if ( (__get_SPSR() & 0x1F) != 16 )
    DispatchKernelExceptionWithRegdump((int)&a5, a2, a3, (int)DispatchPrefetchAbortException, a5);
  __asm
  {
    SRSDB           SP!, #0x13
    CPS             #0x13
  }
  DispatchExceptionWithRegdump((int)&a5, a2, a3, a4, a5);
}

//----- (FFF020B0) --------------------------------------------------------
void __fastcall HandleDataAbortException(int a1, int a2, int a3, int a4, int a5)
{
  int v5; // lr
  unsigned int v6; // lr
  void *v11; // r0

  v6 = v5 - 8;
  if ( (__get_SPSR() & 0x1F) == 16 )
  {
    __asm
    {
      SRSDB           SP!, #0x13; user
      CPS             #0x13
    }
    DispatchExceptionWithRegdump((int)&a5, a2, a3, a4, a5);
  }
  v11 = CopyBytesFromUser;
  if ( v6 >= (unsigned int)CopyBytesFromUser )
  {
    v11 = KDmaAddress::ResetAddress;
    if ( v6 < (unsigned int)KDmaAddress::ResetAddress )
    {
      __asm
      {
        MSR             SPSR_f, #0x40000000
        ADDS            PC, LR, #4
      }
    }
  }
  DispatchKernelExceptionWithRegdump((int)v11, a2, a3, (int)DispatchDataAbortException, a5);
}
// FFF020B0: variable 'v5' is possibly undefined

//----- (FFF02128) --------------------------------------------------------
char *__fastcall HandleIrqException(int a1, int a2, int *a3, int a4, int a5)
{
  int *v5; // r12
  int v6; // lr
  int v7; // lr
  char *result; // r0
  int *v13; // [sp+0h] [bp-20h]
  int v14; // [sp+4h] [bp-1Ch]
  int *v15; // [sp+8h] [bp-18h] BYREF
  int v16; // [sp+Ch] [bp-14h]
  int *v17; // [sp+10h] [bp-10h]
  int v18; // [sp+14h] [bp-Ch] BYREF
  int *v19; // [sp+18h] [bp-8h] BYREF
  int v20; // [sp+1Ch] [bp-4h]

  v7 = v6 - 4;
  if ( (__get_SPSR() & 0x1F) == 16 )
  {
    __asm
    {
      SRSDB           SP!, #0x13
      CPS             #0x13
    }
    v19 = &a5;
    v20 = v7;
    v13 = &a5;
    v14 = a2;
    v15 = a3;
    v16 = a4;
    v17 = v5;
    IrqHandlerImpl(1);
    __asm { RFEFD           SP! }
  }
  v19 = &a5;
  v20 = a2;
  __asm
  {
    CPS             #0x13
    CPS             #0x12
  }
  result = (char *)&v18 + 3;
  if ( (int)((int)&v18 - (((unsigned int)&v18 + 3) & 0xFFFFF000) + 3) >= 0x300 )
  {
    __asm
    {
      SRSDB           SP!, #0x13
      CPS             #0x13
    }
    v15 = v19;
    v16 = v20;
    v17 = a3;
    v18 = a4;
    v19 = v5;
    v20 = v7;
    v13 = (int *)&v15;
    v14 = v7;
    IrqHandlerImpl(0);
    __asm { RFEFD           SP! }
  }
  return result;
}
// FFF02128: variable 'v6' is possibly undefined
// FFF02154: variable 'v5' is possibly undefined

//----- (FFF021F0) --------------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn HandleSvcException(int a1, int a2, int a3, int a4, int a5, int a6, __int16 a7)
{
  int v7; // r4
  int v8; // lr
  u32 v13; // r9
  int v14; // r1
  int v15; // r2
  int v16; // r3
  int v17; // r12
  int v18; // r0
  int (__fastcall *v19)(int, int, int, int, int, int, int, int, int); // r8
  int v23; // [sp-8h] [bp-48h]
  int v25; // [sp-4h] [bp-44h]
  int v26; // [sp+0h] [bp-40h]
  int v27; // [sp+0h] [bp-40h]
  int v28; // [sp+4h] [bp-3Ch]
  int v29; // [sp+8h] [bp-38h]
  int v30; // [sp+Ch] [bp-34h]
  int v31; // [sp+10h] [bp-30h]
  int v32; // [sp+14h] [bp-2Ch]
  int v33; // [sp+14h] [bp-2Ch]
  int v34; // [sp+18h] [bp-28h]
  int v35; // [sp+1Ch] [bp-24h]
  int v36; // [sp+20h] [bp-20h]
  int v37; // [sp+24h] [bp-1Ch]
  _BYTE *v38; // [sp+28h] [bp-18h]
  int v39; // [sp+2Ch] [bp-14h]
  _BYTE v40[8]; // [sp+30h] [bp-10h] BYREF
  int v41; // [sp+38h] [bp-8h]

  __asm { SRSDB           SP!, #0x13 }
  v38 = v40;
  v39 = v8;
  if ( (__get_SPSR() & 0x20) != 0 )
    LOWORD(v13) = *(_WORD *)(v8 - 2);
  else
    v13 = *(_DWORD *)(v8 - 4);
  v13 = (unsigned __int8)v13;
  if ( (unsigned __int8)v13 < 0x80u
    && (v19 = (int (__fastcall *)(int, int, int, int, int, int, int, int, int))svcTable[v13],
        (*((unsigned __int8 *)&v41 + (v13 >> 3)) & (1 << (v13 & 7))) != 0) )
  {
    if ( HIBYTE(a7) )
    {
      v26 = v7;
      __enable_irq();
      v18 = v19(a1, a2, a3, a4, a1, a2, a3, a4, v26);
    }
    else
    {
      __enable_irq();
      v18 = ((int (__fastcall *)(int, int, int, int))v19)(a1, a2, a3, a4);
    }
    __disable_irq();
  }
  else
  {
    SvcStopPointOrInvalidId(v13);
    v18 = 0;
    if ( v32 )
    {
      v18 = v34;
      v14 = v35;
      v15 = v36;
      v16 = v37;
      v17 = v41;
    }
  }
  while ( v39 )
  {
    v29 = v18;
    v30 = v14;
    v31 = v15;
    v33 = v16;
    v38 = (_BYTE *)v17;
    v39 = 0;
    v23 = v18;
    v25 = v14;
    v27 = v15;
    v28 = v16;
    PostSvcDpcHandler();
    v18 = v23;
    v14 = v25;
    v15 = v27;
    v16 = v28;
    if ( v39 )
    {
      v18 = v29;
      v14 = v30;
      v15 = v31;
      v16 = v33;
      v17 = (int)v38;
    }
  }
  __asm { RFEFD           SP! }
}
// FFF02248: positive sp value 10 has been found
// FFF022A0: conditional instruction was optimized away because %0x24.4==0
// FFF021F4: variable 'v8' is possibly undefined
// FFF02240: variable 'v32' is possibly undefined
// FFF0227C: variable 'v7' is possibly undefined
// FFF022E4: variable 'v14' is possibly undefined
// FFF022E4: variable 'v15' is possibly undefined
// FFF022E4: variable 'v16' is possibly undefined
// FFF022E4: variable 'v17' is possibly undefined
// FFF0230C: using guessed type void *svcTable[126];

//----- (FFF02504) --------------------------------------------------------
int __fastcall HandleUndefinedInstructionException(int result, int a2, int a3, int a4, _DWORD *a5)
{
  __get_SPSR();
  if ( &a5 == (_DWORD **)16 )
  {
    __get_SPSR();
    if ( &a5 == (_DWORD **)32 )
    {
      __asm
      {
        SRSDB           SP!, #0x13
        CPS             #0x13
      }
    }
    else
    {
      __asm
      {
        SRSDB           SP!, #0x13
        CPS             #0x13
      }
      if ( (unsigned int)(16 * *a5 + 0x40000000) < 0x30000000 )
      {
        __asm { VMRS            LR, FPEXC }
        if ( (_LR & 0x40000000) == 0 )
        {
          EnableVfpAfterException();
          __asm { RFEFD           SP! }
        }
      }
    }
    DispatchExceptionWithRegdump(result, a2, a3, a4, (int)a5);
  }
  return result;
}

//----- (FFF025A8) --------------------------------------------------------
Result __fastcall InitialProcess::LoadCode(InitialProcess *this, KCodeSet *codeSet)
{
  ExHeader *exheader; // r5
  u32 v4; // r10
  u32 totalAllocSize; // r9
  char *decompressBuffer; // r7
  unsigned int v7; // r2
  bool v8; // zf
  unsigned int v9; // r3
  ExeFs *exeFs; // r5
  char *v11; // r5
  unsigned int v12; // r2
  bool v13; // zf
  unsigned int v14; // r3
  char *src; // [sp+0h] [bp-80h]
  void *textLoadAddr; // [sp+4h] [bp-7Ch] BYREF
  CodeSetInfo codeSetInfo; // [sp+8h] [bp-78h] BYREF
  void *rodataLoadAddr; // [sp+48h] [bp-38h] BYREF
  void *rwDataLoadAddr; // [sp+4Ch] [bp-34h] BYREF

  memset(&codeSetInfo, 0, sizeof(codeSetInfo));
  codeSetInfo.name = this->exheader->info.sci.codeSetInfo.name;
  exheader = this->exheader;
  v4 = (this->exheader->info.sci.codeSetInfo.bssSize + 4095) >> 12;
  src = (char *)&this->cxi->exheader + Ncch::ConvertSize(this->ncch->exeFsOffset, 0, this->ncch->flags[6] + 9);
  InitialProcess::AllocateSegment(
    this,
    &textLoadAddr,
    &codeSetInfo.text,
    &exheader->info.sci.codeSetInfo.textCodeSectionInfo);// this is ctr-arm11 specific stuff
                                                // 
                                                // LGY and Arm9 kernels load the code properly (no -nocodepadding) and honor IsCodeCompressed
  InitialProcess::AllocateSegment(
    this,
    &rodataLoadAddr,
    &codeSetInfo.rodata,
    &this->exheader->info.sci.codeSetInfo.rodataSectionInfo);
  InitialProcess::AllocateSegment(
    this,
    &rwDataLoadAddr,
    &codeSetInfo.rwdata,
    &this->exheader->info.sci.codeSetInfo.dataSectionInfo);
  totalAllocSize = (this->exheader->info.sci.codeSetInfo.dataSectionInfo.size
                  + this->exheader->info.sci.codeSetInfo.textCodeSectionInfo.size
                  + this->exheader->info.sci.codeSetInfo.rodataSectionInfo.size
                  + 4095) >> 12;
  decompressBuffer = (char *)KMemoryManager::AllocateContiguous(&g_memoryManager, totalAllocSize, 1u, MEMOP_REGION_BASE);
  v7 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v8 = v7 == 0;
  if ( v7 )
    v9 = __strex(v7, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v9 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v7 )
    v8 = v9 == 0;
  if ( !v8 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)decompressBuffer, totalAllocSize);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  exeFs = (ExeFs *)&this->cxi->signature[Ncch::ConvertSize(this->ncch->exeFsOffset, 0, this->ncch->flags[6] + 9)];
  memcpy(decompressBuffer, src, exeFs->fileHdrs[0].size);
  LzssDecompress((u8 *)&decompressBuffer[exeFs->fileHdrs[0].size]);
  memcpy(textLoadAddr, decompressBuffer, this->exheader->info.sci.codeSetInfo.textCodeSectionInfo.size);
  v11 = &decompressBuffer[this->exheader->info.sci.codeSetInfo.textCodeSectionInfo.size];
  memcpy(rodataLoadAddr, v11, this->exheader->info.sci.codeSetInfo.rodataSectionInfo.size);
  memcpy(
    rwDataLoadAddr,
    &v11[this->exheader->info.sci.codeSetInfo.rodataSectionInfo.size],
    this->exheader->info.sci.codeSetInfo.dataSectionInfo.size);
  v12 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v13 = v12 == 0;
  if ( v12 )
    v14 = __strex(v12, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v14 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v12 )
    v13 = v14 == 0;
  if ( !v13 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::FreeContiguous(&g_memoryManager.pgMgr, (u32)decompressBuffer, totalAllocSize, MEMOP_NONE);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  codeSetInfo.text_size_total = codeSetInfo.text.size;
  codeSetInfo.ro_size_total = codeSetInfo.rodata.size;
  codeSetInfo.rw_size_total = codeSetInfo.rwdata.size + v4;
  KCodeSet::InitializeDirectly(codeSet, &codeSetInfo, (u32)textLoadAddr, (u32)rodataLoadAddr, (u32)rwDataLoadAddr);
  return 0;
}

//----- (FFF0283C) --------------------------------------------------------
KScheduler *__fastcall KScheduler::KScheduler(KScheduler *this)
{
  KScheduler *result; // r0

  this->__vftable = &KScheduler::vt;
  this->next = 0;
  this->disableCount = 1;
  this->reschedule = 1;
  this->rescheduleInterruptTaskMgrThread = 0;
  this->triggerSgi = 0;
  this->interruptTaskAdded = 0;
  this->coreId = -1;
  this->numThreads = 0;
  this->idleThread = 0;
  this->allThreads.link.prev = 0;
  this->allThreads.link.next = 0;
  result = CONTAINING_RECORD(
             _aeabi_vec_ctor_nocookie_nodtor(
               this->threadsByPrio,
               (void *(__fastcall *)(void *))KThreadIntrusiveList::KThreadIntrusiveList,
               8u,
               0x40u),
             KScheduler,
             threadsByPrio);
  result->prioBitfield[0] = 0;
  result->prioBitfield[1] = 0;
  return result;
}

//----- (FFF028A8) --------------------------------------------------------
void __fastcall KMemoryManager::Intialize(KMemoryManager *this, FcramLayout *a2, u32 fcramAddr, u32 fcramSize)
{
  unsigned int *p_kernelMemoryUsage; // r12

  KPageHeap::Initialize(&this->applicationHeap, a2->applicationAddr, a2->applicationSize);
  KPageHeap::Initialize(&this->systemHeap, a2->systemAddr, a2->systemSize);
  KPageHeap::Initialize(&this->baseHeap, a2->baseAddr, a2->baseSize);
  p_kernelMemoryUsage = &this->pgMgr.kernelMemoryUsage;
  do
    __ldrex(p_kernelMemoryUsage);
  while ( __strex(0, p_kernelMemoryUsage) );
  this->pgMgr.unused_14_zero = 0;
  this->pgMgr.mm = this;
  this->pgMgr.memoryStartAddr = fcramAddr;
  this->pgMgr.numPages = fcramSize >> 12;
  KPageManager::Intialize(&this->pgMgr, fcramSize >> 12);
}

//----- (FFF02928) --------------------------------------------------------
void __fastcall __noreturn KWorkerTaskManager::ThreadFunction(KWorkerTaskManager *this)
{
  KWorkerTask *first; // r5
  KWorkerTask *last; // r0
  bool v4; // zf

  while ( 1 )
  {
    while ( 1 )
    {
      KSchedulerLock::Lock(&g_schedulerLock);
      first = this->first;
      if ( first )
        break;
      this->active = 0;
      KThread::SetSchedulingState(this->handlingThread, KTHREADSCHEDSTAT_PAUSED);
      KSchedulerLock::Unlock(&g_schedulerLock);
    }
    last = this->last;
    v4 = last == first;
    if ( last == first )
    {
      this->last = 0;
      this->first = 0;
    }
    else
    {
      last = first->next;
    }
    if ( !v4 )
      this->first = last;
    first->next = 0;
    this->active = 1;
    KSchedulerLock::Unlock(&g_schedulerLock);
    first->DoWorkerTask(first);
  }
}

//----- (FFF029B0) --------------------------------------------------------
void __fastcall __noreturn KInterruptTaskManager::ThreadFunction(KInterruptTaskManager *this)
{
  unsigned int CPSR; // r4
  KInterruptTask *first; // r6
  KInterruptTask *v4; // r0
  KInterruptTask *last; // r1
  bool v6; // zf

  while ( 1 )
  {
    CPSR = __get_CPSR();
    __disable_irq();
    first = this->first;
    if ( this->first )
      goto LABEL_4;
    __set_CPSR(CPSR);
    KSchedulerLock::Lock(&g_schedulerLock);
    CPSR = __get_CPSR();
    __disable_irq();
    first = this->first;
    if ( this->first )
    {
      KSchedulerLock::Unlock(&g_schedulerLock);
LABEL_4:
      v4 = this->first;
      last = this->last;
      v6 = this->first == last;
      if ( this->first == last )
      {
        this->last = 0;
        this->first = 0;
      }
      else
      {
        v4 = v4->next;
      }
      if ( !v6 )
        this->first = v4;
      __set_CPSR(CPSR);
      first->DoTask(first);
    }
    else
    {
      KThread::SetSchedulingState(this->handlingThread, KTHREADSCHEDSTAT_PAUSED);
      KSchedulerLock::Unlock(&g_schedulerLock);
      KScheduler::RescheduleByForce(current.clc.current.scheduler, 0);
      __set_CPSR(CPSR);
    }
  }
}

//----- (FFF02A60) --------------------------------------------------------
Result __fastcall KThread::InitializeCriticalKernelThread(KThread *this, void *ep, void *arg)
{
  unsigned int v4; // r2
  bool v5; // zf
  unsigned int v6; // r3
  unsigned int v7; // r2
  void *stackBottom; // r8
  unsigned int v9; // r2

  v4 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v5 = v4 == 0;
  if ( v4 )
    v6 = __strex(v4, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v6 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v4 )
    v5 = v6 == 0;
  if ( !v5 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  do
    v7 = __ldrex(&g_memoryManager.pgMgr.kernelMemoryUsage);
  while ( __strex(v7 + 4096, &g_memoryManager.pgMgr.kernelMemoryUsage) );
  stackBottom = KPageHeap::AllocateContiguous(&g_memoryManager.baseHeap, 1u, 1u);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  if ( !stackBottom )
    kernelpanic();
  v9 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( v9 )
  {
    __strex(v9, (unsigned int *)&g_memoryManager.pgMgr.mutex);
LABEL_16:
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
    goto LABEL_17;
  }
  if ( __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex) )
    goto LABEL_16;
LABEL_17:
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)stackBottom, 1u);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  return KThread::Initialize(
           this,
           (u32)ep,
           (u32)arg,
           (u32)stackBottom + 0x1000,
           0,
           0,
           __mrc(15, 0, 0, 0, 5) & 3,
           0,
           KTHREAD_TYPE_KERNEL_CRITICAL);
}
// FFF02AD8: conditional instruction was optimized away because r0.4==300
// FFF02AE0: conditional instruction was optimized away because r0.4==300

//----- (FFF02C68) --------------------------------------------------------
void KDmaController::Initialize(void)
{
  unsigned int v0; // r2
  bool v1; // zf
  unsigned int v2; // r3
  int chanId; // r7
  unsigned int v4; // r2
  bool v5; // zf
  unsigned int v6; // r3
  int v7; // r0

  CDMA.inten = 0xFFFFFFFF;                      // enable all channel interrupts, clear all
  CDMA.intclr = 0xFFFFFFFF;
  CDMA.inten = 0;                               // disable all channel interrupts
  v0 = __ldrex((unsigned int *)&g_dmaManagerLock);
  v1 = v0 == 0;
  if ( v0 )
    v2 = __strex(v0, (unsigned int *)&g_dmaManagerLock);
  else
    v2 = __strex(*(_DWORD *)((int)&CDMA >> 3), (unsigned int *)&g_dmaManagerLock);
  if ( !v0 )
    v1 = v2 == 0;
  if ( !v1 )
    KLightMutex::LockImpl(&g_dmaManagerLock);
  __mcr(15, 0, 0, 7, 10, 5);
  CDMA.dbginst0 = 0x10000;                      // DMAKILL the manager thread
  CDMA.dbginst1 = 0;
  *(_DWORD *)((unsigned int)&CDMA.dbginst1 & ~8u) = 0;// dbgcmd (execute the instruction)
  __mcr(15, 0, 0, 7, 10, 5);
  g_dmaManagerLock.lockingThread = 0;
  if ( g_dmaManagerLock.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_dmaManagerLock);
  for ( chanId = 0; chanId < 8; ++chanId )
  {
    v4 = __ldrex((unsigned int *)&g_dmaManagerLock);
    v5 = v4 == 0;
    if ( v4 )
      v6 = __strex(v4, (unsigned int *)&g_dmaManagerLock);
    else
      v6 = __strex(*(_DWORD *)((int)&CDMA >> 3), (unsigned int *)&g_dmaManagerLock);
    if ( !v4 )
      v5 = v6 == 0;
    if ( !v5 )
      KLightMutex::LockImpl(&g_dmaManagerLock);
    __mcr(15, 0, 0, 7, 10, 5);
    while ( (CDMA.dbgstatus & 1) != 0 )         // wait until instruction finished executing
      ;
    do
    {
      v7 = CDMA.dsr & 0xF;
      if ( v7 == CDMA330THREAD_STATUS_FAULTING )
        kernelpanic();
    }
    while ( v7 );
    CDMA.dbginst0 = ((char)chanId << 8) | 0x10001;// DMAKILL the channel thread
    CDMA.dbginst1 = 0;
    CDMA.dbgcmd = 0;
    __mcr(15, 0, 0, 7, 10, 5);
    g_dmaManagerLock.lockingThread = 0;
    if ( g_dmaManagerLock.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_dmaManagerLock);
  }
}

//----- (FFF02DA8) --------------------------------------------------------
void __fastcall KDmaController::EnableInterrupt(s8 channelId)
{
  unsigned int v2; // r2
  bool v3; // zf
  unsigned int v4; // r3
  u32 inten; // r3

  v2 = __ldrex((unsigned int *)&g_dmaManagerLock);
  v3 = v2 == 0;
  if ( v2 )
    v4 = __strex(v2, (unsigned int *)&g_dmaManagerLock);
  else
    v4 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_dmaManagerLock);
  if ( !v2 )
    v3 = v4 == 0;
  if ( !v3 )
    KLightMutex::LockImpl(&g_dmaManagerLock);
  __mcr(15, 0, 0, 7, 10, 5);
  inten = CDMA.inten;
  CDMA.inten = inten | (1 << channelId);
  __mcr(15, 0, 0, 7, 10, 5);
  g_dmaManagerLock.lockingThread = 0;
  if ( g_dmaManagerLock.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_dmaManagerLock);
}

//----- (FFF02E20) --------------------------------------------------------
Result __fastcall KVfpRegisterDumpHelper::BindInterrupt(s32 coreId)
{
  return KInterruptManager::BindInterrupt(
           &g_interruptManager,
           &g_vfpRegisterDumpHelper.impls[coreId],
           KINTNAME_SGI_DUMP_VFP_REGS,
           coreId,
           0,
           0,
           0);
}

//----- (FFF02E60) --------------------------------------------------------
Result __fastcall KSupervisorPageTable::Initialize(
        KSupervisorPageTable *this,
        u32 *L1Table,
        u32 addressSpaceStart,
        u32 addressSpaceEnd)
{
  this->translationTableSize = 0x3000;
  this->linearAddressRangeStart = 0;
  this->asid = 0;
  this->translationTableBase = 0;
  this->isKernel = 1;
  this->onlyUseSmallPages = 0;
  this->addressSpaceStart = addressSpaceStart;
  this->addressSpaceEnd = addressSpaceEnd;
  this->L1Table = L1Table;
  KMemoryBlockManager::Initialize(&this->memoryBlockMgr, addressSpaceStart, addressSpaceEnd);
  return 0;
}

//----- (FFF02EB8) --------------------------------------------------------
Result __fastcall KTlbMaintenanceHelper::BindInterrupt(s32 coreId)
{
  return KInterruptManager::BindInterrupt(
           &g_interruptManager,
           &g_tlbMaintenanceHelper.impls[coreId],
           KINTNAME_SGI_TLB_MAINTENANCE,
           coreId,
           0,
           0,
           0);
}

//----- (FFF02EF8) --------------------------------------------------------
void __fastcall KInterruptManager::InitializeCore(KInterruptManager *this, s32 coreId)
{
  int i; // lr
  int v3; // r2
  int v4; // r12
  KInterruptEntry *v5; // r3
  int v6; // r2
  int v7; // r3
  KInterruptManager *v8; // r12
  int j; // r1
  _BYTE *v11; // r0
  _BYTE *v12; // r2
  u32 v13; // r0
  int totalNumInterrupts; // r6
  int totalNumInterruptLines; // r0
  BOOL v16; // r1
  int k; // r1
  int v18; // r2
  u32 v19; // r2
  int v20; // r0
  _BYTE *m; // r0
  _BYTE *v22; // r1
  _BYTE *v23; // r3
  _BYTE *v24; // r12
  _BYTE *v25; // r2

  if ( coreId == 1 )
  {
    for ( i = 0; i < 4; ++i )
    {
      v3 = 0;
      v4 = 32;
      do
      {
        v5 = &this->privateInterrupts[i][v3];
        --v4;
        v5->handler = 0;
        v5->autoDisable_ManualClear = 0;
        v5->disabled = 0;
        ++v3;
        v5->priority = 15;
      }
      while ( v4 );
    }
    v6 = 0;
    v7 = 0x60;
    do
    {
      v8 = (KInterruptManager *)((char *)this + 8 * v6);
      --v7;
      v8->sharedInterrupts[0].handler = 0;
      v8->sharedInterrupts[0].autoDisable_ManualClear = 0;
      ++v6;
      v8->sharedInterrupts[0].disabled = 0;
    }
    while ( v7 );
  }
  cpu::SynchronizeAllCores();
  MPCORE.gicd.ctlr = 0;
  cpu::SynchronizeAllCores();
  MPCORE.gicd.icenabler[0] = 0xFFFFFFFF;
  MPCORE.gicd.icpendr[0] = 0xFFFFFFFF;
  for ( j = 0; j < 32; j += 2 )
  {
    v11 = (_BYTE *)(j + 0xFFFEF400);
    v12 = (_BYTE *)(j + 0xFFFEF401);
    *v11 = 0xF0;                                // min priority to all private interrupts, effectively disabling them
    *v12 = 0xF0;
  }
  MPCORE.gicd.icfgr[0] = 0xAAAAAAAA;            // N-N, edge-triggered, for all private interrupts
  MPCORE.gicd.icfgr[1] = 0x28000000;            // same for irqId 0x39 and 0x3a (old cdma faulting irq, new dma event)
  if ( !coreId )
  {
    v13 = (32 * MPCORE.gicd.typer) & 0x3FF;
    totalNumInterrupts = v13 + 32;
    totalNumInterruptLines = (int)(v13 + 0x3F) / 32;
    if ( totalNumInterruptLines > 1 )
    {
      v16 = (totalNumInterruptLines & 1) == 0;
      if ( v16 )
      {
        MPCORE.gicd.icenabler[1] = 0xFFFFFFFF;
        MPCORE.gicd.icpendr[1] = 0xFFFFFFFF;
      }
    }
    else
    {
      v16 = 0;
    }
    for ( k = v16 + 1; k < totalNumInterruptLines; *(_DWORD *)(v19 + 644) = 0xFFFFFFFF )
    {
      v18 = k;
      k += 2;
      v19 = (u32)&MPCORE.gicd + 4 * v18;
      *(_DWORD *)(v19 + offsetof(Mp11GicDistributor, icenabler)) = 0xFFFFFFFF;
      *(_DWORD *)(v19 + offsetof(Mp11GicDistributor, icpendr)) = 0xFFFFFFFF;
      *(_DWORD *)(v19 + 0x184) = 0xFFFFFFFF;
    }
    if ( totalNumInterrupts > 32 )
    {
      v20 = totalNumInterrupts & 1;
      if ( v20 == 1 )
      {
        MPCORE.gicd.ipriorityr[32] = 0xF0;
        MPCORE.gicd.itargetsr[32] = 0;
      }
    }
    else
    {
      v20 = 0;
    }
    for ( m = (_BYTE *)(v20 + 32); (int)m < totalNumInterrupts; *v24 = 0 )
    {
      v22 = m - 0x10C00;                        // priority
      v23 = m - 0x10BFF;
      v24 = m - 0x107FF;                        // targets
      v25 = m - 0x10800;
      m += 2;
      *v22 = 0xF0;
      *v25 = 0;
      *v23 = 0xF0;
    }
    MPCORE.gicd.icfgr[2] = 0x5550755;           // Interrupts 0x00 to 0x1F: edge-triggered, N-N
                                                // Interrupt 0x20: level-sensitive, 1-N
                                                // Interrupt 0x21: level-sensitive, 1-N
                                                // Interrupt 0x22: level-sensitive, 1-N
                                                // Interrupt 0x23: level-sensitive, 1-N
                                                // Interrupt 0x24: edge-triggered, 1-N
                                                // Interrupt 0x25: level-sensitive, 1-N
                                                // Interrupt 0x28: level-sensitive, 1-N
                                                // Interrupt 0x29: level-sensitive, 1-N
                                                // Interrupt 0x2a: level-sensitive, 1-N
                                                // Interrupt 0x2b: level-sensitive, 1-N
                                                // Interrupt 0x2c: level-sensitive, 1-N
                                                // Interrupt 0x2d: level-sensitive, 1-N
                                                // Interrupt 0x30: level-sensitive, 1-N
                                                // Interrupt 0x31: level-sensitive, 1-N
                                                // Interrupt 0x32: level-sensitive, 1-N
                                                // Interrupt 0x33: level-sensitive, 1-N
                                                // Interrupt 0x34: level-sensitive, 1-N
                                                // Interrupt 0x35: level-sensitive, 1-N
                                                // Interrupt 0x36: level-sensitive, 1-N
                                                // Interrupt 0x37: level-sensitive, 1-N
                                                // Interrupt 0x38: level-sensitive, 1-N
                                                // Interrupt 0x39: level-sensitive, 1-N
                                                // Interrupt 0x3a: level-sensitive, 1-N
                                                // Interrupt 0x3b: level-sensitive, 1-N
                                                // Interrupt 0x40: edge-triggered, 1-N
                                                // Interrupt 0x41: edge-triggered, 1-N
                                                // Interrupt 0x42: edge-triggered, 1-N
                                                // Interrupt 0x43: edge-triggered, 1-N
                                                // Interrupt 0x44: edge-triggered, 1-N
                                                // Interrupt 0x45: edge-triggered, 1-N
                                                // Interrupt 0x46: edge-triggered, 1-N
                                                // Interrupt 0x48: edge-triggered, 1-N
                                                // Interrupt 0x49: edge-triggered, 1-N
                                                // Interrupt 0x4a: edge-triggered, 1-N
                                                // Interrupt 0x4b: edge-triggered, 1-N
                                                // Interrupt 0x4c: edge-triggered, 1-N
                                                // Interrupt 0x4d: edge-triggered, 1-N
                                                // Interrupt 0x4e: edge-triggered, 1-N
                                                // Interrupt 0x4f: level-sensitive, 1-N
                                                // Interrupt 0x50: edge-triggered, 1-N
                                                // Interrupt 0x51: edge-triggered, 1-N
                                                // Interrupt 0x52: edge-triggered, 1-N
                                                // Interrupt 0x53: edge-triggered, 1-N
                                                // Interrupt 0x54: edge-triggered, 1-N
                                                // Interrupt 0x55: edge-triggered, 1-N
                                                // Interrupt 0x56: edge-triggered, 1-N
                                                // Interrupt 0x57: edge-triggered, 1-N
                                                // Interrupt 0x58: level-sensitive, 1-N
                                                // Interrupt 0x59: edge-triggered, 1-N
                                                // Interrupt 0x5a: edge-triggered, 1-N
                                                // Interrupt 0x5b: edge-triggered, 1-N
                                                // Interrupt 0x5f: edge-triggered, 1-N
                                                // Interrupt 0x60: edge-triggered, 1-N
                                                // Interrupt 0x61: edge-triggered, 1-N
                                                // Interrupt 0x64: edge-triggered, 1-N
                                                // Interrupt 0x65: edge-triggered, 1-N
                                                // Interrupt 0x66: edge-triggered, 1-N
                                                // Interrupt 0x68: edge-triggered, 1-N
                                                // Interrupt 0x69: edge-triggered, 1-N
                                                // Interrupt 0x6a: edge-triggered, 1-N
                                                // Interrupt 0x6b: edge-triggered, 1-N
                                                // Interrupt 0x6c: edge-triggered, 1-N
                                                // Interrupt 0x6d: edge-triggered, 1-N
                                                // Interrupt 0x6e: edge-triggered, 1-N
                                                // Interrupt 0x6f: edge-triggered, 1-N
                                                // Interrupt 0x70: edge-triggered, 1-N
                                                // Interrupt 0x71: edge-triggered, 1-N
                                                // Interrupt 0x72: edge-triggered, 1-N
                                                // Interrupt 0x73: edge-triggered, 1-N
                                                // Interrupt 0x74: edge-triggered, 1-N
                                                // Interrupt 0x75: edge-triggered, 1-N
                                                // Interrupt 0x76: level-sensitive, 1-N
                                                // Interrupt 0x77: level-sensitive, 1-N
                                                // Interrupt 0x78: edge-triggered, 1-N
                                                // Interrupt 0x79: level-sensitive, 1-N
                                                // Interrupt 0x7a: level-sensitive, 1-N
                                                // Interrupt 0x7b: level-sensitive, 1-N
                                                // Interrupt 0x7c: level-sensitive, 1-N
                                                // Interrupt 0x7d: level-sensitive, 1-N
    MPCORE.gicd.icfgr[3] = 0x555555;
    MPCORE.gicd.icfgr[4] = 0x7FFF3FFF;
    MPCORE.gicd.icfgr[5] = 0xC0FDFFFF;
    MPCORE.gicd.icfgr[6] = 0xFFFF3F0F;
    MPCORE.gicd.icfgr[7] = 0x5575FFF;
    MPCORE.gicd.ctlr = 1;                       // activate distributor
  }
  cpu::SynchronizeAllCores();
  MPCORE.gicc.bpr = 7;                          // no preemption
  MPCORE.gicc.pmr = 0xF0;                       // all interrupts with priority >= 0xF(0) will assert the irq line
  MPCORE.gicc.ctlr = 1;                         // activate interface
  __asm
  {
    CPSIE           A
    CPSIE           F
  }
}
// FFF03048: user specified stroff has not been processed: Mp11GicDistributor offset 388

//----- (FFF03174) --------------------------------------------------------
Result __fastcall KPerformanceCounterControlHelper::BindInterrupt(s32 coreId)
{
  return KInterruptManager::BindInterrupt(&g_interruptManager, &g_perfCounterControlHelper, 4u, coreId, 0, 0, 0);
}

//----- (FFF031B0) --------------------------------------------------------
void __fastcall KCacheMaintenanceHelper::ThreadFunction(KCacheMaintenanceHelper *this)
{
  u32 startAddr; // r0
  u32 endAddr; // r1
  unsigned int v4; // r2
  unsigned int v5; // r0
  u32 v6; // r3
  unsigned int v7; // r1
  unsigned int v8; // r3
  bool v9; // cf
  unsigned int v10; // r0
  u32 i; // r1
  unsigned int v12; // r0
  u32 j; // r1
  unsigned int v14; // r0
  u32 k; // r1
  KThread *thread; // r5
  unsigned __int8 *p_numClients; // r0
  unsigned __int8 v18; // r1
  KThread *next; // r5
  KThread *v20; // r2
  KThreadIntrusiveList *v21; // r3
  int schedulingMask; // r0
  bool v23; // zf

  while ( 1 )
  {
    switch ( this->op )
    {
      case KCACHEMAINTOP_FLAG_BY_MVA:
        startAddr = this->startAddr;
        endAddr = this->endAddr;
        v4 = startAddr & ~0x1Fu;
        v5 = (startAddr + 31) & ~0x1Fu;
        v6 = endAddr + 31;
        v7 = endAddr & ~0x1Fu;
        v8 = v6 & ~0x1Fu;
        if ( v4 < v5 )
          __mcr(15, 0, v4, 7, 14, 1);
        v9 = v5 >= v8;
        if ( v5 < v8 )
          v9 = v7 >= v8;
        if ( !v9 )
          __mcr(15, 0, v7, 7, 14, 1);
        for ( ; v5 < v7; v5 += 32 )
          __mcr(15, 0, v5, 7, 6, 1);
        goto LABEL_23;
      case KCACHEMAINTOP_CLEAN_DCACHE_BY_MVA:
        v10 = this->startAddr;
        for ( i = this->endAddr; v10 < i; v10 += 32 )
          __mcr(15, 0, v10, 7, 10, 1);
        goto LABEL_23;
      case KCACHEMAINTOP_CLEANINV_DCACHE_BY_MVA:
        v12 = this->startAddr;
        for ( j = this->endAddr; v12 < j; v12 += 32 )
          __mcr(15, 0, v12, 7, 14, 1);
        goto LABEL_23;
      case KCACHEMAINTOP_INV_ICACHE_BY_MVA:
        v14 = this->startAddr;
        for ( k = this->endAddr; v14 < k; v14 += 32 )
          __mcr(15, 0, v14, 7, 5, 1);
        goto LABEL_19;
      case KCACHEMAINTOP_FLAG_ENTIRE:
        __mcr(15, 0, 0, 7, 6, 0);
        __mcr(15, 0, 0, 7, 10, 4);
        break;
      case KCACHEMAINTOP_CLEAN_ENTIRE_DCACHE:
        __mcr(15, 0, 0, 7, 10, 0);
        goto LABEL_23;
      case KCACHEMAINTOP_CLEANINV_ENTIRE_DCACHE:
        __mcr(15, 0, 0, 7, 14, 0);
LABEL_23:
        __mcr(15, 0, 0, 7, 10, 4);
        break;
      case KCACHEMAINTOP_INV_ENTIRE_ICACHE:
        __mcr(15, 0, 0, 7, 5, 0);
LABEL_19:
        __mcr(15, 0, 0, 7, 5, 6);
        __mcr(15, 0, 0, 7, 10, 4);
        __mcr(15, 0, 0, 7, 5, 4);
        break;
      default:
        break;
    }
    thread = current.clc.current.thread;
    KSchedulerLock::Lock(&g_schedulerLock);
    KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_PAUSED);
    p_numClients = &this->numClients;
    do
      v18 = __ldrex(p_numClients);
    while ( __strex(v18 - 1, p_numClients) );
    if ( v18 == 1 )
    {
      if ( this->firstClientThread )
      {
        KThread::SetSchedulingState(this->firstClientThread, KTHREADSCHEDSTAT_RUNNING);
        this->firstClientThread = 0;
      }
      __mcr(15, 0, 0, 7, 10, 4);
      this->op = KCACHEMAINTOP_NONE;
      __mcr(15, 0, 0, 7, 10, 4);
      if ( this->waitList.link.next )
      {
        do
        {
          next = this->waitList.link.next;
          if ( !next )
            break;
          v20 = next->link.next;
          v21 = v20 ? (KThreadIntrusiveList *)&v20->link : &this->waitList;
          this->waitList.link.next = v20;
          v21->link.prev = 0;
          next->waiterList = 0;
          KThread::SetSchedulingState(next, KTHREADSCHEDSTAT_RUNNING);
          next->waiterList = 0;
          schedulingMask = next->schedulingMask;
          v23 = schedulingMask == KTHREADSCHEDSTAT_RUNNING;
          if ( schedulingMask != KTHREADSCHEDSTAT_RUNNING )
            v23 = this->waitList.link.next == 0;
        }
        while ( !v23 );
      }
    }
    KSchedulerLock::Unlock(&g_schedulerLock);
  }
}
// FFF031D0: control flows out of bounds to FFF031D4

//----- (FFF033CC) --------------------------------------------------------
void __fastcall KPageTable::InvalidateEntireInstructionCacheLocal()
{
  __mcr(15, 0, 0, 7, 5, 0);
  __mcr(15, 0, 0, 7, 5, 6);
  __mcr(15, 0, 0, 7, 10, 4);
  __mcr(15, 0, 0, 7, 5, 4);
}

//----- (FFF033E4) --------------------------------------------------------
u32 __fastcall crc32(void *data, u32 size, u32 initialValue)
{
  unsigned int i; // r6
  unsigned int v4; // r3
  int v5; // r4
  unsigned int v6; // r12
  u8 *v7; // r0
  u8 v8; // t1
  u32 j; // r1
  int v10; // r4
  u8 v11; // t1
  u32 v12; // r2
  u32 lut[256]; // [sp+4h] [bp+0h]

  for ( i = 0; i < 0x100; ++i )
  {
    v4 = i;
    v5 = 4;
    do
    {
      if ( (v4 & 1) != 0 )
        v6 = (v4 >> 1) ^ 0xEDB88320;
      else
        v6 = v4 >> 1;
      if ( (v6 & 1) != 0 )
        v4 = (v6 >> 1) ^ 0xEDB88320;
      else
        v4 = v6 >> 1;
      --v5;
    }
    while ( v5 );
    lut[i] = v4;
  }
  if ( size )
  {
    v7 = (u8 *)data - 1;
    if ( (size & 1) != 0 )
    {
      v8 = *++v7;
      initialValue = lut[(unsigned __int8)(v8 ^ initialValue)] ^ (initialValue >> 8);
    }
    for ( j = size >> 1; j; initialValue = lut[(unsigned __int8)(v11 ^ v12)] ^ (v12 >> 8) )
    {
      --j;
      v10 = (unsigned __int8)(v7[1] ^ initialValue);
      v11 = v7[2];
      v7 += 2;
      v12 = lut[v10] ^ (initialValue >> 8);
    }
  }
  return ~initialValue;
}
// FFF033E4: using guessed type u32 anonymous_0[259];

//----- (FFF034B4) --------------------------------------------------------
u32 __fastcall InitialProcess::GetCxiSize(InitialProcess *this)
{
  Ncch *ncch; // r6
  s32 v2; // r7
  s32 v3; // r4

  ncch = this->ncch;
  v2 = ncch->flags[6] + 9;
  v3 = Ncch::ConvertSize(ncch->exeFsSize, 0, v2);
  return Ncch::ConvertSize(ncch->exeFsOffset, 0, v2) + v3;
}

//----- (FFF034F0) --------------------------------------------------------
void __fastcall AtomicBoolStore(AtomicBool *this, bool value)
{
  do
    __ldrex((unsigned __int8 *)this);
  while ( __strex(value, (unsigned __int8 *)this) );
}

//----- (FFF03514) --------------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn DispatchKernelExceptionWithRegdump(int a1, int a2, int a3, int a4, int a5)
{
  int v5; // r4
  int v11; // [sp-10h] [bp-10h]
  char v12; // [sp-9h] [bp-9h] BYREF
  int v13[2]; // [sp-8h] [bp-8h] BYREF

  _R2 = __get_CPSR();
  __asm
  {
    CPS             #0x13
    MSR             CPSR_cxsf, R2
  }
  if ( (int)(&v12 - ((unsigned int)&v12 & 0xFFFFF000)) >= 1024 )
  {
    __asm
    {
      SRSDB           SP!, #0x13
      CPS             #0x13
    }
    v11 = a4;
    __asm
    {
      MSR             CPSR_cxsf, R2
      CPS             #0x13
    }
    DispatchExceptionWithRegdump(a4, v5, v13[0], v13[1], a5);
  }
  kernelpanic();
}
// FFF03550: positive sp value 8 has been found
// FFF03554: variable 'v5' is possibly undefined

//----- (FFF03564) --------------------------------------------------------
void __fastcall LzssDecompress(u8 *fileEnd)
{
  unsigned int v1; // r1
  u8 *v2; // r2
  u8 *v3; // r3
  u8 *v4; // r1
  char v5; // r5
  char v6; // t1
  int v7; // r6
  bool v8; // cc
  u8 v9; // t1
  u8 *v10; // r3
  int v11; // r12
  int v12; // t1
  int v13; // t1
  unsigned int v14; // r7
  int v15; // r12

  if ( fileEnd )
  {
    v1 = *((_DWORD *)fileEnd - 2);
    v2 = &fileEnd[*((_DWORD *)fileEnd - 1)];
    v3 = &fileEnd[-HIBYTE(v1)];
    v4 = &fileEnd[-(v1 & 0xFFFFFF)];
    while ( (int)v3 > (int)v4 )
    {
      v6 = *--v3;
      v5 = v6;
      v7 = 8;
      while ( 1 )
      {
        v8 = v7-- < 1;
        if ( v8 )
          break;
        if ( (v5 & 0x80) != 0 )
        {
          v12 = *(v3 - 1);
          v10 = v3 - 1;
          v11 = v12;
          v13 = *(v10 - 1);
          v3 = v10 - 1;
          v14 = ((v13 | (v11 << 8)) & 0xFFFF0FFF) + 2;
          v15 = v11 + 32;
          do
          {
            *(v2 - 1) = v2[v14];
            --v2;
            v8 = v15 < 16;
            v15 -= 16;
          }
          while ( !v8 );
        }
        else
        {
          v9 = *--v3;
          *--v2 = v9;
        }
        v5 *= 2;
        if ( (int)v3 <= (int)v4 )
          return;
      }
    }
  }
}

//----- (FFF035F8) --------------------------------------------------------
Result __fastcall SvcAcceptSession(int a1, Handle a2)
{
  Handle outServerSessionHandle; // [sp+0h] [bp-8h] BYREF

  return AcceptSession(&outServerSessionHandle, a2);
}

//----- (FFF03614) --------------------------------------------------------
Result __fastcall SvcArbitrateAddress(Handle a1, u32 a2, ArbitrationType a3, s32 a4)
{
  s64 timeout; // r4

  return ArbitrateAddress(a1, a2, a3, a4, timeout);
}
// FFF03624: variable 'timeout' is possibly undefined

//----- (FFF03630) --------------------------------------------------------
Result __fastcall SvcConnectToPort(int a1, const char *a2)
{
  Handle outClientSessionHandle; // [sp+0h] [bp-8h] BYREF

  return ConnectToPort(&outClientSessionHandle, a2);
}

//----- (FFF0364C) --------------------------------------------------------
Result __fastcall SvcControlMemory(u8 op, u32 a2, u32 a3, u32 a4)
{
  u32 perms; // r4
  u32 outAddr; // [sp+8h] [bp-8h] BYREF

  return ControlMemory(&outAddr, a2, a3, a4, op, perms);
}
// FFF03660: variable 'perms' is possibly undefined

//----- (FFF03670) --------------------------------------------------------
Result __fastcall SvcControlPerformanceCounter(
        unsigned int a1,
        PerformanceCounterOperation a2,
        u32 a3,
        unsigned int a4)
{
  s64 out; // [sp+8h] [bp-10h] BYREF

  return ControlPerformanceCounter(&out, a2, a3, __PAIR64__(a4, a1));
}

//----- (FFF03698) --------------------------------------------------------
Result __fastcall SvcControlProcessMemory(Handle a1, u32 a2, u32 a3, u32 a4)
{
  u32 op; // r4
  u32 perms; // r5

  return ControlProcessMemory(a1, a2, a3, a4, op, perms);
}
// FFF036A8: variable 'op' is possibly undefined
// FFF036A8: variable 'perms' is possibly undefined

//----- (FFF036B4) --------------------------------------------------------
Result SvcCreateAddressArbiter()
{
  Handle outArbiterHandle; // [sp+0h] [bp-8h] BYREF

  return CreateAddressArbiter(&outArbiterHandle);
}

//----- (FFF036D0) --------------------------------------------------------
Result __fastcall SvcCreateCodeSet(u32 dataPtr, CodeSetInfo *a2, u32 a3, u32 a4)
{
  Handle outHandle; // [sp+4h] [bp-Ch] BYREF

  return CreateCodeSet(&outHandle, a2, a3, a4, dataPtr);
}

//----- (FFF036F0) --------------------------------------------------------
Result __fastcall SvcCreateEvent(int a1, ResetType a2)
{
  Handle outEventHandle; // [sp+0h] [bp-8h] BYREF

  return CreateEvent(&outEventHandle, a2);
}

//----- (FFF0370C) --------------------------------------------------------
Result __fastcall SvcCreateMemoryBlock(u32 othersPerms, u32 a2, u32 a3, u32 a4)
{
  Handle outSharedMemHandle; // [sp+4h] [bp-Ch] BYREF

  return CreateMemoryBlock(&outSharedMemHandle, a2, a3, a4, othersPerms);
}

//----- (FFF0372C) --------------------------------------------------------
Result __fastcall SvcCreateMutex(int a1, BOOL a2)
{
  Handle outMutexHandle; // [sp+0h] [bp-8h] BYREF

  return CreateMutex(&outMutexHandle, a2);
}

//----- (FFF03748) --------------------------------------------------------
Result __fastcall SvcCreatePort(int a1, int a2, const char *a3, s32 a4)
{
  Handle outClientPortHandle; // [sp+0h] [bp-10h] BYREF
  Handle outSessionPortHandle; // [sp+4h] [bp-Ch] BYREF

  return CreatePort(&outSessionPortHandle, &outClientPortHandle, a3, a4);
}

//----- (FFF0376C) --------------------------------------------------------
Result __fastcall SvcCreateProcess(int a1, Handle a2, u32 *a3, s32 a4)
{
  Handle outProcessHandle; // [sp+0h] [bp-8h] BYREF

  return CreateProcess(&outProcessHandle, a2, a3, a4);
}

//----- (FFF03788) --------------------------------------------------------
Result SvcCreateResourceLimit()
{
  Handle outReslimitHandle; // [sp+0h] [bp-8h] BYREF

  return CreateResourceLimit(&outReslimitHandle);
}

//----- (FFF037A4) --------------------------------------------------------
Result __fastcall SvcCreateSemaphore(int a1, s32 a2, s32 a3)
{
  Handle outSemaphoreHandle; // [sp+0h] [bp-8h] BYREF

  return CreateSemaphore(&outSemaphoreHandle, a2, a3);
}

//----- (FFF037C0) --------------------------------------------------------
Result SvcCreateSession()
{
  Handle outClientSessionHandle; // [sp+0h] [bp-10h] BYREF
  Handle outServerSessionHandle; // [sp+4h] [bp-Ch] BYREF

  return CreateSession(&outServerSessionHandle, &outClientSessionHandle);
}

//----- (FFF037E4) --------------------------------------------------------
Result __fastcall SvcCreateSessionToPort(int a1, Handle a2)
{
  Handle outClientSessionHandle; // [sp+0h] [bp-8h] BYREF

  return CreateSessionToPort(&outClientSessionHandle, a2);
}

//----- (FFF03800) --------------------------------------------------------
Result __fastcall SvcCreateThread(s32 priority, u32 a2, u32 a3, u32 a4)
{
  s32 processorId; // r4
  Handle outThreadHandle; // [sp+8h] [bp-8h] BYREF

  return CreateThread(&outThreadHandle, a2, a3, a4, priority, processorId);
}
// FFF03814: variable 'processorId' is possibly undefined

//----- (FFF03824) --------------------------------------------------------
Result __fastcall SvcCreateTimer(int a1, ResetType a2)
{
  Handle outTimerHandle; // [sp+0h] [bp-8h] BYREF

  return CreateTimer(&outTimerHandle, a2);
}

//----- (FFF03840) --------------------------------------------------------
Result __fastcall SvcDebugActiveProcess(int a1, u32 a2)
{
  Handle outHandle; // [sp+0h] [bp-8h] BYREF

  return DebugActiveProcess(&outHandle, a2);
}

//----- (FFF0385C) --------------------------------------------------------
Result __fastcall SvcDuplicateHandle(int a1, Handle a2)
{
  Handle outHandle; // [sp+0h] [bp-8h] BYREF

  return DuplicateHandle(&outHandle, a2);
}

//----- (FFF03878) --------------------------------------------------------
Result __fastcall SvcGetDebugThreadParam(DebugThreadParameter param, int a2, Handle a3, u32 a4)
{
  s32 out2; // [sp+4h] [bp-14h] BYREF
  s64 out1; // [sp+8h] [bp-10h] BYREF

  return GetDebugThreadParam(&out1, &out2, a3, a4, param);
}

//----- (FFF038A4) --------------------------------------------------------
Result __fastcall SvcGetDmaState(int a1, Handle a2)
{
  DmaState outDmaState[4]; // [sp+0h] [bp-8h] BYREF

  return GetDmaState(outDmaState, a2);
}

//----- (FFF038C0) --------------------------------------------------------
Result __fastcall SvcGetHandleInfo(int a1, Handle a2, s32 a3)
{
  s64 out; // [sp+0h] [bp-10h] BYREF

  return GetHandleInfo(&out, a2, a3);
}

//----- (FFF038E0) --------------------------------------------------------
Result __fastcall SvcGetProcessId(int a1, Handle a2)
{
  u32 outPid; // [sp+0h] [bp-8h] BYREF

  return GetProcessId(&outPid, a2);
}

//----- (FFF038FC) --------------------------------------------------------
Result __fastcall SvcGetProcessIdOfThread(int a1, Handle a2)
{
  u32 outPid; // [sp+0h] [bp-8h] BYREF

  return GetProcessIdOfThread(&outPid, a2);
}

//----- (FFF03918) --------------------------------------------------------
Result __fastcall SvcGetProcessIdealProcessor(int a1, Handle a2)
{
  s32 outIdealProcessor; // [sp+0h] [bp-8h] BYREF

  return GetProcessIdealProcessor(&outIdealProcessor, a2);
}

//----- (FFF03934) --------------------------------------------------------
Result __fastcall SvcGetProcessInfo(int a1, Handle a2, s32 a3)
{
  s64 outValue; // [sp+0h] [bp-10h] BYREF

  return GetProcessInfo(&outValue, a2, a3);
}

//----- (FFF03954) --------------------------------------------------------
Result __fastcall SvcGetProcessList(int a1, u32 *a2, s32 a3)
{
  s32 outNumProcesses; // [sp+0h] [bp-8h] BYREF

  return GetProcessList(&outNumProcesses, a2, a3);
}

//----- (FFF03970) --------------------------------------------------------
Result __fastcall SvcGetResourceLimit(int a1, Handle a2)
{
  Handle outReslimit; // [sp+0h] [bp-8h] BYREF

  return GetResourceLimit(&outReslimit, a2);
}

//----- (FFF0398C) --------------------------------------------------------
Result __fastcall SvcGetSystemInfo(int a1, s32 a2, s32 a3)
{
  s64 out; // [sp+0h] [bp-10h] BYREF

  return GetSystemInfo(&out, a2, a3);
}

//----- (FFF039AC) --------------------------------------------------------
Result __fastcall SvcGetThreadId(int a1, Handle a2)
{
  u32 threadId; // [sp+0h] [bp-8h] BYREF

  return GetThreadId(&threadId, a2);
}

//----- (FFF039C8) --------------------------------------------------------
Result __fastcall SvcGetThreadIdealProcessor(int a1, Handle a2)
{
  s32 outIdealProcessor; // [sp+0h] [bp-8h] BYREF

  return GetThreadIdealProcessor(&outIdealProcessor, a2);
}

//----- (FFF039E4) --------------------------------------------------------
Result __fastcall SvcGetThreadInfo(int a1, Handle a2, s32 a3)
{
  s64 outValue; // [sp+0h] [bp-10h] BYREF

  return GetThreadInfo(&outValue, a2, a3);
}

//----- (FFF03A04) --------------------------------------------------------
Result __fastcall SvcGetThreadList(int a1, u32 *a2, s32 a3, Handle a4)
{
  s32 outNumThreads; // [sp+0h] [bp-8h] BYREF

  return GetThreadList(&outNumThreads, a2, a3, a4);
}

//----- (FFF03A20) --------------------------------------------------------
Result __fastcall SvcGetThreadPriority(int a1, Handle a2)
{
  s32 outPriority; // [sp+0h] [bp-8h] BYREF

  return GetThreadPriority(&outPriority, a2);
}

//----- (FFF03A3C) --------------------------------------------------------
Result Svc0x74_CodeSetRelated_stubbed()
{
  Handle codesetHandleMaybe; // [sp+0h] [bp-8h] BYREF

  return Svc0x74Impl_CodeSetRelated_Stubbed(&codesetHandleMaybe);
}

//----- (FFF03A58) --------------------------------------------------------
Result __fastcall SvcOpenProcess(int a1, u32 a2)
{
  Handle outProcessHandle; // [sp+0h] [bp-8h] BYREF

  return OpenProcess(&outProcessHandle, a2);
}

//----- (FFF03A74) --------------------------------------------------------
Result __fastcall SvcOpenThread(int a1, Handle a2, u32 a3)
{
  Handle outThreadHandle; // [sp+0h] [bp-8h] BYREF

  return OpenThread(&outThreadHandle, a2, a3);
}

//----- (FFF03A90) --------------------------------------------------------
Result __fastcall SvcQueryDebugProcessMemory(int a1, int a2, Handle a3, u32 a4)
{
  u32 outPgInfo; // [sp+0h] [bp-18h] BYREF
  MemoryInfo outMemInfo; // [sp+4h] [bp-14h] BYREF

  return QueryDebugProcessMemory(&outMemInfo, &outPgInfo, a3, a4);
}

//----- (FFF03AC0) --------------------------------------------------------
Result __fastcall SvcQueryMemory(int a1, int a2, u32 a3)
{
  u32 outPgInfo; // [sp+0h] [bp-18h] BYREF
  MemoryInfo outMemInfo; // [sp+4h] [bp-14h] BYREF

  return QueryMemory(&outMemInfo, &outPgInfo, a3);
}

//----- (FFF03AF0) --------------------------------------------------------
Result __fastcall SvcQueryProcessMemory(int a1, int a2, Handle a3, u32 a4)
{
  u32 outPgInfo; // [sp+0h] [bp-18h] BYREF
  MemoryInfo outMemInfo; // [sp+4h] [bp-14h] BYREF

  return QueryProcessMemory(&outMemInfo, &outPgInfo, a3, a4);
}

//----- (FFF03B20) --------------------------------------------------------
Result __fastcall SvcReleaseSemaphore(int a1, Handle a2, s32 a3)
{
  s32 outCount; // [sp+0h] [bp-8h] BYREF

  return ReleaseSemaphore(&outCount, a2, a3);
}

//----- (FFF03B3C) --------------------------------------------------------
Result __fastcall SvcReplyAndReceive(int a1, Handle *a2, s32 a3, Handle a4)
{
  s32 outIdx; // [sp+0h] [bp-8h] BYREF

  return ReplyAndReceive(&outIdx, a2, a3, a4);
}

//----- (FFF03B58) --------------------------------------------------------
Result __fastcall SvcReplyAndReceive1(int a1, Handle *a2, s32 a3, Handle a4)
{
  s32 outIdx; // [sp+0h] [bp-8h] BYREF

  return ReplyAndReceive1(&outIdx, a2, a3, a4);
}

//----- (FFF03B74) --------------------------------------------------------
Result __fastcall SvcReplyAndReceive2(int a1, Handle *a2, s32 a3, Handle a4)
{
  s32 outIdx; // [sp+0h] [bp-8h] BYREF

  return ReplyAndReceive2(&outIdx, a2, a3, a4);
}

//----- (FFF03B90) --------------------------------------------------------
Result __fastcall SvcReplyAndReceive3(int a1, Handle *a2, s32 a3, Handle a4)
{
  s32 outIdx; // [sp+0h] [bp-8h] BYREF

  return ReplyAndReceive3(&outIdx, a2, a3, a4);
}

//----- (FFF03BAC) --------------------------------------------------------
Result __fastcall SvcReplyAndReceive4(int a1, Handle *a2, s32 a3, Handle a4)
{
  s32 outIdx; // [sp+0h] [bp-8h] BYREF

  return ReplyAndReceive4(&outIdx, a2, a3, a4);
}

//----- (FFF03BC8) --------------------------------------------------------
Result __fastcall SvcRestartDma(Handle a1, u32 a2, u32 a3, u32 a4)
{
  DmaRestartFlags restartFlags; // r4

  return RestartDma(a1, a2, a3, a4, restartFlags);
}
// FFF03BD4: variable 'restartFlags' is possibly undefined

//----- (FFF03BE0) --------------------------------------------------------
Result __fastcall SvcRun(Handle a1, s32 a2, u32 a3, s32 a4)
{
  u16 *v4; // r4
  u16 *v5; // r5
  StartupInfo info; // [sp+0h] [bp-18h] BYREF

  info.mainThreadPriority = a2;
  info.stackSize = a3;
  info.argc = a4;
  info.argv = v4;
  info.envp = v5;
  return Run(a1, &info);
}
// FFF03BF4: variable 'v4' is possibly undefined
// FFF03BF8: variable 'v5' is possibly undefined

//----- (FFF03C0C) --------------------------------------------------------
Result __fastcall SvcSetTimer(Handle a1, unsigned int a2, s64 a3)
{
  unsigned int v3; // r4

  return SetTimer(a1, a3, __SPAIR64__(v3, a2));
}
// FFF03C1C: variable 'v3' is possibly undefined

//----- (FFF03C28) --------------------------------------------------------
Result __fastcall SvcSignalAndWait(bool waitAll, Handle a2, Handle *a3, s32 a4)
{
  int v4; // r5
  s64 timeout; // [sp+8h] [bp-10h] BYREF

  LODWORD(timeout) = v4;
  return SignalAndWait((s32 *)&timeout + 1, a2, a3, a4, waitAll, timeout);
}
// FFF03C34: variable 'v4' is possibly undefined

//----- (FFF03C50) --------------------------------------------------------
Result __fastcall SvcStartInterProcessDma(u32 srcAddr, Handle a2, u32 a3, Handle a4)
{
  u32 size; // r4
  const DmaConfig *config; // r5
  Handle outDmaHandle; // [sp+Ch] [bp-Ch] BYREF

  return StartInterProcessDma(&outDmaHandle, a2, a3, a4, srcAddr, size, config);
}
// FFF03C68: variable 'size' is possibly undefined
// FFF03C68: variable 'config' is possibly undefined

//----- (FFF03C78) --------------------------------------------------------
Result __fastcall SvcWaitSynchronizationN(unsigned int a1, Handle *a2, s32 a3, bool a4)
{
  unsigned int v4; // r4
  s32 outIdx; // [sp+8h] [bp-8h] BYREF

  return WaitSynchronizationN(&outIdx, a2, a3, a4, __SPAIR64__(v4, a1));
}
// FFF03C8C: variable 'v4' is possibly undefined

//----- (FFF03C9C) --------------------------------------------------------
void __fastcall InitialProcess::AllocateSegment(
        InitialProcess *this,
        void **loadAddr,
        CodeSegmentInfo *sectionBounds,
        ExHeader_CodeSectionInfo *codeSectionInfo)
{
  u32 v5; // r5
  void *allocd; // r7
  unsigned int v7; // r2
  bool v8; // zf
  unsigned int v9; // r3

  sectionBounds->addr = codeSectionInfo->address;
  sectionBounds->size = codeSectionInfo->nbPages;
  v5 = (codeSectionInfo->size + 4095) >> 12;
  allocd = (void *)KMemoryManager::AllocateContiguous(&g_memoryManager, v5, 1u, MEMOP_REGION_BASE);
  v7 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v8 = v7 == 0;
  if ( v7 )
    v9 = __strex(v7, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v9 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v7 )
    v8 = v9 == 0;
  if ( !v8 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)allocd, v5);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  *loadAddr = allocd;
}

//----- (FFF03D48) --------------------------------------------------------
void __fastcall KPageManager::Intialize(KPageManager *this, u32 numPages)
{
  signed __int32 numRefcountPages; // r8
  KMemoryManager *p_mm; // r7
  unsigned int *p_mutex; // r0
  KLightMutex *v7; // r4
  unsigned int v8; // r2
  bool v9; // zf
  unsigned int v10; // r3
  unsigned int *kernMemUsage; // r0
  unsigned int v12; // r2
  u32 *refcounts; // r7
  u32 v14; // r0
  int v15; // r1
  int v16; // r1
  KMemoryManager *mm; // r4
  KLightMutex *v18; // r5
  unsigned int v19; // r2
  bool v20; // zf
  unsigned int v21; // r3
  unsigned int refcountPagePosition; // r0
  unsigned int v23; // r2
  char v24; // cc
  int v25; // r2
  int v26; // r1
  int v27; // r3
  unsigned int v28; // r7
  int v29; // r3
  unsigned int v30; // r8

  numRefcountPages = ((4 * numPages - 1) >> 12) + 1;// one 32-bit word per page
  p_mm = this->mm;
  p_mutex = (unsigned int *)&p_mm->pgMgr.mutex;
  v7 = &p_mm->pgMgr.mutex;
  v8 = __ldrex((unsigned int *)&p_mm->pgMgr.mutex);
  v9 = v8 == 0;
  if ( v8 )
    v10 = __strex(v8, p_mutex);
  else
    v10 = __strex((unsigned int)current.clc.current.thread, p_mutex);
  if ( !v8 )
    v9 = v10 == 0;
  if ( !v9 )
    KLightMutex::LockImpl((KLightMutex *)p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  kernMemUsage = &p_mm->pgMgr.kernelMemoryUsage;
  do
    v12 = __ldrex(kernMemUsage);
  while ( __strex(v12 + (numRefcountPages << 12), kernMemUsage) );
  refcounts = (u32 *)KPageHeap::AllocateContiguous(&p_mm->baseHeap, numRefcountPages, 0);
  __mcr(15, 0, 0, 7, 10, 5);
  v7->lockingThread = 0;
  if ( v7->numWaiters > 0 )
    KLightMutex::UnlockImpl(v7);
  if ( refcounts )
  {
    this->pageRefcounts = refcounts;
    if ( numPages )
    {
      v14 = numPages & 1;
      v15 = 0;
      if ( v14 == 1 )
      {
        v15 = 1;
        *refcounts = 0;
      }
      for ( ; v14 < numPages; v15 = v16 + 1 )
      {
        v14 += 2;
        this->pageRefcounts[v15] = 0;
        v16 = v15 + 1;
        this->pageRefcounts[v16] = 0;
      }
    }
    mm = this->mm;
    v18 = &this->mm->pgMgr.mutex;
    v19 = __ldrex((unsigned int *)v18);
    v20 = v19 == 0;
    if ( v19 )
      v21 = __strex(v19, (unsigned int *)v18);
    else
      v21 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)v18);
    if ( !v19 )
      v20 = v21 == 0;
    if ( !v20 )
      KLightMutex::LockImpl(v18);
    __mcr(15, 0, 0, 7, 10, 5);
    refcountPagePosition = ((unsigned int)refcounts - mm->pgMgr.memoryStartAddr) >> 12;
    v23 = refcountPagePosition + numRefcountPages;
    v24 = (refcountPagePosition + numRefcountPages != 0x7FFFFFFF) & __CFADD__(
                                                                      refcountPagePosition + numRefcountPages,
                                                                      -2147483647);
    if ( refcountPagePosition + numRefcountPages <= 0x7FFFFFFF )
      v24 = (refcountPagePosition != 0x7FFFFFFF) & __CFADD__(refcountPagePosition, -2147483647);
    if ( v24 )
    {
      for ( ; refcountPagePosition < v23; ++refcountPagePosition )
        ++mm->pgMgr.pageRefcounts[refcountPagePosition];
    }
    else
    {
      v25 = numRefcountPages;
      if ( numRefcountPages > 0 )
      {
        v26 = numRefcountPages & 1;
        v27 = 0;
        if ( v26 == 1 )
        {
          v27 = 1;
          ++mm->pgMgr.pageRefcounts[refcountPagePosition];
        }
        if ( numRefcountPages > v26 )
        {
          do
          {
            v28 = refcountPagePosition + v27;
            v29 = v27 + 1;
            v30 = refcountPagePosition + v29;
            v26 += 2;
            ++mm->pgMgr.pageRefcounts[v28];
            v27 = v29 + 1;
            ++mm->pgMgr.pageRefcounts[v30];
          }
          while ( v25 > v26 );
        }
      }
    }
    __mcr(15, 0, 0, 7, 10, 5);
    v18->lockingThread = 0;
    if ( v18->numWaiters > 0 )
      KLightMutex::UnlockImpl(v18);
  }
}
// FFF03DD0: conditional instruction was optimized away because r0.4==300
// FFF03DD8: conditional instruction was optimized away because r0.4==300

//----- (FFF04004) --------------------------------------------------------
KThreadIntrusiveList *__fastcall KThreadIntrusiveList::KThreadIntrusiveList(KThreadIntrusiveList *this)
{
  this->link.prev = 0;
  this->link.next = 0;
  return this;
}

//----- (FFF04014) --------------------------------------------------------
void __fastcall KAffinityMask::Normalize(KAffinityMask *dstAffMask, KAffinityMask *this, u8 numCores)
{
  *dstAffMask = *this & ~(-1 << numCores);
}

//----- (FFF04028) --------------------------------------------------------
void PostSvcDpcHandler(void)
{
  KThread::HandleDpc(current.clc.current.thread);
}

//----- (FFF04038) --------------------------------------------------------
Result __fastcall SvcStopDma(Handle dmaObjectHandle)
{
  KDmaObject *v1; // r0
  KDmaObject *v2; // r4
  KDmaObject *dmaObj; // r5
  u8 typeId; // r8
  int channelId; // r0
  KTypeObj v7; // [sp+0h] [bp-28h] BYREF
  KTypeObj v8; // [sp+8h] [bp-20h] BYREF

  v1 = (KDmaObject *)KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, dmaObjectHandle);
  v2 = v1;
  if ( !v1 )
    return 0xD8E007F7;
  dmaObj = v1;
  v1->GetTypeObj(&v7, v1);
  typeId = v7.typeId;
  dmaObj->GetTypeObj(&v8, dmaObj);
  if ( (typeId | 0x59) != v8.typeId )
  {
    dmaObj = 0;
    v2->DecrementRefcount(v2);
  }
  if ( !dmaObj )
    return 0xD8E007F7;
  dmaObj->DecrementRefcount(dmaObj);            // uaf
  channelId = dmaObj->channelId;
  if ( channelId >= 0 )
    KDmaChannel::AbortTransfer(&g_dmaChannels[channelId]);
  return 0;
}

//----- (FFF04128) --------------------------------------------------------
Result __fastcall SvcClearEvent(Handle eventHandle)
{
  KAutoObject *v1; // r0
  KAutoObject *v2; // r4
  u8 typeId; // r7
  int v4; // r1
  KEvent *v5; // r5
  KEvent *v6; // r4
  Result v7; // r5
  KTypeObj v9; // [sp+0h] [bp-28h] BYREF
  KTypeObj v10; // [sp+8h] [bp-20h] BYREF

  v1 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, eventHandle);
  v2 = v1;
  if ( !v1 )
    return 0xD8E007F7;
  v1->GetTypeObj(&v9, v1);
  typeId = v9.typeId;
  v2->GetTypeObj(&v10, v2);
  v4 = typeId | 0x1F;
  v5 = v4 == v10.typeId ? (KEvent *)v2 : 0;
  if ( v4 != v10.typeId )
    v2->DecrementRefcount(v2);
  if ( !v5 )
    return 0xD8E007F7;
  v6 = v5;
  v7 = KEvent::Clear(v5);
  v6->DecrementRefcount(v6);
  return v7;
}

//----- (FFF04200) --------------------------------------------------------
Result __fastcall SvcClearTimer(Handle timerHandle)
{
  KAutoObject *v1; // r0
  KAutoObject *v2; // r4
  u8 typeId; // r7
  int v4; // r1
  KTimer *v5; // r5
  KTimer *v6; // r4
  Result v7; // r5
  KTypeObj v9; // [sp+0h] [bp-28h] BYREF
  KTypeObj v10; // [sp+8h] [bp-20h] BYREF

  v1 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, timerHandle);
  v2 = v1;
  if ( !v1 )
    return 0xD8E007F7;
  v1->GetTypeObj(&v9, v1);
  typeId = v9.typeId;
  v2->GetTypeObj(&v10, v2);
  v4 = typeId | 0x35;
  v5 = v4 == v10.typeId ? (KTimer *)v2 : 0;
  if ( v4 != v10.typeId )
    v2->DecrementRefcount(v2);
  if ( !v5 )
    return 0xD8E007F7;
  v6 = v5;
  v7 = KTimer::Clear(v5);
  v6->DecrementRefcount(v6);
  return v7;
}

//----- (FFF042D8) --------------------------------------------------------
void __noreturn SvcExitThread(void)
{
  KThread::Exit(current.clc.current.thread);
}

//----- (FFF042F4) --------------------------------------------------------
Result __fastcall SvcCancelTimer(Handle timerHandle)
{
  KAutoObject *v1; // r0
  KAutoObject *v2; // r4
  u8 typeId; // r7
  int v4; // r1
  KTimer *v5; // r5
  KTimer *v6; // r4
  Result v7; // r5
  KTypeObj v9; // [sp+0h] [bp-28h] BYREF
  KTypeObj v10; // [sp+8h] [bp-20h] BYREF

  v1 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, timerHandle);
  v2 = v1;
  if ( !v1 )
    return 0xD8E007F7;
  v1->GetTypeObj(&v9, v1);
  typeId = v9.typeId;
  v2->GetTypeObj(&v10, v2);
  v4 = typeId | 0x35;
  v5 = v4 == v10.typeId ? (KTimer *)v2 : 0;
  if ( v4 != v10.typeId )
    v2->DecrementRefcount(v2);
  if ( !v5 )
    return 0xD8E007F7;
  v6 = v5;
  v7 = KTimer::Cancel(v5);
  v6->DecrementRefcount(v6);
  return v7;
}

//----- (FFF043CC) --------------------------------------------------------
Result __fastcall SvcCloseHandle(Handle handle)
{
  if ( KHandleTable::CloseHandle(&current.clc.current.process->handleTable, handle) )
    return 0;
  else
    return 0xD8E007F7;
}

//----- (FFF043FC) --------------------------------------------------------
void __noreturn SvcExitProcess(void)
{
  KProcess::TerminateCurrentProcess(current.clc.current.process);
  kernelpanic();
}

//----- (FFF04418) --------------------------------------------------------
Result __fastcall SvcSignalEvent(Handle eventHandle)
{
  KAutoObject *v1; // r0
  KAutoObject *v2; // r4
  u8 typeId; // r7
  int v4; // r1
  KEvent *v5; // r5
  KEvent *v6; // r4
  Result v7; // r5
  KTypeObj v9; // [sp+0h] [bp-28h] BYREF
  KTypeObj v10; // [sp+8h] [bp-20h] BYREF

  v1 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, eventHandle);
  v2 = v1;
  if ( !v1 )
    return 0xD8E007F7;
  v1->GetTypeObj(&v9, v1);
  typeId = v9.typeId;
  v2->GetTypeObj(&v10, v2);
  v4 = typeId | 0x1F;
  v5 = v4 == v10.typeId ? (KEvent *)v2 : 0;
  if ( v4 != v10.typeId )
    v2->DecrementRefcount(v2);
  if ( !v5 )
    return 0xD8E007F7;
  v6 = v5;
  v7 = KEvent::Signal(v5);
  v6->DecrementRefcount(v6);
  return v7;
}

//----- (FFF044F0) --------------------------------------------------------
void __fastcall SvcSleepThread(s64 timeout)
{
  if ( ((((unsigned __int64)-timeout >> 32) & 0x80000000) != 0LL) != __OFSUB__(
                                                                       0,
                                                                       HIDWORD(timeout),
                                                                       (_DWORD)timeout == 0) )
  {
    KThread::Sleep(current.clc.current.thread, timeout);
  }
  else if ( !timeout )
  {
    KScheduler::YieldCurrentThread(current.clc.current.scheduler);
  }
}

//----- (FFF04534) --------------------------------------------------------
Result __fastcall SvcReleaseMutex(Handle mutexHandle)
{
  KAutoObject *v1; // r0
  KAutoObject *v2; // r4
  u8 typeId; // r7
  int v4; // r1
  KMutex *v5; // r5
  KMutex *v6; // r4
  Result v7; // r5
  KTypeObj v9; // [sp+0h] [bp-28h] BYREF
  KTypeObj v10; // [sp+8h] [bp-20h] BYREF

  v1 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, mutexHandle);
  v2 = v1;
  if ( !v1 )
    return 0xD8E007F7;
  v1->GetTypeObj(&v9, v1);
  typeId = v9.typeId;
  v2->GetTypeObj(&v10, v2);
  v4 = typeId | 0x39;
  v5 = v4 == v10.typeId ? (KMutex *)v2 : 0;
  if ( v4 != v10.typeId )
    v2->DecrementRefcount(v2);
  if ( !v5 )
    return 0xD8E007F7;
  v6 = v5;
  v7 = KMutex::Unlock(v5, current.clc.current.thread);
  v6->DecrementRefcount(v6);
  return v7;
}

//----- (FFF04618) --------------------------------------------------------
Result __fastcall SvcBindInterrupt(s32 irqId, Handle interruptEvent, s32 priority, BOOL levelSensitive)
{
  KProcess *process; // r10
  KInterruptEvent *v8; // r4
  int v9; // r11
  int v10; // r1
  bool v11; // zf
  Result v13; // r5
  Result v14; // r0
  u8 fiq_mask; // r1
  KTypeObj result; // [sp+0h] [bp-68h] BYREF
  KTypeObj v17; // [sp+10h] [bp-58h]
  KTypeObj v18; // [sp+28h] [bp-40h] BYREF
  KTypeObj v19; // [sp+30h] [bp-38h]
  KTypeObj v20; // [sp+38h] [bp-30h]

  process = current.clc.current.process;
  v8 = KHandleTable::ConvertToInterruptEvent(&current.clc.current.process->handleTable, interruptEvent);
  if ( !v8 )
    return *MakeResultCode((Result *)&result.typeId, 0xFBu, 7u, 1u, 0x3F7u);
  v9 = __mrc(15, 0, 0, 0, 5) & 3;
  v17.typeId = 31;
  v17.name = "KEvent";
  v19.name = "KEvent";                          // "KEvent"
  *(_DWORD *)&v19.typeId = *(_DWORD *)&v17.typeId;
  v8->GetTypeObj(&v18, v8);
  v17 = v18;
  v8->GetTypeObj(&result, v8);
  v20 = result;
  v10 = v19.typeId | v17.typeId;
  v11 = v10 == result.typeId;
  if ( v10 == result.typeId )
    BYTE1(v8[1].KSynchronizationObject::KAutoObject::__vftable) = levelSensitive;// if KEvent, set manual clear=true to iff level-sensitive
  else
    v11 = !levelSensitive;
  if ( !v11 )
    goto LABEL_15;
  if ( irqId == 15 )
  {
    if ( !g_systemControl.targetSystem.isDevUnit )// 
                                                // UnbindInterrupt has a double-free issue in this path,
                                                // so Nintendo just made it inaccessible on retail.
    {
LABEL_15:
      v8->DecrementRefcount(v8);
      return 0xD8E007EE;
    }
    if ( KFiqState::CompareExchangeStrong(&g_fiqState, KFIQSTATE_UNBOUND, KFIQSTATE_BOUND) )
    {
      v13 = 0xD8A007F0;
    }
    else if ( g_fiqHelper.interruptEvent )
    {
      KFiqState::Set(&g_fiqState, KFIQSTATE_UNBOUND);// lol yikes
                                                // it leaks
      v13 = 0xD8A007FC;
    }
    else
    {
      g_fiqHelper.interruptEvent = v8;
      g_fiqHelper.manualClear = levelSensitive;
      g_fiqHelper.active = 0;
      KAutoObject::IncrementRefcount(v8);
      v8->irqId = 15;
      v14 = KInterruptManager::BindInterrupt(&g_interruptManager, &g_fiqHelper.s, 0xFu, v9, priority, 0, 0);
      v13 = v14;
      if ( v14 >= 0 )
      {
        fiq_mask = CONFIG11.fiq_mask;
        CONFIG11.fiq_mask = fiq_mask & ~2;
      }
      else
      {
        v8->irqId = -1;
        v8->DecrementRefcount(v8);
        g_fiqHelper.interruptEvent = 0;
        KFiqState::Set(&g_fiqState, KFIQSTATE_UNBOUND);
      }
    }
  }
  else
  {
    v13 = KProcess::BindUserInterruptEvent(process, v8, irqId, v9, priority, levelSensitive);
  }
  v8->DecrementRefcount(v8);
  return v13;
}

//----- (FFF0485C) --------------------------------------------------------
s64 SvcGetSystemTick(void)
{
  return KHardwareTimer::GetSystemTick(&g_hardwareTimer);
}

//----- (FFF04868) --------------------------------------------------------
int __fastcall SvcSetWifiEnabled(bool a1)
{
  SetWifiEnabled(a1);
  return 0;
}

//----- (FFF04878) --------------------------------------------------------
Result __fastcall SvcMapMemoryBlock(Handle sharedMemHandle, u32 addr, u32 myPerms, u32 othersPerms)
{
  Result result; // r0
  bool v9; // zf
  Result v10; // r1
  bool v11; // zf
  bool v12; // zf
  KProcess *volatile process; // r8
  KAutoObject *v14; // r0
  KSharedMemory *v15; // r4
  KSharedMemory *v16; // r9
  u8 typeId; // r11
  Result v18; // r5
  KTypeObj v19; // [sp+0h] [bp-38h] BYREF
  KTypeObj v20; // [sp+8h] [bp-30h] BYREF

  result = addr << 20;
  if ( addr << 20 )
    result = 0xE0E01BF1;                        // check if the addr is aligned (size not checked?)
  if ( result >= 0 )
  {
    result = 0xE0E01BEE;
    if ( !myPerms )
      goto LABEL_10;
    v9 = myPerms == KMEMPERM_R;
    if ( myPerms != KMEMPERM_R )
      v9 = myPerms == KMEMPERM_W;
    if ( v9 || myPerms == KMEMPERM_RW )
LABEL_10:
      v10 = 0;
    else
      v10 = 0xE0E01BEE;
    if ( v10 < 0 )
      return v10;
    if ( othersPerms != KMEMPERM_W )
    {
      if ( (int)othersPerms > KMEMPERM_W )
      {
        v12 = othersPerms == KMEMPERM_RW;
        if ( othersPerms != KMEMPERM_RW )
          v12 = othersPerms == MEMPERM_DONTCARE;
        if ( !v12 )
          goto LABEL_25;
      }
      else
      {
        v11 = othersPerms == KMEMPERM_NONE;
        if ( othersPerms )
          v11 = othersPerms == KMEMPERM_R;
        if ( !v11 )
          goto LABEL_25;
      }
    }
    result = 0;
LABEL_25:
    if ( result >= 0 )
    {
      if ( !addr || (addr < 0x8000000 || addr >= 0x14000000 ? (result = 0xE0E01BF5) : (result = 0), result >= 0) )// check if in heap or 0x10000000..0x14000000 range
      {
        process = current.clc.current.process;
        v14 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, sharedMemHandle);
        v15 = (KSharedMemory *)v14;
        v16 = 0;
        if ( !v14 )
          return 0xD9001BF7;
        v14->GetTypeObj(&v19, v14);
        typeId = v19.typeId;
        v15->GetTypeObj(&v20, v15);
        if ( (typeId | 0xB0) == v20.typeId )
          v16 = v15;
        else
          v15->DecrementRefcount(v15);
        if ( v16 )
        {
          v18 = KSharedMemory::Map(
                  v16,
                  &process->pgTable,
                  addr,
                  process,
                  (KMemoryPermission)myPerms,
                  (KMemoryPermission)othersPerms);
          v16->DecrementRefcount(v16);
          return v18;
        }
        else
        {
          return 0xD9001BF7;
        }
      }
    }
  }
  return result;
}

//----- (FFF04A14) --------------------------------------------------------
Result __fastcall SvcMapProcessMemory(Handle processHandle, u32 addr, u32 size)
{
  KProcess *volatile curProc; // r7
  KProcess *v6; // r0
  KProcess *v7; // r5
  KProcess *otherProc; // r4
  unsigned __int8 v9; // r11
  u32 *v10; // r0
  Result v11; // r0
  signed __int32 *v12; // r1
  signed __int32 numPages; // r1
  Result v14; // r5
  KTypeObj v16; // [sp+8h] [bp-48h] BYREF
  u32 v17[2]; // [sp+Ch] [bp-44h] FORCED BYREF
  u32 v18; // [sp+14h] [bp-3Ch] BYREF
  char v19; // [sp+18h] [bp-38h] BYREF
  u32 v20; // [sp+1Ch] [bp-34h] BYREF

  curProc = current.clc.current.process;
  v6 = (KProcess *)KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, processHandle);
  v7 = v6;
  if ( !v6 )
    return 0xD9001BF7;
  otherProc = v6;
  v6->GetTypeObj((KTypeObj *)&v19, v6);
  v9 = v20;
  otherProc->GetTypeObj(&v16, otherProc);
  if ( (v9 | 0xC5) != v16.typeId )
  {
    otherProc = 0;
    v7->DecrementRefcount(v7);
  }
  if ( !otherProc )
    return 0xD9001BF7;
  v18 = size >> 12;
  v17[0] = 0x3F00;
  v10 = v17;
  if ( size >> 12 <= 0x3F00 )
    v10 = &v18;
  v11 = KProcessPageTable::MapProcessMemory(&curProc->pgTable, &otherProc->pgTable, addr, 0x100000u, *v10);
  if ( v11 >= 0 )
  {
    v17[0] = 0x6000;
    v12 = (signed __int32 *)&v20;
    if ( (int)(v18 - 0x7F00) > 0x6000 )
      v12 = (signed __int32 *)v17;
    v20 = v18 - 0x7F00;
    numPages = *v12;
    if ( numPages > 0 )
      v11 = KProcessPageTable::MapProcessMemory(
              &curProc->pgTable,
              &otherProc->pgTable,
              addr + 0x7F00000,
              0x8000000u,
              numPages);
  }
  v14 = v11;
  otherProc->DecrementRefcount(otherProc);
  return v14;
}

//----- (FFF04B84) --------------------------------------------------------
Result __fastcall SvcSendSyncRequest(Handle clientSessionHandle)
{
  KAutoObject *v1; // r0
  KAutoObject *v2; // r4
  u8 typeId; // r7
  int v4; // r1
  KClientSession *clientSession; // r5
  KSession *parent; // r4
  Result v7; // r5
  KTypeObj v9; // [sp+0h] [bp-28h] BYREF
  KTypeObj v10; // [sp+8h] [bp-20h] BYREF

  v1 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, clientSessionHandle);
  v2 = v1;
  if ( !v1 )
    return 0xD8E007F7;
  v1->GetTypeObj(&v9, v1);
  typeId = v9.typeId;
  v2->GetTypeObj(&v10, v2);
  v4 = typeId | 0xA5;
  clientSession = v4 == v10.typeId ? (KClientSession *)v2 : 0;
  if ( v4 != v10.typeId )
    v2->DecrementRefcount(v2);
  if ( !clientSession )
    return 0xD8E007F7;
  parent = clientSession->parent;
  KAutoObject::IncrementRefcount(parent);
  clientSession->DecrementRefcount(clientSession);
  v7 = KClientSession::SendSyncRequest(clientSession, current.clc.current.thread);
  parent->DecrementRefcount(parent);
  return v7;
}

//----- (FFF04C84) --------------------------------------------------------
Result __fastcall SvcUnbindInterrupt(s32 interruptId, Handle interruptEventHandle)
{
  KProcess *curProc; // r5
  KInterruptEvent *interruptEventFromHandle; // r0 MAPDST
  Result v6; // r5
  u8 fiq_mask; // r0
  int v9; // r6
  KFiqState v10; // r1
  Result v11; // [sp+4h] [bp-14h] BYREF

  curProc = current.clc.current.process;
  interruptEventFromHandle = KHandleTable::ConvertToInterruptEvent(
                               &current.clc.current.process->handleTable,
                               interruptEventHandle);
  if ( !interruptEventFromHandle )
    return *MakeResultCode(&v11, 0xFBu, 7u, 1u, 0x3F7u);
  if ( interruptId != KINTNAME_SGI_FIQ )
  {
    v6 = KProcess::UnbindUserInterruptEventChecked(curProc, interruptEventFromHandle, interruptId);
LABEL_4:
    interruptEventFromHandle->DecrementRefcount(interruptEventFromHandle);
    return v6;
  }
  if ( g_systemControl.targetSystem.isDevUnit )
  {                                             // this path is vulnerable to a double free if you pass a handle to a different KInterruptEvent.
                                                // 
                                                // To mitigate this, instead of fixing it, NN just made the path unreachable on retail units... (11.14)
    if ( KFiqState::CompareExchangeStrong(&g_fiqState, KFIQSTATE_BOUND, KFIQSTATE_UNBINDING) != KFIQSTATE_BOUND )
    {
      v6 = 0xD8A007F0;
      goto LABEL_4;
    }
    fiq_mask = CONFIG11.fiq_mask;
    CONFIG11.fiq_mask = fiq_mask | 2;
    v9 = KInterruptManager::UnbindKernelInterruptForCore(
           &g_interruptManager,
           KINTNAME_SGI_FIQ,
           __mrc(15, 0, 0, 0, 5) & 3);
    if ( v9 < 0 )
    {
      CONFIG11.fiq_mask &= ~2u;
      v10 = KFIQSTATE_BOUND;
    }
    else
    {
      interruptEventFromHandle->irqId = -1;
      interruptEventFromHandle->DecrementRefcount(interruptEventFromHandle);
      g_fiqHelper.interruptEvent = 0;
      v10 = 0;
    }
    KFiqState::Set(&g_fiqState, v10);
    interruptEventFromHandle->DecrementRefcount(interruptEventFromHandle);
    return v9;
  }
  else
  {
    interruptEventFromHandle->DecrementRefcount(interruptEventFromHandle);
    return 0xD8E007EE;
  }
}

//----- (FFF04DF0) --------------------------------------------------------
void __fastcall SvcStopPointOrInvalidId(u32 svcId)
{
  int pc; // r1
  int v2; // r1
  _BYTE sp[8]; // [sp+0h] [bp-8h] BYREF

  if ( svcId != 0xFF )                          // stop point
  {
    DispatchDebugEventFromException(DBGEVENT_EXCEPTION, EXCEVENT_UNDEFINED_SYSCALL, svcId);
    kernelpanic();
  }
  __enable_irq();
  pc = *(_DWORD *)(((unsigned int)sp & 0xFFFFF000) + 0xF30);
  if ( (*(_DWORD *)(((unsigned int)sp & 0xFFFFF000) + 0xF34) & 0x20) != 0 )
    v2 = pc - 2;
  else
    v2 = pc - 4;
  *(_DWORD *)(((unsigned int)sp & 0xFFFFF000) + 0xF30) = v2;
  KPageTable::CleanInvalidateDataCacheRangeLocal(((unsigned int)sp & 0xFFFFF000) + 0xF30, 4u);
  DispatchDebugEventFromException(DBGEVENT_EXCEPTION, EXCEVENT_STOP_POINT, 0);
  __disable_irq();
}

//----- (FFF04E60) --------------------------------------------------------
Result __fastcall SvcGetThreadContext(ThreadContext *ctx, Handle threadHandle)
{
  return 0xF8C007F4;
}

//----- (FFF04E6C) --------------------------------------------------------
Result __fastcall SvcFlushCodeSegment(u32 addr, u32 size)
{
  return 0xF8C007F4;                            // On LGY firms, cleaninvs the dcache and invs the icache over the selected range
}

//----- (FFF04E78) --------------------------------------------------------
Result __fastcall SvcSendSyncRequest1(Handle clientSessionHandle)
{
  return -121632780;
}

//----- (FFF04E84) --------------------------------------------------------
Result __fastcall SvcSendSyncRequest2(Handle clientSessionHandle)
{
  return -121632780;
}

//----- (FFF04E90) --------------------------------------------------------
Result __fastcall SvcSendSyncRequest3(Handle clientSessionHandle)
{
  return -121632780;
}

//----- (FFF04E9C) --------------------------------------------------------
Result __fastcall SvcSendSyncRequest4(Handle clientSessionHandle)
{
  return -121632780;
}

//----- (FFF04EA8) --------------------------------------------------------
Result __fastcall SvcTerminateProcess(Handle processHandle)
{
  KProcess *proc; // r4

  proc = KHandleTable::ConvertToProcessAllowPseudoHandle(&current.clc.current.process->handleTable, processHandle);
  if ( !proc )
    return 0xD8E007F7;
  if ( current.clc.current.process == proc )
  {
    proc->DecrementRefcount(proc);
    KProcess::TerminateCurrentProcess(proc);
    kernelpanic();
  }
  KProcess::TerminateOtherProcess(proc);
  proc->DecrementRefcount(proc);
  return 0;
}

//----- (FFF04F20) --------------------------------------------------------
Result __fastcall SvcUnmapMemoryBlock(Handle handle, u32 addr)
{
  Result result; // r0
  KProcess *volatile curProc; // r6
  KAutoObject *v6; // r0
  KAutoObject *v7; // r4
  u8 typeId; // r9
  int v9; // r1
  KSharedMemory *v10; // r7
  Result v11; // r5
  KTypeObj v12; // [sp+0h] [bp-30h] BYREF
  KTypeObj v13; // [sp+8h] [bp-28h] BYREF

  result = addr << 20;
  if ( addr << 20 )
    result = 0xE0E01BF1;
  if ( result >= 0 )
  {
    result = addr < 0x8000000 || addr >= 0x14000000 ? 0xE0E01BF5 : 0;
    if ( result >= 0 )
    {
      curProc = current.clc.current.process;
      v6 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, handle);
      v7 = v6;
      if ( !v6 )
        return 0xD9001BF7;
      v6->GetTypeObj(&v12, v6);
      typeId = v12.typeId;
      v7->GetTypeObj(&v13, v7);
      v9 = typeId | 0xB0;
      v10 = v9 == v13.typeId ? (KSharedMemory *)v7 : 0;
      if ( v9 != v13.typeId )
        v7->DecrementRefcount(v7);
      if ( v10 )
      {
        v11 = KSharedMemory::Unmap(v10, &curProc->pgTable, addr, curProc);
        v10->DecrementRefcount(v10);
        return v11;
      }
      else
      {
        return 0xD9001BF7;
      }
    }
  }
  return result;
}

//----- (FFF0503C) --------------------------------------------------------
Result __fastcall SvcUnmapProcessMemory(Handle processHandle, u32 addr, u32 size)
{
  signed __int32 numPages; // r2
  KProcessPageTable *p_pgTable; // r6
  int *v6; // r0
  Result v7; // r0
  Result v8; // r4
  int *v9; // r0
  Result v10; // r0
  int v12; // [sp+0h] [bp-20h] BYREF
  int v13; // [sp+4h] [bp-1Ch] BYREF
  int v14; // [sp+8h] [bp-18h] BYREF
  int v15; // [sp+Ch] [bp-14h] BYREF

  numPages = size >> 12;
  p_pgTable = &current.clc.current.process->pgTable;
  v6 = &v15;
  if ( numPages <= 0x3F00 )
    v6 = &v13;
  v13 = numPages;
  v15 = 0x3F00;
  v7 = KProcessPageTable::UnmapProcessMemory(&current.clc.current.process->pgTable, addr, *v6);
  v12 = 0x6000;
  v8 = v7;
  v9 = &v14;
  if ( v13 - 0x7F00 > 0x6000 )
    v9 = &v12;
  v14 = v13 - 0x7F00;
  if ( *v9 > 0 )
  {
    v10 = KProcessPageTable::UnmapProcessMemory(p_pgTable, addr + 0x7F00000, *v9);
    if ( v8 >= 0 )
      v8 = v10;
  }
  KPageTable::CleanInvalidateEntireDataCache();
  KPageTable::InvalidateEntireInstructionCache();
  return v8;
}

//----- (FFF050F0) --------------------------------------------------------
Result __fastcall SvcBreakDebugProcess(Handle debugHandle)
{
  KDebug *v1; // r0
  KDebug *v2; // r4
  Result v4; // r5

  v1 = KHandleTable::ConvertCurProcHandleToDebug(debugHandle);
  v2 = v1;
  if ( !v1 )
    return -654303230;
  if ( v1->hasDebuggerBreak )
  {
    v1->DecrementRefcount(v1);
    return -668983289;
  }
  else if ( KDebug::IsProcessTerminated(v1) )
  {
    v2->DecrementRefcount(v2);
    return -660594680;
  }
  else
  {
    v4 = KDebug::BreakProcess(v2);
    v2->DecrementRefcount(v2);
    return v4;
  }
}

//----- (FFF05184) --------------------------------------------------------
Result __fastcall SvcOutputDebugString(u32 addr, u32 size)
{
  int v2; // r3
  int v3; // r2
  int v5; // r12
  u32 endAddr; // lr
  bool v7; // cf
  int v8; // r2
  bool v9; // cf
  u32 v10; // r2
  int v11; // r3

  v2 = 0xE0E01BFD;
  if ( (size & 0x80000000) != 0 )
    v3 = 0xE0E01BFD;
  else
    v3 = 0;
  if ( v3 < 0 )
    return 0xE0E01FFD;
  if ( ~addr >= size )                          // if 0xFFFFFFFF - addr < size
    v2 = 0;
  if ( v2 < 0 )
    return 0xE0E01FFD;
  v5 = 0xE0E01BF5;
  endAddr = addr + size;
  if ( size )
  {
    v7 = addr >= endAddr - 1;
    if ( addr <= endAddr - 1 )
      v7 = endAddr - 1 >= 0x40000000;
    if ( !v7 )
      goto LABEL_13;
  }
  else if ( addr < 0x40000000 )
  {
LABEL_13:
    v8 = 0;
    goto LABEL_16;
  }
  v8 = 0xE0E01BF5;
LABEL_16:
  if ( v8 >= 0 )
    return DispatchDebugEvent(DBGEVENT_OUTPUT_STRING, addr, size & 0x7FFFFFFF);
  if ( size )                                   // dead code past this point as the first check is more inclusive than all the others
  {
    v9 = addr >= 0x8000000;
    v10 = endAddr - 1;
    if ( addr >= 0x8000000 )
      v9 = v10 >= addr;
    if ( v9 && v10 < 0x14000000 )
      goto LABEL_23;
  }
  else if ( addr >= 0x8000000 && addr < 0x14000000 )
  {
LABEL_23:
    v11 = 0;
    goto LABEL_27;
  }
  v11 = 0xE0E01BF5;
LABEL_27:
  if ( v11 >= 0 )
    return DispatchDebugEvent(DBGEVENT_OUTPUT_STRING, addr, size & 0x7FFFFFFF);
  if ( size )
  {
    if ( addr > endAddr - 1 || endAddr - 1 >= 0x100000 )
      goto LABEL_31;
  }
  else if ( addr >= 0x100000 )
  {
LABEL_31:
    v5 = 0;
  }
  if ( v5 < 0 )
    return 0xD9001C03;
  return DispatchDebugEvent(DBGEVENT_OUTPUT_STRING, addr, size & 0x7FFFFFFF);
}

//----- (FFF052A8) --------------------------------------------------------
Result __fastcall SvcReadDebugProcessMemory(u32 dstAddr, Handle debugHandle, u32 addr, u32 size)
{
  bool v4; // zf
  int res; // r0
  bool v9; // zf
  KDebug *v10; // r5
  Result res2; // r4

  v4 = dstAddr == 0;
  res = debugHandle;
  if ( v4 )
    res = -656406538;
  if ( !v4 )
  {
    res = (int)KHandleTable::ConvertCurProcHandleToDebug(res);
    v10 = (KDebug *)res;
    v9 = res == 0;
    if ( !res )
      res = 0xD9002002;
    if ( !v9 )
    {
      if ( KDebug::IsProcessTerminated((KDebug *)res) )
      {
        v10->DecrementRefcount(v10);
        return 0xD8A02008;
      }
      else
      {
        if ( ~dstAddr >= size )                 // if (UINT32_MAX - outAddr < size)
        {
          if ( KDebug::CheckMemoryAddressRange(v10, dstAddr, size, 0, 1) >= 0 )
          {
            if ( KDebug::CheckMemoryAddressRange(v10, addr, size, 1, 0) >= 0 )
              res2 = KDebug::ReadProcessMemory(v10, dstAddr, addr, size);
            else
              res2 = 0xD900200B;
          }
          else
          {
            res2 = 0xD900200A;
          }
        }
        else
        {
          res2 = 0xE0E023FD;
        }
        v10->DecrementRefcount(v10);
        return res2;
      }
    }
  }
  return res;
}

//----- (FFF053A8) --------------------------------------------------------
Result __fastcall SvcSetThreadPriority(Handle threadHandle, s32 priority)
{
  Result result; // r0
  KThread *thread; // r4
  int v7; // r6

  if ( (unsigned int)priority >= 0x40 )
    result = 0xE0E01BFD;
  else
    result = 0;
  if ( result >= 0 )
  {
    thread = KHandleTable::ConvertToThreadAllowPseudoHandle(&current.clc.current.process->handleTable, threadHandle);
    if ( thread )
    {
      if ( KProcess::CheckThreadPriority(current.clc.current.process, priority) )
      {
        v7 = KThread::SetPriority(thread, priority);
        if ( v7 >= 0 )
        {
          thread->DecrementRefcount(thread);
          return v7;
        }
        else
        {
          if ( v7 << 22 != 0xFF400000 )
            kernelpanic();
          thread->DecrementRefcount(thread);
          return 0xE0E01BFD;
        }
      }
      else
      {
        return 0xD9001BEA;
      }
    }
    else
    {
      return 0xD9001BF7;
    }
  }
  return result;
}

//----- (FFF05470) --------------------------------------------------------
Result __fastcall SvcContinueDebugEvent(Handle debugHandle, DebugFlags debugFlags)
{
  KDebug *v3; // r0
  KDebug *v4; // r4
  unsigned int CPSR; // r5
  Result v7; // r6

  v3 = KHandleTable::ConvertCurProcHandleToDebug(debugHandle);
  v4 = v3;
  if ( !v3 )
    return 0xD9002002;
  if ( KDebug::NeedsContinue(v3) )
  {
    if ( KDebug::IsProcessTerminated(v4) )
    {
      v4->DecrementRefcount(v4);
      return 0xD8A02008;
    }
    else
    {
      CPSR = __get_CPSR();
      __disable_irq();
      v7 = KDebug::Continue(v4, debugFlags);
      __set_CPSR(CPSR);
      v4->DecrementRefcount(v4);
      return v7;
    }
  }
  else
  {
    v4->DecrementRefcount(v4);
    return 0xD8202007;
  }
}

//----- (FFF05514) --------------------------------------------------------
Result __fastcall SvcWriteDebugProcessMemory(Handle debugHandle, u32 addr, u32 dstAddr, u32 size)
{
  Result result; // r0
  bool v8; // zf
  KDebug *v9; // r5
  Result v10; // r4

  result = (Result)KHandleTable::ConvertCurProcHandleToDebug(debugHandle);
  v9 = (KDebug *)result;
  v8 = result == 0;
  if ( !result )
    result = 0xD9002002;
  if ( !v8 )
  {
    if ( KDebug::IsProcessTerminated((KDebug *)result) )
    {
      v9->DecrementRefcount(v9);
      return 0xD8A02008;
    }
    else
    {
      if ( ~addr >= size )                      // 0xFFFFFFFF - addr < size
      {
        if ( KDebug::CheckMemoryAddressRange(v9, dstAddr, size, 1, 1) >= 0 )
        {
          if ( KDebug::CheckMemoryAddressRange(v9, addr, size, 0, 0) >= 0 )
            v10 = KDebug::WriteProcessMemory(v9, addr, dstAddr, size);
          else
            v10 = 0xD900200A;
        }
        else
        {
          v10 = 0xD900200B;
        }
      }
      else
      {
        v10 = 0xE0E023FD;
      }
      v9->DecrementRefcount(v9);
      return v10;
    }
  }
  return result;
}

//----- (FFF05604) --------------------------------------------------------
Result __fastcall SvcSetProcessResourceLimits(Handle processHandle, Handle resLimitHandle)
{
  KHandleTable *p_handleTable; // r5
  KProcess *proc; // r4
  KAutoObject *v5; // r0
  KAutoObject *v6; // r4
  KProcess *v7; // r8
  u8 typeId; // r9
  KResourceLimit *resLimit; // r0 MAPDST
  bool v10; // zf
  Result v13; // r6
  KTypeObj v14; // [sp+0h] [bp-30h] BYREF
  KTypeObj v15; // [sp+8h] [bp-28h] BYREF

  p_handleTable = &current.clc.current.process->handleTable;
  if ( processHandle == CUR_PROCESS_HANDLE )
  {
    proc = current.clc.current.process;
    KAutoObject::IncrementRefcount(current.clc.current.process);
  }
  else
  {
    v5 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, processHandle);
    v6 = v5;
    v7 = 0;
    if ( v5 )
    {
      v5->GetTypeObj(&v14, v5);
      typeId = v14.typeId;
      v6->GetTypeObj(&v15, v6);
      if ( (typeId | 0xC5) == v15.typeId )
        v7 = (KProcess *)v6;
      else
        v6->DecrementRefcount(v6);
    }
    proc = v7;
  }
  resLimit = KHandleTable::ConvertToResourceLimit(p_handleTable, resLimitHandle);
  v10 = proc == 0;
  if ( proc )
    v10 = resLimit == 0;
  if ( v10 )
    return 0xD8E007F7;                          // resleak!
  v13 = KProcess::SetResourceLimits(proc, resLimit);
  resLimit->DecrementRefcount(resLimit);
  proc->DecrementRefcount(proc);
  return v13;
}

//----- (FFF05724) --------------------------------------------------------
Result __fastcall SvcGetProcessDebugEvent(DebugEventInfo *outDebugEventInfo, Handle debugHandle)
{
  Result result; // r0
  bool v4; // zf
  KDebug *v5; // r5
  KEventInfo *v6; // r0
  KEventInfo *v7; // r4
  u32 tidHigh; // r2
  KCodeSet *codeSet; // r2
  u32 v10; // r1
  u32 v11; // r2
  u32 processEntrypoint; // r0
  KEventInfoData *p_d; // r0
  int i; // r1
  int v15; // r3
  u32 clockTick_high; // r2
  u32 address; // r1
  u32 size; // r2
  u32 permissions; // r3
  DebugEventInfo info; // [sp+0h] [bp-40h] BYREF

  if ( !outDebugEventInfo )
    return 0xD8E007F6;
  result = (Result)KHandleTable::ConvertCurProcHandleToDebug(debugHandle);
  v5 = (KDebug *)result;
  v4 = result == 0;
  if ( !result )
    result = 0xD9002002;
  if ( !v4 )
  {
    v6 = KDebug::GetFirstEventInfoToFetch((KDebug *)result);// 
                                                // bug, the mutex should be held by the entire function body, not just during queue get/pop
                                                // 
                                                // same remark with continue
    v7 = v6;
    if ( v6 )
    {
      memset(&info, 0, sizeof(info));
      info.fields[0] = v6->type;
      info.fields[1] = v6->threadId;
      info.fields[2] = v6->flags;
      switch ( v6->type )
      {
        case DBGEVENT_ATTACH_PROCESS:
          tidHigh = HIDWORD(v6->d.attachProcess.process->codeSet->titleId);
          info.fields[4] = v6->d.attachProcess.process->codeSet->titleId;
          info.fields[5] = tidHigh;
          codeSet = v6->d.attachProcess.process->codeSet;
          v10 = *(_DWORD *)codeSet->processName;
          v11 = *(_DWORD *)&codeSet->processName[4];
          info.fields[6] = v10;
          info.fields[7] = v11;
          info.fields[8] = v6->d.attachProcess.process->pid;
          if ( v6->ignoreContinue )
            info.fields[9] = 1;
          break;
        case DBGEVENT_ATTACH_THREAD:
          info.fields[4] = v6->d.attachThread.creatorThreadId;
          info.fields[5] = v6->d.attachThread.tls;
          processEntrypoint = v6->d.attachThread.processEntrypoint;
LABEL_18:
          info.fields[6] = processEntrypoint;
          break;
        case DBGEVENT_EXIT_THREAD:
        case DBGEVENT_EXIT_PROCESS:
          info.fields[4] = v6->d.exitProcess.reason;
          break;
        case DBGEVENT_EXCEPTION:
          p_d = &v6->d;
          info.fields[4] = v7->d.exception.type;
          info.fields[5] = v7->d.exception.address;
          switch ( info.fields[EXCEVENT_ATTACH_BREAK] )// [4], exception type
          {
            case EXCEVENT_DATA_ABORT:
            case EXCEVENT_UNALIGNED_DATA_ACCESS:
            case EXCEVENT_UNDEFINED_SYSCALL:
              processEntrypoint = v7->d.exception.d.fault.faultInfo;
              goto LABEL_18;
            case EXCEVENT_STOP_POINT:
              info.fields[7] = v7->d.exception.d.fault.faultInfo;
              processEntrypoint = v7->d.exception.d.fault.stopPointType;
              goto LABEL_18;
            case EXCEVENT_USER_BREAK:
              info.fields[6] = v7->d.exception.d.userBreak.reason;
              info.fields[7] = v7->d.exception.d.userBreak.croInfo;
              info.fields[8] = v7->d.exception.d.userBreak.croInfoSize;
              break;
            case EXCEVENT_DEBUGGER_BREAK:
              for ( i = 0; ; ++i )
              {
                v15 = (MPCORE.scu.cfgr & 3) + 1;
                if ( v15 <= i )
                  break;
                info.fields[i + 6] = p_d->exception.d.debuggerBreak.currentThreadIds[i];
              }
              break;
            default:
              goto LABEL_27;
          }
          break;
        case DBGEVENT_SCHEDULE_IN:
        case DBGEVENT_SCHEDULE_OUT:
        case DBGEVENT_SYSCALL_IN:
        case DBGEVENT_SYSCALL_OUT:
          clockTick_high = HIDWORD(v6->d.syscall.clockTick);
          info.fields[4] = v6->d.syscall.clockTick;
          info.fields[5] = clockTick_high;
          info.fields[6] = v6->d.syscall.svcId; // or cpuId
          break;
        case DBGEVENT_OUTPUT_STRING:
          info.fields[4] = v6->d.outputString.str;
          info.fields[5] = v6->d.outputString.size;
          break;
        case DBGEVENT_MAP:
          address = v6->d.map.address;
          size = v6->d.map.size;
          permissions = v6->d.map.permissions;
          info.fields[7] = v6->d.map.state;
          info.fields[4] = address;
          info.fields[5] = size;
          info.fields[6] = permissions;
          break;
        default:
          break;
      }
LABEL_27:
      KDebug::EraseFirstEventInfoToFetchNode(v5);
      KDebug::ProcessEventInfo(v5, v7->type, v7);
      v5->DecrementRefcount(v5);
      if ( CopyBytesToUser(outDebugEventInfo, &info, 0x28u) )
        return 0;
      else
        return 0xE0E01BF5;
    }
    else
    {
      v5->DecrementRefcount(v5);
      return 0xD8402009;
    }
  }
  return result;
}
// FFF057AC: control flows out of bounds to FFF057B0
// FFF0589C: control flows out of bounds to FFF058A0

//----- (FFF059D4) --------------------------------------------------------
Result __fastcall SvcWaitSynchronization1(Handle handle, s64 timeout)
{
  unsigned int v2; // r5
  unsigned int v3; // r7
  KAutoObject *v5; // r0
  KAutoObject *v6; // r4
  u8 typeId; // r10
  int v8; // r1
  KSynchronizationObject *v9; // r6
  Result v10; // r5
  KTypeObj t1; // [sp+0h] [bp-30h] BYREF
  KTypeObj v12; // [sp+8h] [bp-28h] BYREF

  v2 = HIDWORD(timeout);
  v3 = timeout;
  if ( timeout < 0 && timeout != -1 )
    return 0xD8E007FD;
  v5 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, handle);
  v6 = v5;
  if ( !v5 )
    return 0xD8E007F7;
  v5->GetTypeObj(&t1, v5);
  typeId = t1.typeId;
  v6->GetTypeObj(&v12, v6);
  v8 = typeId | 1;
  v9 = v8 == v12.typeId ? (KSynchronizationObject *)v6 : 0;
  if ( v8 != v12.typeId )
    v6->DecrementRefcount(v6);
  if ( !v9 )
    return 0xD8E007F7;
  v10 = KSynchronization::WaitSynchronization1(&g_synchronization, current.clc.current.thread, v9, __SPAIR64__(v2, v3));
  v9->DecrementRefcount(v9);
  return v10;
}

//----- (FFF05AF4) --------------------------------------------------------
Result __fastcall SvcSetGpuProt(bool allowSystem)
{
  SetGpuProt(allowSystem);
  return 0;
}

//----- (FFF05B04) --------------------------------------------------------
Result __fastcall SvcFlushProcessDataCache(Handle a1, u32 a2, u32 a3)
{
  KCacheOperator v4; // [sp+0h] [bp-8h] BYREF

  v4.__vftable = &KCleanInvalidateDataCacheOperator::vt;
  return KCacheOperator::OperateOnProcessCache(&v4, a1, a2, a3);
}

//----- (FFF05B30) --------------------------------------------------------
Result __fastcall SvcGetDebugThreadContext(
        ThreadContext *outThreadContext,
        Handle debugHandle,
        u32 tid,
        ThreadContextControlFlags flags)
{
  KDebug *v8; // r0
  KDebug *debug; // r4
  int res; // r5
  int v11; // r0
  ThreadContext v12; // [sp-E0h] [bp-E0h] BYREF

  if ( !outThreadContext )
    return 0xD8E007F6;
  v8 = KHandleTable::ConvertCurProcHandleToDebug(debugHandle);
  debug = v8;
  if ( !v8 )
    return 0xD9002002;
  if ( KDebug::IsProcessTerminated(v8) )
  {
    debug->DecrementRefcount(debug);
    return 0xD8A02008;
  }
  else
  {
    res = KDebug::GetPausedThreadContextById(debug, &v12, tid, flags);
    debug->DecrementRefcount(debug);
    if ( res >= 0 )
    {
      if ( CopyWordsToUser(outThreadContext, &v12, 0xCCu) )
        v11 = 0;
      else
        v11 = 0xE0E01BF5;
      if ( v11 >= 0 )
        return 0;
      else
        return 0xD900200A;
    }
    else if ( res << 22 == 0xFBC00000 )
    {
      return 0xD9002004;
    }
    else
    {
      return res;
    }
  }
}

//----- (FFF05C24) --------------------------------------------------------
Result __fastcall SvcGetThreadAffinityMask(u8 *outAffinityMask, Handle threadHandle, s32 processorCount)
{
  char procCount; // r5
  char cfgr; // r0
  s32 v6; // r0
  bool v7; // cc
  Result result; // r0
  KThread *v9; // r0
  KThread *v10; // r4
  int v11; // r0
  u32 v12; // [sp+0h] [bp-18h] BYREF

  procCount = processorCount;
  cfgr = MPCORE.scu.cfgr;
  v6 = (cfgr & 3) + 1;
  v7 = v6 < processorCount;
  if ( v6 >= processorCount )
    v7 = processorCount < 0;
  if ( v7 )
    result = 0xD8E007FD;
  else
    result = 0;
  if ( result >= 0 )
  {
    v9 = KHandleTable::ConvertToThreadAllowPseudoHandle(&current.clc.current.process->handleTable, threadHandle);
    if ( v9 )
    {
      v10 = v9;
      LOBYTE(v12) = v9->affinityMask & ~(-1 << procCount);
      if ( CopyBytesToUser(outAffinityMask, &v12, 1u) )
        v11 = 0;
      else
        v11 = 0xE0E01BF5;
      if ( v11 >= 0 )
      {
        v10->DecrementRefcount(v10);
        return 0;
      }
      else
      {
        v10->DecrementRefcount(v10);
        return 0xD9001814;
      }
    }
    else
    {
      return 0xD9001BF7;
    }
  }
  return result;
}

//----- (FFF05CFC) --------------------------------------------------------
Result __fastcall SvcSetDebugThreadContext(
        Result debugHandle,
        u32 tid,
        const ThreadContext *threadContext,
        ThreadContextControlFlags flags)
{
  int v7; // r1
  KDebug *v8; // r0
  KDebug *v9; // r4
  int v10; // r5
  ThreadContext v11; // [sp+0h] [bp-E0h] BYREF

  if ( !threadContext )
    debugHandle = 0xD8E007F6;
  if ( threadContext )
  {
    if ( CopyWordsFromUser(&v11, threadContext, 0xCCu) )
      v7 = 0;
    else
      v7 = 0xE0E01BF5;
    if ( v7 >= 0 )
    {
      v8 = KHandleTable::ConvertCurProcHandleToDebug(debugHandle);
      v9 = v8;
      if ( v8 )
      {
        if ( KDebug::IsProcessTerminated(v8) )
        {
          v9->DecrementRefcount(v9);
          return -660594680;
        }
        else
        {
          v10 = KDebug::SetPausedThreadContextById(v9, &v11, tid, flags);
          v9->DecrementRefcount(v9);
          if ( v10 < 0 && v10 << 22 == 0xFBC00000 )
            return 0xD9002004;
          else
            return v10;
        }
      }
      else
      {
        return 0xD9002002;
      }
    }
    else
    {
      return 0xD900200A;
    }
  }
  return debugHandle;
}

//----- (FFF05DE8) --------------------------------------------------------
Result __fastcall SvcSetHardwareBreakPoint(s32 regId, u32 cr, u32 vr)
{
  bool v4; // zf
  bool v5; // zf
  Result result; // r0
  bool v7; // zf

  if ( regId != 4 )                             // this svc sucks, it doesn't broadcast things to other cores
                                                // and forgets to dsb
  {
    if ( regId > 4 )
    {
      v7 = regId == 5;
      if ( regId != 5 )
        v7 = regId == 0x100;                    // watchpoints
      if ( !v7 && regId != 0x101 )
        goto LABEL_9;
    }
    else
    {
      v4 = regId == 0;
      if ( regId )
        v4 = regId == 1;
      if ( !v4 )
      {
        v5 = regId == 2;
        if ( regId != 2 )
          v5 = regId == 3;
        if ( !v5 )
        {
LABEL_9:
          result = 0xD8E007ED;
          goto LABEL_15;
        }
      }
    }
  }
  result = 0;
LABEL_15:
  if ( result >= 0 )
    return SetHardwareBreakpoint(regId, cr, vr);
  return result;
}

//----- (FFF05E4C) --------------------------------------------------------
Result __fastcall SvcSetThreadAffinityMask(Handle threadHandle, u8 *affinityMask, s32 processorCount)
{
  return 0xF8C007F4;
}

//----- (FFF05E58) --------------------------------------------------------
Result __fastcall SvcStoreProcessDataCache(Handle a1, u32 a2, u32 a3)
{
  KCacheOperator v4; // [sp+0h] [bp-8h] BYREF

  v4.__vftable = &KCleanDataCacheOperator::vt;
  return KCacheOperator::OperateOnProcessCache(&v4, a1, a2, a3);
}

//----- (FFF05E84) --------------------------------------------------------
Result __fastcall SvcTerminateDebugProcess(Handle debugHandle)
{
  KDebug *v1; // r0
  KDebug *v2; // r4
  Result result; // r0
  int v4; // r5

  v1 = KHandleTable::ConvertCurProcHandleToDebug(debugHandle);
  v2 = v1;
  if ( !v1 )
    return 0xD9002002;
  v4 = KDebug::TerminateProcess(v1);
  v2->DecrementRefcount(v2);
  result = v4;
  if ( v4 < 0 && v4 << 22 == 0x82000000 )
    return 0xD8202007;
  return result;
}

//----- (FFF05ED4) --------------------------------------------------------
Result __fastcall SvcGetProcessAffinityMask(u8 *outAffMask, Handle processHandle, s32 coreCount)
{
  char v4; // r4
  char cfgr; // r0
  s32 v6; // r0
  bool v7; // cc
  Result result; // r0
  KProcess *v9; // r0
  KProcess *v10; // r6
  int v11; // r0
  char v12; // [sp+0h] [bp-18h] BYREF

  v4 = coreCount;
  cfgr = MPCORE.scu.cfgr;
  v6 = (cfgr & 3) + 1;
  v7 = v6 < coreCount;
  if ( v6 >= coreCount )
    v7 = coreCount < 0;
  if ( v7 )
    result = 0xD8E007FD;
  else
    result = 0;
  if ( result >= 0 )
  {
    v9 = KHandleTable::ConvertToProcessAllowPseudoHandle(&current.clc.current.process->handleTable, processHandle);
    v10 = v9;
    if ( v9 )
    {
      v12 = v9->affinityMask & ~(-1 << v4);
      if ( CopyBytesToUser(outAffMask, &v12, 1u) )
        v11 = 0;
      else
        v11 = 0xE0E01BF5;
      if ( v11 >= 0 )
      {
        v10->DecrementRefcount(v10);
        return 0;
      }
      else
      {
        return 0xD9001814;
      }
    }
    else
    {
      return 0xD9001BF7;
    }
  }
  return result;
}

//----- (FFF05F90) --------------------------------------------------------
Result __fastcall SvcSetProcessAffinityMask(Handle processHandle, const u8 *affinityMask, s32 numCores)
{
  char cfgr; // r0
  s32 v6; // r0
  bool v7; // cc
  Result result; // r0
  int v9; // r0
  KProcess *v10; // r0
  KProcess *v11; // r5
  u32 kernelFlags; // r0
  KAffinityMask v13; // [sp+0h] [bp-10h] BYREF

  cfgr = MPCORE.scu.cfgr;
  v6 = (cfgr & 3) + 1;
  v7 = v6 < numCores;
  if ( v6 >= numCores )
    v7 = numCores < 0;
  if ( v7 )
    result = 0xD8E007FD;
  else
    result = 0;
  if ( result >= 0 )
  {
    if ( CopyBytesFromUser(&v13, affinityMask, 1u) )
      v9 = 0;
    else
      v9 = 0xE0E01BF5;
    if ( v9 < 0 )
      return 0xD9001814;
    if ( !v13 )
      return 0xE0E01822;
    v10 = KHandleTable::ConvertToProcessAllowPseudoHandle(&current.clc.current.process->handleTable, processHandle);
    v11 = v10;
    if ( !v10 )
      return 0xD9001BF7;
    kernelFlags = v10->capability.kernelFlags;
    if ( (kernelFlags & 0xF00) == MEMOP_REGION_BASE )
      goto LABEL_22;
    if ( numCores == 2 )
    {
      if ( (kernelFlags & 0x2000) != 0 )
      {                                         // can use core2 flag
LABEL_22:
        KAffinityMask::Normalize(&v11->affinityMask, &v13, numCores);
        v11->DecrementRefcount(v11);
        return 0;
      }
    }
    else if ( numCores != 3 )
    {
      goto LABEL_22;
    }
    LOBYTE(numCores) = 2;
    goto LABEL_22;
  }
  return result;
}

//----- (FFF06094) --------------------------------------------------------
Result __fastcall SvcSetThreadIdealProcessor(Handle threadHandle, s32 idealProcessor)
{
  return 0xF8C007F4;
}

//----- (FFF060A0) --------------------------------------------------------
Result __fastcall SvcSetProcessIdealProcessor(Handle processHandle, s32 idealProcessor)
{
  char cfgr; // r1
  KProcess *v5; // r0
  u32 kernelFlags; // r1

  cfgr = MPCORE.scu.cfgr;
  if ( (cfgr & 3) + 1 <= idealProcessor )       // signed op, whoops
                                                // can put < 0 here, causing OOB access
    return 0xE0E01BFD;
  v5 = KHandleTable::ConvertToProcessAllowPseudoHandle(&current.clc.current.process->handleTable, processHandle);
  if ( !v5 )
    return 0xD9001BF7;
  kernelFlags = v5->capability.kernelFlags;
  if ( (kernelFlags & 0xF00) == MEMOP_REGION_BASE )
    goto LABEL_8;
  if ( idealProcessor == 2 )
  {
    if ( (kernelFlags & 0x2000) != 0 )
      goto LABEL_8;
  }
  else if ( idealProcessor != 3 )
  {
LABEL_8:
    v5->idealProcessor = idealProcessor;
    v5->DecrementRefcount(v5);                  // resource leak in some cases...
    return 0;
  }
  return 0xD9001BEA;
}

//----- (FFF06144) --------------------------------------------------------
s32 SvcGetCurrentProcessorNumber(void)
{
  return __mrc(15, 0, 0, 0, 5) & 3;
}

//----- (FFF06150) --------------------------------------------------------
Result __fastcall SvcInvalidateProcessDataCache(Handle a1, u32 a2, u32 a3)
{
  KCacheOperator v4; // [sp+0h] [bp-8h] BYREF

  v4.__vftable = &KInvalidateDataCacheOperator::vt;
  return KCacheOperator::OperateOnProcessCache(&v4, a1, a2, a3);
}

//----- (FFF0617C) --------------------------------------------------------
Result __fastcall SvcGetResourceLimitLimitValues(
        s64 *outLimitValues,
        Handle reslimitHandle,
        const ResourceLimitType *names,
        s32 nameCount)
{
  unsigned int v4; // r7
  unsigned int v5; // r10
  bool v8; // zf
  Result result; // r0
  KResourceLimit *v11; // r5
  int i; // r6
  Result v13; // r4
  __int64 LimitValue; // [sp+0h] [bp-30h] BYREF
  ResourceLimitType type; // [sp+8h] [bp-28h] BYREF

  v8 = outLimitValues == 0;
  result = 0xD8E007F6;
  if ( !v8 )
    v8 = names == 0;
  if ( !v8 )
  {
    result = (unsigned int)nameCount <= 0x7FFFFFFF ? 0 : 0xE0E01BFD;
    if ( result >= 0 )
    {
      v11 = KHandleTable::ConvertToResourceLimit(&current.clc.current.process->handleTable, reslimitHandle);
      if ( v11 )
      {
        if ( nameCount > 0 )
        {
          v5 = 0xD8E007ED;
          v4 = 0xE0E01BF5;
        }
        i = 0;
        if ( nameCount <= 0 )
        {
LABEL_28:
          v13 = 0;
        }
        else
        {
          while ( 1 )
          {
            v13 = CopyWordFromUser(&type, &names[i]) ? 0 : v4;
            if ( v13 < 0 )
              break;
            v13 = (unsigned int)type >= RESLIMIT_MAX ? v5 : 0;
            if ( v13 < 0 )
              break;
            LimitValue = KResourceLimit::GetLimitValue(v11, type);
            v13 = CopyBytesToUser(&outLimitValues[i], &LimitValue, 8u) ? 0 : v4;
            if ( v13 < 0 )
              break;
            if ( ++i >= nameCount )
              goto LABEL_28;
          }
        }
        v11->DecrementRefcount(v11);
        return v13;
      }
      else
      {
        return 0xD8E007F7;
      }
    }
  }
  return result;
}
// FFF061F4: variable 'v4' is possibly undefined
// FFF0620C: variable 'v5' is possibly undefined

//----- (FFF06298) --------------------------------------------------------
Result __fastcall SvcSetResourceLimitLimitValues(
        Handle reslimitHandle,
        const ResourceLimitType *names,
        const s64 *values,
        s32 count)
{
  Result result; // r0
  bool v6; // zf
  SetResourceLimitLimitValuesArgs args; // [sp+0h] [bp-20h] BYREF

  result = 0xD8E007F6;
  v6 = values == 0;
  if ( values )
    v6 = names == 0;
  if ( !v6 )
  {
    if ( (unsigned int)count <= 0x7FFFFFF )
      result = 0;
    else
      result = 0xE0E01BFD;
    if ( result >= 0 )
    {
      args.names = names;
      args.values = values;
      args.count = count;
      args.result = 0xE7E3FFFF;
      args.reslimitHandle = reslimitHandle;
      if ( CallFuncWithStackAlloc((FuncWithStackAlloc)SetResourceLimitLimitValues, &args, 16 * count) )
        return args.result;
      else
        return 0xD86007F3;
    }
  }
  return result;
}

//----- (FFF06310) --------------------------------------------------------
Result __fastcall SvcGetResourceLimitCurrentValues(
        s64 *outCurrentValues,
        Handle reslimitHandle,
        const ResourceLimitType *names,
        s32 nameCount)
{
  unsigned int v4; // r7
  unsigned int v5; // r10
  bool v8; // zf
  Result result; // r0
  KResourceLimit *v11; // r5
  int i; // r6
  Result v13; // r4
  __int64 CurrentValue; // [sp+0h] [bp-30h] BYREF
  unsigned int val; // [sp+8h] [bp-28h] BYREF

  v8 = outCurrentValues == 0;
  result = 0xD8E007F6;
  if ( !v8 )
    v8 = names == 0;
  if ( !v8 )
  {
    result = (unsigned int)nameCount <= 0x7FFFFFFF ? 0 : 0xE0E01BFD;
    if ( result >= 0 )
    {
      v11 = KHandleTable::ConvertToResourceLimit(&current.clc.current.process->handleTable, reslimitHandle);
      if ( v11 )
      {
        if ( nameCount > 0 )
        {
          v5 = 0xD8E007ED;
          v4 = 0xE0E01BF5;
        }
        i = 0;
        if ( nameCount <= 0 )
        {
LABEL_28:
          v13 = 0;
        }
        else
        {
          while ( 1 )
          {
            v13 = CopyWordFromUser(&val, &names[i]) ? 0 : v4;
            if ( v13 < 0 )
              break;
            v13 = val >= RESLIMIT_MAX ? v5 : 0;
            if ( v13 < 0 )
              break;
            CurrentValue = KResourceLimit::GetCurrentValue(v11, (ResourceLimitType)val);
            v13 = CopyBytesToUser(&outCurrentValues[i], &CurrentValue, 8u) ? 0 : v4;
            if ( v13 < 0 )
              break;
            if ( ++i >= nameCount )
              goto LABEL_28;
          }
        }
        v11->DecrementRefcount(v11);
        return v13;
      }
      else
      {
        return 0xD8E007F7;
      }
    }
  }
  return result;
}
// FFF06388: variable 'v4' is possibly undefined
// FFF063A0: variable 'v5' is possibly undefined

//----- (FFF0642C) --------------------------------------------------------
Result __fastcall SvcBreak(UserBreakType breakReason, u32 croInfoAddr, u32 croInfoSize)
{
  Result result; // r0
  Result v7; // r7
  Result IsDebugged; // r0

  if ( breakReason <= (unsigned int)USERBREAK_UNLOAD_RO )
    result = 0;
  else
    result = 0xD8E007ED;
  if ( result >= 0 )
  {
    v7 = 0xF8C007F4;
    if ( !g_systemControl.targetSystem.isDevUnit )
      KProcess::TerminateCurrentProcess(current.clc.current.process);
    switch ( breakReason )
    {
      case USERBREAK_PANIC:
      case USERBREAK_ASSERT:
      case USERBREAK_USER:
        if ( KProcess::IsDebugged(current.clc.current.process) )
        {
          IsDebugged = BreakImpl(breakReason, 0, 0);
        }
        else
        {
          if ( g_systemControl.targetSystem.kernelPanicOnUserBreak )
            ControlSystem(SYSTEMOP_POWER_STATE_CHANGE_SCHEDULING, 0, 0LL);
          KProcess::TerminateCurrentProcess(current.clc.current.process);
          IsDebugged = 0;
        }
        goto LABEL_13;
      case USERBREAK_LOAD_RO:
      case USERBREAK_UNLOAD_RO:
        IsDebugged = KProcess::IsDebugged(current.clc.current.process);
        if ( IsDebugged )
          IsDebugged = BreakImpl(breakReason, croInfoAddr, croInfoSize);
LABEL_13:
        v7 = IsDebugged;
        break;
      default:
        return v7;
    }
    return v7;
  }
  return result;
}
// FFF06474: control flows out of bounds to FFF06478

//----- (FFF0653C) --------------------------------------------------------
void __fastcall IrqHandlerImpl(BOOL user)
{
  if ( KInterruptManager::HandleIncomingInterrupt(&g_interruptManager) )
    KScheduler::TrySwitchingToInterruptTaskMgrThread(current.clc.current.scheduler);
  if ( user )
  {
    if ( current.clc.current.thread->shallTerminate )
    {
      KInterruptTaskManager::EnqueueTask(
        current.clc.current.interruptTaskManager,
        &current.clc.current.thread->KInterruptTask);
      KScheduler::TrySwitchingThread(current.clc.current.scheduler);
    }
  }
}

//----- (FFF06598) --------------------------------------------------------
Result __fastcall KCodeSet::InitializeDirectly(
        KCodeSet *this,
        CodeSetInfo *codeSetInfo,
        u32 textLoadAddr,
        u32 rodataLoadAddr,
        u32 rwDataLoadAddr)
{
  KCodeSegment::InitializeDirectly(&this->text, &codeSetInfo->text, textLoadAddr);
  KCodeSegment::InitializeDirectly(&this->rodata, &codeSetInfo->rodata, rodataLoadAddr);
  KCodeSegment::InitializeDirectly(&this->data, &codeSetInfo->rwdata, rwDataLoadAddr);
  KCodeSegment::EnsureCacheCoherencyForCode(&this->text);
  this->numCodePages = codeSetInfo->text_size_total;
  this->numConstPages = codeSetInfo->ro_size_total;
  this->numDataPages = codeSetInfo->rw_size_total;
  *(_QWORD *)this->processName = codeSetInfo->name;
  this->processName[8] = 0;
  this->unk1_from_codesetinfo = codeSetInfo->unk1;
  this->titleId = codeSetInfo->program_id;
  return 0;
}

//----- (FFF06620) --------------------------------------------------------
void __fastcall DumpVfpSprsForUserDispatch(ERRF_ExceptionInfo *info)
{
  __asm { VMRS            R1, FPEXC }
  info->fpexc = _R1;
  _R1 &= 0x6FFFFFFFu;
  __asm
  {
    VMSR            FPEXC, R1
    VMRS            R1, FPINST
  }
  info->fpinst = _R1;
  __asm { VMRS            R1, FPINST2 }
  info->fpint2 = _R1;
}

//----- (FFF06644) --------------------------------------------------------
void __fastcall KScheduler::TrySwitchingToInterruptTaskMgrThread(KScheduler *this)
{
  this->rescheduleInterruptTaskMgrThread = 1;
  this->reschedule = 1;
  if ( !this->disableCount )
    KScheduler::SwitchThread(this, 0);
  this->rescheduleInterruptTaskMgrThread = 0;
}

//----- (FFF06674) --------------------------------------------------------
Result __fastcall KCodeSegment::InitializeDirectly(KCodeSegment *this, CodeSegmentInfo *segmentInfo, u32 loadAddr)
{
  u32 totalNumPages; // r2

  this->baseUserVa = segmentInfo->addr;
  this->totalNumPages = segmentInfo->size;
  totalNumPages = this->totalNumPages;
  if ( totalNumPages )
    KPageGroup::AddRange(&this->pgGroup, loadAddr, totalNumPages);
  return 0;
}

//----- (FFF066BC) --------------------------------------------------------
KHandleTable *__fastcall KHandleTable::KHandleTable(KHandleTable *this)
{
  this->entries = 0;
  this->firstFreeEntry = 0;
  this->count = 0;
  this->mutex.lockingThread = 0;
  this->mutex.numWaiters = 0;
  this->mutex.ticketCount = 0;
  return this;
}

//----- (FFF066DC) --------------------------------------------------------
Result __fastcall KSharedMemory::Map(
        KSharedMemory *this,
        KProcessPageTable *dstPgTable,
        u32 dstAddr,
        KProcess *dstProcess,
        KMemoryPermission myPerms,
        KMemoryPermission othersPerms)
{
  u32 tmemAddr; // lr
  Result result; // r0
  unsigned __int8 *v10; // r0
  unsigned __int8 v11; // r1
  KMemoryPermission ownerPerms; // r1
  bool v13; // zf
  u32 v14; // r12
  unsigned __int8 *p_sharedMemMapRefcount; // r0
  unsigned __int8 v16; // r1
  int v17; // r2
  unsigned __int8 *v18; // r0
  unsigned __int8 v19; // r1
  unsigned __int8 *v20; // r0
  unsigned __int8 v21; // r1
  unsigned __int8 *v22; // r0
  unsigned __int8 v23; // r1
  unsigned __int8 *v24; // r1
  signed __int8 v25; // r0
  unsigned __int8 *v26; // r0
  unsigned __int8 v27; // r1
  Result v28; // r0
  unsigned __int8 *v29; // r0
  unsigned __int8 v30; // r1

  tmemAddr = this->transferMemAddress;
  result = 0xE0E01BEE;
  if ( !tmemAddr )                              // sharedmem
  {
    if ( this->ownerProcess == dstProcess )
      ownerPerms = this->ownerPerms;
    else
      ownerPerms = this->othersPerms;
    v13 = othersPerms == MEMPERM_DONTCARE;
    if ( othersPerms == MEMPERM_DONTCARE )
      v13 = (myPerms & ~ownerPerms) == 0;       // if othersPerms is "don't care", just check if myPerms is allowed
    if ( !v13 )
      return result;
    if ( this->isDeviceSharedMem )
    {
      if ( dstAddr )
        return result;
      v14 = KMemoryManager::ConvertSharedMemPaLinearWithAppMemType(this->pgGrp.list.link.next->blockInfo->baseAddress - 0xC0000000);
      p_sharedMemMapRefcount = (unsigned __int8 *)&this->sharedMemMapRefcount;
      do
        v16 = __ldrex(p_sharedMemMapRefcount);
      while ( __strex(v16 + 1, p_sharedMemMapRefcount) );// no overflow check?
      v17 = KPageTable::CheckAndMapPageGroup(dstPgTable, v14, &this->pgGrp, KMEMSTATE_SHARED, myPerms);
      if ( v17 < 0 )
      {
        v18 = (unsigned __int8 *)&this->sharedMemMapRefcount;
        do
          v19 = __ldrex(v18);
        while ( __strex(v19 - 1, v18) );
      }
      return v17;
    }
    if ( dstAddr )
    {
      v20 = (unsigned __int8 *)&this->sharedMemMapRefcount;
      do
        v21 = __ldrex(v20);
      while ( __strex(v21 + 1, v20) );
      v17 = KPageTable::CheckAndMapPageGroup(dstPgTable, dstAddr, &this->pgGrp, KMEMSTATE_SHARED, myPerms);
      if ( v17 < 0 )
      {
        v22 = (unsigned __int8 *)&this->sharedMemMapRefcount;
        do
          v23 = __ldrex(v22);
        while ( __strex(v23 - 1, v22) );
        return v17;
      }
      return v17;
    }
    return -522183691;
  }
  if ( !dstAddr )
    return -522183691;
  if ( this->ownerProcess == dstProcess )
  {
    v10 = (unsigned __int8 *)&this->sharedMemMapRefcount;
    do
      v11 = __ldrex(v10);
    while ( __strex(v11 - 1, v10) );
    return 0xD900182C;
  }
  if ( othersPerms != MEMPERM_DONTCARE )
  {
    result = 0xD900182E;                        // else if tranfermem
    if ( (this->ownerPerms & ~othersPerms) == 0 && (myPerms & ~this->othersPerms) == 0 )
    {
      v24 = (unsigned __int8 *)&this->sharedMemMapRefcount;
      do
        v25 = __ldrex(v24);
      while ( __strex(v25 + 1, v24) );
      if ( v25 > 1 )
      {
        v26 = (unsigned __int8 *)&this->sharedMemMapRefcount;
        do
          v27 = __ldrex(v26);
        while ( __strex(v27 - 1, v26) );
        return 0xD900182D;
      }
      v28 = KPageTable::CheckAndMapPageGroup(dstPgTable, dstAddr, &this->pgGrp, KMEMSTATE_SHARED, myPerms);
      v17 = v28;
      if ( v28 < 0 )
      {
        v29 = (unsigned __int8 *)&this->sharedMemMapRefcount;
        do
          v30 = __ldrex(v29);
        while ( __strex(v30 - 1, v29) );
        return v17;
      }
      return v17;
    }
  }
  return result;
}

//----- (FFF069E4) --------------------------------------------------------
Result __fastcall KSharedMemory::Unmap(
        KSharedMemory *this,
        KProcessPageTable *dstPgTable,
        u32 addr,
        KProcess *dstProcess)
{
  Result result; // r0
  unsigned __int8 *p_sharedMemMapRefcount; // r1
  unsigned __int8 v7; // r2

  result = KPageTable::CheckAndUnmapPageGroup(dstPgTable, addr, &this->pgGrp);
  if ( result >= 0 )
  {
    p_sharedMemMapRefcount = (unsigned __int8 *)&this->sharedMemMapRefcount;
    do
      v7 = __ldrex(p_sharedMemMapRefcount);
    while ( __strex(v7 - 1, p_sharedMemMapRefcount) );
  }
  return result;
}

//----- (FFF06A44) --------------------------------------------------------
Result __fastcall KClientSession::SendSyncRequest(KClientSession *this, KThread *thread)
{
  int v4; // r5

  KSchedulerLock::Lock(&g_schedulerLock);
  thread->ipcClosedByRemote = 0;
  thread->ipcPxiBufferTooFragmented = 0;
  v4 = KServerSession::SendSyncRequest(&this->parent->server, thread);
  if ( v4 >= 0 )
  {
    KSchedulerLock::Unlock(&g_schedulerLock);
    if ( thread->ipcClosedByRemote )
    {
      return 0xC920181A;
    }
    else if ( thread->ipcPxiBufferTooFragmented )
    {
      return 0xC8A01836;
    }
    else
    {
      return v4;
    }
  }
  else
  {
    KSchedulerLock::Unlock(&g_schedulerLock);
    return v4;
  }
}

//----- (FFF06ACC) --------------------------------------------------------
Result __fastcall KSynchronization::WaitSynchronization1(
        KSynchronization *this,
        KThread *thread,
        KSynchronizationObject *obj,
        s64 timeout)
{
  unsigned int ticksLo; // r7
  int ticksHi; // r10
  unsigned __int64 v8; // kr20_8
  Result synchronizationResult; // r4
  s64 v10; // r2
  KTimerTask *v11; // r1
  KTimerTask *v13; // r1
  KTimerTask *v14; // r1
  KTimerTask *v15; // r1

  KSchedulerLock::Lock(&g_schedulerLock);
  if ( ((((unsigned __int64)-timeout >> 32) & 0x80000000) != 0LL) != __OFSUB__(
                                                                       0,
                                                                       HIDWORD(timeout),
                                                                       (_DWORD)timeout == 0) )
  {
    v8 = __PAIR64__(
           (((0x44A2FA85 * (unsigned __int64)(unsigned int)timeout) >> 32) + 0x44A2FA85LL * SHIDWORD(timeout)) >> 32,
           (unsigned __int64)(0x44A2FA85 * timeout) >> 32)
       + KHardwareTimer::GetSystemTick(&g_hardwareTimer);
    ticksHi = HIDWORD(v8);
    ticksLo = v8;
    if ( ((((unsigned __int64)-__SPAIR64__(ticksHi, ticksLo) >> 32) & 0x80000000) != 0LL) == __OFSUB__(
                                                                                               0,
                                                                                               ticksHi,
                                                                                               ticksLo == 0) )
    {
      ticksLo = 0xFFFFFFFF;
      ticksHi = 0x7FFFFFFF;
    }
    KSchedulerLock::Lock(&g_hardwareTimer.lock);
  }
  else
  {
    ticksLo = 0;
    ticksHi = 0;
  }
  if ( obj->TryAcquire(obj, thread) )
  {
    if ( ((((unsigned __int64)-__SPAIR64__(ticksHi, ticksLo) >> 32) & 0x80000000) != 0LL) != __OFSUB__(
                                                                                               0,
                                                                                               ticksHi,
                                                                                               ticksLo == 0) )
    {
      KSchedulerLock::UnlockSingleCoreResched(&g_hardwareTimer.lock);
      ticksLo = 0;
      ticksHi = 0;
    }
    synchronizationResult = 0;
    v10 = __PAIR64__(ticksHi, ticksLo);
    if ( ((((unsigned __int64)-__SPAIR64__(ticksHi, ticksLo) >> 32) & 0x80000000) != 0LL) == __OFSUB__(// always true with the above if block
                                                                                               0,
                                                                                               ticksHi,
                                                                                               ticksLo == 0) )
      goto LABEL_32;
    if ( !thread )
    {
LABEL_31:
      v13 = 0;
      goto LABEL_14;
    }
LABEL_30:
    v13 = &thread->KTimerTask;
LABEL_14:
    KHardwareTimer::RegisterTask(&g_hardwareTimer, v13, v10);
    KSchedulerLock::UnlockSingleCoreResched(&g_hardwareTimer.lock);
    goto LABEL_32;
  }
  if ( timeout )
  {
    thread->signaledObject = 0;
    thread->synchronizationResult = 0x9401BFE;
    KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_PAUSED);
    if ( !thread->shallTerminate )
    {
      KSynchronizationObject::AddWaiter(obj, thread);
      if ( ((((unsigned __int64)-__SPAIR64__(ticksHi, ticksLo) >> 32) & 0x80000000) != 0LL) != __OFSUB__(
                                                                                                 0,
                                                                                                 ticksHi,
                                                                                                 ticksLo == 0) )
      {
        if ( thread )                           // we need to wait
          v14 = &thread->KTimerTask;
        else
          v14 = 0;
        KHardwareTimer::RegisterTask(&g_hardwareTimer, v14, __SPAIR64__(ticksHi, ticksLo));
        KSchedulerLock::UnlockSingleCoreResched(&g_hardwareTimer.lock);
      }
      KSchedulerLock::Unlock(&g_schedulerLock);
      if ( ((((unsigned __int64)-timeout >> 32) & 0x80000000) != 0LL) != __OFSUB__(
                                                                           0,
                                                                           HIDWORD(timeout),
                                                                           (_DWORD)timeout == 0) )
      {
        if ( thread )
          v15 = &thread->KTimerTask;
        else
          v15 = 0;
        KHardwareTimer::CancelTask(&g_hardwareTimer, v15);
      }
      synchronizationResult = thread->synchronizationResult;
      KSchedulerLock::Lock(&g_schedulerLock);
      KSynchronizationObject::RemoveWaiter(obj, thread);
      goto LABEL_32;
    }
    if ( ((((unsigned __int64)-__SPAIR64__(ticksHi, ticksLo) >> 32) & 0x80000000) != 0LL) != __OFSUB__(
                                                                                               0,
                                                                                               ticksHi,
                                                                                               ticksLo == 0) )
    {
      KSchedulerLock::UnlockSingleCoreResched(&g_hardwareTimer.lock);
      ticksLo = 0;
      ticksHi = 0;
    }
    KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_RUNNING);
    synchronizationResult = 0xD920060D;
    v10 = __PAIR64__(ticksHi, ticksLo);
    if ( ((((unsigned __int64)-__SPAIR64__(ticksHi, ticksLo) >> 32) & 0x80000000) != 0LL) == __OFSUB__(
                                                                                               0,
                                                                                               ticksHi,
                                                                                               ticksLo == 0) )
    {
LABEL_32:
      KSchedulerLock::Unlock(&g_schedulerLock);
      return synchronizationResult;
    }
    if ( !thread )
      goto LABEL_31;
    goto LABEL_30;
  }
  if ( ((((unsigned __int64)-__SPAIR64__(ticksHi, ticksLo) >> 32) & 0x80000000) != 0LL) != __OFSUB__(
                                                                                             0,
                                                                                             ticksHi,
                                                                                             ticksLo == 0) )
  {
    if ( thread )
      v11 = &thread->KTimerTask;
    else
      v11 = 0;
    KHardwareTimer::RegisterTask(&g_hardwareTimer, v11, __SPAIR64__(ticksHi, ticksLo));
    KSchedulerLock::UnlockSingleCoreResched(&g_hardwareTimer.lock);
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
  return 0x9401BFE;
}

//----- (FFF06D98) --------------------------------------------------------
void __fastcall KThread::EnableExclusiveVfp(KThread *this)
{
  KThread *volatile threadWithVfp; // r6

  threadWithVfp = current.clc.current.threadWithVfp;
  KThreadContext::EnableCurrentThreadVfp();
  if ( threadWithVfp )
    KThreadContext::StoreVfpRegsAndDisable(threadWithVfp->context);
  KThreadContext::LoadVfp(this->context);
  do
    __ldrex((unsigned int *)&current.clc.current.threadWithVfp);
  while ( __strex((unsigned int)this, (unsigned int *)&current.clc.current.threadWithVfp) );
}

//----- (FFF06DD8) --------------------------------------------------------
void __fastcall KVfpRegisterDumpHelper::DumpAndDisableVfpRegsForThread(KThread *thread, s32 coreId)
{
  KCoreLocalContext *p_clc; // r4
  unsigned int *p_threadWithVfp; // r4
  KThread *threadWithVfp; // t1
  KVfpRegisterDumpHelperImpl *v5; // r2

  p_clc = &g_coreLocalRegions[coreId].clc;
  threadWithVfp = p_clc->current.threadWithVfp;
  p_threadWithVfp = (unsigned int *)&p_clc->current.threadWithVfp;
  if ( threadWithVfp == thread )
  {
    if ( (__mrc(15, 0, 0, 0, 5) & 3) == coreId )
    {
      KThreadContext::StoreVfpRegsAndDisable(thread->context);
      do
        __ldrex(p_threadWithVfp);
      while ( __strex(0, p_threadWithVfp) );
    }
    else
    {
      v5 = &g_vfpRegisterDumpHelper.impls[coreId];
      v5->threadToDumpTo = thread;
      __mcr(15, 0, 0, 7, 10, 5);
      MPCORE.gicd.sgir = (1 << coreId << 16) & 0xFF0000 | KINTNAME_SGI_DUMP_VFP_REGS;
      while ( v5->threadToDumpTo )
        __yield();
    }
  }
}

//----- (FFF06E80) --------------------------------------------------------
void __fastcall SetWifiEnabled(bool enable)
{
  u8 wifi_cnt; // r1
  u8 v2; // r1

  wifi_cnt = CONFIG11.wifi_cnt;
  if ( enable )
    v2 = wifi_cnt | 1;
  else
    v2 = wifi_cnt & ~1;
  CONFIG11.wifi_cnt = v2;
}

//----- (FFF06EA0) --------------------------------------------------------
void __fastcall SetGpuProt(BOOL allowSystem)
{
  int v1; // r1

  if ( !allowSystem )                           // this svc uses the O3DS field on O3DS,
                                                // and the N3DS fields on N3DS (different reg values),
                                                // as well as different app mem types?
                                                // 
                                                // 
                                                // O3DS
                                                // 
                                                // allowSystem || memType==2 (96MB) => 0x26800000 (low byte=3)
                                                // memType == 3 (80MB) => 0x25800000 (5)
                                                // memType == 4 (74MB) => 0x25000000 (6)
                                                // else (0 (64MB) and 5 (32MB), 5 is bugged and will let you GSPWN over more of SYSTEM)
                                                // => 0x24800000 (7)
    allowSystem = 0;
  if ( g_systemControl.systemHeapGpuAccessAllowed != allowSystem )
  {
    if ( allowSystem )                          // all configs protect the 2nd half (last 0x200000 bytes) of QTM mem:
                                                // 0x1F200000..0x1F400000
    {
      v1 = 0x460;                               // cutoff at 0x2D000000
                                                // (default at kernel init is 0x2D800000 instead)
    }
    else if ( g_systemControl.appMemType == 7 ) // 178MB app mem type, most of system mem locked out
    {
      v1 = 0x490;                               // cutoff at 0x2B800000
    }
    else
    {
      v1 = 0x4F0;                               // cutoff at 0x28800000
    }
    CONFIG11.gpuprot = v1 | 0x100;              // protect kernel (in axiwram)
    g_systemControl.systemHeapGpuAccessAllowed = allowSystem;
  }
}

//----- (FFF06EF4) --------------------------------------------------------
Result __fastcall SetTimer(Handle timerHandle, s64 initialTimeoutNs, s64 intervalNs)
{
  bool v3; // nf
  unsigned int v4; // r6
  unsigned int v5; // r8
  KTimer *v7; // r9
  KAutoObject *v8; // r0
  KTimer *v9; // r4
  u8 typeId; // r11
  Result v11; // r5
  KTypeObj v12; // [sp+0h] [bp-38h] BYREF
  KTypeObj v13; // [sp+8h] [bp-30h] BYREF

  v4 = HIDWORD(initialTimeoutNs);
  v3 = initialTimeoutNs < 0;
  v5 = initialTimeoutNs;
  if ( initialTimeoutNs >= 0 )
    v3 = intervalNs < 0;
  if ( v3 )
    return 0xD8E007FD;
  v7 = 0;
  v8 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, timerHandle);
  v9 = (KTimer *)v8;
  if ( !v8 )
    return 0xD8E007F7;
  v8->GetTypeObj(&v12, v8);
  typeId = v12.typeId;
  v9->GetTypeObj(&v13, v9);
  if ( (typeId | 0x35) == v13.typeId )
    v7 = v9;
  else
    v9->DecrementRefcount(v9);
  if ( !v7 )
    return 0xD8E007F7;
  v11 = KTimer::Set(v7, __SPAIR64__(v4, v5), intervalNs);
  v7->DecrementRefcount(v7);
  return v11;
}

//----- (FFF06FF4) --------------------------------------------------------
Result __fastcall CreatePort(
        Handle *outSessionPortHandle,
        Handle *outClientPortHandle,
        const char *name,
        s32 maxSessionCount)
{
  int v7; // r0
  Result result; // r0
  KHandleTable *p_handleTable; // r6
  KPort *v10; // r0
  KPort *v11; // r4
  int v12; // r5
  char kName[11]; // [sp+0h] [bp-38h] BYREF
  char v14; // [sp+Bh] [bp-2Dh]
  KTypeObj v15; // [sp+10h] [bp-28h] BYREF

  *outSessionPortHandle = 0;
  *outClientPortHandle = 0;
  if ( name )
  {
    v7 = CopyStringFromUser(kName, name, 0xCu);
    if ( v7 < 0 )
    {
      result = 0xD9001814;
      goto LABEL_9;
    }
    if ( v7 == 12 && v14 )
    {
      result = 0xE0E0181E;
      v14 = 0;
      goto LABEL_9;
    }
  }
  else
  {
    kName[0] = 0;
  }
  result = 0;
LABEL_9:
  if ( result >= 0 )
  {
    p_handleTable = &current.clc.current.process->handleTable;
    v10 = (KPort *)KSlabHeap::Allocate(&g_portAllocator.slabHeap);
    v11 = v10;
    if ( v10 )
    {
      KPort::KPort(v10);
      KAutoObject::Initialize(v11);
    }
    if ( !v11 )
      return 0xC8601808;
    KPort::Initialize(v11, maxSessionCount);
    v12 = KObjectAllocator::Register(&g_portAllocator, v11);
    if ( v12 >= 0 )
    {
      if ( kName[0] )
      {
        v12 = KObjectName::RegisterObject(&v11->client, kName);
        *outClientPortHandle = 0;
      }
      else
      {
        v11->client.GetTypeObj(&v15, &v11->client);
        v12 = KHandleTable::Add(p_handleTable, outClientPortHandle, &v11->client, v15.typeId);
      }
      if ( v12 >= 0 )
      {
        v11->server.GetTypeObj(&v15, &v11->server);
        v12 = KHandleTable::Add(p_handleTable, outSessionPortHandle, &v11->server, v15.typeId);
      }
    }
    v11->server.DecrementRefcount(&v11->server);
    v11->client.DecrementRefcount(&v11->client);
    return v12;
  }
  return result;
}
// FFF070A4: conditional instruction was optimized away because r0.4!=0

//----- (FFF071C4) --------------------------------------------------------
Result __fastcall OpenThread(Handle *outThreadHandle, Handle processHandle, u32 threadId)
{
  KProcess *v5; // r6
  KHandleTable *p_handleTable; // r7
  KProcess *proc; // r4
  KAutoObject *v8; // r0
  KProcess *v9; // r4
  u8 typeId; // r11
  KThread *v11; // r0
  KThread *v12; // r5
  KProcess *owner; // r1
  KSynchronizationObject_vtbl *v14; // r0
  Result v16; // r6
  KThread *v17; // r4
  unsigned int v18; // r2
  bool v19; // zf
  unsigned int v20; // r3
  KThreadLinkedListNode *next; // r0
  KThread *thread; // r2
  KTypeObj v23; // [sp+0h] [bp-38h] BYREF
  KTypeObj v24; // [sp+8h] [bp-30h] BYREF

  *outThreadHandle = 0;
  v5 = 0;
  p_handleTable = &current.clc.current.process->handleTable;
  if ( !processHandle )
  {
    v17 = 0;                                    // all processes
    v18 = __ldrex((unsigned int *)&g_threadAllocator.container.mutex);
    v19 = v18 == 0;
    if ( v18 )
      v20 = __strex(v18, (unsigned int *)&g_threadAllocator.container.mutex);
    else
      v20 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_threadAllocator.container.mutex);
    if ( !v18 )
      v19 = v20 == 0;
    if ( !v19 )
      KLightMutex::LockImpl(&g_threadAllocator.container.mutex);
    __mcr(15, 0, 0, 7, 10, 5);
    next = (KThreadLinkedListNode *)g_threadAllocator.container.list.link.next;
    if ( (KAutoObjectLinkedListLink *)g_threadAllocator.container.list.link.next != &g_threadAllocator.container.list.link )
    {
      while ( 1 )
      {
        thread = next->thread;
        if ( thread->threadId == threadId )
          break;
        next = next->link.next;
        if ( next == (KThreadLinkedListNode *)&g_threadAllocator.container.list.link )
          goto LABEL_28;
      }
      v17 = next->thread;
      KAutoObject::IncrementRefcount(thread);
    }
LABEL_28:
    __mcr(15, 0, 0, 7, 10, 5);
    g_threadAllocator.container.mutex.lockingThread = 0;
    if ( g_threadAllocator.container.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_threadAllocator.container.mutex);
    if ( !v17 )
      return 0xD9001819;
    v17->GetTypeObj(&v23, v17);
    v16 = KHandleTable::Add(p_handleTable, outThreadHandle, v17, v23.typeId);
    v17->DecrementRefcount(v17);
    return v16;
  }
  if ( processHandle == CUR_PROCESS_HANDLE )
  {
    proc = current.clc.current.process;
    KAutoObject::IncrementRefcount(current.clc.current.process);
  }
  else
  {
    v8 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, processHandle);
    v9 = (KProcess *)v8;
    if ( !v8 )
      return 0xD9001BF7;
    v8->GetTypeObj(&v23, v8);
    typeId = v23.typeId;
    v9->GetTypeObj(&v24, v9);
    if ( (typeId | 0xC5) == v24.typeId )
      v5 = v9;
    else
      v9->DecrementRefcount(v9);
    proc = v5;
  }
  if ( !proc )
    return 0xD9001BF7;
  v11 = KThread::FindById(threadId);            // it's literally inlined above, though...
  v12 = v11;
  if ( !v11 )
  {
    proc->DecrementRefcount(proc);
    return 0xD9001819;
  }
  owner = v11->owner;
  v14 = v11->KSynchronizationObject::KAutoObject::__vftable;
  if ( owner == proc )
  {
    v14->GetTypeObj(&v23, v12);
    v16 = KHandleTable::Add(p_handleTable, outThreadHandle, v12, v23.typeId);
    v12->DecrementRefcount(v12);
    proc->DecrementRefcount(proc);
    return v16;
  }
  v14->DecrementRefcount(v12);
  proc->DecrementRefcount(proc);
  return 0xD9001819;                            // no proc handle
}

//----- (FFF07460) --------------------------------------------------------
Result __fastcall RestartDma(Handle dmaObjectHandle, u32 dstAddr, u32 srcAddr, u32 size, DmaRestartFlags restartFlags)
{
  KDmaObject *v8; // r0
  KDmaObject *v9; // r4
  KDmaObject *dmaObj; // r9
  u8 typeId; // r11
  Result result; // r0
  int channelId; // r4
  KTypeObj v14; // [sp+0h] [bp-38h] BYREF
  KTypeObj v15; // [sp+8h] [bp-30h] BYREF

  v8 = (KDmaObject *)KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, dmaObjectHandle);
  v9 = v8;
  dmaObj = 0;
  if ( v8 )
  {
    v8->GetTypeObj(&v14, v8);
    typeId = v14.typeId;
    v9->GetTypeObj(&v15, v9);
    if ( (typeId | 0x59) == v15.typeId )
      dmaObj = v9;
    else
      v9->DecrementRefcount(v9);
  }
  if ( size <= 0x7FFFFFFF )
    result = 0;
  else
    result = 0xE0E01BFD;
  if ( result >= 0 )
  {
    if ( dmaObj )
    {
      dmaObj->DecrementRefcount(dmaObj);
      channelId = dmaObj->channelId;
      if ( channelId >= 0 )
      {
        result = KDmaManager::CheckAndPrepareChannelRestart(// check if it's indeed possible to restart
                                                // 
                                                // however there are far fewer checks being done, see
                                                // 3dbrew/3DS System Flaws: svcStartInterProcessDma
                   &g_dmaManager,
                   channelId,
                   dstAddr,
                   srcAddr,
                   size,
                   restartFlags);
        if ( result >= 0 )
          return KDmaChannel::Restart(&g_dmaChannels[channelId], dstAddr, srcAddr, size, restartFlags);
      }
      else
      {
        return 0xD9400415;
      }
    }
    else
    {
      return 0xD8E007F7;
    }
  }
  return result;
}

//----- (FFF075A8) --------------------------------------------------------
Result __fastcall CreateEvent(Handle *outEventHandle, ResetType resetType)
{
  KProcess *process; // r6
  KHandleTable *p_handleTable; // r10
  KResourceLimit *reslimit; // r5
  bool v6; // r9
  KEvent *v8; // r0
  KEvent *v9; // r4
  KEvent *v10; // r0
  int v11; // r6
  bool v12; // zf
  KTypeObj v13; // [sp+0h] [bp-38h] BYREF

  *outEventHandle = 0;
  process = current.clc.current.process;
  p_handleTable = &current.clc.current.process->handleTable;
  reslimit = current.clc.current.process->reslimit;
  if ( reslimit )
    v6 = KResourceLimit::Reserve(current.clc.current.process->reslimit, RESLIMIT_EVENT, 1);
  else
    v6 = 1;
  if ( !v6 )
    return 0xC860180F;
  v8 = (KEvent *)KSlabHeap::Allocate(&g_eventAllocator.slabHeap);
  v9 = v8;
  if ( v8 )
  {
    v10 = (KEvent *)KSynchronizationObject::KSynchronizationObject(v8);
    v10->irqId = -1;
    v10->KInterruptEvent::KSynchronizationObject::KAutoObject::__vftable = &KEvent::vt;
    v10 = (KEvent *)((char *)v10 + 0x14);
    v10->KInterruptEvent::KSynchronizationObject::KAutoObject::__vftable = (KInterruptEvent_vtbl *)&KEvent::vt_KInterruptTask;// "next" pointer
    v10->refcount = 0;
    KAutoObject::Initialize(v9);
  }
  if ( v9 )
  {
    KEvent::Initialize(v9, process, resetType);
    reslimit = 0;
    v11 = KObjectAllocator::Register(&g_eventAllocator, v9);
    if ( v11 >= 0 )
    {
      v9->GetTypeObj(&v13, v9);
      v11 = KHandleTable::Add(p_handleTable, outEventHandle, v9, v13.typeId);
    }
    v9->DecrementRefcount(v9);
  }
  else
  {
    v11 = 0xC8601801;
  }
  v12 = reslimit == 0;
  if ( reslimit )
    v12 = !v6;
  if ( !v12 )
    KResourceLimit::Release(reslimit, RESLIMIT_EVENT, 1);
  return v11;
}
// FFF07638: conditional instruction was optimized away because r0.4!=0
// FFF0764C: CONTAINING_RECORD: too small offset 20 for struct 'KEvent'

//----- (FFF07720) --------------------------------------------------------
Result __fastcall CreateMutex(Handle *outMutexHandle, BOOL initiallyLocked)
{
  KProcess *process; // r11
  KHandleTable *p_handleTable; // r10
  KResourceLimit *reslimit; // r5
  bool v6; // r9
  KMutex *v8; // r0
  KMutex *v9; // r4
  KMutex *v10; // r0
  int v11; // r6
  bool v12; // zf
  KTypeObj v13; // [sp+0h] [bp-38h] BYREF

  *outMutexHandle = 0;
  process = current.clc.current.process;
  p_handleTable = &current.clc.current.process->handleTable;
  reslimit = current.clc.current.process->reslimit;
  if ( reslimit )
    v6 = KResourceLimit::Reserve(current.clc.current.process->reslimit, RESLIMIT_MUTEX, 1);
  else
    v6 = 1;
  if ( !v6 )
    return 0xC860180D;
  v8 = (KMutex *)KSlabHeap::Allocate(&g_mutexAllocator.slabHeap);
  v9 = v8;
  if ( v8 )
  {
    v10 = (KMutex *)KSynchronizationObject::KSynchronizationObject(v8);
    v10->link.prev = 0;
    v10->__vftable = &KMutex::vt;
    v10->link.next = 0;
    KAutoObject::Initialize(v9);
  }
  if ( v9 )
  {
    KMutex::Initialize(v9, process, initiallyLocked);
    reslimit = 0;
    v11 = KObjectAllocator::Register(&g_mutexAllocator, v9);
    if ( v11 >= 0 )
    {
      v9->GetTypeObj(&v13, v9);
      v11 = KHandleTable::Add(p_handleTable, outMutexHandle, v9, v13.typeId);
    }
    v9->DecrementRefcount(v9);
  }
  else
  {
    v11 = 0xC8601801;
  }
  v12 = reslimit == 0;
  if ( reslimit )
    v12 = !v6;
  if ( !v12 )
    KResourceLimit::Release(reslimit, RESLIMIT_MUTEX, 1);
  return v11;
}
// FFF077B0: conditional instruction was optimized away because r0.4!=0

//----- (FFF07890) --------------------------------------------------------
Result __fastcall CreateTimer(Handle *outTimerHandle, ResetType resetType)
{
  KProcess *process; // r6
  KHandleTable *p_handleTable; // r10
  KResourceLimit *reslimit; // r5
  bool v6; // r9
  KTimer *v8; // r0
  KTimer *v9; // r4
  KTimer *v10; // r0
  int v11; // r6
  bool v12; // zf
  KTypeObj v13; // [sp+0h] [bp-38h] BYREF

  *outTimerHandle = 0;
  process = current.clc.current.process;
  p_handleTable = &current.clc.current.process->handleTable;
  reslimit = current.clc.current.process->reslimit;
  if ( reslimit )
    v6 = KResourceLimit::Reserve(current.clc.current.process->reslimit, RESLIMIT_TIMER, 1);
  else
    v6 = 1;
  if ( !v6 )
    return 0xC8601810;
  v8 = (KTimer *)KSlabHeap::Allocate(&g_timerAllocator.slabHeap);
  v9 = v8;
  if ( v8 )
  {
    v10 = (KTimer *)KSynchronizationObject::KSynchronizationObject(v8);
    v10->KSynchronizationObject::KAutoObject::__vftable = &KTimer::vt;
    v10 = (KTimer *)((char *)v10 + 20);
    v10->KSynchronizationObject::KAutoObject::__vftable = (KTimer_vtbl *)&KTimer::vt_KTimerTask;// "next" pointer
    v10->refcount = 0;
    KAutoObject::Initialize(v9);
  }
  if ( v9 )
  {
    KTimer::Initialize(v9, process, resetType);
    reslimit = 0;
    v11 = KObjectAllocator::Register(&g_timerAllocator, v9);
    if ( v11 >= 0 )
    {
      v9->GetTypeObj(&v13, v9);
      v11 = KHandleTable::Add(p_handleTable, outTimerHandle, v9, v13.typeId);
    }
    v9->DecrementRefcount(v9);
  }
  else
  {
    v11 = 0xC8601801;
  }
  v12 = reslimit == 0;
  if ( reslimit )
    v12 = !v6;
  if ( !v12 )
    KResourceLimit::Release(reslimit, RESLIMIT_TIMER, 1);
  return v11;
}
// FFF07920: conditional instruction was optimized away because r0.4!=0

//----- (FFF07A00) --------------------------------------------------------
Result __fastcall GetDmaState(DmaState *outDmaState, Handle dmaObjectHandle)
{
  KDmaObject *v3; // r0
  KDmaObject *v4; // r4
  KDmaObject *dmaObj; // r5
  u8 typeId; // r9
  int channelId; // r0
  DmaState state; // r0
  KTypeObj v10; // [sp+0h] [bp-30h] BYREF
  KTypeObj v11; // [sp+8h] [bp-28h] BYREF

  v3 = (KDmaObject *)KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, dmaObjectHandle);
  v4 = v3;
  if ( !v3 )
    return 0xD8E007F7;
  dmaObj = v3;
  v3->GetTypeObj(&v10, v3);
  typeId = v10.typeId;
  dmaObj->GetTypeObj(&v11, dmaObj);
  if ( (typeId | 0x59) != v11.typeId )
  {
    dmaObj = 0;
    v4->DecrementRefcount(v4);
  }
  if ( !dmaObj )
    return 0xD8E007F7;
  dmaObj->DecrementRefcount(dmaObj);
  channelId = dmaObj->channelId;                // wtf, this is a UaF
  if ( channelId >= 0 )
    state = KDmaChannel::GetDmaState(&g_dmaChannels[channelId]);
  else
    state = DMASTATE_DONE;                      // well, well...
  *outDmaState = state;
  return 0;
}

//----- (FFF07AF4) --------------------------------------------------------
Result __fastcall GetThreadId(u32 *threadId, Handle threadHandle)
{
  KThread *v3; // r0

  *threadId = 0;
  v3 = KHandleTable::ConvertToThreadAllowPseudoHandle(&current.clc.current.process->handleTable, threadHandle);
  if ( !v3 )
    return 0xD9001BF7;
  *threadId = v3->threadId;
  v3->DecrementRefcount(v3);
  return 0;
}

//----- (FFF07B48) --------------------------------------------------------
Result Svc0x74Impl_CodeSetRelated_Stubbed(Handle *codesetHandleMaybe, ...)
{
  *codesetHandleMaybe = 0;
  return -121632780;
}

//----- (FFF07B64) --------------------------------------------------------
Result __fastcall OpenProcess(Handle *outProcessHandle, u32 pid)
{
  KProcess *v3; // r0
  KAutoObject *v4; // r4
  KHandleTable *p_handleTable; // r5
  Result v7; // r5
  KTypeObj v8; // [sp+0h] [bp-18h] BYREF

  *outProcessHandle = 0;
  v3 = KProcess::OpenById(pid);
  v4 = v3;
  if ( !v3 )
    return 0xD9001818;
  p_handleTable = &current.clc.current.process->handleTable;
  v3->GetTypeObj(&v8, v3);
  v7 = KHandleTable::Add(p_handleTable, outProcessHandle, v4, v8.typeId);
  v4->DecrementRefcount(v4);
  return v7;
}

//----- (FFF07BF4) --------------------------------------------------------
Result __fastcall QueryMemory(MemoryInfo *outMemInfo, u32 *outPgInfo, u32 addr)
{
  Result result; // r0
  u32 size; // r0
  char perms; // r2
  unsigned __int8 state; // r3
  MemoryInfo *__shifted(MemoryInfo,4) p_size; // r4
  KMemoryInfo v9; // [sp+0h] [bp-18h] BYREF

  result = 0;
  memset(&v9, 0, sizeof(v9));
  outMemInfo->baseAddress = 0;
  outMemInfo->size = 0;
  outMemInfo->perms = 0;
  outMemInfo->state = 0;
  *outPgInfo = 0;
  if ( addr >= 0x40000000 )
    result = 0xE0E01BF5;
  if ( result >= 0 )
  {
    result = KPageTable::QueryInfo(&current.clc.current.process->pgTable, &v9, outPgInfo, addr);
    if ( result >= 0 )
    {
      size = v9.size;
      perms = v9.perms;
      state = v9.state;
      outMemInfo->baseAddress = v9.baseAddress;
      p_size = (MemoryInfo *__shifted(MemoryInfo,4))&outMemInfo->size;
      ADJ(p_size)->size = size;
      ADJ(p_size)->perms = perms & KMEMPERM_RW;
      ADJ(p_size)->state = state;
      return 0;
    }
  }
  return result;
}

//----- (FFF07C8C) --------------------------------------------------------
Result __fastcall CreateThread(Handle *outThreadHandle, u32 ep, u32 arg, u32 stackTop, s32 priority, s32 processorId)
{
  Result result; // r0
  char cfgr; // r0
  s32 v9; // r0
  bool v10; // cc
  KProcess *volatile parentProcess; // r6
  u32 kernelFlags; // r1
  KResourceLimit *reslimit; // r7
  bool v14; // r8
  KThread *v15; // r0
  KThread *v16; // r4
  KThread *v17; // r0
  int v18; // r9
  bool v19; // zf
  int v20; // r6
  KTypeObj v21; // [sp+0h] [bp-40h] BYREF

  *outThreadHandle = 0;
  if ( (unsigned int)priority < 0x40 )
    result = 0;
  else
    result = 0xE0E01BFD;
  if ( result >= 0 )
  {
    cfgr = MPCORE.scu.cfgr;
    v9 = (cfgr & 3) + 1;
    v10 = v9 <= processorId;
    if ( v9 > processorId )
      v10 = processorId <= -3;
    result = v10 ? 0xD8E007FD : 0;              // I think this is return (procId <= -3 || procId >= numCores) ? 0xD8E007FD : 0;
    if ( result >= 0 )
    {
      parentProcess = current.clc.current.process;
      v19 = !KProcess::CheckThreadPriority(current.clc.current.process, priority);
      result = 0xD9001BEA;
      if ( !v19 )
      {
        kernelFlags = parentProcess->capability.kernelFlags;
        if ( (kernelFlags & 0xF00) != MEMOP_REGION_BASE )// only allow core3 for base sysmodules
                                                // only allow core2 for base sysmodules who have bit2 kernelflag set
        {
          if ( processorId == 2 )
          {
            if ( (kernelFlags & 0x2000) == 0 )
              return result;
          }
          else if ( processorId == 3 )
          {
            return result;
          }
        }
        reslimit = parentProcess->reslimit;
        if ( reslimit )
          v14 = KResourceLimit::Reserve(parentProcess->reslimit, RESLIMIT_THREAD, 1);
        else
          v14 = 1;
        if ( v14 )
        {
          v15 = (KThread *)KSlabHeap::Allocate(&g_threadAllocator.slabHeap);
          v16 = v15;
          if ( v15 )
          {
            v17 = (KThread *)KSynchronizationObject::KSynchronizationObject(v15);
            v17->KTimerTask::next = 0;
            v17->KWorkerTask::next = 0;
            v17->KInterruptTask::next = 0;
            v17->KSynchronizationObject::KAutoObject::__vftable = &KThread::vt;
            v17->KTimerTask::__vftable = &KThread::vt_KTimerTask;
            v17->KWorkerTask::__vftable = &KThread::vt_KWorkerTask;
            v17->KInterruptTask::KInterruptHandler::__vftable = &KThread::vt_KInterruptTask;
            v17->shallTerminate = 0;
            v17->wantedLightMutex = 0;
            v17->synchronizationResult = 0xE7E3FFFF;
            v17->syncObjectWaitAllList.count = 0;
            v17->syncObjectWaitAllList.link.next = (KSynchronizationObjectLinkedListNode *)&v17->syncObjectWaitAllList.link;
            v17->heldMutexListRootNode = 0;
            v17->syncObjectWaitAllList.link.prev = (KSynchronizationObjectLinkedListNode *)&v17->syncObjectWaitAllList.link;
            v17->mutexTryingToAcquireList.count = 0;
            v17->mutexTryingToAcquireList.link.next = (KMutexLinkedListNode *)&v17->mutexTryingToAcquireList.link;
            v17->mutexTryingToAcquireList.link.prev = (KMutexLinkedListNode *)&v17->mutexTryingToAcquireList.link;
            v17->affinityMask = 0;
            v17->owner = 0;
            v17->context = 0;
            KAutoObject::Initialize(v16);
          }
          if ( v16 )
          {
            v18 = KThread::InitializeUserThread(v16, ep, arg, stackTop, priority, processorId, parentProcess);
            if ( v18 >= 0 && (v18 = KObjectAllocator::Register(&g_threadAllocator, v16), v18 >= 0) )
            {
              v16->GetTypeObj(&v21, v16);
              v20 = KHandleTable::Add(&parentProcess->handleTable, outThreadHandle, v16, v21.typeId);
              if ( v20 >= 0 )
                KThread::PrepareToRun(v16);
              else
                v16->DecrementRefcount(v16);
              return v20;
            }
            else
            {
              v16->DecrementRefcount(v16);
              return v18;
            }
          }
          else
          {
            v19 = reslimit == 0;
            if ( reslimit )
              v19 = !v14;
            if ( !v19 )
              KResourceLimit::Release(reslimit, RESLIMIT_THREAD, 1);
            return 0xC8601803;
          }
        }
        else
        {
          return 0xC860180C;
        }
      }
    }
  }
  return result;
}
// FFF07DA8: conditional instruction was optimized away because r0.4!=0
// FFF07E78: conditional instruction was optimized away because zf.1==1
// FFF07EFC: conditional instruction was optimized away because zf.1==1
// FFF07F70: conditional instruction was optimized away because zf.1==1

//----- (FFF07FC0) --------------------------------------------------------
Result __fastcall GetProcessId(u32 *outPid, Handle processHandle)
{
  KProcess *v3; // r0

  *outPid = 0;
  v3 = KHandleTable::ConvertToProcessAllowPseudoHandle(&current.clc.current.process->handleTable, processHandle);
  if ( !v3 )
    return 0xD9001BF7;
  *outPid = v3->pid;
  v3->DecrementRefcount(v3);
  return 0;
}

//----- (FFF08010) --------------------------------------------------------
Result __fastcall AcceptSession(Handle *outServerSessionHandle, Handle serverPortHandle)
{
  KHandleTable *p_handleTable; // r6
  KAutoObject *v4; // r0
  KAutoObject *v5; // r4
  u8 typeId; // r9
  int v7; // r1
  KServerPort *serverPort; // r5
  KServerPort *v9; // r4
  KServerSession *v10; // r0
  KAutoObject *v11; // r5
  Result v12; // r6
  KTypeObj v14; // [sp+0h] [bp-30h] BYREF
  KTypeObj v15; // [sp+8h] [bp-28h] BYREF

  *outServerSessionHandle = 0;
  p_handleTable = &current.clc.current.process->handleTable;
  v4 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, serverPortHandle);
  v5 = v4;
  if ( !v4 )
    return 0xD8E007F7;
  v4->GetTypeObj(&v14, v4);
  typeId = v14.typeId;
  v5->GetTypeObj(&v15, v5);
  v7 = typeId | 0x55;
  serverPort = v7 == v15.typeId ? (KServerPort *)v5 : 0;
  if ( v7 != v15.typeId )
    v5->DecrementRefcount(v5);
  v9 = serverPort;
  if ( !serverPort )
    return 0xD8E007F7;
  v10 = KServerPort::AcceptSession(serverPort);
  v11 = v10;
  if ( v10 )
  {
    v10->GetTypeObj(&v14, v10);
    v12 = KHandleTable::Add(p_handleTable, outServerSessionHandle, v11, v14.typeId);
    v11->DecrementRefcount(v11);
    v9->DecrementRefcount(v9);
    return v12;
  }
  else
  {
    v9->DecrementRefcount(v9);
    return 0xD8401823;
  }
}

//----- (FFF08160) --------------------------------------------------------
Result __fastcall ConnectToPort(Handle *outClientSessionHandle, const char *name)
{
  int v3; // r0
  Result result; // r0
  KHandleTable *p_handleTable; // r7
  KClientPort *Object; // r0
  KClientPort *v7; // r5
  KClientPort *v8; // r4
  u8 typeId; // r10
  int v10; // r5
  KClientSession *v11; // r4
  Result v12; // r4
  KClientSession *v13; // [sp+0h] [bp-48h] BYREF
  KTypeObj v14; // [sp+8h] [bp-40h] BYREF
  char kName[12]; // [sp+10h] [bp-38h] BYREF
  KTypeObj v16; // [sp+20h] [bp-28h] BYREF

  *outClientSessionHandle = 0;
  if ( name )
  {
    v3 = CopyStringFromUser(kName, name, 0xCu);
    if ( v3 < 0 )
    {
      result = 0xD9001814;
      goto LABEL_9;
    }
    if ( v3 == 12 && kName[11] )
    {
      result = 0xE0E0181E;
      kName[11] = 0;
      goto LABEL_9;
    }
  }
  else
  {
    kName[0] = 0;
  }
  result = 0;
LABEL_9:
  if ( result >= 0 )
  {
    p_handleTable = &current.clc.current.process->handleTable;
    Object = (KClientPort *)KObjectName::FindObject(kName);
    v7 = Object;
    if ( !Object )
      return 0xD88007FA;
    v8 = Object;
    Object->GetTypeObj(&v14, Object);
    typeId = v14.typeId;
    v8->GetTypeObj(&v16, v8);
    if ( (typeId | 0x65) != v16.typeId )
    {
      v8 = 0;
      v7->DecrementRefcount(v7);
    }
    if ( v8 )
    {
      v10 = KClientPort::CreateSession(v8, &v13);
      v8->DecrementRefcount(v8);
      if ( v10 >= 0 )
      {
        v11 = v13;
        v13->GetTypeObj(&v14, v13);
        v12 = KHandleTable::Add(p_handleTable, outClientSessionHandle, v11, v14.typeId);
        v13->DecrementRefcount(v13);
        return v12;
      }
      else
      {
        return v10;
      }
    }
    else
    {
      return 0xD88007FA;
    }
  }
  return result;
}

//----- (FFF082F4) --------------------------------------------------------
Result __fastcall ControlMemory(u32 *outAddr, u32 addr0, u32 addr1, u32 size, u8 op, u32 perms)
{
  Result result; // r0
  u32 endAddr; // r11
  KProcess *volatile curProc; // r9
  u32 LinearAddrRangeBase; // r0
  u32 linearAddrLimit; // r1
  bool v14; // cc
  u32 v15; // r0
  bool v16; // cf
  bool v17; // cf
  bool v18; // cf
  u32 v19; // r0
  u32 linearAddrLimit2; // r0
  u32 v21; // r1
  u32 v22; // r0
  bool v23; // cf
  bool v24; // cf
  bool v25; // cf
  u32 v26; // r0
  bool v27; // cf
  u32 v28; // r0
  bool v29; // zf
  bool v30; // zf
  u32 isLoader; // r0
  int v32; // r7
  bool v33; // zf
  int v34; // r4
  int outAddra[2]; // [sp+Ch] [bp-3Ch] BYREF

  *outAddr = 0;
  result = addr0 << 20;                         // check if aligned
  if ( addr0 << 20 )
    result = 0xE0E01BF1;
  if ( result >= 0 )
  {
    result = addr1 << 20;
    if ( addr1 << 20 )
      result = 0xE0E01BF1;
    if ( result >= 0 )
    {
      result = size << 20;
      if ( size << 20 )
        result = 0xE0E01BF2;
      if ( result >= 0 )
      {
        switch ( op )                           // check operation
        {
          case MEMOP_FREE:
          case MEMOP_ALLOC:
          case MEMOP_MAP:
          case MEMOP_UNMAP:
          case MEMOP_PROT:
            result = 0;
            break;
          default:
            result = 0xE0E01BEE;
            break;
        }
        if ( result >= 0 )
        {
          endAddr = addr0 + size;
          curProc = current.clc.current.process;
          if ( op == 3 )
          {
            if ( (op & 0x10000) == 0 )
            {
LABEL_57:
              if ( addr0 && addr0 - 0x8000000 < 0x6000000 && endAddr > 0xE000000 )// 
                                                // if normal, check if addr0 is within
                                                // 
                                                // * 0x08000000..0x0E000000 (size not properly checked for that subrange)
                                                // * 0x10000000..0x14000000 (not freeable!)
                return 0xE0E01BFD;
              if ( size )
              {
                v25 = addr0 >= 0x8000000;
                v26 = endAddr - 1;
                if ( addr0 >= 0x8000000 )
                  v25 = v26 >= addr0;
                if ( v25 && v26 < 0x14000000 )
                  goto LABEL_67;
              }
              else if ( addr0 >= 0x8000000 && addr0 < 0x14000000 )
              {
LABEL_67:
                result = 0;
                goto LABEL_71;
              }
              result = 0xE0E01BF5;
LABEL_71:
              if ( result < 0 )
                return result;
              if ( op == MEMOP_MAP || op == MEMOP_UNMAP )
              {
                if ( size )
                {
                  v27 = addr1 >= 0x100000;      // looks like we can remap heap to grow data/bss
                  v28 = addr1 + size - 1;
                  if ( addr1 >= 0x100000 )
                    v27 = v28 >= addr1;
                  if ( v27 && v28 < 0x14000000 )
                    goto LABEL_80;
                }
                else if ( addr1 >= 0x100000 && addr1 < 0x14000000 )
                {
LABEL_80:
                  result = 0;
                  goto LABEL_84;
                }
                result = 0xE0E01BF5;
LABEL_84:
                if ( result < 0 )
                  return result;
              }
LABEL_85:
              if ( !size )
                return 0;
              if ( op == 1 )
                goto LABEL_97;
              v29 = perms == 0;
              if ( perms )
                v29 = perms == 1;
              if ( v29 )
                goto LABEL_95;
              v30 = perms == 2;
              if ( perms != 2 )
                v30 = perms == 3;
              if ( v30 )
LABEL_95:
                result = 0;
              else
                result = 0xE0E01BEE;
              if ( result >= 0 )
              {
LABEL_97:
                isLoader = curProc->pid;
                v32 = op & 0xFFFFFF;
                if ( isLoader != 1 )
                  isLoader = 0;
                if ( (-isLoader & v32 & 0xF00) == 0 )
                  v32 = curProc->capability.kernelFlags & 0xF00 | op & 0xFFF0FF;
                v33 = op == 3;
                if ( op == 3 )
                  v33 = isLoader == 0;
                if ( !v33 || KProcess::ReserveResource(current.clc.current.process, RESLIMIT_COMMIT, size) )
                {
                  outAddra[0] = 0;
                  v34 = KProcessPageTable::ControlMemory(
                          &curProc->pgTable,
                          (u32 *)outAddra,
                          addr0,
                          addr1,
                          size,
                          v32,
                          perms);
                  if ( v34 >= 0 )
                  {
                    if ( op == MEMOP_FREE )     // bug here, if loader alloc fails, this will grow the reslimit
                      KProcess::ReleaseResource(current.clc.current.process, RESLIMIT_COMMIT, size);
                    *outAddr = outAddra[0];
                    return 0;
                  }
                  else
                  {
                    if ( op == 3 )
                      KProcess::ReleaseResource(current.clc.current.process, RESLIMIT_COMMIT, size);
                    return v34;
                  }
                }
                else
                {
                  return -933226486;
                }
              }
              return result;
            }
            if ( addr0 )
            {
              LinearAddrRangeBase = KProcess::GetLinearAddrRangeBase(current.clc.current.process);
              if ( LinearAddrRangeBase == 0x14000000 )
                linearAddrLimit = 0x1C000000;
              else
                linearAddrLimit = LinearAddrRangeBase + 0x10000000;
              if ( size )
              {
                v14 = LinearAddrRangeBase > addr0;
                v15 = endAddr - 1;
                if ( v14 )
                  return 0xE0E01BF5;
                v16 = addr0 >= v15;
                if ( addr0 <= v15 )
                  v16 = v15 >= linearAddrLimit;
                if ( v16 )
                  return 0xE0E01BF5;
              }
              else
              {
                v17 = LinearAddrRangeBase >= addr0;
                if ( LinearAddrRangeBase <= addr0 )
                  v17 = addr0 >= linearAddrLimit;
                if ( v17 )
                  return 0xE0E01BF5;
              }
            }
            if ( !addr1 )
              goto LABEL_85;
          }
          else
          {
            if ( op != 1 )
              goto LABEL_57;
            if ( size )
            {
              v18 = addr0 >= 0x8000000;
              v19 = endAddr - 1;
              if ( addr0 >= 0x8000000 )
                v18 = v19 >= addr0;
              if ( v18 && v19 < 0x10000000 )
                goto LABEL_85;
            }
            else if ( addr0 >= 0x8000000 && addr0 < 0x10000000 )
            {
              goto LABEL_85;
            }
            linearAddrLimit2 = KProcess::GetLinearAddrRangeBase(current.clc.current.process);
            if ( linearAddrLimit2 == 0x14000000 )
              v21 = 0x1C000000;
            else
              v21 = linearAddrLimit2 + 0x10000000;
            if ( size )
            {
              v14 = linearAddrLimit2 > addr0;
              v22 = endAddr - 1;
              if ( !v14 )
              {
                v23 = addr0 >= v22;
                if ( addr0 <= v22 )
                  v23 = v22 >= v21;
                if ( !v23 )
                  goto LABEL_85;
              }
            }
            else
            {
              v24 = linearAddrLimit2 >= addr0;
              if ( linearAddrLimit2 <= addr0 )
                v24 = addr0 >= v21;
              if ( !v24 )
                goto LABEL_85;
            }
          }
          return 0xE0E01BF5;
        }
      }
    }
  }
  return result;
}
// FFF08358: control flows out of bounds to FFF0835C
// FFF082F4: using guessed type u32 outAddr;

//----- (FFF086A0) --------------------------------------------------------
Result __fastcall CreateCodeSet(Handle *outHandle, CodeSetInfo *codeSetInfo, u32 textPtr, u32 rodataPtr, u32 dataPtr)
{
  bool v6; // zf
  Result result; // r0
  bool v10; // zf
  KProcessPageTable *p_pgTable; // r10
  KCodeSet *v12; // r0
  KCodeSet *v13; // r4
  int v14; // r6
  KHandleTable *p_handleTable; // r6
  KTypeObj v16; // [sp+0h] [bp-68h] BYREF
  CodeSetInfo codeSetInfoKern; // [sp+8h] [bp-60h] BYREF

  v6 = codeSetInfo == 0;
  if ( codeSetInfo )
    v6 = textPtr == 0;
  *outHandle = 0;
  result = 0xD8E007F6;
  if ( !v6 )
  {
    v10 = rodataPtr == 0;
    if ( rodataPtr )
      v10 = dataPtr == 0;
    if ( !v10 )
    {
      result = CopyBytesFromUser(&codeSetInfoKern, codeSetInfo, 0x40u) ? 0 : 0xE0E01BF5;
      if ( result >= 0 )
      {
        p_pgTable = &current.clc.current.process->pgTable;
        v12 = (KCodeSet *)KSlabHeap::Allocate(&g_codeSetAllocator.slabHeap);
        v13 = v12;
        if ( v12 )
        {
          KCodeSet::KCodeSet(v12);
          KAutoObject::Initialize(v13);
        }
        if ( v13 )
        {
          KCodeSet::Initialize(v13, &codeSetInfoKern, p_pgTable, textPtr, rodataPtr, dataPtr);
          v14 = KObjectAllocator::Register(&g_codeSetAllocator, v13);
          if ( v14 >= 0 )
          {
            p_handleTable = &current.clc.current.process->handleTable;
            v13->GetTypeObj(&v16, v13);
            v14 = KHandleTable::Add(p_handleTable, outHandle, v13, v16.typeId);
          }
          v13->DecrementRefcount(v13);
          return v14;
        }
        else
        {
          return 0xD8601402;
        }
      }
    }
  }
  return result;
}
// FFF0872C: conditional instruction was optimized away because r0.4!=0

//----- (FFF087E4) --------------------------------------------------------
Result __fastcall CreateProcess(Handle *outProcessHandle, Handle codeSetHandle, u32 *kernelCaps, s32 numKernelCaps)
{
  Result result; // r0
  KHandleTable *p_handleTable; // r6
  KAutoObject *v9; // r0
  KAutoObject *v10; // r5
  u8 typeId; // r11
  int v12; // r1
  KCodeSet *v13; // r4
  KCodeSet *codeSet; // r5
  KProcess *v15; // r0
  KProcess *v16; // r4
  KProcess *v17; // r0
  KHandleTable *__shifted(KProcess,0xDC) v18; // r0
  KProcess *v19; // r10
  int v20; // r4
  KTypeObj v21; // [sp+0h] [bp-38h] BYREF
  KTypeObj v22; // [sp+8h] [bp-30h] BYREF

  *outProcessHandle = 0;
  if ( (unsigned int)numKernelCaps <= 0x7FFFFFFF )
    result = 0;
  else
    result = 0xE0E01BFD;
  if ( result >= 0 )
  {
    if ( numKernelCaps <= 0 || kernelCaps )
    {                                           // note: kernelCaps addr not validated (!)
      p_handleTable = &current.clc.current.process->handleTable;
      v9 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, codeSetHandle);
      v10 = v9;
      if ( !v9 )
        return 0xD9001BF7;
      v9->GetTypeObj(&v21, v9);
      typeId = v21.typeId;
      v10->GetTypeObj(&v22, v10);
      v12 = typeId | 0x68;
      if ( v12 == v22.typeId )
        v13 = (KCodeSet *)v10;
      else
        v13 = 0;
      if ( v12 != v22.typeId )
        v10->DecrementRefcount(v10);
      codeSet = v13;
      if ( v13 )
      {
        v15 = (KProcess *)KSlabHeap::Allocate(&g_processAllocator.slabHeap);
        v16 = v15;
        if ( v15 )
        {
          v17 = (KProcess *)KSynchronizationObject::KSynchronizationObject(v15);
          v17->KSynchronizationObject::KAutoObject::__vftable = &KProcess::vt;
          v17->KWorkerTask::__vftable = &KProcess::vt_KWorkerTask;
          v17->next = 0;
          v17->pgTable.mutex.lockingThread = 0;
          v17->pgTable.mutex.numWaiters = 0;
          v17->pgTable.mutex.ticketCount = 0;
          v17->pgTable.memoryBlockMgr.blocks.link.next = (KMemoryBlockLinkedListNode *)&v17->pgTable.memoryBlockMgr.blocks.link;
          v17->pgTable.memoryBlockMgr.blocks.count = 0;
          v17->pgTable.memoryBlockMgr.blocks.link.prev = (KMemoryBlockLinkedListNode *)&v17->pgTable.memoryBlockMgr.blocks.link;
          v17->kernAllocatedForProcess = 0;
          v17->threadLocalPages.link.next = (KThreadLocalPageLinkedListNode *)&v17->threadLocalPages.link;
          v17->threadLocalPages.count = 0;
          v17->threadLocalPages.link.prev = (KThreadLocalPageLinkedListNode *)&v17->threadLocalPages.link;
          v17->state = KPROCSTATE_CREATED;
          v17->affinityMask = 0;
          v17->threadCount = 0;
          v17->capability.kernelFlags = 0;
          v17->capability.intendedKernelVersion = 0;
          v18 = KHandleTable::KHandleTable(&v17->handleTable);
          ADJ(v18)->unused_234 = 0;
          ADJ(v18)->unused_238 = 0LL;
          ADJ(v18)->unused_240 = 0LL;
          ADJ(v18)->unused_248 = 0LL;
          ADJ(v18)->unused_250 = 0LL;
          ADJ(v18)->unused_258 = 0LL;
          ADJ(v18)->unused_260 = 0LL;
          ADJ(v18)->unused_268 = 0LL;
          KAutoObject::Initialize(v16);
        }
        v19 = v16;
        if ( v16 )
        {
          v20 = KProcess::Initialize(v16, codeSet, kernelCaps, numKernelCaps);
          codeSet->DecrementRefcount(codeSet);
          if ( v20 >= 0 )
          {
            v20 = KObjectAllocator::Register(&g_processAllocator, v19);
            if ( v20 < 0
              || (v19->GetTypeObj(&v21, v19),
                  v20 = KHandleTable::Add(p_handleTable, outProcessHandle, v19, v21.typeId),
                  v20 < 0) )
            {
              v19->DecrementRefcount(v19);
            }
          }
          return v20;
        }
        else
        {
          return 0xC860180A;
        }
      }
      else
      {
        return 0xD9001BF7;
      }
    }
    else
    {
      return 0xD8E007F6;
    }
  }
  return result;
}
// FFF088E4: conditional instruction was optimized away because r0.4!=0

//----- (FFF08A74) --------------------------------------------------------
Result __fastcall CreateSession(Handle *outServerSessionHandle, Handle *outClientSessionHandle)
{
  KSession *v4; // r0
  KSession *v5; // r4
  KSession *v6; // r0
  KServerSession *__shifted(KSession,8) v7; // r0
  KClientSession *__shifted(KSession,0x2C) v8; // r0
  KHandleTable *p_handleTable; // r7
  int v11; // r5
  KTypeObj v12; // [sp+0h] [bp-20h] BYREF

  *outServerSessionHandle = 0;
  *outClientSessionHandle = 0;
  v4 = (KSession *)KSlabHeap::Allocate(&g_sessionAllocator.slabHeap);
  v5 = v4;
  if ( v4 )
  {
    v6 = (KSession *)KAutoObject::KAutoObject(v4);
    v6->__vftable = &KSession::vt;
    v7 = (KServerSession *__shifted(KSession,8))KSynchronizationObject::KSynchronizationObject(&v6->server);
    ADJ(v7)->server.__vftable = &KServerSession::vt;
    ADJ(v7)->server.syncRequestWaitList.link.prev = 0;
    ADJ(v7)->server.syncRequestWaitList.link.next = 0;
    ADJ(v7)->server.currentRequestingThread = 0;
    v8 = (KClientSession *__shifted(KSession,0x2C))KSynchronizationObject::KSynchronizationObject(&ADJ(v7)->client);
    ADJ(v8)->client.__vftable = &KClientSession::vt;
    ADJ(v8)->client.status = 0;
    KAutoObject::Initialize(v5);
  }
  if ( !v5 )
    return 0xC8601809;
  KSession::Initialize(v5, 0);
  KObjectAllocator::Register(&g_sessionAllocator, v5);
  p_handleTable = &current.clc.current.process->handleTable;
  v5->server.GetTypeObj(&v12, &v5->server);
  v11 = KHandleTable::Add(p_handleTable, outServerSessionHandle, &v5->server, v12.typeId);
  if ( v11 >= 0 )
  {
    v5->client.GetTypeObj(&v12, &v5->client);
    v11 = KHandleTable::Add(p_handleTable, outClientSessionHandle, &v5->client, v12.typeId);
  }
  v5->server.DecrementRefcount(&v5->server);
  v5->client.DecrementRefcount(&v5->client);
  return v11;
}
// FFF08AB8: conditional instruction was optimized away because r0.4!=0

//----- (FFF08BF0) --------------------------------------------------------
Result __fastcall GetHandleInfo(s64 *out, Handle handle, s32 type)
{
  KProcess *volatile process; // r4
  KProcess *v6; // r0
  KThread *volatile thread; // r4
  KProcess *v9; // r4
  int creationTime; // r5
  int creationTime_high; // r6
  u8 typeId; // r10
  KTypeObj v13; // [sp+0h] [bp-30h] BYREF
  KTypeObj v14; // [sp+8h] [bp-28h] BYREF

  *out = 0LL;
  if ( handle == CUR_PROCESS_HANDLE )
  {
    process = current.clc.current.process;
    KAutoObject::IncrementRefcount(current.clc.current.process);
    v6 = process;
  }
  else if ( handle == CUR_THREAD_HANDLE )
  {
    thread = current.clc.current.thread;
    KAutoObject::IncrementRefcount(current.clc.current.thread);
    v6 = (KProcess *)thread;
  }
  else
  {
    v6 = (KProcess *)KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, handle);
  }
  if ( !v6 )
    return 0xD8E007F7;
  v9 = v6;
  creationTime = 0;
  creationTime_high = 0;
  switch ( type )
  {
    case 0:
      v6->GetTypeObj(&v13, v6);
      typeId = v13.typeId;
      v9->GetTypeObj(&v14, v9);
      if ( (typeId | 0xC5) == v14.typeId )
      {
        creationTime = v9->creationTime;
        creationTime_high = HIDWORD(v9->creationTime);
      }
      goto LABEL_19;
    case 1:
      creationTime = v6->refcount - 1;
      creationTime_high = creationTime >> 31;
LABEL_19:
      *(_DWORD *)out = creationTime;
      *((_DWORD *)out + 1) = creationTime_high;
      v9->DecrementRefcount(v9);
      return 0;
    case 2:
    case 0x32107:
      goto LABEL_19;
  }
  v6->DecrementRefcount(v6);
  return 0xD8E007ED;
}

//----- (FFF08D68) --------------------------------------------------------
Result __fastcall GetSystemInfo(s64 *out, s32 type, s32 subType)
{
  u32 v4; // r0
  u32 v5; // r7
  u32 v6; // r6
  u32 TotalNumPages; // r0
  u32 regionSize; // r1
  u32 v9; // r0
  u32 v10; // r0
  u32 v11; // r0

  v4 = 0;
  if ( type == 2 )
    v4 = (u32)&g_memoryManager;
  *(_DWORD *)out = 0;
  *((_DWORD *)out + 1) = 0;
  if ( type == 2 )
  {
    v4 = *(_DWORD *)(v4 + 0x70);                // ->pgMgr.kernelMemoryUsage
  }
  else if ( type > 2 )
  {
    if ( type != 3 && type == 26 )
      v4 = 5;
  }                                             // number of initial processes
  else if ( !type )
  {
    if ( subType )
    {
      switch ( subType )
      {
        case 1:
          TotalNumPages = KPageHeap::GetTotalNumPages(&g_memoryManager.applicationHeap);
          regionSize = g_memoryManager.applicationHeap.regionSize;
          v9 = TotalNumPages << 12;
          break;
        case 2:
          v10 = KPageHeap::GetTotalNumPages(&g_memoryManager.systemHeap);
          regionSize = g_memoryManager.systemHeap.regionSize;
          v9 = v10 << 12;
          break;
        case 3:
          v11 = KPageHeap::GetTotalNumPages(&g_memoryManager.baseHeap);
          regionSize = g_memoryManager.baseHeap.regionSize;
          v9 = v11 << 12;
          break;
        default:
          goto LABEL_21;
      }
      v4 = regionSize - v9;
      goto LABEL_21;
    }
    v5 = KPageHeap::GetTotalNumPages(&g_memoryManager.applicationHeap) << 12;
    v6 = KPageHeap::GetTotalNumPages(&g_memoryManager.systemHeap) << 12;
    v4 = 0x10000000 - v5 - v6 - (KPageHeap::GetTotalNumPages(&g_memoryManager.baseHeap) << 12);
  }
LABEL_21:
  *(_DWORD *)out = v4;
  *((_DWORD *)out + 1) = 0;
  return 0;
}

//----- (FFF08E7C) --------------------------------------------------------
Result __fastcall GetThreadInfo(s64 *outValue, Handle threadHandle, s32 type)
{
  KThread *volatile thread; // r4
  KAutoObject *v4; // r0
  KAutoObject *v5; // r4
  u8 typeId; // r7
  int v7; // r1
  KThread *v8; // r5
  KTypeObj v10; // [sp+0h] [bp-28h] BYREF
  KTypeObj v11; // [sp+8h] [bp-20h] BYREF

  *outValue = 0LL;
  if ( threadHandle == CUR_THREAD_HANDLE )
  {
    thread = current.clc.current.thread;
    KAutoObject::IncrementRefcount(current.clc.current.thread);
  }
  else
  {
    v4 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, threadHandle);
    v5 = v4;
    if ( !v4 )
      return 0xD8E007F7;
    v4->GetTypeObj(&v10, v4);
    typeId = v10.typeId;
    v5->GetTypeObj(&v11, v5);
    v7 = typeId | 0x8D;
    if ( v7 == v11.typeId )
      v8 = (KThread *)v5;
    else
      v8 = 0;
    if ( v7 != v11.typeId )
      v5->DecrementRefcount(v5);
    thread = v8;
  }
  if ( thread )
  {
    thread->DecrementRefcount(thread);
    return 0xD8E007ED;
  }
  return 0xD8E007F7;
}

//----- (FFF08F84) --------------------------------------------------------
Result __fastcall GetThreadList(s32 *outNumThreads, u32 *outTids, s32 maxNumThreads, Handle processHandle)
{
  Result result; // r0
  GetThreadListArgs v6; // [sp+0h] [bp-20h] BYREF

  *outNumThreads = 0;
  if ( !outTids )
    return 0xD8E007F6;
  if ( (unsigned int)maxNumThreads <= 0x1FFFFFFF )
    result = 0;
  else
    result = 0xE0E01BFD;
  if ( result >= 0 )
  {
    v6.outThreadIds = outTids;
    v6.maxNumThreads = maxNumThreads;
    v6.processHandle = processHandle;
    v6.result = 0xE7E3FFFF;
    v6.outNumThreads = outNumThreads;
    if ( CallFuncWithStackAlloc((FuncWithStackAlloc)GetThreadListImpl, &v6, 4 * maxNumThreads) )
      return v6.result;
    else
      return 0xD86007F3;
  }
  return result;
}

//----- (FFF09000) --------------------------------------------------------
Result __fastcall SignalAndWait(s32 *idx, Handle signal, Handle *handles, s32 numHandles, bool waitAll, s64 timeout)
{
  *idx = 0;
  return 0xF8C007F4;
}

//----- (FFF09014) --------------------------------------------------------
Result __fastcall GetProcessInfo(s64 *outValue, Handle processHandle, s32 type)
{
  KProcess *volatile process; // r4
  KAutoObject *v6; // r0
  KAutoObject *v7; // r4
  unsigned __int8 v8; // r9
  int v9; // r1
  KProcess *v10; // r8
  Result result; // r0
  KLightMutex *p_mutex; // r0
  unsigned int v13; // r2
  bool v14; // zf
  unsigned int v15; // r3
  s64 TotalPrivateOrSharedMemSize; // r8
  KLightMutex *v17; // r0
  __int64 v18; // r0
  unsigned int *p_pgTable; // r0
  unsigned int v20; // r2
  bool v21; // zf
  unsigned int v22; // r3
  KLightMutex *v23; // r0
  unsigned int v24; // r2
  bool v25; // zf
  unsigned int v26; // r3
  KLightMutex *v27; // r0
  unsigned int v28; // r2
  bool v29; // zf
  unsigned int v30; // r3
  Result QtmStaticMappedConversionOffset; // r0
  Result v32; // r5
  unsigned int v33; // [sp+0h] [bp-30h] BYREF
  int v34; // [sp+4h] [bp-2Ch]
  char v35; // [sp+8h] [bp-28h] BYREF
  int v36; // [sp+Ch] [bp-24h]

  *outValue = 0LL;
  if ( processHandle == CUR_PROCESS_HANDLE )
  {
    process = current.clc.current.process;
    KAutoObject::IncrementRefcount(current.clc.current.process);
  }
  else
  {
    v6 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, processHandle);
    v7 = v6;
    if ( !v6 )
      return 0xD8E007F7;
    v6->GetTypeObj((KTypeObj *)&v33, v6);       // I wish "force new variable" actually worked
    v8 = v34;
    v7->GetTypeObj((KTypeObj *)&v35, v7);
    v9 = v8 | 0xC5;
    if ( v9 == (unsigned __int8)v36 )
      v10 = (KProcess *)v7;
    else
      v10 = 0;
    if ( v9 != (unsigned __int8)v36 )
      v7->DecrementRefcount(v7);
    process = v10;
  }
  if ( !process )
    return 0xD8E007F7;
  switch ( type )
  {
    case 0:
      p_mutex = &process->pgTable.mutex;
      v13 = __ldrex((unsigned int *)&process->pgTable);
      v14 = v13 == 0;
      if ( v13 )
        v15 = __strex(v13, (unsigned int *)p_mutex);
      else
        v15 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)p_mutex);
      if ( !v13 )
        v14 = v15 == 0;
      if ( !v14 )
        KLightMutex::LockImpl(p_mutex);
      __mcr(15, 0, 0, 7, 10, 5);
      TotalPrivateOrSharedMemSize = KMemoryBlockManger::GetTotalPrivateOrSharedMemSize(&process->pgTable.memoryBlockMgr);
      v17 = &process->pgTable.mutex;
      __mcr(15, 0, 0, 7, 10, 5);
      process->pgTable.mutex.lockingThread = 0;
      if ( process->pgTable.mutex.numWaiters > 0 )
        goto LABEL_48;
      goto LABEL_21;
    case 1:
      p_pgTable = (unsigned int *)&process->pgTable;
      v20 = __ldrex((unsigned int *)&process->pgTable);
      v21 = v20 == 0;
      if ( v20 )
        v22 = __strex(v20, p_pgTable);
      else
        v22 = __strex((unsigned int)current.clc.current.thread, p_pgTable);
      if ( !v20 )
        v21 = v22 == 0;
      if ( !v21 )
        KLightMutex::LockImpl((KLightMutex *)p_pgTable);
      __mcr(15, 0, 0, 7, 10, 5);
      v17 = &process->pgTable.mutex;
      TotalPrivateOrSharedMemSize = process->pgTable.unk_24;
      __mcr(15, 0, 0, 7, 10, 5);
      process->pgTable.mutex.lockingThread = 0;
      if ( process->pgTable.mutex.numWaiters > 0 )
        goto LABEL_48;
      goto LABEL_21;
    case 2:
      v23 = &process->pgTable.mutex;
      v24 = __ldrex((unsigned int *)&process->pgTable);
      v25 = v24 == 0;
      if ( v24 )
        v26 = __strex(v24, (unsigned int *)v23);
      else
        v26 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)v23);
      if ( !v24 )
        v25 = v26 == 0;
      if ( !v25 )
        KLightMutex::LockImpl(v23);
      __mcr(15, 0, 0, 7, 10, 5);
      TotalPrivateOrSharedMemSize = KMemoryBlockManger::GetTotalPrivateMemSize(&process->pgTable.memoryBlockMgr);
      v17 = &process->pgTable.mutex;
      __mcr(15, 0, 0, 7, 10, 5);
      process->pgTable.mutex.lockingThread = 0;
      if ( process->pgTable.mutex.numWaiters > 0 )
        goto LABEL_48;
      goto LABEL_21;
    case 3:
      v27 = &process->pgTable.mutex;
      v28 = __ldrex((unsigned int *)&process->pgTable);
      v29 = v28 == 0;
      if ( v28 )
        v30 = __strex(v28, (unsigned int *)v27);
      else
        v30 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)v27);
      if ( !v28 )
        v29 = v30 == 0;
      if ( !v29 )
        KLightMutex::LockImpl(v27);
      __mcr(15, 0, 0, 7, 10, 5);
      v17 = &process->pgTable.mutex;
      TotalPrivateOrSharedMemSize = process->pgTable.unk_28;
      __mcr(15, 0, 0, 7, 10, 5);
      process->pgTable.mutex.lockingThread = 0;
      if ( process->pgTable.mutex.numWaiters > 0 )
LABEL_48:
        KLightMutex::UnlockImpl(v17);
LABEL_21:
      v18 = TotalPrivateOrSharedMemSize
          + KHandleTable::GetTotalAllocatedSize(&process->handleTable)
          + process->kernAllocatedForProcess;
      goto LABEL_62;
    case 4:
      LODWORD(v18) = process->handleTable.count;
      goto LABEL_54;
    case 5:
      LODWORD(v18) = process->handleTable.maxCount;
      goto LABEL_54;
    case 6:
      LODWORD(v18) = process->unused_234;
      goto LABEL_54;
    case 7:
      KProcess::DumpThreadIds(process, (s32 *)&v33, 0, 0);
      LODWORD(v18) = v33;
      goto LABEL_54;
    case 8:
      LODWORD(v18) = process->maxAllowedThreadCount;// always 0
      goto LABEL_54;
    case 19:
      v18 = process->capability.kernelFlags & 0xF00LL;
      goto LABEL_62;
    case 20:
      v18 = 0x20000000 - KProcess::GetLinearAddrRangeBase(process);
      goto LABEL_62;
    case 21:
      QtmStaticMappedConversionOffset = KProcess::GetQtmStaticMappedConversionOffset((s32 *)&v33, process);
      if ( QtmStaticMappedConversionOffset < 0 )
        goto LABEL_64;
      LODWORD(v18) = v33;
LABEL_54:
      v18 = (int)v18;
      goto LABEL_62;
    case 22:
      QtmStaticMappedConversionOffset = KProcess::GetQtmStaticMappedBase((s32 *)&v33, process);
      if ( QtmStaticMappedConversionOffset >= 0 )
        goto LABEL_61;
      goto LABEL_64;
    case 23:
      QtmStaticMappedConversionOffset = KProcess::GetQtmStaticMappedSize((s32 *)&v33, process);
      if ( QtmStaticMappedConversionOffset >= 0 )
      {
LABEL_61:
        v18 = v33;
LABEL_62:
        *outValue = v18;
        process->DecrementRefcount(process);
        result = 0;
      }
      else
      {
LABEL_64:
        v32 = QtmStaticMappedConversionOffset;
        process->DecrementRefcount(process);
        result = v32;
      }
      break;
    default:
      process->DecrementRefcount(process);
      return 0xD8E007ED;
  }
  return result;
}
// FFF090F0: control flows out of bounds to FFF090F4

//----- (FFF09410) --------------------------------------------------------
Result __fastcall GetProcessList(s32 *outNumProcesses, u32 *outPids, s32 maxNumProcesses)
{
  Result result; // r0
  GetProcessListArgs v5; // [sp+0h] [bp-18h] BYREF

  *outNumProcesses = 0;
  if ( !outPids )
    return 0xD8E007F6;
  if ( (unsigned int)maxNumProcesses <= 0x1FFFFFFF )
    result = 0;
  else
    result = 0xE0E01BFD;
  if ( result >= 0 )
  {
    v5.outPids = outPids;
    v5.maxNumProcesses = maxNumProcesses;
    v5.result = 0xE7E3FFFF;
    v5.outNumProcesses = outNumProcesses;
    if ( CallFuncWithStackAlloc((FuncWithStackAlloc)GetProcessListImpl, &v5, 4 * maxNumProcesses) )
      return v5.result;
    else
      return 0xD86007F3;
  }
  return result;
}

//----- (FFF0948C) --------------------------------------------------------
Result __fastcall CreateSemaphore(Handle *outSemaphoreHandle, s32 initialCount, s32 maxCount)
{
  Result result; // r0
  KProcess *process; // r9
  KHandleTable *p_handleTable; // r11
  KResourceLimit *reslimit; // r5
  bool v9; // r8
  KSynchronizationObject *v10; // r0
  KSemaphore *v11; // r4
  KSemaphore *v12; // r0
  int v13; // r9
  bool v14; // zf
  KTypeObj v15; // [sp+0h] [bp-38h] BYREF

  *outSemaphoreHandle = 0;
  if ( (unsigned int)initialCount <= 0x7FFFFFFF )
    result = 0;
  else
    result = 0xE0E01BFD;
  if ( result >= 0 )
  {
    if ( initialCount <= maxCount )
    {
      process = current.clc.current.process;
      p_handleTable = &current.clc.current.process->handleTable;
      reslimit = current.clc.current.process->reslimit;
      if ( reslimit )
        v9 = KResourceLimit::Reserve(current.clc.current.process->reslimit, RESLIMIT_SEMAPHORE, 1);
      else
        v9 = 1;
      if ( v9 )
      {
        v10 = (KSynchronizationObject *)KSlabHeap::Allocate(&g_semaphoreAllocator.slabHeap);
        v11 = (KSemaphore *)v10;
        if ( v10 )
        {
          v12 = (KSemaphore *)KSynchronizationObject::KSynchronizationObject(v10);
          v12->next = 0;
          v12->irqId = -1;
          v12->KInterruptEvent::KSynchronizationObject::KAutoObject::__vftable = (KInterruptEvent_vtbl *)&KSemaphore::vt;// 
                                                // interrupt task part
          v12 = (KSemaphore *)((char *)v12 + 0x14);
          v12->KInterruptEvent::KSynchronizationObject::KAutoObject::__vftable = (KInterruptEvent_vtbl *)&KSemaphore::vt_KInterruptTask;
          v12->waiters.link.next = 0;
          KAutoObject::Initialize(v11);
        }
        if ( v11 )
        {
          KSemaphore::Initialize(v11, process, initialCount, maxCount);
          reslimit = 0;
          v13 = KObjectAllocator::Register(&g_semaphoreAllocator, v11);
          if ( v13 >= 0 )
          {
            v11->GetTypeObj(&v15, v11);
            v13 = KHandleTable::Add(p_handleTable, outSemaphoreHandle, v11, v15.typeId);
          }
          v11->DecrementRefcount(v11);
        }
        else
        {
          v13 = 0xC8601801;
        }
        v14 = reslimit == 0;
        if ( reslimit )
          v14 = !v9;
        if ( !v14 )
          KResourceLimit::Release(reslimit, RESLIMIT_SEMAPHORE, 1);
        return v13;
      }
      else
      {
        return 0xC860180E;
      }
    }
    else
    {
      return 0xD90007EE;
    }
  }
  return result;
}
// FFF09544: conditional instruction was optimized away because r0.4!=0
// FFF09560: CONTAINING_RECORD: too small offset 20 for struct 'KSemaphore'

//----- (FFF09644) --------------------------------------------------------
Result __fastcall DuplicateHandle(Handle *outHandle, Handle handle)
{
  KHandleTable *p_handleTable; // r5
  KAutoObject *process; // r4
  Result v6; // r5
  KTypeObj v7; // [sp+0h] [bp-18h] BYREF

  *outHandle = 0;
  p_handleTable = &current.clc.current.process->handleTable;
  if ( handle == CUR_PROCESS_HANDLE )
  {
    process = current.clc.current.process;
    KAutoObject::IncrementRefcount(current.clc.current.process);
  }
  else if ( handle == CUR_THREAD_HANDLE )
  {
    process = current.clc.current.thread;
    KAutoObject::IncrementRefcount(current.clc.current.thread);
  }
  else
  {
    process = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, handle);
  }
  if ( !process )
    return 0xD8E007F7;
  process->GetTypeObj(&v7, process);
  v6 = KHandleTable::Add(p_handleTable, outHandle, process, v7.typeId);
  process->DecrementRefcount(process);
  return v6;
}

//----- (FFF09720) --------------------------------------------------------
Result __fastcall ReplyAndReceive(s32 *outIdx, Handle *handles, s32 numHandles, Handle replyTargetHandle)
{
  Result result; // r0
  ReplyAndReceiveArgs v6; // [sp+0h] [bp-20h] BYREF

  *outIdx = 0;
  if ( !handles )
    return 0xD8E007F6;
  if ( (unsigned int)numHandles <= 0x1FFFFFFF )
    result = 0;
  else
    result = 0xE0E01BFD;
  if ( result >= 0 )
  {
    v6.handles = handles;
    v6.numHandles = numHandles;
    v6.replyTargetHandle = replyTargetHandle;
    v6.res = 0xE7E3FFFF;
    v6.outIdx = outIdx;
    if ( CallFuncWithStackAlloc((FuncWithStackAlloc)ReplyAndReceiveImpl, &v6, 4 * numHandles) )
      return v6.res;
    else
      return 0xD86007F3;
  }
  return result;
}

//----- (FFF0979C) --------------------------------------------------------
Result __fastcall ArbitrateAddress(Handle arbiterHandle, u32 address, ArbitrationType type, s32 value, s64 timeout)
{
  Result result; // r0
  KAutoObject *v8; // r0
  KAutoObject *v9; // r4
  u8 typeId; // r11
  int v11; // r1
  KAddressArbiter *v12; // r10
  Result v13; // r5
  signed int v14; // r5
  signed int v15; // r5
  signed int v16; // r5
  signed int v17; // r5
  KTypeObj v18; // [sp+0h] [bp-48h] BYREF
  KTypeObj v19; // [sp+8h] [bp-40h] BYREF

  if ( (address & 3) != 0 )
    return 0xD8E007F1;
  v8 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, arbiterHandle);
  v9 = v8;
  if ( !v8 )
    return 0xD8E007F7;
  v8->GetTypeObj(&v18, v8);
  typeId = v18.typeId;
  v9->GetTypeObj(&v19, v9);
  v11 = typeId | 0x98;
  v12 = v11 == v19.typeId ? (KAddressArbiter *)v9 : 0;
  if ( v11 != v19.typeId )
    v9->DecrementRefcount(v9);
  if ( !v12 )
    return 0xD8E007F7;
  switch ( type )
  {
    case ARBITRATION_SIGNAL:
      v13 = KAddressArbiter::Signal(v12, address, value);
      v12->DecrementRefcount(v12);
      result = v13;
      break;
    case ARBITRATION_WAIT_IF_LESS_THAN:
      v14 = KAddressArbiter::WaitIfLessThan(v12, current.clc.current.thread, address, value, 0);
      v12->DecrementRefcount(v12);
      result = v14;
      break;
    case ARBITRATION_DECREMENT_AND_WAIT_IF_LESS_THAN:
      v15 = KAddressArbiter::WaitIfLessThan(v12, current.clc.current.thread, address, value, 1);
      v12->DecrementRefcount(v12);
      result = v15;
      break;
    case ARBITRATION_WAIT_IF_LESS_THAN_TIMEOUT:
      v16 = KAddressArbiter::WaitIfLessThanWithTimeout(v12, current.clc.current.thread, address, value, 0, timeout);
      v12->DecrementRefcount(v12);
      result = v16;
      break;
    case ARBITRATION_DECREMENT_AND_WAIT_IF_LESS_THAN_TIMEOUT:
      v17 = KAddressArbiter::WaitIfLessThanWithTimeout(v12, current.clc.current.thread, address, value, 1, timeout);
      v12->DecrementRefcount(v12);
      result = v17;
      break;
    default:
      v12->DecrementRefcount(v12);
      result = 0xD8E093ED;
      break;
  }
  return result;
}
// FFF09864: control flows out of bounds to FFF09868

//----- (FFF099C4) --------------------------------------------------------
Result __fastcall GetResourceLimit(Handle *outReslimit, Handle processHandle)
{
  KProcess *v3; // r7
  KHandleTable *p_handleTable; // r5
  KProcess *process; // r4
  KAutoObject *v6; // r0
  KProcess *v7; // r4
  u8 typeId; // r9
  KResourceLimit *reslimit; // r7
  Result v10; // r5
  KTypeObj v12; // [sp+0h] [bp-30h] BYREF
  KTypeObj v13; // [sp+8h] [bp-28h] BYREF

  *outReslimit = 0;
  v3 = 0;
  p_handleTable = &current.clc.current.process->handleTable;
  if ( processHandle == CUR_PROCESS_HANDLE )
  {
    process = current.clc.current.process;
    KAutoObject::IncrementRefcount(current.clc.current.process);
  }
  else
  {
    v6 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, processHandle);
    v7 = (KProcess *)v6;
    if ( !v6 )
      return 0xD9001BF7;
    v6->GetTypeObj(&v12, v6);
    typeId = v12.typeId;
    v7->GetTypeObj(&v13, v7);
    if ( (typeId | 0xC5) == v13.typeId )
      v3 = v7;
    else
      v7->DecrementRefcount(v7);
    process = v3;
  }
  if ( !process )
    return 0xD9001BF7;
  reslimit = process->reslimit;
  if ( reslimit )
  {
    reslimit->GetTypeObj(&v12, process->reslimit);// possible uaf here
    v10 = KHandleTable::Add(p_handleTable, outReslimit, reslimit, v12.typeId);
    process->DecrementRefcount(process);
    return v10;
  }
  else
  {
    process->DecrementRefcount(process);
    return 0xD8A093F8;
  }
}

//----- (FFF09B24) --------------------------------------------------------
Result __fastcall ReleaseSemaphore(s32 *outCount, Handle semaphoreHandle, s32 releaseCount)
{
  KSemaphore *v3; // r7
  Result result; // r0
  KAutoObject *v7; // r0
  KSemaphore *v8; // r4
  u8 typeId; // r9
  Result v10; // r5
  KTypeObj v11; // [sp+0h] [bp-30h] BYREF
  KTypeObj v12; // [sp+8h] [bp-28h] BYREF

  v3 = 0;
  *outCount = 0;
  if ( (unsigned int)releaseCount <= 0x7FFFFFFF )
    result = 0;
  else
    result = 0xE0E01BFD;
  if ( result >= 0 )
  {
    v7 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, semaphoreHandle);
    v8 = (KSemaphore *)v7;
    if ( !v7 )
      return 0xD8E007F7;
    v7->GetTypeObj(&v11, v7);
    typeId = v11.typeId;
    v8->GetTypeObj(&v12, v8);
    if ( (typeId | 0x2F) == v12.typeId )
      v3 = v8;
    else
      v8->DecrementRefcount(v8);
    if ( v3 )
    {
      v10 = KSemaphore::Release(v3, outCount, releaseCount);
      v3->DecrementRefcount(v3);
      return v10;
    }
    else
    {
      return 0xD8E007F7;
    }
  }
  return result;
}

//----- (FFF09C1C) --------------------------------------------------------
Result __fastcall ReplyAndReceive1(s32 *outIdx, Handle *handles, s32 numHandles, Handle replyTargetHandle)
{
  *outIdx = 0;
  return -121632780;
}

//----- (FFF09C30) --------------------------------------------------------
Result __fastcall ReplyAndReceive2(s32 *outIdx, Handle *handles, s32 numHandles, Handle replyTargetHandle)
{
  *outIdx = 0;
  return -121632780;
}

//----- (FFF09C44) --------------------------------------------------------
Result __fastcall ReplyAndReceive3(s32 *outIdx, Handle *handles, s32 numHandles, Handle replyTargetHandle)
{
  *outIdx = 0;
  return -121632780;
}

//----- (FFF09C58) --------------------------------------------------------
Result __fastcall ReplyAndReceive4(s32 *outIdx, Handle *handles, s32 numHandles, Handle replyTargetHandle)
{
  *outIdx = 0;
  return -121632780;
}

//----- (FFF09C6C) --------------------------------------------------------
Result __fastcall CreateMemoryBlock(Handle *outSharedMemHandle, u32 addr, u32 size, u32 ownerPerms, u32 othersPerms)
{
  Result result; // r0
  bool v9; // zf
  Result v10; // r1
  bool v11; // zf
  bool v12; // zf
  KProcess *volatile process; // r10
  bool v14; // cf
  u32 v15; // r0
  KResourceLimit *reslimit; // r5
  bool v17; // r11
  KSharedMemory *v18; // r0
  KSharedMemory *v19; // r4
  Result v20; // r0
  Result v21; // r7
  bool v22; // zf
  bool v23; // zf
  bool v24; // zf
  Result v25; // r0
  Result v26; // r5
  KTypeObj v27; // [sp+0h] [bp-40h] BYREF

  *outSharedMemHandle = 0;
  result = size << 20;
  if ( size << 20 )                             // check alignment
    result = 0xE0E01BF2;
  if ( result < 0 )
    return result;
  result = 0xE0E01BEE;
  if ( !ownerPerms )
    goto LABEL_10;
  v9 = ownerPerms == KMEMPERM_R;
  if ( ownerPerms != KMEMPERM_R )
    v9 = ownerPerms == KMEMPERM_W;
  if ( v9 || ownerPerms == KMEMPERM_RW )
LABEL_10:
    v10 = 0;
  else
    v10 = 0xE0E01BEE;
  if ( v10 < 0 )
    return v10;
  v11 = othersPerms == KMEMPERM_NONE;
  if ( othersPerms )
    v11 = othersPerms == KMEMPERM_R;
  if ( v11 )
    goto LABEL_20;
  v12 = othersPerms == KMEMPERM_W;
  if ( othersPerms != KMEMPERM_W )
    v12 = othersPerms == KMEMPERM_RW;
  if ( v12 )
LABEL_20:
    result = 0;
  if ( result < 0 )
    return result;
  process = current.clc.current.process;
  if ( addr )
  {
    if ( size )                                 // data + mappable range check
                                                // no alignment check on addr?
    {
      v14 = addr >= 0x100000;
      v15 = addr + size - 1;
      if ( addr >= 0x100000 )
        v14 = v15 >= addr;
      if ( v14 && v15 < 0x14000000 )
        goto LABEL_33;
    }
    else if ( addr >= 0x100000 && addr < 0x14000000 )
    {
LABEL_33:
      result = 0;
      goto LABEL_37;
    }
    result = 0xE0E01BF5;
LABEL_37:
    if ( result < 0 )
      return result;
    goto LABEL_38;
  }
  if ( (current.clc.current.process->capability.kernelFlags & 0xF00) == MEMOP_REGION_APPLICATION )
    return 0xD92007EA;                          // addr=0 (alloc new linear block) not allowed for applications
                                                // 
                                                // applications can only create transfermem
LABEL_38:
  if ( size << 20 )
  {
    *outSharedMemHandle = 0;
    return 0xD8E007F2;
  }
  reslimit = current.clc.current.process->reslimit;
  if ( reslimit )
    v17 = KResourceLimit::Reserve(current.clc.current.process->reslimit, RESLIMIT_SHAREDMEMORY, 1);
  else
    v17 = 1;
  if ( !v17 )
    return 0xC860180B;
  v18 = (KSharedMemory *)KSlabHeap::Allocate(&g_sharedMemoryAllocator.slabHeap);
  v19 = v18;
  if ( v18 )
  {
    KSharedMemory::KSharedMemory(v18);
    KAutoObject::Initialize(v19);
  }
  if ( v19 )
  {
    v20 = KSharedMemory::Initialize(v19, process, addr, size, ownerPerms, othersPerms);
    if ( v20 < 0 )
    {
      if ( v20 << 22 == 0xFCC00000 )            // out of mem
      {
        v21 = 0xD86093F3;
        v19->DecrementRefcount(v19);
        v22 = reslimit == 0;
        if ( reslimit )
          v22 = !v17;
        if ( v22 )
          return v21;
      }
      else
      {
        v21 = v20;
        v19->DecrementRefcount(v19);
        v24 = reslimit == 0;
        if ( reslimit )
          v24 = !v17;
        if ( v24 )
          return v21;
      }
      KResourceLimit::Release(reslimit, RESLIMIT_SHAREDMEMORY, 1);
      return v21;
    }
    v25 = KObjectAllocator::Register(&g_sharedMemoryAllocator, v19);
    if ( v25 >= 0 )
    {
      v19->GetTypeObj(&v27, v19);
      v25 = KHandleTable::Add(&process->handleTable, outSharedMemHandle, v19, v27.typeId);
    }
    v26 = v25;
    v19->DecrementRefcount(v19);
    return v26;
  }
  else
  {
    v23 = reslimit == 0;
    if ( reslimit )
      v23 = !v17;
    if ( !v23 )
      KResourceLimit::Release(reslimit, RESLIMIT_SHAREDMEMORY, 1);
    return 0xC8601802;
  }
}
// FFF09DF8: conditional instruction was optimized away because r0.4!=0
// FFF09F54: conditional instruction was optimized away because zf.1==1

//----- (FFF09FA4) --------------------------------------------------------
Result __fastcall GetThreadPriority(s32 *outPriority, Handle threadHandle)
{
  KThread *v3; // r0

  *outPriority = 0;
  v3 = KHandleTable::ConvertToThreadAllowPseudoHandle(&current.clc.current.process->handleTable, threadHandle);
  if ( !v3 )
    return 0xD9001BF7;
  *outPriority = v3->dynamicPriority;
  v3->DecrementRefcount(v3);
  return 0;
}

//----- (FFF09FF8) --------------------------------------------------------
Result __fastcall DebugActiveProcess(Handle *outHandle, u32 pid)
{
  KProcess *reused_var; // r0
  bool v4; // zf
  KProcess *v5; // r4
  KHandleTable *p_handleTable; // r8
  KDebug *v7; // r0
  KDebug *debug; // r5
  KDebug *v9; // r0
  int v10; // r6
  KTypeObj v11; // [sp+0h] [bp-20h] BYREF

  *outHandle = 0;
  if ( !g_systemControl.targetSystem.isDevUnit )
    return 0xF8C007F4;
  reused_var = KProcess::OpenById(pid);
  v5 = reused_var;
  v4 = reused_var == 0;
  if ( !reused_var )
    reused_var = (KProcess *)0xD9002003;
  if ( !v4 )
  {
    if ( (v5->capability.kernelFlags & 1) != 0 || (current.clc.current.process->capability.kernelFlags & 2) != 0 )
    {
      if ( v5->debug )
      {
        reused_var->DecrementRefcount(reused_var);
        return 0xD9002006;
      }
      else if ( KProcess::IsTerminated(v5) )
      {
        v5->DecrementRefcount(v5);
        return 0xD8A02008;
      }
      else
      {
        p_handleTable = &current.clc.current.process->handleTable;
        v7 = (KDebug *)KSlabHeap::Allocate(&g_debugAllocator.slabHeap);
        debug = v7;
        if ( v7 )
        {
          v9 = (KDebug *)KSynchronizationObject::KSynchronizationObject(v7);
          v9->KSynchronizationObject::KAutoObject::__vftable = &KDebug::vt;
          v9->KWorkerTask::__vftable = &KDebug::vt_KWorkerTask;
          v9->next = 0;
          v9->eventsToFetch.link.next = (KEventInfoLinkedListNode *)&v9->eventsToFetch.link;
          v9->eventsToFetch.count = 0;
          v9->eventsToFetch.link.prev = (KEventInfoLinkedListNode *)&v9->eventsToFetch.link;
          v9->eventsToContinue.link.next = (KEventInfoLinkedListNode *)&v9->eventsToContinue.link;
          v9->eventsToContinue.count = 0;
          v9->eventsToContinue.link.prev = (KEventInfoLinkedListNode *)&v9->eventsToContinue.link;
          v9->debugThreads.count = 0;
          v9->debugThreads.link.next = 0;
          v9->debugThreads.link.next = (KDebugThreadLinkedListNode *)&v9->debugThreads.link;
          v9->debugThreads.link.prev = 0;
          v9->debugThreads.link.prev = (KDebugThreadLinkedListNode *)&v9->debugThreads.link;
          v9->orderedThreadListForBreak.link.next = (KThreadLinkedListNode *)&v9->orderedThreadListForBreak.link;
          v9->orderedThreadListForBreak.count = 0;
          v9->orderedThreadListForBreak.link.prev = (KThreadLinkedListNode *)&v9->orderedThreadListForBreak.link;
          v9->lock.lockingThread = 0;
          v9->lock.lockCount = 0;
          KAutoObject::Initialize(debug);
        }
        if ( debug )
        {
          KDebug::Intialize(debug, v5);
          v10 = KObjectAllocator::Register(&g_debugAllocator, debug);
          if ( v10 >= 0 )
          {
            KDebug::Attach(debug, v5);
            debug->GetTypeObj(&v11, debug);
            v10 = KHandleTable::Add(p_handleTable, outHandle, debug, v11.typeId);
          }
          debug->DecrementRefcount(debug);
          v5->DecrementRefcount(v5);
          return v10;
        }
        else
        {
          v5->DecrementRefcount(v5);
          return 0xD86007F3;
        }
      }
    }
    else
    {
      reused_var->DecrementRefcount(reused_var);
      return 0xD9002005;
    }
  }
  return (Result)reused_var;
}
// FFF0A104: conditional instruction was optimized away because r0.4!=0

//----- (FFF0A25C) --------------------------------------------------------
Result __fastcall QueryProcessMemory(MemoryInfo *outMemInfo, u32 *outPgInfo, Handle processHandle, u32 addr)
{
  KProcess *v4; // r5
  Result result; // r0
  KProcess *volatile process; // r4
  KAutoObject *v10; // r0
  KAutoObject *v11; // r4
  u8 typeId; // r10
  int v13; // r5
  u32 size; // r0
  char perms; // r2
  unsigned __int8 state; // r3
  KMemoryInfo v17; // [sp+0h] [bp-40h] BYREF
  KTypeObj v18; // [sp+10h] [bp-30h] BYREF
  KTypeObj v19; // [sp+18h] [bp-28h] BYREF

  v4 = 0;
  memset(&v17, 0, sizeof(v17));
  outMemInfo->baseAddress = 0;
  outMemInfo->size = 0;
  outMemInfo->perms = 0;
  outMemInfo->state = 0;
  if ( addr < 0x40000000 )
    result = 0;
  else
    result = 0xE0E01BF5;
  *outPgInfo = 0;
  if ( result < 0 )
    return result;
  if ( processHandle == CUR_PROCESS_HANDLE )
  {
    process = current.clc.current.process;
    KAutoObject::IncrementRefcount(current.clc.current.process);
  }
  else
  {
    v10 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, processHandle);
    v11 = v10;
    if ( !v10 )
      return 0xD9001BF7;
    v10->GetTypeObj(&v18, v10);
    typeId = v18.typeId;
    v11->GetTypeObj(&v19, v11);
    if ( (typeId | 0xC5) == v19.typeId )
      v4 = (KProcess *)v11;
    else
      v11->DecrementRefcount(v11);
    process = v4;
  }
  if ( !process )
    return 0xD9001BF7;
  v13 = KPageTable::QueryInfo(&process->pgTable, &v17, outPgInfo, addr);
  if ( v13 >= 0 )
  {
    size = v17.size;
    perms = v17.perms;
    state = v17.state;
    outMemInfo->baseAddress = v17.baseAddress;
    outMemInfo->size = size;
    outMemInfo->perms = perms & 3;
    outMemInfo->state = state;
    v13 = 0;
    outMemInfo->perms = v17.perms & 7;
  }
  process->DecrementRefcount(process);
  return v13;
}

//----- (FFF0A3E8) --------------------------------------------------------
Result __fastcall CreateResourceLimit(Handle *outReslimitHandle)
{
  KHandleTable *p_handleTable; // r6
  KResourceLimit *v3; // r0
  KResourceLimit *v4; // r4
  KResourceLimit *v5; // r0
  int v7; // r7
  KTypeObj v8; // [sp+0h] [bp-20h] BYREF

  *outReslimitHandle = 0;
  p_handleTable = &current.clc.current.process->handleTable;
  v3 = (KResourceLimit *)KSlabHeap::Allocate(&g_resourceLimitAllocator.slabHeap);
  v4 = v3;
  if ( v3 )
  {
    v5 = (KResourceLimit *)KAutoObject::KAutoObject(v3);
    v5->__vftable = &KResourceLimit::vt;
    v5->mutex.lockingThread = 0;
    v5->mutex.numWaiters = 0;
    v5->mutex.ticketCount = 0;
    v5->timeLimit.category = KCPUTIMELIMIT_CATEGORY_APPLICATION;
    v5->timeLimit.currentWdTicksElapsed = 0;
    v5->timeLimit.previousWdCounterValue = 0;
    v5->timeLimit.limitTick = 0;
    KAutoObject::Initialize(v4);
  }
  if ( !v4 )
    return 0xC8601801;
  KResourceLimit::Initialize(v4);
  v7 = KObjectAllocator::Register(&g_resourceLimitAllocator, v4);
  if ( v7 >= 0 )
  {
    v4->GetTypeObj(&v8, v4);
    v7 = KHandleTable::Add(p_handleTable, outReslimitHandle, v4, v8.typeId);
  }
  v4->DecrementRefcount(v4);
  return v7;
}
// FFF0A42C: conditional instruction was optimized away because r0.4!=0

//----- (FFF0A4F8) --------------------------------------------------------
Result __fastcall CreateSessionToPort(Handle *outClientSessionHandle, Handle clientPortHandle)
{
  KHandleTable *p_handleTable; // r5
  KAutoObject *v4; // r0
  KAutoObject *v5; // r4
  u8 typeId; // r9
  int v7; // r1
  KClientPort *clientPort; // r7
  KClientPort *v9; // r4
  Result result; // r0
  KClientSession *v11; // r7
  Result v12; // r5
  KClientSession *clientSession; // [sp+0h] [bp-38h] BYREF
  KTypeObj v14; // [sp+8h] [bp-30h] BYREF
  KTypeObj v15; // [sp+10h] [bp-28h] BYREF

  *outClientSessionHandle = 0;
  p_handleTable = &current.clc.current.process->handleTable;
  v4 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, clientPortHandle);
  v5 = v4;
  if ( !v4 )
    return 0xD8E007F7;
  v4->GetTypeObj(&v14, v4);
  typeId = v14.typeId;
  v5->GetTypeObj(&v15, v5);
  v7 = typeId | 0x65;
  clientPort = v7 == v15.typeId ? (KClientPort *)v5 : 0;
  if ( v7 != v15.typeId )
    v5->DecrementRefcount(v5);
  v9 = clientPort;
  if ( !clientPort )
    return 0xD8E007F7;
  result = KClientPort::CreateSession(clientPort, &clientSession);
  if ( result >= 0 )
  {
    v11 = clientSession;
    clientSession->GetTypeObj(&v14, clientSession);
    v12 = KHandleTable::Add(p_handleTable, outClientSessionHandle, v11, v14.typeId);
    clientSession->DecrementRefcount(clientSession);
    v9->DecrementRefcount(v9);
    return v12;
  }
  return result;
}

//----- (FFF0A630) --------------------------------------------------------
Result __fastcall GetDebugThreadParam(s64 *out1, s32 *out2, Handle debugHandle, u32 tid, DebugThreadParameter param)
{
  KDebug *v7; // r0
  KDebug *v9; // r4
  KProcess *process; // r8
  KThread *v11; // r0
  Result v12; // r5
  int var; // r1

  *out1 = 0LL;
  *out2 = 0;
  v7 = KHandleTable::ConvertCurProcHandleToDebug(debugHandle);
  if ( !v7 )
    return 0xD9002002;
  v9 = v7;
  process = v7->process;
  v11 = KThread::FindById(tid);
  v12 = -654303228;
  if ( v11 )
  {
    var = (int)v11->owner;
    if ( (KProcess *)var == process )
    {
      if ( param )
      {
        if ( param == DBGTHREAD_PARAMETER_SCHEDULING_MASK_LOW )
        {
          var = v11->schedulingMask & 0xF;
        }
        else if ( param == DBGTHREAD_PARAMETER_CPU_IDEAL )
        {
          var = v11->idealProcessor;
        }
        else
        {
          if ( param == DBGTHREAD_PARAMETER_CPU_CREATOR )
            var = v11->coreId;
          else
            v12 = 0xF8C007F4;
          if ( param != DBGTHREAD_PARAMETER_CPU_CREATOR )
            goto LABEL_5;
        }
      }
      else
      {
        var = v11->basePriority;
      }
      v12 = 0;
      *out2 = var;
    }
LABEL_5:
    v11->DecrementRefcount(v11);
  }
  v9->DecrementRefcount(v9);
  return v12;
}

//----- (FFF0A700) --------------------------------------------------------
Result __fastcall CreateAddressArbiter(Handle *outArbiterHandle)
{
  KProcess *process; // r10
  KHandleTable *p_handleTable; // r11
  KResourceLimit *reslimit; // r7
  bool v5; // r8
  KAddressArbiter *v7; // r0
  KAddressArbiter *v8; // r4
  KAddressArbiter *v9; // r0
  int v10; // r7
  bool v11; // zf
  KTypeObj v12; // [sp+0h] [bp-30h] BYREF

  *outArbiterHandle = 0;
  process = current.clc.current.process;
  p_handleTable = &current.clc.current.process->handleTable;
  reslimit = current.clc.current.process->reslimit;
  if ( reslimit )
    v5 = KResourceLimit::Reserve(current.clc.current.process->reslimit, RESLIMIT_ADDRESSARBITER, 1);
  else
    v5 = 1;
  if ( !v5 )
    return 0xC8601833;
  v7 = (KAddressArbiter *)KSlabHeap::Allocate(&g_addressArbiterAllocator.slabHeap);
  v8 = v7;
  if ( v7 )
  {
    v9 = (KAddressArbiter *)KAutoObject::KAutoObject(v7);
    v9->__vftable = &KAddressArbiter::vt;
    v9->waitList.link.prev = 0;
    v9->waitList.link.next = 0;
    KAutoObject::Initialize(v8);
  }
  if ( v8 )
  {
    KAddressArbiter::Initialize(v8, process);
    v10 = KObjectAllocator::Register(&g_addressArbiterAllocator, v8);
    if ( v10 >= 0 )
    {
      v8->GetTypeObj(&v12, v8);
      v10 = KHandleTable::Add(p_handleTable, outArbiterHandle, v8, v12.typeId);
    }
    v8->DecrementRefcount(v8);
    return v10;
  }
  else
  {
    v11 = reslimit == 0;
    if ( reslimit )
      v11 = !v5;
    if ( !v11 )
      KResourceLimit::Release(reslimit, RESLIMIT_ADDRESSARBITER, 1);
    return 0xC8601801;
  }
}
// FFF0A790: conditional instruction was optimized away because r0.4!=0
// FFF0A828: conditional instruction was optimized away because zf.1==1

//----- (FFF0A894) --------------------------------------------------------
Result __fastcall GetProcessIdOfThread(u32 *outPid, Handle threadHandle)
{
  KThread *v3; // r0
  KThread *v5; // r4

  *outPid = 0;
  v3 = KHandleTable::ConvertToThreadAllowPseudoHandle(&current.clc.current.process->handleTable, threadHandle);
  if ( !v3 )
    return 0xD9001BF7;
  v5 = v3;
  *outPid = KThread::GetProcessId(v3);
  v5->DecrementRefcount(v5);
  return 0;
}

//----- (FFF0A8F0) --------------------------------------------------------
Result __fastcall WaitSynchronizationN(s32 *outIdx, Handle *handles, s32 numHandles, bool waitAll, s64 timeout)
{
  Result result; // r0
  WaitSynchronizationNArgs v7; // [sp+0h] [bp-30h] BYREF

  *outIdx = 0;
  if ( !handles )
    return 0xD8E007F6;
  if ( (unsigned int)numHandles <= 0x1FFFFFFF )
    result = 0;
  else
    result = 0xE0E01BFD;
  if ( result >= 0 )
  {
    if ( timeout >= 0 || timeout == -1 )
    {
      v7.handles = handles;
      v7.res = 0xE7E3FFFF;
      v7.numHandles = numHandles;
      v7.outIdx = outIdx;
      v7.waitAll = waitAll;
      v7.timeout = timeout;
      if ( CallFuncWithStackAlloc((FuncWithStackAlloc)WaitSynchronizationNImpl, &v7, 4 * numHandles) )
        return v7.res;
      else
        return 0xD86007F3;
    }
    else
    {
      return 0xD8E007FD;
    }
  }
  return result;
}

//----- (FFF0A9A8) --------------------------------------------------------
Result __fastcall GetThreadIdealProcessor(s32 *outIdealProcessor, Handle threadHandle)
{
  KThread *v3; // r0

  *outIdealProcessor = 0;
  v3 = KHandleTable::ConvertToThreadAllowPseudoHandle(&current.clc.current.process->handleTable, threadHandle);
  if ( !v3 )
    return 0xD9001BF7;
  *outIdealProcessor = v3->idealProcessor;
  v3->DecrementRefcount(v3);
  return 0;
}

//----- (FFF0A9F8) --------------------------------------------------------
Result __fastcall QueryDebugProcessMemory(MemoryInfo *outMemInfo, u32 *outPgInfo, Handle debugHandle, u32 addr)
{
  KDebug *v7; // r0
  KDebug *v8; // r4
  Result result; // r0
  int res; // r5

  outMemInfo->baseAddress = 0;
  outMemInfo->size = 0;
  outMemInfo->perms = 0;
  outMemInfo->state = 0;
  *outPgInfo = 0;
  v7 = KHandleTable::ConvertCurProcHandleToDebug(debugHandle);
  v8 = v7;
  if ( !v7 )
    return 0xD9002002;
  if ( KDebug::IsProcessTerminated(v7) )
  {
    v8->DecrementRefcount(v8);
    return 0xD8A02008;
  }
  else
  {
    res = KDebug::QueryProcessMemory(v8, outMemInfo, outPgInfo, addr);
    v8->DecrementRefcount(v8);
    result = res;
    if ( res < 0 && (res & 0x3FF) == 0x3F5 )
      return 0xE0E0200A;
  }
  return result;
}

//----- (FFF0AAB0) --------------------------------------------------------
Result __fastcall ControlProcessMemory(Handle processHandle, u32 addr0, u32 addr1, u32 size, u32 op, u32 perms)
{
  Result result; // r0
  bool v11; // zf
  Result v12; // r1
  KAutoObject *v13; // r0
  KAutoObject *v14; // r11
  int v15; // r1
  KProcess *proc; // r4
  KProcessPageTable *pgTable; // r0
  u32 v18; // r2
  u32 addr; // r1
  Result Alias; // r0
  Result v21; // r5
  KMemoryState expectedStateSrc; // [sp+0h] [bp-40h] BYREF
  KMemoryPermission minPerms; // [sp+4h] [bp-3Ch]
  KMemoryState stateDst; // [sp+8h] [bp-38h] BYREF
  KMemoryState newPerms; // [sp+Ch] [bp-34h]
  KMemoryState newStateDst; // [sp+10h] [bp-30h]
  KMemoryUpdateFlags v27; // [sp+18h] [bp-28h]

  result = 0xD8E007F6;
  if ( addr0 )
  {
    v11 = op == MEMOP_MAP;
    if ( op != MEMOP_MAP )
      v11 = op == MEMOP_UNMAP;
    if ( !v11 || addr1 )
    {
      result = 0xE0E01BF1;                      // check if addrs are aligned and non-null
      v12 = addr0 << 20;
      if ( addr0 << 20 )
        v12 = 0xE0E01BF1;
      if ( v12 < 0 )
        return v12;
      if ( !(addr1 << 20) )
        result = 0;
      if ( result >= 0 )
      {
        result = size << 20;
        if ( size << 20 )
          result = 0xE0E01BF2;
        if ( result >= 0 )
        {
          v13 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, processHandle);
          v14 = v13;
          if ( !v13 )
            return 0xD9001BF7;
          v13->GetTypeObj((KTypeObj *)&stateDst, v13);
          newStateDst = newPerms;
          v14->GetTypeObj((KTypeObj *)&expectedStateSrc, v14);
          v15 = (unsigned __int8)newStateDst | 0xC5;
          proc = v15 == (unsigned __int8)minPerms ? (KProcess *)v14 : 0;
          if ( v15 != (unsigned __int8)minPerms )
            v14->DecrementRefcount(v14);
          if ( !proc )
            return 0xD9001BF7;
          pgTable = &proc->pgTable;
          v18 = size >> 12;
          switch ( op )
          {
            case MEMOP_MAP:
              if ( addr0 != addr1 )
              {
                Alias = KPageTable::CreateAlias(
                          pgTable,
                          addr1,
                          addr0,
                          size >> 12,
                          KMEMSTATE_PRIVATE_DATA,
                          KMEMPERM_RW,
                          KMEMSTATE_LOCKED,
                          KMEMPERM_NONE,
                          KMEMSTATE_ALIAS_CODE,
                          (KMemoryPermission)(perms | KMEMPERM_KRW));
                goto LABEL_37;
              }
              newPerms = perms | KMEMPERM_KRW;
              expectedStateSrc = KMEMSTATE_PRIVATE_DATA;
              minPerms = KMEMPERM_RW;
              stateDst = KMEMSTATE_PRIVATE_ALIAS_CODE;
              addr = addr1;
              break;
            case MEMOP_UNMAP:
              if ( addr0 != addr1 )
              {
                Alias = KPageTable::DestroyAlias(
                          pgTable,
                          addr1,
                          addr0,
                          size >> 12,
                          KMEMSTATE_LOCKED,
                          KMEMPERM_NONE,
                          KMEMSTATE_ALIAS_CODE,
                          KMEMPERM_NONE,
                          KMEMSTATE_PRIVATE_DATA,
                          (KMemoryPermission)(perms | KMEMPERM_KRW),
                          v27);
                goto LABEL_37;
              }
              minPerms = KMEMPERM_NONE;
              expectedStateSrc = KMEMSTATE_PRIVATE_ALIAS_CODE;
              stateDst = KMEMSTATE_PRIVATE_DATA;
              newPerms = perms | KMEMPERM_KRW;
              addr = addr0;
              break;
            case MEMOP_PROT:
              Alias = KPageTable::Operate(
                        pgTable,
                        addr0,
                        v18,
                        0,
                        MEMSTATE_FREE,
                        (KMemoryPermission)(perms | KMEMPERM_KRW),
                        KMEMUPDATE_PERMS,
                        0x300u);
LABEL_37:
              v21 = Alias;
              proc->DecrementRefcount(proc);
              return v21;
            default:
              proc->DecrementRefcount(proc);
              return 0xF8C007F4;
          }
          Alias = KPageTable::CheckAndUpdateAddrRangeMaskedStateAndPerms(
                    pgTable,
                    addr,
                    v18,
                    KMEMSTATE_FLAGS_ANY,
                    expectedStateSrc,
                    minPerms,
                    stateDst,
                    (KMemoryPermission)newPerms);// map/unmap: change permissions and state
          goto LABEL_37;
        }
      }
    }
  }
  return result;
}

//----- (FFF0AD40) --------------------------------------------------------
Result __fastcall GetProcessIdealProcessor(s32 *outIdealProcessor, Handle processHandle)
{
  KProcess *v3; // r0

  *outIdealProcessor = 0;
  v3 = KHandleTable::ConvertToProcessAllowPseudoHandle(&current.clc.current.process->handleTable, processHandle);
  if ( !v3 )
    return 0xD9001BF7;
  *outIdealProcessor = v3->idealProcessor;
  v3->DecrementRefcount(v3);
  return 0;
}

//----- (FFF0AD90) --------------------------------------------------------
Result __fastcall ControlPerformanceCounter(s64 *out, PerformanceCounterOperation op, u32 param1, u64 param2)
{
  unsigned int pid; // r4
  Result result; // r0
  unsigned int v7; // r1
  KProcess *proc; // r0
  u32 v9; // r1
  unsigned int v10; // r3
  s64 CounterValue; // r0

  *out = 0LL;
  pid = current.clc.current.process->pid;
  if ( op == PERFCOUNTEROP_ENABLE )
  {
LABEL_5:
    while ( 1 )
    {
      v7 = __ldrex(&g_perfCounterMgrExclusivePid);
      if ( v7 != -1 )
        break;
      if ( !__strex(pid, &g_perfCounterMgrExclusivePid) )
      {
LABEL_9:
        if ( v7 == -1 )
        {
          KPerformanceCounterManager::Enable(&g_perfCounterMgr);
          return 0;
        }
        proc = KProcess::OpenById(g_perfCounterMgrExclusivePid);
        if ( proc )
        {
          proc->DecrementRefcount(proc);
          return 0xC8401FF0;
        }
        v9 = g_perfCounterMgrExclusivePid;
        while ( 1 )
        {
          v10 = __ldrex(&g_perfCounterMgrExclusivePid);
          if ( v10 != v9 )
            break;
          if ( !__strex(0xFFFFFFFF, &g_perfCounterMgrExclusivePid) )
            goto LABEL_5;
        }
        __clrex();
      }
    }
    __clrex();
    goto LABEL_9;
  }
  if ( g_perfCounterMgrExclusivePid != pid )
    return 0xD8A01FEA;
  switch ( op )
  {
    case PERFCOUNTEROP_DISABLE:
      KPerformanceCounterManager::Disable();
      do
        __ldrex(&g_perfCounterMgrExclusivePid);
      while ( __strex(-1u, &g_perfCounterMgrExclusivePid) );
      goto LABEL_29;
    case PERFCOUNTEROP_GET_VALUE:
      CounterValue = KPerformanceCounterManager::GetCounterValue(&g_perfCounterMgr, (PerformanceCounterName)param1);
      goto LABEL_24;
    case PERFCOUNTEROP_SET_VALUE:
      KPerformanceCounterManager::SetCounterValue(&g_perfCounterMgr, (PerformanceCounterName)param1, param2);
      goto LABEL_29;
    case PERFCOUNTEROP_GET_OVERFLOW_FLAGS:
      CounterValue = KPerformanceCounterManager::GetOverflowFlags();
LABEL_24:
      *out = CounterValue;
      goto LABEL_29;
    case PERFCOUNTEROP_RESET:
      KPerformanceCounterManager::ResetCounters(&g_perfCounterMgr, param1, param2);
      goto LABEL_29;
    case PERFCOUNTEROP_GET_EVENT:
      *out = (unsigned int)KPerformanceCounterManager::GetEvent(&g_perfCounterMgr, (PerformanceCounterName)param1);
      goto LABEL_29;
    case PERFCOUNTEROP_SET_EVENT:
      KPerformanceCounterManager::SetEvent(
        &g_perfCounterMgr,
        (PerformanceCounterName)param1,
        (PerformanceCounterEvent)param2);
      goto LABEL_29;
    case PERFCOUNTEROP_SET_VIRTUAL_COUNTER_ENABLED:
      KPerformanceCounterManager::SetVirtualCounterEnabled(&g_perfCounterMgr, param1 != 0);
LABEL_29:
      result = 0;
      break;
    default:
      result = 0xF8C007F4;
      break;
  }
  return result;
}
// FFF0ADE0: control flows out of bounds to FFF0ADE4

//----- (FFF0AF94) --------------------------------------------------------
Result __fastcall KCacheOperator::OperateOnProcessCache(KCacheOperator *this, Handle processHandle, u32 addr, u32 size)
{
  KCacheOperator *v5; // r10
  bool v8; // cc
  KProcess *proc; // r11
  KAutoObject *v10; // r0
  KProcess *v11; // r11
  u8 typeId; // r8
  int v13; // r1
  KProcess *v14; // r4
  KLightMutex *p_mutex; // r4
  unsigned int v16; // r2
  unsigned int v17; // r1
  bool v18; // zf
  unsigned int v19; // r2
  KLightMutex *v20; // [sp+0h] [bp-78h]
  u32 totalSz; // [sp+4h] [bp-74h]
  KTranslationTableTraversalContext v22; // [sp+8h] [bp-70h] BYREF
  KTranslationTableIterator it; // [sp+10h] [bp-68h] BYREF
  KTranslationTableIterator it2; // [sp+18h] [bp-60h]
  int v25; // [sp+20h] [bp-58h]
  KTypeObj v26; // [sp+28h] [bp-50h] BYREF
  KTypeObj v27; // [sp+30h] [bp-48h] BYREF

  v5 = this;
  if ( !addr )
    this = (KCacheOperator *)0xD8E007F6;
  if ( !addr )
    return (Result)this;
  if ( addr >= 0x40000000 )                     // very loose address check
    return 0xE0E01BF5;
  v8 = size > 0x40000000;
  if ( size <= 0x40000000 )
    v8 = addr + size > 0x40000000;
  if ( v8 )
    return 0xE0E01BF5;
  if ( v5->GetThreshold(v5) <= size )
  {
    v5->DoEntireOperation(v5);                  // notice it ignores the address past the first few checks
    return 0;
  }
  if ( processHandle == CUR_PROCESS_HANDLE )
  {
    proc = current.clc.current.process;
    KAutoObject::IncrementRefcount(current.clc.current.process);
  }
  else
  {
    v10 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, processHandle);
    v11 = (KProcess *)v10;
    if ( !v10 )
      return 0xD9001BF7;
    v10->GetTypeObj(&v27, v10);
    typeId = v27.typeId;
    v11->GetTypeObj(&v26, v11);
    v13 = typeId | 0xC5;
    if ( v13 == v26.typeId )
      v14 = v11;
    else
      v14 = 0;
    if ( v13 != v26.typeId )
      v11->DecrementRefcount(v11);
    proc = v14;
  }
  if ( !proc )
    return 0xD9001BF7;
  p_mutex = &proc->pgTable.mutex;
  v25 = 0;
  v20 = &proc->pgTable.mutex;
  totalSz = size;
  v16 = __ldrex((unsigned int *)&proc->pgTable);
  if ( v16 )
  {
    __strex(v16, (unsigned int *)p_mutex);
  }
  else if ( !__strex((unsigned int)current.clc.current.thread, (unsigned int *)p_mutex) )
  {
    goto LABEL_25;
  }
  KLightMutex::LockImpl(&proc->pgTable.mutex);
LABEL_25:
  __mcr(15, 0, 0, 7, 10, 5);
  KTranslationTableIterator::CreateFromEntry(&proc->pgTable.L1Table, &it, &v22, addr);
  __mcr(15, 0, 0, 7, 10, 5);
  p_mutex->lockingThread = 0;
  if ( proc->pgTable.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&proc->pgTable.mutex);
  it2.size = 0;
  if ( it.pa )
    it.size -= (it.size - 1) & addr;            // misaligned addr
  else
    totalSz = 0;                                // if addr is invalid don't do anything
LABEL_30:
  v25 += it2.size;
  for ( it2 = it; ; it2.size += it.size )
  {
    if ( it2.size + v25 >= totalSz )
    {
      if ( v25 == totalSz )
        goto LABEL_51;
      it2.size = totalSz - v25;
LABEL_54:
      v5->DoRangeOperation(v5, it2.pa + 0xC0000000, it2.size);// operate on each chunk
      goto LABEL_30;
    }
    v17 = __ldrex((unsigned int *)v20);
    v18 = v17 == 0;
    if ( v17 )
      v19 = __strex(v17, (unsigned int *)v20);
    else
      v19 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)v20);
    if ( !v17 )
      v18 = v19 == 0;
    if ( !v18 )
      KLightMutex::LockImpl(v20);
    __mcr(15, 0, 0, 7, 10, 5);
    KTranslationTableIterator::Advance(&proc->pgTable.L1Table, &it, &v22);
    __mcr(15, 0, 0, 7, 10, 5);
    v20->lockingThread = 0;
    if ( proc->pgTable.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(v20);
    if ( !it.pa )
      break;
    if ( it2.pa + it2.size != it.pa )
      goto LABEL_54;
  }
  totalSz = 0;
  v25 = 0;
LABEL_51:
  if ( totalSz )
  {
    proc->DecrementRefcount(proc);              // path for invalid addr
    return 0;
  }
  proc->DecrementRefcount(proc);
  return 0xE0E01BF5;
}

//----- (FFF0B2BC) --------------------------------------------------------
Result __fastcall KProcessPageTable::UnmapProcessMemory(KProcessPageTable *this, u32 addr, u32 numPages)
{
  u32 v3; // r5
  u32 dstPos; // r4
  Result result; // r0
  KMemoryInfo outMemoryInfo; // [sp+10h] [bp-30h] BYREF
  u32 pageInfo; // [sp+20h] [bp-20h] BYREF

  v3 = addr + (numPages << 12);
  for ( dstPos = addr; ; dstPos = outMemoryInfo.baseAddress + outMemoryInfo.size )
  {
    result = KPageTable::QueryInfo(this, &outMemoryInfo, &pageInfo, dstPos);
    if ( result < 0 || outMemoryInfo.baseAddress + outMemoryInfo.size > v3 )
      break;
    if ( *(_QWORD *)&outMemoryInfo.perms == 0x58060000001BLL// shared memstate, krw_rw
      && KPageTable::Operate(
           this,
           dstPos,
           outMemoryInfo.size >> 12,
           0,
           MEMSTATE_FREE,
           KMEMPERM_NONE,
           KMEMUPDATE_NONE,
           0) < 0 )
    {
      kernelpanic();
    }
  }
  return result;
}

//----- (FFF0B368) --------------------------------------------------------
Result __fastcall KProcessPageTable::MapProcessMemory(
        KProcessPageTable *dstPgTbl,
        KPageTable *srcPgTbl,
        u32 dstAddr,
        u32 srcAddr,
        u32 numPages)
{
  Result result; // r0
  u32 pos; // r4
  int v10; // r1
  u32 v11; // r6
  u32 dstPos; // r4
  Result v13; // r0
  KMemoryInfo info; // [sp+10h] [bp-50h] BYREF
  u32 endDstAddr; // [sp+20h] [bp-40h]
  u32 pageInfo[3]; // [sp+24h] [bp-3Ch] BYREF

  pageInfo[2] = (u32)dstPgTbl;
  result = KPageTable::CheckMemoryBlockAttributes(dstPgTbl, dstAddr, numPages << 12, MEMSTATE_FREE, KMEMPERM_NONE);
  if ( result >= 0 )
  {
    endDstAddr = dstAddr + (numPages << 12);
    while ( 1 )
    {
      for ( pos = 0; ; pos += info.size )
      {
        v10 = KPageTable::QueryInfo(srcPgTbl, &info, pageInfo, srcAddr + pos);
        if ( v10 < 0 )
          break;
        if ( info.baseAddress == srcAddr + pos )
        {
          if ( info.size + pos > numPages << 12 )
            break;
          if ( (info.state & (unsigned __int16)KMEMSTATE_FLAG_CODE_ALLOWED) != 0 )
          {
            v10 = KPageTable::RemapMemoryInterprocess(// only text/rodata/data/bss/heap
                                                // 
                                                // why.....?
                    dstPgTbl,
                    srcPgTbl,
                    dstAddr + pos,
                    srcAddr + pos,
                    info.size >> 12,
                    KMEMSTATE_SHARED,
                    KMEMPERM_KRW_RW);
            if ( v10 < 0 )
              break;
          }
        }
        else
        {
          if ( pos )
          {
            v10 = 0xD940060E;
            break;
          }
          pos = info.baseAddress - srcAddr;
        }
      }
      result = v10;
      if ( v10 >= 0 )
        break;
      if ( v10 != 0xD940060E )
        kernelpanic();
      v11 = endDstAddr;
      for ( dstPos = dstAddr; ; dstPos = info.baseAddress + info.size )
      {
        v13 = KPageTable::QueryInfo(dstPgTbl, &info, pageInfo, dstPos);
        if ( v13 < 0 || info.baseAddress + info.size > v11 )
          break;
        if ( *(_QWORD *)&info.perms == 0x58060000001BLL
          && KPageTable::Operate(dstPgTbl, dstPos, info.size >> 12, 0, MEMSTATE_FREE, KMEMPERM_NONE, KMEMUPDATE_NONE, 0) < 0 )
        {
          kernelpanic();                        // Unmap KRW_RW shared memory if it's already there in the destination process
                                                // 
                                                // This is inlined UnmapProcessMemory
        }
      }
      if ( v13 < 0 )
        kernelpanic();
    }
  }
  return result;
}

//----- (FFF0B530) --------------------------------------------------------
void __fastcall SetResourceLimitLimitValues(SetResourceLimitLimitValuesArgs *args, ResourceLimitKvPair *pairs)
{
  s32 v4; // r6
  Result v5; // r4
  Result v6; // r9
  ResourceLimitKvPair *v7; // r4
  Result v8; // r0
  int v9; // r0
  Result v10; // r0
  KResourceLimit *v11; // r6
  s32 i; // r4
  ResourceLimitKvPair *v13; // r3
  u32 value_high; // r0
  unsigned int v15; // [sp+0h] [bp-30h] BYREF
  int dst; // [sp+8h] [bp-28h] BYREF
  int v17; // [sp+Ch] [bp-24h]

  v4 = 0;
  if ( args->count <= 0 )
  {
LABEL_19:
    v11 = KHandleTable::ConvertToResourceLimit(&current.clc.current.process->handleTable, args->reslimitHandle);
    if ( v11 )
    {
      for ( i = 0; args->count > i; ++i )
      {
        v13 = &pairs[i];
        if ( v13->name == RESLIMIT_COMMIT )
        {
          value_high = HIDWORD(v13->value);
          if ( value_high )
            g_kernelSharedConfigPagePtr->appMemAlloc = value_high;
        }
        KResourceLimit::SetLimitValue(v11, v13->name, v13->value);
      }
      args->result = 0;
      v11->DecrementRefcount(v11);
    }
    else
    {
      v10 = 0xD8E007F7;
LABEL_16:
      args->result = v10;
    }
  }
  else
  {
    while ( 1 )
    {
      v5 = CopyWordFromUser(&v15, &args->names[v4]) ? 0 : 0xE0E01BF5;
      args->result = v5;
      if ( v5 < 0 )
        break;
      v6 = v15 >= RESLIMIT_MAX ? 0xD8E007ED : 0;
      args->result = v6;
      if ( v6 < 0 )
        break;
      v7 = &pairs[v4];
      v7->name = v15;
      v8 = CopyBytesFromUser(&dst, &args->values[v4], 8u) ? 0 : 0xE0E01BF5;
      args->result = v8;
      if ( v8 < 0 )
        break;
      v9 = v17;
      if ( v17 < 0 )
      {
        v10 = 0xD8E007FD;
        goto LABEL_16;
      }
      LODWORD(v7->value) = dst;
      ++v4;
      HIDWORD(v7->value) = v9;
      if ( v4 >= args->count )
        goto LABEL_19;
    }
  }
}
// FFF2F0D4: using guessed type KernelSharedConfig *g_kernelSharedConfigPagePtr;

//----- (FFF0B6B8) --------------------------------------------------------
Result __fastcall Run(Handle processHandle, const StartupInfo *info)
{
  KProcess *v3; // r0
  KProcess *v5; // r4
  Result v6; // r5

  v3 = KHandleTable::ConvertToProcessAllowPseudoHandle(&current.clc.current.process->handleTable, processHandle);
  if ( !v3 )
    return 0xD9001BF7;
  v5 = v3;
  v6 = KProcess::Run(v3, info->mainThreadPriority, info->stackSize);
  v5->DecrementRefcount(v5);
  return v6;
}

//----- (FFF0B710) --------------------------------------------------------
Result __fastcall KEvent::Clear(KEvent *this)
{
  unsigned int v2; // r2
  bool v3; // zf
  unsigned int v4; // r3
  BOOL manualInterruptReenable; // r0
  bool v6; // zf
  Result v7; // r5

  v2 = __ldrex((unsigned int *)&g_eventSignalMutex);
  v3 = v2 == 0;
  if ( v2 )
    v4 = __strex(v2, (unsigned int *)&g_eventSignalMutex);
  else
    v4 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_eventSignalMutex);
  if ( !v2 )
    v3 = v4 == 0;
  if ( !v3 )
    KLightMutex::LockImpl(&g_eventSignalMutex);
  __mcr(15, 0, 0, 7, 10, 5);
  manualInterruptReenable = this->manualInterruptReenable;
  this->signaled = 0;
  v6 = !manualInterruptReenable;
  if ( manualInterruptReenable )
    v6 = this->irqId == -1;
  if ( v6 )
  {
    v7 = 0;
    __mcr(15, 0, 0, 7, 10, 5);
    g_eventSignalMutex.lockingThread = 0;
    if ( g_eventSignalMutex.numWaiters <= 0 )
      return v7;
    goto LABEL_12;
  }
  v7 = KInterruptEvent::ReenableInterrupt(this);// this is referred to as "(manual) clear" in some places
  __mcr(15, 0, 0, 7, 10, 5);
  g_eventSignalMutex.lockingThread = 0;
  if ( g_eventSignalMutex.numWaiters > 0 )
LABEL_12:
    KLightMutex::UnlockImpl(&g_eventSignalMutex);
  return v7;
}

//----- (FFF0B7C4) --------------------------------------------------------
Result __fastcall KEvent::Signal(KEvent *this)
{
  unsigned int v2; // r2
  bool v3; // zf
  unsigned int v4; // r3

  v2 = __ldrex((unsigned int *)&g_eventSignalMutex);
  v3 = v2 == 0;
  if ( v2 )
    v4 = __strex(v2, (unsigned int *)&g_eventSignalMutex);
  else
    v4 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_eventSignalMutex);
  if ( !v2 )
    v3 = v4 == 0;
  if ( !v3 )
    KLightMutex::LockImpl(&g_eventSignalMutex);
  __mcr(15, 0, 0, 7, 10, 5);
  if ( !this->signaled )
  {
    this->signaled = 1;
    KSynchronizationObject::NotifyWaiters(this, this->resetType == RESET_PULSE);
  }
  __mcr(15, 0, 0, 7, 10, 5);
  g_eventSignalMutex.lockingThread = 0;
  if ( g_eventSignalMutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_eventSignalMutex);
  return 0;
}

//----- (FFF0B854) --------------------------------------------------------
Result __fastcall KMutex::Unlock(KMutex *this, KThread *thread)
{
  s32 lockCount; // r0
  s32 v6; // r0

  KSchedulerLock::Lock(&g_schedulerLock);
  if ( this->lockingThread == thread )
  {
    lockCount = this->lockCount;
    if ( lockCount > 0 )
    {
      v6 = lockCount - 1;
      this->lockCount = v6;
      if ( !v6 )
      {
        this->lockingThread = 0;
        KThread::RelinquishMutex(thread, this);
        KSynchronizationObject::NotifyWaiters(this, 0);
      }
      KSchedulerLock::Unlock(&g_schedulerLock);
      return 0;
    }
    else
    {
      KSchedulerLock::Unlock(&g_schedulerLock);
      return 0xD8A007FF;
    }
  }
  else
  {
    KSchedulerLock::Unlock(&g_schedulerLock);
    return 0xD8E0041F;
  }
}

//----- (FFF0B8F4) --------------------------------------------------------
Result __fastcall KTimer::Clear(KTimer *this)
{
  this->signaled = 0;
  return 0;
}

//----- (FFF0B904) --------------------------------------------------------
Result __fastcall KTimer::Cancel(KTimer *this)
{
  Result result; // r0

  this->allowedToRegister = 0;
  if ( KHardwareTimer::CancelTask(&g_hardwareTimer, &this->KTimerTask) )
    this->DecrementRefcount(this);
  result = 0;
  this->signaled = 0;
  return result;
}

//----- (FFF0B948) --------------------------------------------------------
bool __fastcall KInterruptManager::HandleIncomingInterrupt(KInterruptManager *this)
{
  KIrqAcknowledgmentInfo v2; // kr00_8
  KInterruptEntry *handler; // r5
  KInterruptEntry *v4; // r5
  KInterruptHandler *v5; // t1
  KInterruptTask *v6; // r5
  KIrqAcknowledgmentInfo v8; // [sp+0h] [bp-20h] BYREF

  KInterruptController::AcknowledgeIrq(&v8);
  v2 = v8;
  if ( v8.irqId == 1023 )                       // spurious
    return 0;
  if ( v8.irqId <= 0x1F )
  {
    handler = &this->privateInterrupts[__mrc(15, 0, 0, 0, 5) & 3][v2.irqId];
    if ( handler->handler )
    {
      if ( !handler->autoDisable_ManualClear )
        goto LABEL_11;
      KInterruptController::SetInterruptPriority(v2.irqId, 0xFu);
      goto LABEL_10;
    }
LABEL_15:
    KInterruptController::EndOfInterrupt(v2.irqId, v2.coreId);
    return 0;
  }
  if ( v8.irqId - 0x20 > 0x5F )
    goto LABEL_15;
  v4 = (KInterruptEntry *)((char *)this + 8 * v8.irqId - 0x100);
  v5 = v4[128].handler;
  handler = v4 + 128;
  if ( !v5 )
    goto LABEL_15;
  if ( !handler->autoDisable_ManualClear )
    goto LABEL_11;
  KInterruptController::DisableInterrupt(v8.irqId);
LABEL_10:
  handler->disabled = 1;
LABEL_11:
  __mcr(15, 0, 0, 7, 10, 4);
  v6 = handler->handler->OnInterrupt(handler->handler, v2.irqId);
  KInterruptController::EndOfInterrupt(v2.irqId, v2.coreId);
  if ( !v6 )
    return 0;
  if ( v6 != (KInterruptTask *)1 )
    KInterruptTaskManager::EnqueueTask(current.clc.current.interruptTaskManager, v6);
  return 1;
}

//----- (FFF0BA5C) --------------------------------------------------------
Result __fastcall SetHardwareBreakpoint(s32 regId, u32 cr, u32 vr)
{
  KDebug *v6; // r0
  KDebug *v7; // r7
  KDebug *debug; // r4
  u8 typeId; // r10
  KTypeObj v11; // [sp+0h] [bp-30h] BYREF
  KTypeObj v12; // [sp+8h] [bp-28h] BYREF

  __mcr(14, 0, __mrc(14, 0, 0, 1, 0) | 0x8000, 0, 1, 0);// enable monitor-mode debugging
  if ( (cr & 0x200000) != 0 )                   // if vr type = contextId, get it from the debug handle
  {
    v6 = (KDebug *)KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, vr);
    v7 = v6;
    if ( !v6 )
      return 0xD9002002;
    debug = v6;
    v6->GetTypeObj(&v11, v6);
    typeId = v11.typeId;
    debug->GetTypeObj(&v12, debug);
    if ( (typeId | 0x4D) != v12.typeId )
    {
      debug = 0;
      v7->DecrementRefcount(v7);
    }
    if ( !debug )
      return 0xD9002002;
    vr = debug->process->pgTable.asid;          // context id = asid in HOS
  }
  if ( regId == 4 )
  {
    __mcr(14, 0, __mrc(14, 0, 0, 4, 5) & ~1u, 0, 4, 5);
    __mcr(14, 0, vr, 0, 4, 4);
    __mcr(14, 0, cr, 0, 4, 5);
  }
  else if ( regId > 4 )
  {
    switch ( regId )
    {
      case 5:
        __mcr(14, 0, __mrc(14, 0, 0, 5, 5) & ~1u, 0, 5, 5);
        __mcr(14, 0, vr, 0, 5, 4);
        __mcr(14, 0, cr, 0, 5, 5);
        break;
      case 256:
        __mcr(14, 0, __mrc(14, 0, 0, 0, 7) & ~1u, 0, 0, 7);
        __mcr(14, 0, vr, 0, 0, 6);
        __mcr(14, 0, cr, 0, 0, 7);
        break;
      case 257:
        __mcr(14, 0, __mrc(14, 0, 0, 1, 7) & ~1u, 0, 1, 7);
        __mcr(14, 0, vr, 0, 1, 6);
        __mcr(14, 0, cr, 0, 1, 7);
        break;
    }
  }
  else if ( regId )
  {
    switch ( regId )
    {
      case 1:
        __mcr(14, 0, __mrc(14, 0, 0, 1, 5) & ~1u, 0, 1, 5);
        __mcr(14, 0, vr, 0, 1, 4);
        __mcr(14, 0, cr, 0, 1, 5);
        break;
      case 2:
        __mcr(14, 0, __mrc(14, 0, 0, 2, 5) & ~1u, 0, 2, 5);
        __mcr(14, 0, vr, 0, 2, 4);
        __mcr(14, 0, cr, 0, 2, 5);
        break;
      case 3:
        __mcr(14, 0, __mrc(14, 0, 0, 3, 5) & ~1u, 0, 3, 5);
        __mcr(14, 0, vr, 0, 3, 4);
        __mcr(14, 0, cr, 0, 3, 5);
        break;
    }
  }
  else
  {
    __mcr(14, 0, __mrc(14, 0, 0, 0, 5) & ~1u, 0, 0, 5);
    __mcr(14, 0, vr, 0, 0, 4);
    __mcr(14, 0, cr, 0, 0, 5);
  }
  return 0;
}

//----- (FFF0BC44) --------------------------------------------------------
Result __fastcall KDebug::ReadProcessMemory(KDebug *this, u32 dstAddr, u32 addr, u32 size)
{
  KProcess *process; // r0
  KThread *v7; // r2
  unsigned __int8 *p_dpcFlags; // r0
  unsigned __int8 v9; // r3
  u32 curAddr; // r4
  u32 endAddr; // r7
  Result result; // r0
  u32 v13; // r8
  u32 curOutAddr; // r4
  u32 endAddrDst; // r7
  u32 v16; // r2
  Result v17; // r4
  KProcessPageTable *srcPgTbl; // [sp+14h] [bp-5Ch]
  KProcessPageTable *p_pgTable; // [sp+1Ch] [bp-54h]
  KMemoryInfo outMemoryInfo; // [sp+20h] [bp-50h] BYREF
  int pageInfo[3]; // [sp+34h] [bp-3Ch] BYREF
  u32 v22; // [sp+40h] [bp-30h]
  u32 v24; // [sp+48h] [bp-28h]

  pageInfo[2] = (int)this;
  v22 = dstAddr;
  v24 = size;
  process = this->process;
  p_pgTable = &current.clc.current.process->pgTable;
  srcPgTbl = &process->pgTable;
  v7 = (KThread *)__ldrex((unsigned int *)&process->pgTable);
  if ( v7 && v7->owner == process )
  {
    v7->debugThread->debugPauseRequested = 1;
    p_dpcFlags = &ADJ(v7->kernelStackTop)->dpcFlags;// this code block here is kinda awful
                                                // if the debug-paused thread (note: not checked!) was holding the memory manager mutex, unpause it and set dpc
                                                // 
                                                // but this shouldn't happen because we always set dpc if the thread is in svc
    do
      v9 = __ldrex(p_dpcFlags);
    while ( __strex(v9 | 4, p_dpcFlags) );
    KThread::SetDebugPauseState(v7, 0);
  }
  curAddr = addr;
  endAddr = addr + size;
  result = 0;
  if ( addr < addr + size )
  {
    do
    {
      result = KPageTable::QueryInfo(srcPgTbl, &outMemoryInfo, (u32 *)pageInfo, curAddr);
      if ( result < 0 )
        break;
      v13 = outMemoryInfo.baseAddress + outMemoryInfo.size >= endAddr ? endAddr - curAddr : outMemoryInfo.baseAddress
                                                                                          + outMemoryInfo.size
                                                                                          - curAddr;
      result = KPageTable::CheckAddrRangeMaskedStateAndPerms(
                 srcPgTbl,
                 curAddr,
                 v13,
                 KMEMSTATE_FLAG_DEBUGGABLE,     // bug! Stuff like 0xBB05 (regular private data) doesn't have this flag... oops!
                 KMEMSTATE_FLAG_DEBUGGABLE,
                 KMEMPERM_NONE);
      if ( result < 0 )
      {
        result = KPageTable::CheckAddrRangeMaskedStateAndPerms(
                   srcPgTbl,
                   curAddr,
                   v13,
                   MEMSTATE_FREE,
                   MEMSTATE_FREE,
                   KMEMPERM_R);
        if ( result < 0 )
          break;
      }
      curAddr = outMemoryInfo.baseAddress + outMemoryInfo.size;
    }
    while ( outMemoryInfo.baseAddress + outMemoryInfo.size < endAddr );
  }
  if ( result >= 0 )
  {
    curOutAddr = v22;
    endAddrDst = v22 + size;
    if ( v22 >= v22 + size )
    {
LABEL_22:
      result = 0;
    }
    else
    {
      while ( 1 )
      {
        result = KPageTable::QueryInfo(p_pgTable, &outMemoryInfo, (u32 *)pageInfo, curOutAddr);
        if ( result < 0 )
          break;
        v16 = outMemoryInfo.baseAddress + outMemoryInfo.size >= endAddrDst ? endAddrDst - curOutAddr : outMemoryInfo.baseAddress + outMemoryInfo.size - curOutAddr;
        result = KPageTable::CheckAddrRangeMaskedStateAndPerms(
                   p_pgTable,
                   curOutAddr,
                   v16,
                   MEMSTATE_FREE,
                   MEMSTATE_FREE,
                   KMEMPERM_W);
        if ( result < 0 )
          break;
        curOutAddr = outMemoryInfo.baseAddress + outMemoryInfo.size;
        if ( outMemoryInfo.baseAddress + outMemoryInfo.size >= endAddrDst )
          goto LABEL_22;
      }
    }
    if ( result >= 0 )
    {
      v17 = KProcessPageTable::CopyMemoryForDebug(p_pgTable, v22, srcPgTbl, addr, size);
      KProcess::CleanInvalidateDataCacheRange(this->process, addr, size);// BUG: assumes paddr is in FCRAM
      return v17;
    }
  }
  return result;
}
// FFF0BC44: using guessed type u32 pageInfo[3];

//----- (FFF0BE58) --------------------------------------------------------
Result __fastcall KDebug::WriteProcessMemory(KDebug *this, u32 addr, u32 dstAddr, u32 size)
{
  KProcess *process; // r0
  KThread *v7; // r2
  unsigned __int8 *p_dpcFlags; // r0
  unsigned __int8 v9; // r3
  u32 v10; // r4
  u32 v11; // r7
  Result result; // r0
  u32 v13; // r8
  u32 v14; // r7
  u32 v15; // r4
  u32 v16; // r2
  Result v17; // r4
  KProcessPageTable *srcPageTable; // [sp+14h] [bp-5Ch]
  KProcessPageTable *p_pgTable; // [sp+1Ch] [bp-54h]
  KMemoryInfo outMemoryInfo; // [sp+20h] [bp-50h] BYREF
  int pageInfo[3]; // [sp+34h] [bp-3Ch] BYREF
  u32 srcAddr; // [sp+40h] [bp-30h]
  u32 v24; // [sp+48h] [bp-28h]

  pageInfo[2] = (int)this;
  srcAddr = addr;
  v24 = size;
  process = this->process;
  srcPageTable = &current.clc.current.process->pgTable;
  p_pgTable = &process->pgTable;
  v7 = (KThread *)__ldrex((unsigned int *)&process->pgTable);
  if ( v7 && v7->owner == process )
  {
    v7->debugThread->debugPauseRequested = 1;   // this code block here is awful
                                                // if the debug-paused thread (note: not checked!) was holding the memory manager mutex, unpause it and set dpc
                                                // 
                                                // but this shouldn't happen because we always set dpc if the thread is in svc
    p_dpcFlags = &ADJ(v7->kernelStackTop)->dpcFlags;
    do
      v9 = __ldrex(p_dpcFlags);
    while ( __strex(v9 | KDPCFLAG_DEBUG_PAUSE, p_dpcFlags) );
    KThread::SetDebugPauseState(v7, 0);
  }
  v10 = dstAddr;
  v11 = dstAddr + size;
  result = 0;
  if ( dstAddr < dstAddr + size )
  {
    do
    {
      result = KPageTable::QueryInfo(p_pgTable, &outMemoryInfo, (u32 *)pageInfo, v10);
      if ( result < 0 )
        break;
      v13 = outMemoryInfo.baseAddress + outMemoryInfo.size >= v11 ? v11 - v10 : outMemoryInfo.baseAddress
                                                                              + outMemoryInfo.size
                                                                              - v10;
      result = KPageTable::CheckAddrRangeMaskedStateAndPerms(
                 p_pgTable,
                 v10,
                 v13,
                 KMEMSTATE_FLAG_DEBUGGABLE,     // bug! Stuff like 0xBB05 (regular private data) doesn't have this flag... oops!
                 KMEMSTATE_FLAG_DEBUGGABLE,
                 KMEMPERM_NONE);
      if ( result < 0 )
      {
        result = KPageTable::CheckAddrRangeMaskedStateAndPerms(
                   p_pgTable,
                   v10,
                   v13,
                   MEMSTATE_FREE,
                   MEMSTATE_FREE,
                   KMEMPERM_W);
        if ( result < 0 )
          break;
      }
      v10 = outMemoryInfo.baseAddress + outMemoryInfo.size;
    }
    while ( outMemoryInfo.baseAddress + outMemoryInfo.size < v11 );
  }
  if ( result >= 0 )
  {
    v14 = srcAddr;
    v15 = srcAddr + size;
    if ( srcAddr >= srcAddr + size )
    {
LABEL_22:
      result = 0;
    }
    else
    {
      while ( 1 )
      {
        result = KPageTable::QueryInfo(srcPageTable, &outMemoryInfo, (u32 *)pageInfo, v14);
        if ( result < 0 )
          break;
        v16 = outMemoryInfo.baseAddress + outMemoryInfo.size >= v15 ? v15 - v14 : outMemoryInfo.baseAddress
                                                                                + outMemoryInfo.size
                                                                                - v14;
        result = KPageTable::CheckAddrRangeMaskedStateAndPerms(
                   srcPageTable,
                   v14,
                   v16,
                   MEMSTATE_FREE,
                   MEMSTATE_FREE,
                   KMEMPERM_R);
        if ( result < 0 )
          break;
        v14 = outMemoryInfo.baseAddress + outMemoryInfo.size;
        if ( outMemoryInfo.baseAddress + outMemoryInfo.size >= v15 )
          goto LABEL_22;
      }
    }
    if ( result >= 0 )
    {
      v17 = KProcessPageTable::CopyMemoryForDebug(p_pgTable, dstAddr, srcPageTable, srcAddr, size);
      KProcess::CleanInvalidateDataCacheRange(this->process, dstAddr, size);
      KPageTable::InvalidateEntireInstructionCache();
      return v17;
    }
  }
  return result;
}
// FFF0BE58: using guessed type u32 pageInfo[3];

//----- (FFF0C078) --------------------------------------------------------
Result __fastcall KDebug::BreakProcess(KDebug *this)
{
  KSchedulerLock *p_lock; // r5
  BOOL signalingSyncEvent; // r0
  bool v4; // zf
  int v5; // r0
  char cfgr; // r1
  int v7; // r3
  KThread *thread; // r2
  KThreadLinkedListNode *node; // r1
  u32 threadId; // r1
  KProcess *process; // r0
  KThread *v12; // r1
  KThread *v13; // r1
  KThread *v14; // r2
  ExceptionDispatchContext *excCtx; // r0
  u32 pc; // r3
  Result result; // r0
  s32 threadIds[4]; // [sp+18h] [bp-30h] BYREF

  p_lock = &this->lock;
  memset(threadIds, 0, sizeof(threadIds));
  KSchedulerLock::Lock(&this->lock);
  KSchedulerLock::Lock(&g_schedulerLock);
  signalingSyncEvent = this->signalingSyncEvent;
  this->hasDebuggerBreak = 1;
  v4 = !signalingSyncEvent;
  if ( !signalingSyncEvent )
    v4 = !this->hasBreakSvc;
  if ( v4 )
    KDebug::PauseProcess(this, 0);
  v5 = 0;
  cfgr = MPCORE.scu.cfgr;
  v7 = (cfgr & 3) + 1;
  while ( v7 > v5 )
  {
    for ( node = this->orderedThreadListForBreak.link.next; ; node = node->link.next )
    {
      if ( node == (KThreadLinkedListNode *)&this->orderedThreadListForBreak.link )
      {
        threadId = -1;
        goto LABEL_12;
      }
      thread = node->thread;
      if ( thread->coreId == v5 && !ADJ(thread->kernelStackTop)->svcId )
        break;
    }
    threadId = thread->threadId;
LABEL_12:
    threadIds[v5++] = threadId;
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
  KSchedulerLock::UnlockSingleCoreResched(p_lock);
  process = this->process;
  v12 = (KThread *)__ldrex((unsigned int *)&g_eventSignalMutex);// avoid deadlock?
                                                // pause the thread we might not have paused before
  if ( v12 )
  {
    if ( v12->owner == process )
    {
      v13 = (KThread *)__ldrex((unsigned int *)&g_eventSignalMutex);
      if ( v13 )
      {
        if ( v13->owner == process && (v13->coreId & 0x80000000) == 0 && !v13->debugThread->debugPauseRequested )
        {
          v14 = (KThread *)__ldrex((unsigned int *)&g_eventSignalMutex);
          if ( v14 )
          {
            if ( v14->owner == process && (v14->coreId & 0x80000000) == 0 )
            {
              v14->debugThread->debugPauseRequested = 1;
              KThread::SetDebugPauseState(v14, 0);
            }
          }
        }
      }
    }
  }
  excCtx = this->excCtx;
  if ( excCtx )
    pc = excCtx->pc;
  else
    pc = ADJ(this->process->mainThread->kernelStackTop)[-1].ctx.fpexc;
  result = KDebug::EmplaceAysncEventInfo(
             this,
             DBGEVENT_EXCEPTION,
             1,
             pc,
             EXCEVENT_DEBUGGER_BREAK,
             threadIds[0],
             threadIds[1],
             threadIds[2],
             threadIds[3]);
  if ( result >= 0 )
  {
    KSynchronizationObject::NotifyWaiters(this, 0);
    return 0;
  }
  return result;
}

//----- (FFF0C27C) --------------------------------------------------------
Result __fastcall KDebug::Continue(KDebug *this, DebugFlags debugFlags)
{
  int v4; // r9
  unsigned int CPSR; // r7
  KThread *userDebuggerThread; // r0
  KThread *volatile thread; // r8
  KLinkedListNode *v8; // r0
  KEventInfoLinkedListNode *next; // r8
  KEventInfo *eventInfo; // r4
  KEventInfo *v11; // r1
  DebugEventType type; // r0
  bool v13; // zf
  bool v14; // zf
  u16 v15; // r0
  BOOL v16; // r1
  KThread *v17; // r0
  bool v18; // zf
  KThread *userBreakThread; // r0
  u16 numBlockingEvents; // r0
  BOOL hasAttachBreak; // r1
  KEventInfoLinkedListNode *v23; // [sp+0h] [bp-28h] BYREF

  v4 = 1;
  KSchedulerLock::Lock(&g_schedulerLock);
  CPSR = __get_CPSR();
  __disable_irq();
  userDebuggerThread = this->userDebuggerThread;
  this->debugFlags = debugFlags;
  if ( !userDebuggerThread )
  {
    thread = current.clc.current.thread;
    this->userDebuggerThread = current.clc.current.thread;
    this->userDebuggerCoreId = __mrc(15, 0, 0, 0, 5) & 3;
    v8 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
    if ( v8 )
    {
      v8->link.next = 0;
      v8->link.prev = 0;
      v8->data = 0;
    }
    v8->data = thread;
    KLinkedList::InsertAfter(
      (KLinkedList *)&g_debuggerThreadLinkedList,
      (KLinkedListLink *)&g_debuggerThreadLinkedList.link,
      v8);
  }
  KSchedulerLock::Lock(&g_schedulerLock);
  next = this->eventsToContinue.link.next;
  eventInfo = next->eventInfo;
  v23 = next;
  KLinkedList::EraseNode((KLinkedList *)&this->eventsToContinue, (KLinkedListLink **)&v23);
  KSlabHeap::Free(&g_linkedListNodeSlabHeap, next);
  KSchedulerLock::Unlock(&g_schedulerLock);
  if ( this->numAttachOrDetachEvents )
  {
    --this->numAttachOrDetachEvents;
    v11 = eventInfo;
    --this->numBlockingEvents;
    if ( eventInfo->needsToBeContinued && !eventInfo->isProcessed )
    {
LABEL_8:
      eventInfo->isProcessed = 1;
      goto LABEL_71;
    }
LABEL_9:
    KSlabHeap::Free(&g_eventInfoSlabHeap, v11);
    goto LABEL_71;
  }
  type = eventInfo->type;
  if ( !this->hasDebuggerBreak )
  {
    v18 = type == DBGEVENT_EXCEPTION;
    if ( type == DBGEVENT_EXCEPTION )
      v18 = eventInfo->d.exception.type == EXCEVENT_USER_BREAK;
    if ( v18 )
    {
      userBreakThread = this->userBreakThread;
      --this->numBlockingEvents;
      if ( userBreakThread )
        KThread::SetDebugPauseState(userBreakThread, 0);
      else
        KDebug::UnpauseAllThreads(this, 0);
      this->hasBreakSvc = 0;
      if ( !eventInfo->needsToBeContinued || eventInfo->isProcessed )
        KSlabHeap::Free(&g_eventInfoSlabHeap, eventInfo);
      else
        eventInfo->isProcessed = 1;
    }
    else                                        // other exceptions
    {
      if ( eventInfo->ignoreContinue )
      {
        v11 = eventInfo;
        --this->numBlockingEvents;
        if ( eventInfo->needsToBeContinued && !eventInfo->isProcessed )
          goto LABEL_8;
        goto LABEL_9;
      }
      if ( !eventInfo->needsToBeContinued || eventInfo->isProcessed )
        KSlabHeap::Free(&g_eventInfoSlabHeap, eventInfo);
      else
        eventInfo->isProcessed = 1;
      KSchedulerLock::Lock(&g_schedulerLock);
      numBlockingEvents = this->numBlockingEvents;
      hasAttachBreak = this->hasAttachBreak;
      this->excCtx = 0;
      this->numBlockingEvents = numBlockingEvents - 1;
      if ( hasAttachBreak )
      {
        KDebug::UnpauseAllThreads(this, 1);
        this->hasAttachBreak = 0;
      }
      else
      {
        this->signalingSyncEventThread->debugThread->debugPauseRequested = 0;
        KThread::SetDebugPauseState(this->signalingSyncEventThread, 0);
      }
      KSchedulerLock::Unlock(&g_schedulerLock);
    }
LABEL_70:
    this->signalingSyncEvent = 0;
    goto LABEL_71;
  }                                             // endif (!hasDebuggerBreak)
  v13 = type == DBGEVENT_EXCEPTION;
  if ( type == DBGEVENT_EXCEPTION )
    v13 = eventInfo->d.exception.type == EXCEVENT_DEBUGGER_BREAK;
  if ( !v13 )
  {
    v14 = type == DBGEVENT_EXCEPTION;
    if ( type == DBGEVENT_EXCEPTION )
      type = eventInfo->d.exception.type;
    v11 = eventInfo;
    if ( v14 )
      v14 = type == DBGEVENT_DLL_UNLOAD;
    if ( v14 )
      this->deferredUserBreakContinue = 1;
    else
      this->deferredExceptionContinue = 1;
    --this->numBlockingEvents;
    if ( eventInfo->needsToBeContinued && !eventInfo->isProcessed )
      goto LABEL_8;
    goto LABEL_9;
  }
  if ( this->deferredExceptionContinue )
  {
    this->deferredExceptionContinue = 0;
    if ( !eventInfo->needsToBeContinued || eventInfo->isProcessed )
      KSlabHeap::Free(&g_eventInfoSlabHeap, eventInfo);
    else
      eventInfo->isProcessed = 1;
    KSchedulerLock::Lock(&g_schedulerLock);
    v15 = this->numBlockingEvents;
    v16 = this->hasAttachBreak;
    this->excCtx = 0;
    this->numBlockingEvents = v15 - 1;
    if ( v16 )
    {
      KDebug::UnpauseAllThreads(this, 1);
      this->hasAttachBreak = 0;
    }
    else
    {
      this->signalingSyncEventThread->debugThread->debugPauseRequested = 0;
      KThread::SetDebugPauseState(this->signalingSyncEventThread, 0);
    }
    KSchedulerLock::Unlock(&g_schedulerLock);
  }
  else if ( this->deferredUserBreakContinue )
  {
    this->deferredUserBreakContinue = 0;
    if ( !eventInfo->needsToBeContinued || eventInfo->isProcessed )
      KSlabHeap::Free(&g_eventInfoSlabHeap, eventInfo);
    else
      eventInfo->isProcessed = 1;
    v17 = this->userBreakThread;
    --this->numBlockingEvents;
    if ( v17 )
      KThread::SetDebugPauseState(v17, 0);
    else
      KDebug::UnpauseAllThreads(this, 0);
    this->hasBreakSvc = 0;
  }
  else
  {
    if ( !eventInfo->needsToBeContinued || eventInfo->isProcessed )
      KSlabHeap::Free(&g_eventInfoSlabHeap, eventInfo);
    else
      eventInfo->isProcessed = 1;
    --this->numBlockingEvents;
    KDebug::UnpauseAllThreads(this, 0);
    v4 = 0;
  }
  this->hasDebuggerBreak = 0;
  if ( v4 )
    goto LABEL_70;
LABEL_71:
  __set_CPSR(CPSR);
  KSchedulerLock::Unlock(&g_schedulerLock);
  return 0;
}
// FFF0C2F0: conditional instruction was optimized away because r0.4!=0

//----- (FFF0C6DC) --------------------------------------------------------
Result __fastcall KDebug::EraseFirstEventInfoToFetchNode(KDebug *this)
{
  KEventInfoLinkedList *p_eventsToFetch; // r0
  KLinkedListLink *next; // r4
  KLinkedListLink *v5; // [sp+0h] [bp-10h] BYREF

  KSchedulerLock::Lock(&g_schedulerLock);
  p_eventsToFetch = &this->eventsToFetch;
  next = (KLinkedListLink *)this->eventsToFetch.link.next;
  v5 = next;
  KLinkedList::EraseNode((KLinkedList *)p_eventsToFetch, &v5);
  KSlabHeap::Free(&g_linkedListNodeSlabHeap, next);
  KSchedulerLock::Unlock(&g_schedulerLock);
  return 0;
}

//----- (FFF0C728) --------------------------------------------------------
Result __fastcall KDebug::GetPausedThreadContextById(
        KDebug *this,
        ThreadContext *outThreadContext,
        u32 tid,
        ThreadContextControlFlags flags)
{
  KDebugThreadLinkedListNode *i; // r2
  KThread *thread; // r4
  KDebugThread *debugThread; // r2
  bool v12; // zf
  Result ThreadContext; // r4

  for ( i = this->debugThreads.link.next; ; i = i->link.next )
  {
    if ( i == (KDebugThreadLinkedListNode *)&this->debugThreads.link )
      return 0xD88007EF;
    thread = i->debugThread->thread;
    if ( (thread->schedulingMask & 0xF) != KTHREADSCHEDSTAT_TERMINATED && thread->threadId == tid )
      break;
  }
  if ( !thread || thread->owner != this->process )
    return 0xD88007EF;
  debugThread = thread->debugThread;
  if ( (unsigned __int8)(debugThread->thread->schedulingMask & 0x80) >> 7 )// 
                                                // we can access the thread ctx if at least one of the following is true:
                                                // 
                                                // - the thread debug paused
                                                // - the thread is in a svc and is about to be debug paused
                                                // - the thread is paused
    goto LABEL_17;
  v12 = ADJ(debugThread->thread->kernelStackTop)->svcId == 0;
  if ( !ADJ(debugThread->thread->kernelStackTop)->svcId )
    v12 = !debugThread->debugPauseRequested;
  if ( v12 && (debugThread->thread->schedulingMask & 0xF) != 0 )
    return 0xD90007EE;
LABEL_17:
  KSchedulerLock::Lock(&g_schedulerLock);
  ThreadContext = KDebug::GetThreadContext(this, outThreadContext, thread, flags);
  KSchedulerLock::Unlock(&g_schedulerLock);
  return ThreadContext;
}

//----- (FFF0C824) --------------------------------------------------------
BOOL __fastcall KDebug::NeedsContinue(KDebug *this)
{
  return this->numBlockingEvents != 0;
}

//----- (FFF0C834) --------------------------------------------------------
Result __fastcall KDebug::SetPausedThreadContextById(
        KDebug *this,
        ThreadContext *threadContext,
        u32 tid,
        ThreadContextControlFlags flags)
{
  KDebugThreadLinkedListNode *i; // r2
  KThread *thread; // r4
  KDebugThread *debugThread; // r2
  bool v12; // zf
  Result v13; // r4

  for ( i = this->debugThreads.link.next; ; i = i->link.next )
  {
    if ( i == (KDebugThreadLinkedListNode *)&this->debugThreads.link )
      return 0xD88007EF;
    thread = i->debugThread->thread;
    if ( (thread->schedulingMask & 0xF) != KTHREADSCHEDSTAT_TERMINATED && thread->threadId == tid )
      break;
  }
  if ( !thread || thread->owner != this->process )
    return 0xD88007EF;
  debugThread = thread->debugThread;
  if ( (unsigned __int8)(debugThread->thread->schedulingMask & KTHREADSCHEDSTAT_DEBUG_PAUSE_FLAG) >> 7 )// 
                                                // we can access the thread ctx if at least one of the following is true:
                                                // 
                                                // - the thread debug paused
                                                // - the thread is in a svc and is about to be debug paused
                                                // - the thread is paused
    goto LABEL_17;
  v12 = ADJ(debugThread->thread->kernelStackTop)->svcId == 0;
  if ( !ADJ(debugThread->thread->kernelStackTop)->svcId )
    v12 = !debugThread->debugPauseRequested;
  if ( v12 && (debugThread->thread->schedulingMask & 0xF) != 0 )
    return 0xD90007EE;
LABEL_17:
  KSchedulerLock::Lock(&g_schedulerLock);
  v13 = KDebug::SetThreadContext(this, threadContext, thread, flags);
  KSchedulerLock::Unlock(&g_schedulerLock);
  return v13;
}

//----- (FFF0C930) --------------------------------------------------------
Result __fastcall KDebug::TerminateProcess(KDebug *this)
{
  KProcess *process; // r0

  if ( this->processTerminated )
    return 0xD8800608;
  process = this->process;
  if ( !process || KProcess::IsTerminated(process) )
    return 0xD8800608;
  KWorkerTaskManager::AddTask(KWORKERTYPE_HIGH_PRIO, &this->KWorkerTask);
  return 0;
}

//----- (FFF0C97C) --------------------------------------------------------
Result __fastcall BreakImpl(UserBreakType breakReason, u32 croInfoAddr, u32 croInfoSize)
{
  KDebug *debug; // r5
  bool v5; // zf
  KThread *currentThread; // r9
  bool v10; // zf
  int v11; // r4

  debug = current.clc.current.process->debug;
  if ( !debug )
    return 0;
  v5 = breakReason == USERBREAK_LOAD_RO;
  if ( breakReason != USERBREAK_LOAD_RO )
    v5 = breakReason == USERBREAK_UNLOAD_RO;
  if ( !v5 )
    return KDebug::BreakNoRo(current.clc.current.process->debug, breakReason);
  currentThread = current.clc.current.thread;   // else
  KDebug::BreakCurrentProcess(current.clc.current.process->debug, current.clc.current.thread);
  KSchedulerLock::Lock(&g_schedulerLock);
  debug->userBreakThread = currentThread;
  KThread::SetDebugPauseState(currentThread, 1);
  v10 = breakReason == USERBREAK_LOAD_RO;
  if ( breakReason != USERBREAK_LOAD_RO )
    v10 = breakReason == USERBREAK_UNLOAD_RO;
  if ( !v10 )
    kernelpanic();
  v11 = KDebug::EmplaceAysncEventInfo(
          debug,
          DBGEVENT_EXCEPTION,
          1,
          breakReason,
          EXCEVENT_USER_BREAK,
          croInfoAddr,
          croInfoSize,
          0,
          0);
  if ( v11 >= 0 )
  {
    KSynchronizationObject::NotifyWaiters(debug, 0);
    KDebug::RequestReschedulingForDebugger(debug, debug->userDebuggerCoreId);
    KDebug::RequestReschedulingForDebugger(debug, __mrc(15, 0, 0, 0, 5) & 3);
    KSchedulerLock::Unlock(&g_schedulerLock);   // pause here
    KSchedulerLock::Lock(&g_schedulerLock);
    debug->userBreakThread = 0;
    KDebug::UnbreakCurrentProcess(debug);
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
  return v11;
}

//----- (FFF0CAD4) --------------------------------------------------------
void __fastcall KDebug::ProcessEventInfo(KDebug *this, DebugEventType type, KEventInfo *info)
{
  if ( !info->needsToBeContinued || info->isProcessed )
    KSlabHeap::Free(&g_eventInfoSlabHeap, info);
  else
    info->isProcessed = 1;
}

//----- (FFF0CB08) --------------------------------------------------------
KEventInfo *__fastcall KDebug::GetFirstEventInfoToFetch(KDebug *this)
{
  KEventInfo *eventInfo; // r4

  KSchedulerLock::Lock(&g_schedulerLock);
  if ( this->eventsToFetch.count )
  {
    KSchedulerLock::Unlock(&g_schedulerLock);
    KSchedulerLock::Lock(&g_schedulerLock);
    eventInfo = this->eventsToFetch.link.next->eventInfo;
    KSchedulerLock::Unlock(&g_schedulerLock);
    return eventInfo;
  }
  else
  {
    KSchedulerLock::Unlock(&g_schedulerLock);
    return 0;
  }
}

//----- (FFF0CB60) --------------------------------------------------------
void __fastcall KThread::HandleDpc(KThread *this)
{
  u8 schedulingMask; // r2
  KMutex *v3; // r0
  KMutexIntrusiveLinkPtr p_link; // r2
  bool v5; // zf
  KThreadStackParametersPtr v6; // r1
  u8 dpcFlags; // r12
  unsigned __int8 *p_dpcFlags; // r0

  if ( this->shallTerminate )
  {
    __enable_irq();
    KThread::SignalExitToDebug(this);           // inlined KThread::Exit
    KHardwareTimer::CancelTask(&g_hardwareTimer, &this->KTimerTask);
    KSchedulerLock::Lock(&g_schedulerLock);
    KSchedulerLock::Lock(&g_schedulerLock);
    schedulingMask = this->schedulingMask;
    this->schedulingMask = schedulingMask & 0xF0 | KTHREADSCHEDSTAT_TERMINATED;
    KScheduler::AdjustThreadScheduling(current.clc.current.scheduler, this, schedulingMask);
    KSchedulerLock::Unlock(&g_schedulerLock);
    KScheduler::RemoveTerminatingThread(current.clc.current.scheduler, this);
    this->signaled = 1;
    KSynchronizationObject::NotifyWaiters(this, 0);
    while ( 1 )
    {
      p_link = &ADJ(this->heldMutexListRootNode)->link;
      v5 = p_link == 0;
      if ( p_link )
      {
        v3 = ADJ(p_link);
        v5 = p_link == (KMutexIntrusiveLinkPtr)20;
      }
      if ( v5 )
      {
        KThread::RemoveVfpUsageFromCurrentContext(this);
        KWorkerTaskManager::AddTask(KWORKERTYPE_LOW_PRIO, &this->KWorkerTask);
        KSchedulerLock::Unlock(&g_schedulerLock);
        kernelpanic();
      }
      KMutex::ForceUnlock(v3, this);
    }
  }
  if ( (ADJ(this->kernelStackTop)->dpcFlags & KDPCFLAG_TERMINATE) != 0 )
    KThread::HandleDebugStopDpc(this);          // Wrong DPC flag!
                                                // 
                                                // This means the anti event/pg table deadlock stuff doesn't work (thread will resume execution!)
                                                // 
                                                // This also means attached thread may hang termination forever
  v6 = ADJ(this->kernelStackTop) + 1;
  dpcFlags = ADJ(v6)->dpcFlags;
  p_dpcFlags = &ADJ(v6)->dpcFlags;
  do
    __ldrex(p_dpcFlags);
  while ( __strex(0, p_dpcFlags) );
  if ( (dpcFlags & KDPCFLAG_OUT_OF_TIME_PAUSE) != 0 )
    KScheduler::TrySwitchingThread(current.clc.current.scheduler);
}
// FFF0CBF8: variable 'v3' is possibly undefined

//----- (FFF0CCA8) --------------------------------------------------------
KCodeSet *__fastcall KCodeSet::KCodeSet(KCodeSet *this)
{
  KCodeSet *v1; // r0
  KCodeSegment *__shifted(KCodeSet,8) v2; // r0
  KCodeSegment *__shifted(KCodeSet,0x1C) v3; // r0
  KCodeSet *result; // r0

  v1 = (KCodeSet *)KAutoObject::KAutoObject(this);
  v1->__vftable = &KCodeSet::vt;
  v2 = KCodeSegment::KCodeSegment(&v1->text);
  v3 = KCodeSegment::KCodeSegment(&ADJ(v2)->rodata);
  result = CONTAINING_RECORD(KCodeSegment::KCodeSegment(&ADJ(v3)->data), KCodeSet, data);
  result->numCodePages = 0;
  result->numConstPages = 0;
  result->numDataPages = 0;
  return result;
}

//----- (FFF0CCE8) --------------------------------------------------------
Result __fastcall KProcess::Initialize(KProcess *this, KCodeSet *codeSet, u32 *kernelCaps, u32 numCaps)
{
  unsigned __int8 *p_state; // r0
  u32 v8; // r0
  unsigned int *p_kernAllocatedForProcess; // r0
  u32 pid; // r8
  bool ShouldOnlyUseSmallPages; // r0
  unsigned __int16 *p_threadCount; // r0
  unsigned int *p_unused_234; // r0
  unsigned __int64 *p_unused_238; // r3
  unsigned __int64 *p_unused_240; // r3
  unsigned __int64 *p_unused_248; // r3
  unsigned __int64 *p_unused_250; // r3
  unsigned __int64 *p_unused_258; // r3
  unsigned __int64 *p_unused_260; // r3
  unsigned __int64 *p_unused_268; // r3
  Result result; // r0
  u32 LinearAddrRangeBase; // r0
  u32 kernelFlags; // r1

  p_state = (unsigned __int8 *)&this->state;
  do
    __ldrex(p_state);
  while ( __strex(0, p_state) );
  this->mainThread = 0;
  this->codeSet = codeSet;
  this->reslimit = 0;
  do
    v8 = __ldrex(&g_pidCounter);
  while ( __strex(v8 + 1, &g_pidCounter) );
  this->pid = v8;
  this->creationTime = KHardwareTimer::GetSystemTick(&g_hardwareTimer);
  p_kernAllocatedForProcess = &this->kernAllocatedForProcess;
  do
    __ldrex(p_kernAllocatedForProcess);
  while ( __strex(0, p_kernAllocatedForProcess) );
  pid = this->pid;
  ShouldOnlyUseSmallPages = KProcess::ShouldOnlyUseSmallPages(this->codeSet->titleId);
  KProcessPageTable::Initialize(&this->pgTable, pid, ShouldOnlyUseSmallPages);
  KAutoObject::IncrementRefcount(this->codeSet);
  KProcess::ChangeAffinityMask(&this->affinityMask, 0, 1);
  this->idealProcessor = -1;
  p_threadCount = (unsigned __int16 *)&this->threadCount;
  do
    __ldrex(p_threadCount);
  while ( __strex(0, p_threadCount) );
  p_unused_234 = &this->unused_234;
  this->maxAllowedThreadCount = 0;
  do
    __ldrex(p_unused_234);
  while ( __strex(0, p_unused_234) );
  p_unused_238 = &this->unused_238;
  do
    __ldrexd(p_unused_238);
  while ( __strexd(0LL, p_unused_238) );
  p_unused_240 = &this->unused_240;
  do
    __ldrexd(p_unused_240);
  while ( __strexd(0LL, p_unused_240) );
  p_unused_248 = &this->unused_248;
  do
    __ldrexd(p_unused_248);
  while ( __strexd(0LL, p_unused_248) );
  p_unused_250 = &this->unused_250;
  do
    __ldrexd(p_unused_250);
  while ( __strexd(0LL, p_unused_250) );
  p_unused_258 = &this->unused_258;
  do
    __ldrexd(p_unused_258);
  while ( __strexd(0LL, p_unused_258) );
  p_unused_260 = &this->unused_260;
  do
    __ldrexd(p_unused_260);
  while ( __strexd(0LL, p_unused_260) );
  p_unused_268 = &this->unused_268;
  do
    __ldrexd(p_unused_268);
  while ( __strexd(0LL, p_unused_268) );
  this->boundIrqIds[0] = 0;
  this->boundIrqIds[1] = 0;
  this->boundIrqIds[2] = 0;
  this->boundIrqIds[3] = 0;
  result = KCapability::Initialize(&this->capability, kernelCaps, numCaps, &this->pgTable);
  if ( result >= 0 )
  {
    LinearAddrRangeBase = KProcess::GetLinearAddrRangeBase(this);
    kernelFlags = this->capability.kernelFlags;
    this->pgTable.linearAddressRangeStart = LinearAddrRangeBase;
    KProcessPageTable::MapSharedConfigPages(&this->pgTable, (kernelFlags & 8) != 0);// Shared page writing cap
    KHandleTable::Initialize(&this->handleTable, this->capability.handleTableSize);
    this->debug = 0;
    result = KCodeSet::CheckAndMap(
               this->codeSet,
               &this->pgTable,
               this->capability.kernelFlags & 0xF00,
               (this->capability.kernelFlags & 0x1000) != 0);
    if ( result >= 0 )
      return 0;
  }
  return result;
}

//----- (FFF0CF78) --------------------------------------------------------
Result __fastcall KProcess::UnbindUserInterruptEventChecked(
        KProcess *this,
        KInterruptEvent *interruptEvent,
        u32 interruptId)
{
  Result result; // r0

  result = KInterruptManager::UnbindUserInterruptEventChecked(&g_interruptManager, interruptEvent, interruptId);
  if ( result >= 0 )
    this->boundIrqIds[interruptId >> 5] &= ~(1 << (interruptId & 0x1F));
  return result;
}

//----- (FFF0CFBC) --------------------------------------------------------
BOOL __fastcall KProcess::IsDebugged(KProcess *this)
{
  return this->debug != 0;
}

//----- (FFF0CFCC) --------------------------------------------------------
Result __fastcall KProcess::SetResourceLimits(KProcess *this, KResourceLimit *reslimit)
{
  ResourceLimitType v2; // r5
  s64 *currentResLimitValues; // r6
  Result result; // r0
  bool v7; // zf
  s32 CurrentValue; // r0
  s64 *v9; // r2
  KLightMutex *p_mutex; // r0
  unsigned int v11; // r2
  bool v12; // zf
  unsigned int v13; // r3
  s32 TotalCommittedMemory; // r9
  BOOL v15; // r5
  int v16; // r5
  u32 v17; // r0
  int v18; // r5
  u32 v19; // r0
  int v20; // r5
  u32 v21; // r0
  int v22; // r5
  u32 v23; // r0
  int v24; // r5
  u32 v25; // r0
  int v26; // r5
  u32 v27; // r0
  ResourceLimitType i; // r4
  s32 v29; // r0
  s64 v30[10]; // [sp+0h] [bp-70h] BYREF
  s32 outNumThreads; // [sp+50h] [bp-20h] BYREF

  result = (Result)this->reslimit;
  v7 = result == 0;
  if ( result )
  {
    result = 0xD8A093F9;
  }
  else
  {
    v2 = RESLIMIT_PRIORITY;
    currentResLimitValues = v30;
  }
  if ( v7 )
  {                                             // note how attaching the reslimit to a process does not
                                                // increment the reslimit's refcount (!!)
    do
    {
      CurrentValue = KResourceLimit::GetCurrentValue(reslimit, v2);
      v9 = &currentResLimitValues[v2++];
      *v9 = CurrentValue;
    }
    while ( (unsigned int)v2 < RESLIMIT_MAX );
    p_mutex = &this->pgTable.mutex;
    v11 = __ldrex((unsigned int *)&this->pgTable);
    v12 = v11 == 0;
    if ( v11 )
      v13 = __strex(v11, (unsigned int *)p_mutex);
    else
      v13 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)p_mutex);
    if ( !v11 )
      v12 = v13 == 0;
    if ( !v12 )
      KLightMutex::LockImpl(p_mutex);
    __mcr(15, 0, 0, 7, 10, 5);
    TotalCommittedMemory = KMemoryBlockManager::GetTotalCommittedMemory(&this->pgTable.memoryBlockMgr);
    __mcr(15, 0, 0, 7, 10, 5);
    this->pgTable.mutex.lockingThread = 0;
    if ( this->pgTable.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&this->pgTable.mutex);
    v15 = KResourceLimit::Reserve(reslimit, RESLIMIT_COMMIT, TotalCommittedMemory);
    KProcess::DumpThreadIds(this, &outNumThreads, 0, 0);
    v16 = v15 & KResourceLimit::Reserve(reslimit, RESLIMIT_THREAD, outNumThreads);
    v17 = KObjectAllocator::CountObjectsOwnedByProcess(&g_eventAllocator, this);
    v18 = v16 & KResourceLimit::Reserve(reslimit, RESLIMIT_EVENT, v17);
    v19 = KObjectAllocator::CountObjectsOwnedByProcess(&g_mutexAllocator, this);
    v20 = v18 & KResourceLimit::Reserve(reslimit, RESLIMIT_MUTEX, v19);
    v21 = KObjectAllocator::CountObjectsOwnedByProcess(&g_semaphoreAllocator, this);
    v22 = v20 & KResourceLimit::Reserve(reslimit, RESLIMIT_SEMAPHORE, v21);
    v23 = KObjectAllocator::CountObjectsOwnedByProcess(&g_timerAllocator, this);
    v24 = v22 & KResourceLimit::Reserve(reslimit, RESLIMIT_TIMER, v23);
    v25 = KObjectAllocator::CountObjectsOwnedByProcess(&g_sharedMemoryAllocator, this);
    v26 = v24 & KResourceLimit::Reserve(reslimit, RESLIMIT_SHAREDMEMORY, v25);
    v27 = KObjectAllocator::CountObjectsOwnedByProcess(&g_addressArbiterAllocator, this);
    if ( (KResourceLimit::Reserve(reslimit, RESLIMIT_ADDRESSARBITER, v27) & v26) != 0 )
    {
      result = 0;
      this->reslimit = reslimit;
    }
    else
    {
      for ( i = RESLIMIT_PRIORITY; (unsigned int)i < RESLIMIT_MAX; ++i )
      {
        v29 = KResourceLimit::GetCurrentValue(reslimit, i);// not sure what the point is here...
        KResourceLimit::Release(reslimit, i, v29);
        KResourceLimit::Reserve(reslimit, i, currentResLimitValues[i]);
      }
      return 0xD8609013;
    }
  }
  return result;
}
// FFF0D000: variable 'v2' is possibly undefined
// FFF0D004: variable 'currentResLimitValues' is possibly undefined

//----- (FFF0D1E0) --------------------------------------------------------
Result __fastcall KProcess::Run(KProcess *this, u32 mainThreadPrio, u32 mainThreadStackSize)
{
  KResourceLimit *reslimit; // r4
  bool v6; // r6
  KResourceLimit *v8; // r0
  Result v9; // r0
  bool v10; // zf
  Result v11; // r5
  bool v12; // zf
  KThread *v13; // r0
  KThread *v14; // r9
  KThread *v15; // r0
  unsigned __int8 *p_state; // r0
  bool v17; // zf

  reslimit = this->reslimit;
  if ( reslimit )
    v6 = KResourceLimit::Reserve(this->reslimit, RESLIMIT_THREAD, 1);
  else
    v6 = KPROCSTATE_RUNNING;
  if ( !v6 )
    return 0xC860180C;
  v8 = this->reslimit;
  if ( v8 && !KResourceLimit::Reserve(v8, RESLIMIT_COMMIT, mainThreadStackSize) )
  {
    v11 = 0xC860180A;
    v12 = reslimit == 0;
    if ( reslimit )
      v12 = !v6;
    if ( v12 )
      return v11;
LABEL_12:
    KResourceLimit::Release(reslimit, RESLIMIT_THREAD, 1);
    return v11;
  }
  v9 = KPageTable::Operate(
         &this->pgTable,
         0x10000000 - mainThreadStackSize,
         mainThreadStackSize >> 12,
         0,
         KMEMSTATE_LOCKED,
         KMEMPERM_KRW_RW,
         KMEMUPDATE_NONE,
         this->capability.kernelFlags & 0xF00);
  if ( v9 < 0 )
  {
    v10 = reslimit == 0;
    v11 = v9;
    if ( reslimit )
      v10 = !v6;
    if ( v10 )
      return v11;
    goto LABEL_12;
  }
  v13 = (KThread *)KSlabHeap::Allocate(&g_threadAllocator.slabHeap);
  v14 = v13;
  if ( v13 )
  {
    v15 = (KThread *)KSynchronizationObject::KSynchronizationObject(v13);
    v15->KTimerTask::next = 0;
    v15->KWorkerTask::next = 0;
    v15->KSynchronizationObject::KAutoObject::__vftable = &KThread::vt;
    v15->KTimerTask::__vftable = &KThread::vt_KTimerTask;
    v15->KInterruptTask::next = 0;
    v15->KWorkerTask::__vftable = &KThread::vt_KWorkerTask;
    v15->KInterruptTask::KInterruptHandler::__vftable = &KThread::vt_KInterruptTask;
    v15->shallTerminate = 0;
    v15->wantedLightMutex = 0;
    v15->synchronizationResult = 0xE7E3FFFF;
    v15->syncObjectWaitAllList.link.next = (KSynchronizationObjectLinkedListNode *)&v15->syncObjectWaitAllList.link;
    v15->syncObjectWaitAllList.count = 0;
    v15->syncObjectWaitAllList.link.prev = (KSynchronizationObjectLinkedListNode *)&v15->syncObjectWaitAllList.link;
    v15->heldMutexListRootNode = 0;
    v15->mutexTryingToAcquireList.link.next = (KMutexLinkedListNode *)&v15->mutexTryingToAcquireList.link;
    v15->mutexTryingToAcquireList.count = 0;
    v15->mutexTryingToAcquireList.link.prev = (KMutexLinkedListNode *)&v15->mutexTryingToAcquireList.link;
    v15->affinityMask = 0;
    v15->owner = 0;
    v15->context = 0;
    KAutoObject::Initialize(v14);
  }
  this->mainThread = v14;
  if ( !v14 )
  {
    v11 = 0xC8601803;
    v17 = reslimit == 0;
    if ( reslimit )
      v17 = !v6;
    if ( v17 )
      return v11;
    goto LABEL_12;
  }
  KThread::InitializeUserThread(
    this->mainThread,
    this->codeSet->text.baseUserVa,
    0,
    0x10000000u,
    mainThreadPrio,
    -2,
    this);
  KObjectAllocator::Register(&g_threadAllocator, this->mainThread);
  p_state = (unsigned __int8 *)&this->state;
  do
    __ldrex(p_state);
  while ( __strex(KPROCSTATE_RUNNING, p_state) );
  KThread::PrepareToRun(this->mainThread);
  return 0;
}
// FFF0D310: conditional instruction was optimized away because r0.4!=0
// FFF0D400: conditional instruction was optimized away because zf.1==1

//----- (FFF0D460) --------------------------------------------------------
Result __fastcall KProcess::BindUserInterruptEvent(
        KProcess *this,
        KInterruptEvent *interruptEvent,
        u32 irqId,
        s32 coreId,
        s32 priority,
        bool levelSensitive)
{
  Result result; // r0

  if ( irqId >= 0x80 || ((this->capability.irqAcl[irqId >> 5] >> (irqId & 0x1F)) & 1) == 0 )
    return 0xD92007EA;
  result = KInterruptManager::BindUserInterruptEvent(
             &g_interruptManager,
             interruptEvent,
             irqId,
             coreId,
             priority,
             1,
             levelSensitive);
  if ( result >= 0 )
    this->boundIrqIds[irqId >> 5] |= 1 << (irqId & 0x1F);
  return result;
}

//----- (FFF0D4EC) --------------------------------------------------------
void __fastcall KDebug::DoWorkerTask(KWorkerTask *__shifted(KDebug,0x14) this)
{
  KProcess::TerminateOtherProcess(ADJ(this)->process);
}

//----- (FFF0D4F4) --------------------------------------------------------
Result __fastcall KProcess::TerminateOtherProcess(KProcess *this)
{
  unsigned __int8 *p_state; // r1

  KProcess::SetDebugTerminatedFlag(this);
  if ( KProcess::TerminateImpl1(this) )
  {
    p_state = (unsigned __int8 *)&this->state;
    do
      __ldrex(p_state);
    while ( __strex(KPROCSTATE_TERMINATED, p_state) );
    KSynchronizationObject::NotifyWaiters(this, 0);
    this->DecrementRefcount(this);
  }
  return 0;
}

//----- (FFF0D554) --------------------------------------------------------
void __fastcall SetEightBytesTo1(bool *statusArray, bool isFree)
{
  int v2; // r1

  v2 = isFree | (isFree << 8) | ((isFree | (isFree << 8)) << 16);
  *(_DWORD *)statusArray = v2;
  *((_DWORD *)statusArray + 1) = v2;
}

//----- (FFF0D56C) --------------------------------------------------------
// local variable allocation has failed, the output may be wrong!
KFiqState __fastcall KFiqState::CompareExchangeStrong(KFiqState *this, KFiqState oldVal, KFiqState newVal)
{
  int v3; // r3
  unsigned int v4; // r1
  unsigned __int8 v5; // r2

  v4 = oldVal & 0xFFFF00FF | v3 & 0xFFFF0000 | (unsigned __int16)((_WORD)newVal << 8);
  while ( 1 )
  {
    v5 = __ldrex((unsigned __int8 *)this);
    v4 = v4 & 0xFF00FFFF | (v5 << 16) & 0xFF0000;
    if ( v5 != (unsigned __int8)v4 )
      break;
    if ( !__strex(v4 << 16 >> 24, (unsigned __int8 *)this) )
      return v4 << 8 >> 24;
  }
  __clrex();
  return v4 << 8 >> 24;
}
// FFF0D56C: variables would overlap: r2.1 and r2.2

//----- (FFF0D5D4) --------------------------------------------------------
void __fastcall KFiqState::Set(KFiqState *this, KFiqState newState)
{
  do
    __ldrex((unsigned __int8 *)this);
  while ( __strex(newState, (unsigned __int8 *)this) );
}

//----- (FFF0D5FC) --------------------------------------------------------
KInterruptEvent *__fastcall KHandleTable::ConvertToInterruptEvent(KHandleTable *this, Handle handle)
{
  KInterruptEvent *result; // r0
  KInterruptEvent *v3; // r4
  unsigned __int8 v4; // r6
  int v5; // r1
  KInterruptEvent *v6; // r5
  _BYTE v7[8]; // [sp+0h] [bp-20h] BYREF
  char v8; // [sp+8h] [bp-18h] BYREF
  int v9; // [sp+Ch] [bp-14h]

  result = (KInterruptEvent *)KHandleTable::ConvertToAutoObject(this, handle);
  v3 = result;
  if ( result )
  {
    result->GetTypeObj((KTypeObj *)v7, result);
    v4 = v7[4];
    v3->GetTypeObj((KTypeObj *)&v8, v3);
    v5 = v4 | 3;
    if ( v5 == (unsigned __int8)v9 )
      v6 = v3;
    else
      v6 = 0;
    if ( v5 != (unsigned __int8)v9 )
      v3->DecrementRefcount(v3);
    return v6;
  }
  return result;
}

//----- (FFF0D684) --------------------------------------------------------
void __fastcall KThreadContext::LoadVfp(KThreadContext *ctx)
{
  _R1 = ctx->fpscr;
  __asm { VMSR            FPSCR, R1 }
}

//----- (FFF0D698) --------------------------------------------------------
bool __fastcall KScheduler::RemoveTerminatingThread(KScheduler *this, KThread *thread)
{
  KSchedulerLock::Lock(&g_schedulerLock);
  if ( (thread->schedulingMask & 0xF) == KTHREADSCHEDSTAT_RUNNING )
    KScheduler::RemoveThread(this, thread, thread->dynamicPriority);
  thread->alive = 0;
  KSchedulerLock::Unlock(&g_schedulerLock);
  return 1;
}

//----- (FFF0D6E8) --------------------------------------------------------
Result __fastcall KScheduler::ChangeAppPreemptionMode(u32 newMode)
{
  Result v2; // r4

  KSchedulerLock::Lock(&g_schedulerLock);
  if ( g_schedulerAppPreemptionMode == newMode )
    goto LABEL_6;
  v2 = 0xC8A01414;
  if ( !g_cpuTimeLimiterMode0.active && !g_cpuTimeLimiterMode1.active )
  {
    g_schedulerAppPreemptionMode = newMode;
LABEL_6:
    v2 = 0;
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
  return v2;
}

//----- (FFF0D75C) --------------------------------------------------------
void __fastcall KScheduler::YieldCurrentThread(KScheduler *this)
{
  KThread *volatile curThread; // r5
  unsigned __int32 prio; // r1
  KThreadIntrusiveLink *p_link; // r0
  KThread *next; // r3
  KThread *prev; // r1
  KThread *v7; // r12
  KThreadIntrusiveLink *v8; // r7
  s32 dynamicPriority; // r0
  int coreId; // r8
  KThreadIntrusiveList *v11; // r1
  KThreadIntrusiveLink *v12; // r12
  BOOL v13; // r9
  KThreadIntrusiveLink *v14; // r10
  int v15; // r2
  unsigned int CPSR; // r5

  curThread = current.clc.current.thread;
  KSchedulerLock::Lock(&g_schedulerLock);
  prio = curThread->dynamicPriority;
  p_link = &this->threadsByPrio[prio].link;
  next = this->threadsByPrio[prio].link.next;
  if ( next && next == p_link->prev )
    this->prioBitfield[prio >> 5] &= ~(0x80000000 >> (prio & 0x1F));// no more threads with that priority
  __mcr(15, 0, 0, 7, 10, 5);
  prev = curThread->link.prev;
  v7 = curThread->link.next;
  if ( prev )
    v8 = &prev->link;
  else
    v8 = p_link;
  if ( v7 )
    p_link = &v7->link;
  v8->next = v7;
  p_link->prev = prev;
  --this->numThreads;                           // remove thread
  if ( g_coreLocalRegions[this->coreId].clc.current.thread == curThread )// almost always true except on rare occurences just after creation?
    this->reschedule = 1;
  dynamicPriority = curThread->dynamicPriority; // and now insert it back
  coreId = this->coreId;
  v11 = &this->threadsByPrio[dynamicPriority];
  v12 = (KThreadIntrusiveLink *)v11->link.prev;
  v13 = this->threadsByPrio[dynamicPriority].link.next == 0;
  if ( v11->link.prev )
    v14 = v12 + 20;
  else
    v14 = &this->threadsByPrio[dynamicPriority].link;
  curThread->link.next = 0;
  curThread->link.prev = (KThread *)v12;
  v14->next = curThread;
  v11->link.prev = curThread;
  __mcr(15, 0, 0, 7, 10, 5);
  if ( v13 )
    this->prioBitfield[(unsigned int)dynamicPriority >> 5] |= 0x80000000 >> (dynamicPriority & 0x1F);
  v15 = this->coreId;
  ++this->numThreads;
  if ( v15 != coreId || current.clc.current.thread->dynamicPriority > dynamicPriority )
    this->reschedule = 1;
  this->disableCount = 2;
  KSchedulerLock::Unlock(&g_schedulerLock);
  CPSR = __get_CPSR();
  __disable_irq();
  this->disableCount = 0;
  this->reschedule = 1;
  KScheduler::SwitchThread(this, 0);
  __set_CPSR(CPSR);
}

//----- (FFF0D8DC) --------------------------------------------------------
void __fastcall KScheduler::InitializeNewThread(KScheduler *this, KThread *thread)
{
  u32 coreId; // r1
  signed __int32 idealProcessor; // r1
  signed __int32 i; // r4
  int v7; // r0
  signed __int32 v8; // r1
  int v9; // r0
  KAffinityMask affinityMask; // [sp+0h] [bp-18h] BYREF

  KSchedulerLock::Lock(&g_schedulerLock);
  coreId = thread->coreId;
  thread->alive = 1;
  if ( coreId == -1 )
  {
    affinityMask = thread->affinityMask;
    idealProcessor = thread->idealProcessor;
    if ( idealProcessor >= 0 && KAffinityMask::CheckCoreAllowed(&affinityMask, idealProcessor) )
    {
      i = thread->idealProcessor;
    }
    else
    {
      for ( i = 0; ; ++i )
      {
        v7 = (MPCORE.scu.cfgr & 3) + 1;
        if ( v7 <= i )
          kernelpanic();
        if ( KAffinityMask::CheckCoreAllowed(&affinityMask, i) )
          break;
      }
    }
    v8 = thread->coreId;
    thread->coreId = i;
    if ( v8 >= 0 )
    {
      v9 = (MPCORE.scu.cfgr & 3) + 1;
      if ( v9 > v8 )
        KVfpRegisterDumpHelper::DumpAndDisableVfpRegsForThread(thread, v8);
    }
  }
  if ( (thread->schedulingMask & 0xF) == KTHREADSCHEDSTAT_RUNNING )
    KScheduler::AddThread(this, thread);
  KSchedulerLock::Unlock(&g_schedulerLock);
}

//----- (FFF0D9C8) --------------------------------------------------------
void __fastcall KSemaphore::Initialize(KSemaphore *this, KProcess *ownerProcess, s32 initialCount, s32 maxCount)
{
  unsigned int *p_count; // r0

  KAutoObject::IncrementRefcount(ownerProcess);
  p_count = (unsigned int *)&this->count;
  this->ownerProcess = ownerProcess;
  do
    __ldrex(p_count);
  while ( __strex(initialCount, p_count) );
  this->maxCount = maxCount;
}

//----- (FFF0DA04) --------------------------------------------------------
Result __fastcall KSemaphore::Release(KSemaphore *this, s32 *outCount, s32 releaseCount)
{
  unsigned int *p_count; // r3
  s32 maxCount; // r12
  s32 v6; // r4
  Result result; // r0

  p_count = (unsigned int *)&this->count;
  maxCount = this->maxCount;
  do
  {
    v6 = __ldrex(p_count);
    if ( v6 + releaseCount > maxCount )
    {
      __clrex();
      return 0xD8E007FD;
    }
  }
  while ( __strex(v6 + releaseCount, p_count) );
  KSynchronizationObject::NotifyWaiters(this, 0);
  result = 0;
  *outCount = v6;
  return result;
}

//----- (FFF0DA54) --------------------------------------------------------
Result __fastcall KClientPort::CreateSession(KClientPort *this, KClientSession **outClientSessionPtr)
{
  int maxSessionCount; // r2
  unsigned __int16 *p_currentSessionCount; // r0
  signed __int16 v6; // r1
  KSession *v7; // r0
  KSession *v8; // r4
  KSession *v9; // r0
  KServerSession *__shifted(KSession,8) v10; // r0
  KClientSession *v11; // r0
  unsigned __int16 *v12; // r1
  unsigned __int16 v14; // r0

  maxSessionCount = this->maxSessionCount;
  p_currentSessionCount = (unsigned __int16 *)&this->currentSessionCount;
  do
  {
    v6 = __ldrex(p_currentSessionCount);
    if ( v6 >= maxSessionCount )
    {
      __clrex();
      return 0xD0401834;
    }
  }
  while ( __strex(v6 + 1, p_currentSessionCount) );
  v7 = (KSession *)KSlabHeap::Allocate(&g_sessionAllocator.slabHeap);
  v8 = v7;
  if ( v7 )
  {
    v9 = (KSession *)KAutoObject::KAutoObject(v7);
    v9->__vftable = &KSession::vt;
    v10 = (KServerSession *__shifted(KSession,8))KSynchronizationObject::KSynchronizationObject(&v9->server);
    ADJ(v10)->server.__vftable = &KServerSession::vt;
    ADJ(v10)->server.syncRequestWaitList.link.prev = 0;
    ADJ(v10)->server.syncRequestWaitList.link.next = 0;
    ADJ(v10)->server.currentRequestingThread = 0;
    v11 = (KClientSession *)KSynchronizationObject::KSynchronizationObject(&ADJ(v10)->client);
    v11->__vftable = &KClientSession::vt;
    v11->status = 0;
    KAutoObject::Initialize(v8);
  }
  if ( v8 )
  {
    KSession::Initialize(v8, this);
    KObjectAllocator::Register(&g_sessionAllocator, v8);
    KServerPort::Connect(&this->parent->server, &v8->server);
    *outClientSessionPtr = &v8->client;
    return 0;
  }
  else
  {
    v12 = (unsigned __int16 *)&this->currentSessionCount;
    do
      v14 = __ldrex(v12);
    while ( __strex(v14 - 1, v12) );
    if ( this->maxSessionCount == v14 )
      KSynchronizationObject::NotifyWaiters(this, 0);// client port became available
    return 0xC8601809;
  }
}
// FFF0DAB8: conditional instruction was optimized away because r0.4!=0

//----- (FFF0DBB4) --------------------------------------------------------
void __fastcall KDmaManager::AbortAll(KDmaManager *this)
{
  int i; // r4

  for ( i = 0; i < 8; ++i )
    KDmaChannel::AbortTransferForPowerStateChange(&g_dmaChannels[(char)i]);
  KDmaController::KillManagerThread();
  KDmaController::ClearAllInterrupts();
}

//----- (FFF0DBF4) --------------------------------------------------------
Result __fastcall KDmaManager::CheckAndPrepareChannelRestart(
        KDmaManager *this,
        s8 channelId,
        u32 dstAddr,
        u32 srcAddr,
        u32 size,
        DmaRestartFlags restartFlags)
{
  int state; // r0
  bool v7; // zf

  state = (unsigned __int8)g_dmaChannels[channelId].state;
  v7 = state == KDMACHANSTATE_STARTED;
  if ( state != KDMACHANSTATE_STARTED )
    v7 = state == KDMACHANSTATE_RESTARTED;
  if ( v7 )
    return 0xD04007F0;                          // kernel9 has additional locking code here (iirc)
  else
    return 0;
}

//----- (FFF0DC24) --------------------------------------------------------
KAutoObject *__fastcall KObjectName::FindObject(const char *name)
{
  unsigned int v2; // r2
  bool v3; // zf
  unsigned int v4; // r3
  KObjectNameLinkedListNode *next; // r3
  KObjectName *objectName; // r2
  int v7; // r1
  KAutoObject *obj; // r4

  v2 = __ldrex((unsigned int *)&g_objectNameListMutex);
  v3 = v2 == 0;
  if ( v2 )
    v4 = __strex(v2, (unsigned int *)&g_objectNameListMutex);
  else
    v4 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_objectNameListMutex);
  if ( !v2 )
    v3 = v4 == 0;
  if ( !v3 )
    KLightMutex::LockImpl(&g_objectNameListMutex);
  __mcr(15, 0, 0, 7, 10, 5);
  next = g_objectNameList.link.next;
  if ( (KObjectNameLinkedListLink *)g_objectNameList.link.next == &g_objectNameList.link )
  {
LABEL_13:
    __mcr(15, 0, 0, 7, 10, 5);
    g_objectNameListMutex.lockingThread = 0;
    if ( g_objectNameListMutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_objectNameListMutex);
    return 0;
  }
  else
  {
    while ( 1 )
    {
      objectName = next->objectName;
      v7 = 0;
      if ( objectName->name[0] == *name )
        break;
LABEL_12:
      next = next->link.next;
      if ( next == (KObjectNameLinkedListNode *)&g_objectNameList.link )
        goto LABEL_13;
    }
    while ( objectName->name[v7] )
    {
      ++v7;
      if ( objectName->name[v7] != name[v7] )
        goto LABEL_12;
    }
    obj = objectName->obj;
    KAutoObject::IncrementRefcount(obj);
    __mcr(15, 0, 0, 7, 10, 5);
    g_objectNameListMutex.lockingThread = 0;
    if ( g_objectNameListMutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_objectNameListMutex);
    return obj;
  }
}

//----- (FFF0DD08) --------------------------------------------------------
Result __fastcall KObjectName::RegisterObject(KAutoObject *obj, const char *name)
{
  KObjectName *objName; // r0
  KObjectName *v5; // r4
  unsigned int v7; // r2
  bool v8; // zf
  unsigned int v9; // r3
  KLinkedListNode *v10; // r0

  objName = (KObjectName *)KSlabHeap::Allocate(&g_objectNameSlabHeap);
  v5 = objName;
  if ( !objName )
    return 0xD86007F3;
  *(_DWORD *)objName->name = 0;
  *(_DWORD *)&objName->name[4] = 0;
  *(_DWORD *)&objName->name[8] = 0;
  objName->obj = 0;
  objName->obj = obj;
  strncpy(objName->name, name, 0xCu);
  v5->name[11] = 0;
  KAutoObject::IncrementRefcount(obj);          // note: there's no "unregister" method, therefore this will prevent the object from being deleted forever
  v7 = __ldrex((unsigned int *)&g_objectNameListMutex);
  v8 = v7 == 0;
  if ( v7 )
    v9 = __strex(v7, (unsigned int *)&g_objectNameListMutex);
  else
    v9 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_objectNameListMutex);
  if ( !v7 )
    v8 = v9 == 0;
  if ( !v8 )
    KLightMutex::LockImpl(&g_objectNameListMutex);
  __mcr(15, 0, 0, 7, 10, 5);
  v10 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
  if ( v10 )
  {
    v10->link.next = 0;
    v10->link.prev = 0;
    v10->data = 0;
  }
  v10->data = v5;
  KLinkedList::InsertAfter((KLinkedList *)&g_objectNameList, (KLinkedListLink *)&g_objectNameList.link, v10);
  __mcr(15, 0, 0, 7, 10, 5);
  g_objectNameListMutex.lockingThread = 0;
  if ( g_objectNameListMutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_objectNameListMutex);
  return 0;
}
// FFF0DD3C: conditional instruction was optimized away because r0.4!=0
// FFF0DDD0: conditional instruction was optimized away because r0.4!=0

//----- (FFF0DE2C) --------------------------------------------------------
KServerSession *__fastcall KServerPort::AcceptSession(KServerPort *this)
{
  KServerSessionLinkedListNode *next; // r4
  KServerSession *serverSession; // r6
  KServerSessionLinkedListNode *v5; // [sp+0h] [bp-18h] BYREF

  KSchedulerLock::Lock(&g_schedulerLock);
  if ( this->incomingServerSessions.count )
  {
    next = this->incomingServerSessions.link.next;
    serverSession = next->serverSession;
    v5 = next;
    KLinkedList::EraseNode((KLinkedList *)&this->incomingServerSessions, (KLinkedListLink **)&v5);
    KSlabHeap::Free(&g_linkedListNodeSlabHeap, next);
    KSchedulerLock::Unlock(&g_schedulerLock);
    return serverSession;
  }
  else
  {
    KSchedulerLock::Unlock(&g_schedulerLock);
    return 0;
  }
}

//----- (FFF0DE94) --------------------------------------------------------
void __fastcall KCodeSegment::EnsureCacheCoherencyForCode(KCodeSegment *this)
{
  KBlockInfoLinkedListNode *node; // r4
  KBlockInfo *blockInfo; // r0
  u32 baseAddress; // r7
  u32 v5; // r6

  for ( node = this->pgGroup.list.link.next;
        node != (KBlockInfoLinkedListNode *)&this->pgGroup.list.link;
        node = node->link.next )
  {
    blockInfo = node->blockInfo;
    baseAddress = blockInfo->baseAddress;
    v5 = blockInfo->numPages << 12;
    KPageTable::CleanInvalidateDataCacheRange(blockInfo->baseAddress, v5);
    KPageTable::CleanInvalidateInstructionCacheRange(baseAddress, v5);
  }
}

//----- (FFF0DEE0) --------------------------------------------------------
KCodeSegment *__fastcall KCodeSegment::KCodeSegment(KCodeSegment *this)
{
  this->baseUserVa = 0;
  this->totalNumPages = 0;
  return CONTAINING_RECORD(KPageGroup::KPageGroup(&this->pgGroup), KCodeSegment, pgGroup);
}

//----- (FFF0DF00) --------------------------------------------------------
Result __fastcall KHandleTable::Initialize(KHandleTable *this, s32 handleTableSize)
{
  unsigned int v4; // r2
  bool v5; // zf
  unsigned int v6; // r3
  KHandleTableEntry *Contiguous; // r10
  unsigned int v8; // r2
  Result result; // r0
  int i; // r0
  KHandleTableEntry *v11; // r1
  KHandleTableEntry *v12; // r1

  if ( (unsigned int)handleTableSize <= 0x28 )
  {
    if ( handleTableSize <= 0 )
      LOWORD(handleTableSize) = 40;
    this->entries = this->internalTable;
    this->handleTableSize = handleTableSize;
    goto LABEL_25;
  }
  v4 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  v5 = v4 == 0;
  if ( v4 )
    v6 = __strex(v4, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  else
    v6 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( !v4 )
    v5 = v6 == 0;
  if ( !v5 )
    KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  Contiguous = (KHandleTableEntry *)KPageHeap::AllocateContiguous(
                                      &g_memoryManager.baseHeap,
                                      (unsigned int)(8 * handleTableSize + 4095) >> 12,
                                      0);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  if ( !Contiguous )
    return 0xD86007F3;
  v8 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( v8 )
  {
    __strex(v8, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  }
  else if ( !__strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex) )
  {
    goto LABEL_16;
  }
  KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
LABEL_16:
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)Contiguous, (unsigned int)(8 * handleTableSize + 4095) >> 12);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  this->entries = Contiguous;
  this->handleTableSize = handleTableSize;
LABEL_25:
  this->nextId = 1;
  this->count = 0;
  this->maxCount = 0;
  for ( i = 0; this->handleTableSize - 1 > i; ++i )
  {
    v11 = &this->entries[i];
    v11->used.info = (u32)&this->entries[i + 1];
    v11->used.object = 0;
  }
  result = 0;
  v12 = &this->entries[this->handleTableSize - 1];
  v12->used.object = 0;
  v12->used.info = 0;
  this->firstFreeEntry = this->entries;
  return result;
}

//----- (FFF0E148) --------------------------------------------------------
void __fastcall KProcess::ChangeAffinityMask(u8 *newAffMask, u8 affMask, bool add)
{
  bool v3; // zf
  u8 v4; // r2
  int v5; // r1
  u8 v6; // r1

  v3 = !add;
  v4 = *newAffMask;
  v5 = 1 << affMask;
  if ( v3 )
    v6 = v4 & ~(_BYTE)v5;
  else
    v6 = v5 | v4;
  *newAffMask = v6;
}

//----- (FFF0E168) --------------------------------------------------------
void __fastcall KAffinityMask::MakeAllCoresMask(KAffinityMask *result)
{
  char cfgr; // r1

  cfgr = MPCORE.scu.cfgr;
  *result = ~(-1 << ((cfgr & 3) + 1));
}

//----- (FFF0E18C) --------------------------------------------------------
Result __fastcall KSharedMemory::Initialize(
        KSharedMemory *this,
        KProcess *ownerProcess,
        u32 addr,
        u32 size,
        u32 ownerPerms,
        u32 othersPerms)
{
  unsigned __int8 *p_sharedMemMapRefcount; // r0
  u32 numPages; // r7
  u32 v12; // r0
  bool v13; // zf
  KResourceLimit *reslimit; // r8
  u32 kernelFlags; // r0
  unsigned int v16; // r2
  bool v17; // zf
  unsigned int v18; // r3
  int v19; // r0
  void *Contiguous; // r11
  KPageHeapBlock *next; // r5
  unsigned int *p_kernAllocatedForProcess; // r0
  unsigned int v23; // r1
  unsigned __int8 *v24; // r0
  int v25; // r7
  bool v27; // zf
  unsigned __int8 *v28; // r0
  KPageHeapBlock *ContiguousBackwards; // r0
  unsigned __int8 *v30; // r0
  u32 v31; // [sp+8h] [bp-40h]
  __int16 newPerms; // [sp+Ch] [bp-3Ch]
  KProcessPageTable *addra; // [sp+10h] [bp-38h]
  u32 addr_4; // [sp+14h] [bp-34h]
  KPageGroup pgGrp; // [sp+18h] [bp-30h] BYREF

  this->othersPerms = othersPerms;
  this->ownerPerms = ownerPerms;
  this->ownerProcess = ownerProcess;
  this->isDeviceSharedMem = 0;
  p_sharedMemMapRefcount = (unsigned __int8 *)&this->sharedMemMapRefcount;
  do
    __ldrex(p_sharedMemMapRefcount);
  while ( __strex(0xFFu, p_sharedMemMapRefcount) );
  numPages = (size + 4095) >> 12;
  this->transferMemAddress = addr;
  if ( addr )
  {
    addra = &ownerProcess->pgTable;
    v12 = ((__int64)current.clc.current.process->codeSet->titleId >> 8) & 0xFFFFF;
    v13 = v12 == 0x36E;                         // Skylanders: Spyros Adventure (us, eu)
    if ( v12 != 0x36E )
      v13 = v12 == 0x4C0;
    if ( v13 && size == 0x2000 )
      goto LABEL_54;
    v27 = v12 == 0x531;                         // VectorRacing (jp, us)
    if ( v12 != 0x531 )
      v27 = v12 == 0x8B8;
    if ( v27 && size == 0x14000 )
    {
LABEL_54:
      this->workaround = 1;
      addr_4 = addr + (numPages << 12) - 4096;
      if ( KPageTable::AnalyzeRange(addra, &this->pgGrp, addr, numPages - 1) < 0 )// 
                                                // 
                                                // skylanders/vectorracing workaround:
                                                // 
                                                // - sharedmem is: <all but last page> + a freshly allocated page
                                                // - last page (which is not actually part of the shardmem) is reprotected back to rw
        kernelpanic();
      if ( KPageTable::CheckAndChangeGroupStateAndPerms(
             addra,
             addr,
             &this->pgGrp,
             KMEMSTATE_FLAGS_ANY,
             KMEMSTATE_PRIVATE_DATA,
             KMEMPERM_KRW_RW,
             KMEMSTATE_LOCKED,
             (KMemoryPermission)(ownerPerms | KMEMPERM_KRW)) < 0 )
        kernelpanic();
      KPageGroup::KPageGroup(&pgGrp);
      if ( KPageTable::AnalyzeRange(addra, &pgGrp, addr_4, 1u) < 0 )
        kernelpanic();
      v25 = KPageTable::CheckAndChangeGroupStateAndPerms(
              addra,
              addr_4,
              &pgGrp,
              KMEMSTATE_FLAGS_ANY,
              KMEMSTATE_PRIVATE_DATA,
              KMEMPERM_KRW_RW,
              KMEMSTATE_LOCKED,
              KMEMPERM_KRW_RW);
      if ( v25 < 0 )
        kernelpanic();
      KPageGroup::EraseAll(&pgGrp);
      ContiguousBackwards = KMemoryManager::AllocateContiguousBackwards(&g_memoryManager, 1u, MEMOP_REGION_BASE);
      if ( !ContiguousBackwards )
        kernelpanic();
      KPageGroup::AddRange(&this->pgGrp, (u32)ContiguousBackwards, ContiguousBackwards->numPages);
      KPageGroup::~KPageGroup(&pgGrp);
      KPageGroup::IncrefPages(&this->pgGrp);
      KAutoObject::IncrementRefcount(this->ownerProcess);
      v30 = (unsigned __int8 *)&this->sharedMemMapRefcount;
      do
        __ldrex(v30);
      while ( __strex(1u, v30) );
    }
    else
    {                                           // no workaround
      v25 = KPageTable::AnalyzeRange(addra, &this->pgGrp, addr, (size + 4095) >> 12);
      if ( v25 >= 0 )
      {
        v25 = KPageTable::CheckAndChangeGroupStateAndPerms(
                addra,
                addr,
                &this->pgGrp,
                KMEMSTATE_FLAGS_ANY,
                KMEMSTATE_PRIVATE_DATA,
                KMEMPERM_KRW_RW,
                KMEMSTATE_LOCKED,
                (KMemoryPermission)(ownerPerms | KMEMPERM_KRW));
        if ( v25 >= 0 )
        {
          KPageGroup::IncrefPages(&this->pgGrp);
          KAutoObject::IncrementRefcount(this->ownerProcess);
          v28 = (unsigned __int8 *)&this->sharedMemMapRefcount;
          do
            __ldrex(v28);
          while ( __strex(1u, v28) );
        }
      }
    }
    return v25;
  }
  if ( numPages )                               // sharedmem, alloc new pages
                                                // applications are not allowed to do this
  {
    reslimit = ownerProcess->reslimit;
    if ( reslimit )
      v31 = KResourceLimit::Reserve(reslimit, RESLIMIT_COMMIT, numPages << 12) | othersPerms & 0xFFFFFF00;
    else
      LOBYTE(v31) = 1;
    kernelFlags = ownerProcess->capability.kernelFlags;
    if ( (kernelFlags & 0x40) == 0 )            // NOT "shared device memory" flag
    {
      next = KMemoryManager::AllocateContiguousBackwards(&g_memoryManager, (size + 4095) >> 12, MEMOP_REGION_BASE);
      if ( next )
      {
        do
        {
          KPageGroup::AddRange(&this->pgGrp, (u32)next, next->numPages);
          next = next->link.next;
        }
        while ( next );
        goto LABEL_36;
      }
      if ( reslimit && (_BYTE)v31 )
LABEL_26:
        KResourceLimit::Release(reslimit, RESLIMIT_COMMIT, numPages << 12);
      return 0xD86007F3;
    }
    newPerms = kernelFlags & 0xF00;
    v16 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
    v17 = v16 == 0;
    if ( v16 )
      v18 = __strex(v16, (unsigned int *)&g_memoryManager.pgMgr.mutex);
    else
      v18 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
    if ( !v16 )
      v17 = v18 == 0;
    if ( !v17 )
      KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
    __mcr(15, 0, 0, 7, 10, 5);
    v19 = newPerms & 0xF00;
    switch ( v19 )
    {
      case MEMOP_REGION_APPLICATION:
        Contiguous = KPageHeap::AllocateContiguous(&g_memoryManager.applicationHeap, (size + 4095) >> 12, 0);
        __mcr(15, 0, 0, 7, 10, 5);
        g_memoryManager.pgMgr.mutex.lockingThread = 0;
        if ( g_memoryManager.pgMgr.mutex.numWaiters <= 0 )
          goto LABEL_32;
        break;
      case MEMOP_REGION_SYSTEM:
        Contiguous = KPageHeap::AllocateContiguous(&g_memoryManager.systemHeap, (size + 4095) >> 12, 0);
        __mcr(15, 0, 0, 7, 10, 5);
        g_memoryManager.pgMgr.mutex.lockingThread = 0;
        if ( g_memoryManager.pgMgr.mutex.numWaiters <= 0 )
          goto LABEL_32;
        break;
      case MEMOP_REGION_BASE:
        Contiguous = KPageHeap::AllocateContiguous(&g_memoryManager.baseHeap, (size + 4095) >> 12, 0);
        __mcr(15, 0, 0, 7, 10, 5);
        g_memoryManager.pgMgr.mutex.lockingThread = 0;
        if ( g_memoryManager.pgMgr.mutex.numWaiters <= 0 )
        {
LABEL_32:
          if ( Contiguous )
          {
            KPageGroup::AddRange(&this->pgGrp, (u32)Contiguous, (size + 4095) >> 12);
            this->isDeviceSharedMem = 1;
            goto LABEL_36;
          }
          if ( reslimit && (_BYTE)v31 )
            goto LABEL_26;
          return 0xD86007F3;
        }
        break;
      default:
        kernelpanic();
    }
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
    goto LABEL_32;
  }
LABEL_36:
  p_kernAllocatedForProcess = &ownerProcess->kernAllocatedForProcess;
  do
    v23 = __ldrex(p_kernAllocatedForProcess);
  while ( __strex(v23 + size, p_kernAllocatedForProcess) );
  KPageGroup::IncrefPages(&this->pgGrp);
  KAutoObject::IncrementRefcount(this->ownerProcess);
  v24 = (unsigned __int8 *)&this->sharedMemMapRefcount;
  do
    __ldrex(v24);
  while ( __strex(1u, v24) );
  return 0;
}
// FFF0E2E8: conditional instruction was optimized away because %newPerms.4<F01u

//----- (FFF0E71C) --------------------------------------------------------
KSharedMemory *__fastcall KSharedMemory::KSharedMemory(KSharedMemory *this)
{
  KSharedMemory *v1; // r0
  KSharedMemory *this_; // r0

  v1 = (KSharedMemory *)KAutoObject::KAutoObject(this);
  v1->__vftable = &KSharedMemory::vt;
  this_ = (KSharedMemory *)&KPageGroup::KPageGroup(&v1->pgGrp)[-1].list.link;
  this_->ownerProcess = 0;
  this_->ownerPerms = KMEMPERM_NONE;
  this_->othersPerms = KMEMPERM_NONE;
  this_->sharedMemMapRefcount = 0;
  this_->workaround = 0;
  return this_;
}

//----- (FFF0E754) --------------------------------------------------------
s32 __fastcall KResourceLimit::GetCurrentValue(KResourceLimit *this, ResourceLimitType type)
{
  return this->currentValues[type];
}

//----- (FFF0E760) --------------------------------------------------------
KCpuTimeLimit *__fastcall KResourceLimit::GetTimeLimit(KResourceLimit *this)
{
  KResourceLimit *v1; // r4
  int v2; // r0

  v1 = this;
  v2 = this->limitValues[RESLIMIT_CPUTIME];
  if ( v2 >= 10000 )
    return 0;
  if ( v2 != 1000 )
    return &v1->timeLimit;
  KSchedulerLock::Lock(&g_schedulerLock);
  if ( g_sysmoduleReslimitSet )
    v1 = (KResourceLimit *)((char *)v1 + offsetof(KResourceLimit, timeLimit));
  if ( !g_sysmoduleReslimitSet )
    v1 = 0;
  KSchedulerLock::Unlock(&g_schedulerLock);
  return (KCpuTimeLimit *)v1;
}

//----- (FFF0E7C0) --------------------------------------------------------
Result __fastcall KServerSession::SendSyncRequest(KServerSession *this, KThread *thread)
{
  Result v3; // r6
  KThreadIntrusiveLink *p_link; // r4
  KThread *prev; // r0
  KThreadIntrusiveLink *v7; // r2
  KThreadIntrusiveLink link; // r0
  KThreadIntrusiveLink *v9; // r2

  v3 = 0xE7E3FFFF;
  if ( this->parent->client.status != KSESSIONSTATUS_NORMAL )
    return 0xC920181A;
  p_link = &this->syncRequestWaitList.link;
  thread->waiterList = &this->syncRequestWaitList;
  KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_PAUSED);
  prev = this->syncRequestWaitList.link.prev;
  if ( prev )
    v7 = &prev->link;
  else
    v7 = &this->syncRequestWaitList.link;
  thread->link.prev = prev;
  thread->link.next = 0;
  v7->next = thread;
  p_link->prev = thread;
  if ( thread->shallTerminate )
  {
    link = thread->link;
    if ( link.prev )
      v9 = &link.prev->link;
    else
      v9 = &this->syncRequestWaitList.link;
    if ( link.next )
      p_link = &link.next->link;
    v9->next = link.next;
    p_link->prev = link.prev;
    KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_RUNNING);
    thread->waiterList = 0;
  }
  else
  {
    v3 = 0;
    KSynchronizationObject::NotifyWaiters(this, 0);// signal the server session (so that ReplyAndReceive wakes up)
  }
  return v3;
}

//----- (FFF0E880) --------------------------------------------------------
void __fastcall KAddressArbiter::Initialize(KAddressArbiter *this, KProcess *owner)
{
  KAutoObject::IncrementRefcount(owner);
  this->owner = owner;
}

//----- (FFF0E89C) --------------------------------------------------------
signed int __fastcall KAddressArbiter::WaitIfLessThan(
        KAddressArbiter *this,
        KThread *thread,
        u32 addr,
        s32 value,
        bool decrement)
{
  signed int v9; // r8
  KThreadIntrusiveList *p_waitList; // r5
  KThread *prev; // r0
  KThreadIntrusiveLink *p_link; // r1
  KThreadIntrusiveLink link; // r0
  KThreadIntrusiveLink *v14; // r2
  unsigned int CPSR; // r2
  unsigned int par; // r0
  BOOL validAddr; // r0
  s32 v18; // r0
  KThreadIntrusiveLink v19; // r0
  KThreadIntrusiveList *v20; // r2
  KThreadIntrusiveLink *v21; // r3
  KThread *v22; // r1
  KThread *next; // r0
  KThreadIntrusiveLink *v24; // r2
  KThreadIntrusiveLink *v25; // r3
  s32 readValue[10]; // [sp+0h] [bp-28h] BYREF

  readValue[0] = value;
  v9 = 0;
  KSchedulerLock::Lock(&g_schedulerLock);
  p_waitList = &this->waitList;
  thread->waiterList = &this->waitList;
  thread->arbitrationAddr = addr;
  KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_PAUSED);
  prev = this->waitList.link.prev;
  if ( prev )
    p_link = &prev->link;
  else
    p_link = &this->waitList.link;
  thread->link.prev = prev;
  thread->link.next = 0;
  p_link->next = thread;
  p_waitList->link.prev = thread;
  if ( thread->shallTerminate )
  {
    link = thread->link;
    if ( link.prev )
      v14 = &link.prev->link;
    else
      v14 = &this->waitList.link;
    if ( link.next )
      p_waitList = (KThreadIntrusiveList *)&link.next->link;
    v14->next = link.next;
    p_waitList->link.prev = link.prev;
    KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_RUNNING);
    thread->waiterList = 0;
  }
  else
  {
    if ( decrement )
    {
      CPSR = __get_CPSR();                      // exclusive ldrt/strt don't exist
      __disable_irq();
      __mcr(15, 0, addr >> 12 << 12, 7, 8, 3);
      par = __mrc(15, 0, 7, 4, 0);
      if ( (par & 1) != 0 || !((par >> 12 << 12) | addr & 0xFFF) )
      {
        __set_CPSR(CPSR);
        validAddr = 0;
      }
      else
      {
        while ( 1 )
        {
          v18 = __ldrex((unsigned int *)addr);
          if ( v18 >= value )
            break;
          if ( !__strex(v18 - 1, (unsigned int *)addr) )
            goto LABEL_19;
        }
        __clrex();
LABEL_19:
        readValue[0] = v18;
        __set_CPSR(CPSR);
        validAddr = 1;
      }
    }
    else
    {
      validAddr = CopyWordFromUser(readValue, (const void *)addr);
    }
    if ( validAddr )
    {
      if ( readValue[0] >= value )
      {
        v19 = thread->link;
        v20 = &this->waitList;
        if ( v19.prev )
          v21 = &v19.prev->link;
        else
          v21 = &this->waitList.link;
        if ( v19.next )
          v20 = (KThreadIntrusiveList *)&v19.next->link;
        v21->next = v19.next;
        v20->link.prev = v19.prev;
        KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_RUNNING);
        thread->waiterList = 0;
      }
    }
    else
    {
      v22 = thread->link.prev;
      next = thread->link.next;
      v24 = &this->waitList.link;
      if ( v22 )
        v25 = &v22->link;
      else
        v25 = &this->waitList.link;
      if ( next )
        v24 = &next->link;
      v25->next = next;
      v24->prev = v22;
      KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_RUNNING);
      v9 = 0xD9001814;
      thread->waiterList = 0;
    }
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
  return v9;
}

//----- (FFF0EA70) --------------------------------------------------------
signed int __fastcall KAddressArbiter::WaitIfLessThanWithTimeout(
        KAddressArbiter *this,
        KThread *thread,
        u32 addr,
        s32 value,
        bool decrement,
        s64 timeout)
{
  signed int v8; // r9
  unsigned int v9; // r7
  int v10; // r10
  unsigned __int64 v11; // kr10_8
  KThreadIntrusiveLink *p_link; // r11
  KThread *prev; // r0
  KThreadIntrusiveLink *v14; // r1
  KThreadIntrusiveLink link; // r0
  KThreadIntrusiveLink *v16; // r2
  unsigned int CPSR; // r1
  u32 v18; // r0
  unsigned int v19; // lr
  unsigned int v20; // r3
  BOOL validAddr; // r0
  KHardwareTimer *v22; // r1
  KThreadIntrusiveLink v23; // r0
  KThreadIntrusiveLink *v24; // r2
  KThreadIntrusiveLink *v25; // r3
  KThreadIntrusiveLink v26; // r0
  KThreadIntrusiveLink *v27; // r2
  KThreadIntrusiveLink *v28; // r3
  KThreadIntrusiveLink v29; // r0
  KThreadIntrusiveLink *v30; // r2
  KThreadIntrusiveLink *v31; // r3
  KTimerTask *v32; // r1
  KTimerTask *v33; // r1
  KHardwareTimer *reused; // [sp+4h] [bp-3Ch] BYREF

  v8 = 0;
  KSchedulerLock::Lock(&g_schedulerLock);
  if ( ((((unsigned __int64)-timeout >> 32) & 0x80000000) != 0LL) != __OFSUB__(
                                                                       0,
                                                                       HIDWORD(timeout),
                                                                       (_DWORD)timeout == 0) )
  {
    reused = &g_hardwareTimer;
    v11 = __PAIR64__(
            (((1151531653 * (unsigned __int64)(unsigned int)timeout) >> 32) + 1151531653LL * SHIDWORD(timeout)) >> 32,
            (unsigned __int64)(1151531653 * timeout) >> 32)
        + KHardwareTimer::GetSystemTick(&g_hardwareTimer);
    v10 = HIDWORD(v11);
    v9 = v11;
    if ( ((((unsigned __int64)-__SPAIR64__(v10, v9) >> 32) & 0x80000000) != 0LL) == __OFSUB__(0, v10, v9 == 0) )
    {
      v9 = 0xFFFFFFFF;
      v10 = 0x7FFFFFFF;
    }
    KSchedulerLock::Lock(&reused->lock);
  }
  else
  {
    v9 = 0;
    v10 = 0;
  }
  p_link = &this->waitList.link;
  thread->arbitrationAddr = addr;
  thread->synchronizationResult = 0x9401BFE;
  thread->signaledObject = 0;
  thread->waiterList = &this->waitList;
  KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_PAUSED);
  prev = this->waitList.link.prev;
  if ( prev )
    v14 = &prev->link;
  else
    v14 = &this->waitList.link;
  thread->link.prev = prev;
  thread->link.next = 0;
  v14->next = thread;
  p_link->prev = thread;
  if ( thread->shallTerminate )
  {
    link = thread->link;
    if ( link.prev )
      v16 = &link.prev->link;
    else
      v16 = &this->waitList.link;
    if ( link.next )
      p_link = &link.next->link;
    v16->next = link.next;
    p_link->prev = link.prev;
    KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_RUNNING);
    thread->waiterList = 0;
  }
  else
  {
    if ( decrement )
    {
      CPSR = __get_CPSR();
      v18 = addr;
      __disable_irq();
      v19 = CPSR;
      __mcr(15, 0, v18 >> 12 << 12, 7, 8, 3);
      v20 = __mrc(15, 0, 7, 4, 0);
      if ( (v20 & 1) != 0 || !((v20 >> 12 << 12) | addr & 0xFFF) )
      {
        __set_CPSR(CPSR);
        validAddr = 0;
      }
      else
      {
        while ( 1 )
        {
          v22 = (KHardwareTimer *)__ldrex((unsigned int *)addr);
          if ( (int)v22 >= value )
            break;
          if ( !__strex((unsigned int)&v22[-1].lock.lockCount + 3, (unsigned int *)addr) )
            goto LABEL_24;
        }
        __clrex();
LABEL_24:
        reused = v22;
        __set_CPSR(v19);
        validAddr = 1;
      }
    }
    else
    {
      validAddr = CopyWordFromUser(&reused, (const void *)addr);
    }
    if ( validAddr )
    {
      if ( (int)reused < value )
      {
        if ( !timeout )
        {
          if ( ((((unsigned __int64)-__SPAIR64__(v10, v9) >> 32) & 0x80000000) != 0LL) != __OFSUB__(0, v10, v9 == 0) )
          {
            KSchedulerLock::UnlockSingleCoreResched(&g_hardwareTimer.lock);
            v9 = 0;
            v10 = 0;
          }
          v26 = thread->link;
          v27 = &this->waitList.link;
          if ( v26.prev )
            v28 = &v26.prev->link;
          else
            v28 = &this->waitList.link;
          if ( v26.next )
            v27 = &v26.next->link;
          v28->next = v26.next;
          v27->prev = v26.prev;
          KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_RUNNING);
          v8 = 0x9401BFE;
          thread->waiterList = 0;
        }
      }
      else
      {
        if ( ((((unsigned __int64)-__SPAIR64__(v10, v9) >> 32) & 0x80000000) != 0LL) != __OFSUB__(0, v10, v9 == 0) )
        {
          KSchedulerLock::UnlockSingleCoreResched(&g_hardwareTimer.lock);
          v9 = 0;
          v10 = 0;
        }
        v23 = thread->link;
        v24 = &this->waitList.link;
        if ( v23.prev )
          v25 = &v23.prev->link;
        else
          v25 = &this->waitList.link;
        if ( v23.next )
          v24 = &v23.next->link;
        v25->next = v23.next;
        v24->prev = v23.prev;
        KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_RUNNING);
        thread->waiterList = 0;
      }
    }
    else
    {
      if ( ((((unsigned __int64)-__SPAIR64__(v10, v9) >> 32) & 0x80000000) != 0LL) != __OFSUB__(0, v10, v9 == 0) )
      {
        KSchedulerLock::UnlockSingleCoreResched(&g_hardwareTimer.lock);
        v9 = 0;
        v10 = 0;
      }
      v29 = thread->link;
      v30 = &this->waitList.link;
      if ( v29.prev )
        v31 = &v29.prev->link;
      else
        v31 = &this->waitList.link;
      if ( v29.next )
        v30 = &v29.next->link;
      v31->next = v29.next;
      v30->prev = v29.prev;
      KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_RUNNING);
      v8 = -654305260;
      thread->waiterList = 0;
    }
  }
  if ( ((((unsigned __int64)-__SPAIR64__(v10, v9) >> 32) & 0x80000000) != 0LL) != __OFSUB__(0, v10, v9 == 0) )
  {
    if ( thread )
      v32 = &thread->KTimerTask;
    else
      v32 = 0;
    KHardwareTimer::RegisterTask(&g_hardwareTimer, v32, __SPAIR64__(v10, v9));
    KSchedulerLock::UnlockSingleCoreResched(&g_hardwareTimer.lock);
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
  if ( v8 >= 0 )
  {
    if ( ((((unsigned __int64)-timeout >> 32) & 0x80000000) != 0LL) != __OFSUB__(
                                                                         0,
                                                                         HIDWORD(timeout),
                                                                         (_DWORD)timeout == 0) )
    {
      if ( thread )
        v33 = &thread->KTimerTask;
      else
        v33 = 0;
      KHardwareTimer::CancelTask(&g_hardwareTimer, v33);
    }
    return thread->synchronizationResult;
  }
  return v8;
}

//----- (FFF0EE34) --------------------------------------------------------
Result __fastcall KAddressArbiter::Signal(KAddressArbiter *value, u32 addr, s32 val)
{
  int numSignaled; // r7
  s32 v7; // r9
  KThread *v8; // r4
  KThread *v9; // r5
  int dynamicPriority; // r0
  KThreadIntrusiveLink *v11; // r1
  KThread *v12; // r0
  KThread *v13; // r2
  KThreadIntrusiveLink *v14; // r3
  KThread *next; // r4
  KThread *v16; // r5
  KThread *prev; // r1
  KThreadIntrusiveLink *p_link; // r2
  KThreadIntrusiveLink *v19; // r3

  numSignaled = 0;
  if ( val < 0 )                                // signal all
  {
    KSchedulerLock::Lock(&g_schedulerLock);
    next = value->waitList.link.next;
    if ( next )
    {
      do
      {
        v16 = next->link.next;
        if ( next->arbitrationAddr == addr )
        {
          next->signaledObject = 0;
          next->synchronizationResult = 0;
          prev = next->link.prev;
          p_link = &value->waitList.link;
          if ( prev )
            v19 = &prev->link;
          else
            v19 = &value->waitList.link;
          if ( v16 )
            p_link = &v16->link;
          v19->next = v16;
          p_link->prev = prev;
          KThread::SetSchedulingState(next, KTHREADSCHEDSTAT_RUNNING);
          ++numSignaled;
          next->waiterList = 0;
        }
        next = v16;
      }
      while ( v16 );
LABEL_25:
      KSchedulerLock::Unlock(&g_schedulerLock);
      if ( numSignaled )
        return 0;
      goto LABEL_28;
    }
  }
  else
  {
    KSchedulerLock::Lock(&g_schedulerLock);
    v7 = 0;
    if ( val > 0 )
    {
      do
      {
        v8 = value->waitList.link.next;
        v9 = 0;
        dynamicPriority = 0x80;
        if ( !v8 )
          break;
        do
        {
          if ( v8->arbitrationAddr == addr && v8->dynamicPriority < dynamicPriority )
          {
            v9 = v8;
            dynamicPriority = v8->dynamicPriority;
          }
          v8 = v8->link.next;
        }
        while ( v8 );
        if ( !v9 )
          break;
        v9->signaledObject = 0;
        v9->synchronizationResult = 0;
        v11 = &value->waitList.link;
        v12 = v9->link.prev;
        v13 = v9->link.next;
        if ( v12 )
          v14 = &v12->link;
        else
          v14 = &value->waitList.link;
        if ( v13 )
          v11 = &v13->link;
        v14->next = v13;
        v11->prev = v12;
        KThread::SetSchedulingState(v9, KTHREADSCHEDSTAT_RUNNING);
        ++v7;
        ++numSignaled;
        v9->waiterList = 0;
      }
      while ( v7 < val );
      goto LABEL_25;
    }
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
LABEL_28:
  if ( (__mrc(15, 0, 0, 0, 5) & 3) == 0 && current.clc.current.thread->dynamicPriority >= 50 )
    cpu::WaitCycles(1614u);                     // Zelda games workaround (fasthax fix caused lag issues)
                                                // This path is only called if numSignaled = 0
  return 0;                                     // remove mch2 oracle
}

//----- (FFF0EFCC) --------------------------------------------------------
Result __fastcall KInterruptEvent::ReenableInterrupt(KInterruptEvent *this)
{
  return KInterruptManager::ReenablePublicInterruptOrFiq(&g_interruptManager, this->irqId);
}

//----- (FFF0EFDC) --------------------------------------------------------
void __fastcall KInterruptTaskManager::EnqueueTask(KInterruptTaskManager *this, KInterruptTask *task)
{
  KInterruptTask *last; // r2
  KScheduler *volatile scheduler; // r0

  last = this->last;
  if ( last )
    last->next = task;
  this->last = task;
  if ( !last )
    this->first = task;
  scheduler = current.clc.current.scheduler;
  current.clc.current.scheduler->interruptTaskAdded = 1;
  scheduler->reschedule = 1;
}

//----- (FFF0F00C) --------------------------------------------------------
Result __fastcall KThread::InitializeUserThread(
        KThread *this,
        u32 ep,
        u32 arg,
        u32 stackTop,
        s32 priority,
        s32 idealCore,
        KProcess *parentProcess)
{
  unsigned int *p_kernAllocatedForProcess; // r12
  u32 v13; // r3
  unsigned int v14; // r1
  u32 outAddr[10]; // [sp+18h] [bp-28h] BYREF

  if ( KPageTable::OperateOnAnyFreeBlockInRegionWithGuardPage(// allocate kernel stack
         &g_supervisorPageTable,
         outAddr,
         1u,
         0xFF400000,
         0x800u,
         0,
         KMEMSTATE_LOCKED,
         KMEMPERM_KRW,
         KMEMUPDATE_NONE,
         MEMOP_REGION_BASE) < 0 )
    return 0xC8601801;
  p_kernAllocatedForProcess = &parentProcess->kernAllocatedForProcess;
  v13 = outAddr[0] + 0x1000;
  do
    v14 = __ldrex(p_kernAllocatedForProcess);
  while ( __strex(v14 + 0x1000, p_kernAllocatedForProcess) );
  return KThread::Initialize(this, ep, arg, v13, stackTop, priority, idealCore, parentProcess, KTHREAD_TYPE_USER);
}

//----- (FFF0F0D4) --------------------------------------------------------
void __fastcall KThreadContext::Initialize(
        KThreadContext *this,
        u32 ep,
        u32 kernStackTop,
        u32 stackTop,
        u32 arg,
        BOOL isUser)
{
  u32 v6; // r5
  u32 v7; // r8
  u32 v9; // r1
  u32 v10; // r5
  void (__fastcall __noreturn *v11)(int, int, int, int, int); // r12
  u32 v12; // r7
  u32 v13; // r2
  int v14; // r3
  u32 v15; // r1
  u32 *v17; // r5

  if ( kernStackTop )
  {
    v6 = kernStackTop & ~7u;
    if ( isUser )
    {
      v7 = ep & 1;
      if ( (ep & 1) != 0 )
        v7 = 32;
      v9 = v6 - 16;
      *(_DWORD *)(v6 - 4) = v7 | 0x10;
      v10 = v6 - 4;
      v11 = KThread::UserThreadStarter;
      v12 = stackTop & ~7u;
      *(_DWORD *)(v10 - 8) = 0;
      *(_DWORD *)(v10 - 4) = ep;
      v13 = v9;
      v14 = 6;
      *(_DWORD *)(v10 - 12) = v12;
      do
      {
        *(_DWORD *)(v13 - 4) = 0;
        --v14;
        *(_DWORD *)(v13 - 8) = 0;
        v13 -= 8;
      }
      while ( v14 );
      *(_DWORD *)(v9 - 52) = arg;
      v15 = v9 - 52;
    }
    else if ( ep )
    {
      v17 = (u32 *)(v6 - 4);
      v15 = (u32)(v17 - 1);
      v11 = (void (__fastcall __noreturn *)(int, int, int, int, int))KThread::SupervisorThreadStarter;
      *v17 = ep;
      *(v17 - 1) = arg;
    }
    else
    {
      v11 = 0;
      v15 = kernStackTop & ~7u;
    }
    this->r4 = 0;
    this->r5 = 0;
    this->r6 = 0;
    this->r7 = 0;
    this->r8 = 0;
    this->r9 = 0;
    this->r10 = 0;
    this->r11 = 0;
    this->sp = v15;
    this->lr = (u32)v11;
    this->fpscr = 0x3C00000;
    this->fpexc = 0;
    memset(this->d, 0, sizeof(this->d));
  }
}
// FFF13E44: using guessed type int KThread::SupervisorThreadStarter();

//----- (FFF0F1BC) --------------------------------------------------------
Result __fastcall KProcess::GetQtmStaticMappedSize(s32 *out, KProcess *this)
{
  u32 foundAddr; // r5
  u32 v5; // r3
  KProcessPageTable *p_pgTable; // r4
  Result result; // r0
  u32 v8; // r4
  KProcessPageTable *v9; // r8
  KMemoryInfo info2; // [sp+8h] [bp-40h] BYREF
  KMemoryInfo outMemoryInfo; // [sp+18h] [bp-30h] BYREF
  u32 v12; // [sp+28h] [bp-20h] BYREF
  u32 pageInfo; // [sp+2Ch] [bp-1Ch] BYREF

  v5 = 0x1E800000;
  p_pgTable = &this->pgTable;
  do
  {
    if ( KPageTable::QueryInfo(p_pgTable, &outMemoryInfo, &pageInfo, v5) < 0 )
      break;
    if ( outMemoryInfo.state == KMEMSTATE_STATIC )
    {
      foundAddr = outMemoryInfo.baseAddress;
      result = 0;
      goto LABEL_7;
    }
    v5 = outMemoryInfo.baseAddress + outMemoryInfo.size;
  }
  while ( outMemoryInfo.baseAddress + outMemoryInfo.size < 0x1EC00000 );
  result = -522183692;
LABEL_7:
  if ( result >= 0 )
  {
    v8 = foundAddr;
    v9 = &this->pgTable;
    if ( foundAddr < 0x1EC00000 )
    {
      do
      {
        if ( KPageTable::QueryInfo(v9, &info2, &v12, v8) < 0 )
          break;
        if ( info2.state != KMEMSTATE_STATIC )
          break;
        v8 = info2.baseAddress + info2.size;
      }
      while ( info2.baseAddress + info2.size < 0x1EC00000 );
    }
    *out = v8 - foundAddr;
    return 0;
  }
  return result;
}
// FFF0F22C: variable 'foundAddr' is possibly undefined

//----- (FFF0F290) --------------------------------------------------------
Result __fastcall KProcess::GetQtmStaticMappedBase(s32 *out, KProcess *this)
{
  u32 v3; // r3
  KProcessPageTable *p_pgTable; // r5
  u32 pageInfo; // [sp+4h] [bp-24h] BYREF
  KMemoryInfo outMemoryInfo; // [sp+8h] [bp-20h] BYREF

  v3 = 511705088;
  p_pgTable = &this->pgTable;
  do
  {
    if ( KPageTable::QueryInfo(p_pgTable, &outMemoryInfo, &pageInfo, v3) < 0 )
      break;
    if ( outMemoryInfo.state == KMEMSTATE_STATIC )
    {
      *out = outMemoryInfo.baseAddress;
      return 0;
    }
    v3 = outMemoryInfo.baseAddress + outMemoryInfo.size;
  }
  while ( outMemoryInfo.baseAddress + outMemoryInfo.size < 0x1EC00000 );
  return 0xE0E01BF4;
}

//----- (FFF0F308) --------------------------------------------------------
BOOL __fastcall KProcess::ShouldOnlyUseSmallPages(u64 titleId)
{
  return titleId && titleId == g_systemControl.titleIdForSmallPageWorkaround;
}

//----- (FFF0F338) --------------------------------------------------------
Result __fastcall KProcess::GetQtmStaticMappedConversionOffset(s32 *out, KProcess *this)
{
  u32 v3; // r3
  KProcessPageTable *p_pgTable; // r5
  Result result; // r0
  u32 pageInfo; // [sp+4h] [bp-24h] BYREF
  KMemoryInfo outMemoryInfo; // [sp+8h] [bp-20h] BYREF

  v3 = 0x1E800000;
  p_pgTable = &this->pgTable;
  do
  {
    if ( KPageTable::QueryInfo(p_pgTable, &outMemoryInfo, &pageInfo, v3) < 0 )
      break;
    if ( outMemoryInfo.state == KMEMSTATE_STATIC )
    {
      result = 0;
      goto LABEL_7;
    }
    v3 = outMemoryInfo.baseAddress + outMemoryInfo.size;
  }
  while ( outMemoryInfo.baseAddress + outMemoryInfo.size < 0x1EC00000 );
  result = 0xE0E01BF4;
LABEL_7:
  if ( result >= 0 )
  {
    *out = 0x800000;
    return 0;
  }
  return result;
}

//----- (FFF0F3B8) --------------------------------------------------------
u32 __fastcall KMemoryManager::ConvertSharedMemPaLinearWithAppMemType(u32 pa)
{
  u32 v1; // r0
  int v2; // r1

  v1 = pa - 0x20000000;
  if ( (unsigned __int8)g_kernelSharedConfigPagePtr->appMemType == 7 )
    v2 = 0x30000000;
  else
    v2 = 0x14000000;                            // always use the old mapping... is that a bug?
  return v1 + v2;
}
// FFF2F0D4: using guessed type KernelSharedConfig *g_kernelSharedConfigPagePtr;

//----- (FFF0F3E4) --------------------------------------------------------
Result __fastcall StartInterProcessDma(
        Handle *outDmaHandle,
        Handle dstProcessHandle,
        u32 dstAddr,
        Handle srcProcessHandle,
        u32 srcAddr,
        u32 size,
        const DmaConfig *config)
{
  bool v7; // zf
  Result result; // r0
  u32 minSize; // r2
  Result v12; // r3
  int v13; // r9
  u32 adjSizeDst; // r1
  bool v15; // zf
  Result v16; // r12
  u32 endAddrDst; // r1
  Result v18; // r1
  u32 adjSizeSrc; // r1
  bool v20; // zf
  u32 endAddrSrc; // r1
  KHandleTable *p_handleTable; // r9
  KProcess *dstProcess; // r7
  KAutoObject *v24; // r0
  KAutoObject *v25; // r7
  u8 typeId; // r11
  int v27; // r1
  KProcess *v28; // r8
  KProcess *srcProcess; // r8
  KAutoObject *v30; // r0
  KAutoObject *v31; // r8
  u8 v32; // r10
  int v33; // r1
  KProcess *v34; // r9
  int v35; // r9
  KTypeObj v36; // [sp+0h] [bp-68h] BYREF
  KDmaChannel *outDmaChannel; // [sp+Ch] [bp-5Ch] BYREF
  DmaConfig dmaCfg; // [sp+10h] [bp-58h] BYREF
  KTypeObj v39; // [sp+28h] [bp-40h] BYREF

  v7 = dstAddr == 0;
  *outDmaHandle = 0;
  result = 0xD8E007F6;
  if ( dstAddr )
    v7 = srcAddr == 0;
  if ( !v7 )
  {
    v7 = !CopyBytesFromUser(&dmaCfg, config, 0x18u);
    result = 0xE0E01BF5;
    if ( v7 )
      v12 = 0xE0E01BF5;
    else
      v12 = 0;
    if ( v12 < 0 )
      return v12;
    v13 = 0xD8E007ED;
    adjSizeDst = size;
    if ( !((unsigned __int8)(dmaCfg.flags & DMACFGFLAG_DST_IS_DEVICE) >> 1) )
      goto LABEL_23;
    if ( dmaCfg.dstCfg.allowedAlignments == 4 )
    {
      minSize = 4;
    }
    else
    {
      v15 = dmaCfg.dstCfg.allowedAlignments == 8;
      if ( dmaCfg.dstCfg.allowedAlignments != 8 )
        v15 = dmaCfg.dstCfg.allowedAlignments == 0xC;
      if ( !v15 && dmaCfg.dstCfg.allowedAlignments != 0xF )
      {
        v16 = 0xD8E007ED;
LABEL_19:
        if ( v16 < 0 )
          return v16;
        if ( minSize < size )
          adjSizeDst = minSize;
LABEL_23:
        if ( adjSizeDst )
        {
          endAddrDst = adjSizeDst + dstAddr - 1;
          if ( dstAddr <= endAddrDst && endAddrDst < 0x40000000 )
            goto LABEL_26;
        }
        else if ( dstAddr < 0x40000000 )
        {
LABEL_26:
          v18 = 0;
          goto LABEL_29;
        }
        v18 = 0xE0E01BF5;
LABEL_29:
        if ( v18 < 0 )
          return v18;
        adjSizeSrc = size;
        if ( (dmaCfg.flags & DMACFGFLAG_SRC_IS_DEVICE) == 0 )
          goto LABEL_45;
        if ( dmaCfg.srcCfg.allowedAlignments == 4 )
        {
          minSize = 4;
        }
        else
        {
          v20 = dmaCfg.srcCfg.allowedAlignments == 8;
          if ( dmaCfg.srcCfg.allowedAlignments != 8 )
            v20 = dmaCfg.srcCfg.allowedAlignments == 0xC;
          if ( !v20 )
            v20 = dmaCfg.srcCfg.allowedAlignments == 0xF;
          if ( !v20 )
            goto LABEL_42;
          minSize = 8;
        }
        v13 = 0;
LABEL_42:
        if ( v13 < 0 )
          return v13;
        if ( minSize < size )
          adjSizeSrc = minSize;
LABEL_45:
        if ( adjSizeSrc )
        {
          endAddrSrc = adjSizeSrc + srcAddr - 1;
          if ( srcAddr <= endAddrSrc && endAddrSrc < 0x40000000 )
            goto LABEL_48;
        }
        else if ( srcAddr < 0x40000000 )
        {
LABEL_48:
          result = 0;
        }
        if ( result < 0 )
          return result;
        p_handleTable = &current.clc.current.process->handleTable;
        if ( dstProcessHandle == CUR_PROCESS_HANDLE )
        {
          dstProcess = current.clc.current.process;
          KAutoObject::IncrementRefcount(current.clc.current.process);
        }
        else
        {
          v24 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, dstProcessHandle);
          v25 = v24;
          if ( !v24 )
            return 0xD9001BF7;
          v24->GetTypeObj(&v36, v24);
          typeId = v36.typeId;
          v25->GetTypeObj(&v39, v25);
          v27 = typeId | 0xC5;
          if ( v27 == v39.typeId )
            v28 = (KProcess *)v25;
          else
            v28 = 0;
          if ( v27 != v39.typeId )
            v25->DecrementRefcount(v25);
          dstProcess = v28;
        }
        if ( dstProcess )
        {
          if ( srcProcessHandle == CUR_PROCESS_HANDLE )
          {
            srcProcess = current.clc.current.process;
            KAutoObject::IncrementRefcount(current.clc.current.process);
          }
          else
          {
            v30 = KHandleTable::ConvertToAutoObject(p_handleTable, srcProcessHandle);
            v31 = v30;
            if ( !v30 )
              goto LABEL_76;
            v30->GetTypeObj(&v36, v30);
            v32 = v36.typeId;
            v31->GetTypeObj(&v39, v31);
            v33 = v32 | 0xC5;
            if ( v33 == v39.typeId )
              v34 = (KProcess *)v31;
            else
              v34 = 0;
            if ( v33 != v39.typeId )
              v31->DecrementRefcount(v31);
            srcProcess = v34;
          }
          if ( srcProcess )
          {
            v35 = KDmaManager::ValidateUserParameters(dstAddr, srcAddr, size, &dmaCfg, dstProcess, srcProcess);
            if ( v35 < 0 )
            {
              dstProcess->DecrementRefcount(dstProcess);
              srcProcess->DecrementRefcount(srcProcess);
              return v35;
            }
            v13 = KDmaManager::InitializeChannel(
                    &g_dmaManager,
                    outDmaHandle,
                    &outDmaChannel,
                    dmaCfg.channelId,
                    dmaCfg.flags);
            if ( v13 >= 0 )
            {
              KDmaChannel::Start(outDmaChannel, dstAddr, srcAddr, size, &dmaCfg, dstProcess, srcProcess);
            }
            else
            {
              dstProcess->DecrementRefcount(dstProcess);
              srcProcess->DecrementRefcount(srcProcess);
            }
            return v13;
          }
LABEL_76:
          dstProcess->DecrementRefcount(dstProcess);
          return 0xD9001BF7;
        }
        return 0xD9001BF7;
      }
      minSize = 8;
    }
    v16 = 0;
    goto LABEL_19;
  }
  return result;
}
// FFF0F4A8: variable 'minSize' is possibly undefined

//----- (FFF0F7EC) --------------------------------------------------------
void __fastcall WaitSynchronizationNImpl(WaitSynchronizationNArgs *args, KSynchronizationObject **objects)
{
  u32 zero; // r7
  s32 v5; // r6
  s32 v6; // r2
  KHandleTable *p_handleTable; // r9
  Result v8; // r0
  KAutoObject *v9; // r0
  KSynchronizationObject *v10; // r4
  u8 typeId; // r11
  int v12; // r1
  KSynchronizationObject *v13; // r10
  s32 numHandles; // r0
  int timeout_high; // r3
  s32 i; // r4
  u32 tmp; // [sp+4h] [bp-5Ch] BYREF
  s64 v18; // [sp+8h] [bp-58h]
  KSynchronization *v19; // [sp+18h] [bp-48h]
  KTypeObj v20; // [sp+28h] [bp-38h] BYREF
  KTypeObj v21; // [sp+30h] [bp-30h] BYREF

  v5 = 0;
  v6 = args->numHandles;
  if ( v6 > 0 )
    zero = 0;
  p_handleTable = &current.clc.current.process->handleTable;
  v19 = &g_synchronization;
  if ( v6 > 0 )
  {
    do
    {
      tmp = zero;
      v8 = CopyWordFromUser(&tmp, &args->handles[v5]) ? 0 : 0xE0E01BF5;
      args->res = v8;
      if ( v8 < 0 )
        break;
      v9 = KHandleTable::ConvertToAutoObject(p_handleTable, tmp);
      v10 = (KSynchronizationObject *)v9;
      if ( !v9 )
        goto LABEL_21;
      v9->GetTypeObj(&v21, v9);
      typeId = v21.typeId;
      v10->GetTypeObj(&v20, v10);
      v12 = typeId | 1;
      if ( v12 == v20.typeId )
        v13 = v10;
      else
        v13 = (KSynchronizationObject *)zero;
      if ( v12 != v20.typeId )
        v10->DecrementRefcount(v10);
      if ( !v13 )
      {
LABEL_21:
        args->res = 0xD8E007F7;
        break;
      }
      objects[v5++] = v13;
    }
    while ( args->numHandles > v5 );
  }
  numHandles = args->numHandles;
  if ( numHandles == v5 )
  {
    timeout_high = HIDWORD(args->timeout);
    LODWORD(v18) = args->timeout;
    HIDWORD(v18) = timeout_high;
    args->res = KSynchronization::WaitSynchronizationN(
                  v19,
                  args->outIdx,
                  current.clc.current.thread,
                  objects,
                  numHandles,
                  args->waitAll,
                  v18);
  }
  for ( i = 0; v5 > i; ++i )                    // close all translated objects, esp. if one handle has failed translation
    objects[i]->DecrementRefcount(objects[i]);
}
// FFF0F824: variable 'zero' is possibly undefined

//----- (FFF0F978) --------------------------------------------------------
// local variable allocation has failed, the output may be wrong!
void __fastcall ReplyAndReceiveImpl(ReplyAndReceiveArgs *args, KSynchronizationObject **syncObjects)
{
  int numHandles; // r6
  Result v5; // r4
  Handle replyTargetHandle; // r2
  Handle *handles; // r10
  int v8; // r0
  int v9; // r1
  int v10; // r1
  int v11; // r9
  KSynchronizationObject *v12; // r8
  KAutoObject *v13; // r0
  int v14; // r1
  KSynchronizationObject *v15; // r5
  KAutoObject *v16; // r0
  KServerSession *v17; // r4
  unsigned __int8 v18; // r8
  int v19; // r1
  KServerSession *v20; // r5
  Result v21; // r8
  KServerSession *v22; // r5
  unsigned __int8 v23; // r9
  Result v24; // r0
  int v25; // r4
  KSynchronizationObject *v26; // r0
  u32 reused_stackloc; // [sp+8h] [bp-78h] BYREF
  Handle replyTargetHandle_reused; // [sp+Ch] [bp-74h]
  KThread *thread; // [sp+14h] [bp-6Ch]
  s32 *v30; // [sp+20h] [bp-60h]
  s32 outIdx; // [sp+28h] [bp-58h] BYREF
  int v32; // [sp+2Ch] [bp-54h]
  KTypeObj v33; // [sp+38h] [bp-48h] BYREF
  KTypeObj v34; // [sp+40h] [bp-40h] BYREF
  KHandleTable *p_handleTable; // [sp+48h] [bp-38h]
  unsigned int v36; // [sp+4Ch] [bp-34h]
  int v37; // [sp+54h] [bp-2Ch]

  numHandles = args->numHandles;
  v5 = -404488193;
  v30 = args->outIdx;
  replyTargetHandle = args->replyTargetHandle;
  handles = args->handles;
  if ( numHandles > 0 )
  {
    v8 = numHandles & 1;
    v9 = 0;
    if ( v8 == 1 )
    {
      v9 = 1;
      *syncObjects = 0;
    }
    for ( ; v8 < numHandles; v9 = v10 + 1 )
    {
      syncObjects[v9] = 0;
      v10 = v9 + 1;
      v8 += 2;
      syncObjects[v10] = 0;
    }
  }
  replyTargetHandle_reused = replyTargetHandle;
  v11 = 0;
  p_handleTable = &current.clc.current.process->handleTable;
  thread = current.clc.current.thread;
  if ( numHandles <= 0 )
  {
all_translated:
    if ( HIWORD(*(_DWORD *)(__mrc(15, 0, 13, 0, 3) + 128)) != 0xFFFF && replyTargetHandle_reused )
    {                                           // reply part
      v16 = KHandleTable::ConvertToAutoObject(p_handleTable, replyTargetHandle_reused);
      v17 = (KServerSession *)v16;
      if ( !v16 )
        goto LABEL_28;
      v16->GetTypeObj((KTypeObj *)&outIdx, v16);
      v18 = v32;
      v17->GetTypeObj((KTypeObj *)&reused_stackloc, v17);
      v19 = v18 | 0x95;
      if ( v19 == (unsigned __int8)replyTargetHandle_reused )
        v20 = v17;
      else
        v20 = 0;
      if ( v19 != (unsigned __int8)replyTargetHandle_reused )
        v17->DecrementRefcount(v17);
      if ( !v20 )
      {
LABEL_28:
        v21 = 0xD8E007F7;
        goto LABEL_41;
      }
      v5 = KServerSession::ReplyOrAbortRequest(v20, thread, 1);
      if ( v5 < 0 )
      {
        v21 = v5;
        *v30 = -1;
        v20->DecrementRefcount(v20);
        goto LABEL_41;
      }
      v20->DecrementRefcount(v20);
    }
    if ( numHandles > 0 )
    {
      do
      {
        v5 = KSynchronization::WaitSynchronizationN(
               &g_synchronization,
               &outIdx,
               thread,
               syncObjects,
               numHandles,
               0,
               -1LL);
        if ( v5 < 0 )
          break;
        v22 = (KServerSession *)syncObjects[outIdx];
        v22->GetTypeObj((KTypeObj *)&reused_stackloc, v22);
        v23 = replyTargetHandle_reused;
        v22->GetTypeObj(&v33, v22);
        if ( (v23 | 0x95) != v33.typeId )
          break;
        v24 = KServerSession::ReceiveSyncRequest(v22, thread);
        v5 = v24;
      }
      while ( v24 == 0xC8A01836 );              // ignore request with too fragmented pxibufs
      *v30 = outIdx;
    }
    else
    {
      *v30 = 0;
    }
  }
  else
  {
    while ( 1 )
    {
      v12 = 0;
      reused_stackloc = 0;
      v5 = CopyWordFromUser(&reused_stackloc, &handles[v11]) ? 0 : 0xE0E01BF5;
      if ( v5 < 0 )
        break;
      v13 = KHandleTable::ConvertToAutoObject(p_handleTable, reused_stackloc);
      v15 = (KSynchronizationObject *)v13;
      if ( v13 )
      {
        v36 = v14 & 0xFFFFFF00 | 1;             // any kind of sync object
        v13->GetTypeObj(&v33, v13);
        v37 = *(_DWORD *)&v33.typeId;
        v15->GetTypeObj(&v34, v15);
        if ( ((unsigned __int8)v36 | (unsigned __int8)v37) == v34.typeId )
          v12 = v15;
        else
          v15->DecrementRefcount(v15);
      }
      syncObjects[v11] = v12;
      if ( !v12 )
        goto LABEL_28;
      if ( numHandles <= ++v11 )
        goto all_translated;
    }
  }
  v21 = v5;
LABEL_41:
  v25 = 0;
  if ( v21 == 0xD9400415 )
    v21 = 0xC920181A;
  if ( numHandles > 0 )
  {
    do
    {
      v26 = syncObjects[v25];
      if ( v26 )
        v26->DecrementRefcount(v26);
      ++v25;
    }
    while ( v25 < numHandles );
  }
  args->res = v21;
}
// FFF0F978: variables would overlap: lvar "reused_stackloc" ^8.4(user-defined) and ^8.8

//----- (FFF0FD1C) --------------------------------------------------------
void __fastcall GetThreadListImpl(GetThreadListArgs *args, u32 *tidBuffer)
{
  Handle processHandle; // r1
  KProcess *v5; // r7
  KProcess *volatile process; // r5
  KProcess *v7; // r0
  KAutoObject *v8; // r0
  KAutoObject *v9; // r5
  u8 typeId; // r9
  int v11; // r0
  s32 v12; // r5
  unsigned int v13; // r2
  bool v14; // zf
  KThreadLinkedListNode *node; // r0
  s32 i; // r5
  Result v17; // r0
  KTypeObj v18; // [sp+0h] [bp-30h] BYREF
  KTypeObj v19; // [sp+8h] [bp-28h] BYREF
  u32 src; // [sp+10h] [bp-20h] BYREF

  processHandle = args->processHandle;
  v5 = 0;
  if ( !processHandle )                         // if no process handle, dump all thread ids
  {
    v12 = 0;
    v13 = __ldrex((unsigned int *)&g_threadAllocator.container.mutex);
    v14 = v13 == 0;
    if ( v13 )
      __strex(v13, (unsigned int *)&g_threadAllocator.container.mutex);
    else
      v13 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_threadAllocator.container.mutex);
    if ( v14 )
      v14 = v13 == 0;
    if ( !v14 )
      KLightMutex::LockImpl(&g_threadAllocator.container.mutex);
    __mcr(15, 0, 0, 7, 10, 5);
    for ( node = (KThreadLinkedListNode *)g_threadAllocator.container.list.link.next;
          node != (KThreadLinkedListNode *)&g_threadAllocator.container.list.link;
          ++v12 )
    {
      if ( args->maxNumThreads > v12 )
        tidBuffer[v12] = node->thread->threadId;
      node = node->link.next;
    }
    __mcr(15, 0, 0, 7, 10, 5);
    g_threadAllocator.container.mutex.lockingThread = 0;
    if ( g_threadAllocator.container.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_threadAllocator.container.mutex);
    *args->outNumThreads = v12;
    v11 = 0;
    goto LABEL_27;
  }
  if ( processHandle == CUR_PROCESS_HANDLE )
  {
    process = current.clc.current.process;
    KAutoObject::IncrementRefcount(current.clc.current.process);
    v7 = process;
  }
  else
  {
    v8 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, processHandle);
    v9 = v8;
    if ( !v8 )
    {
LABEL_11:
      args->result = 0xD8E007F7;
      return;
    }
    v8->GetTypeObj(&v18, v8);
    typeId = v18.typeId;
    v9->GetTypeObj(&v19, v9);
    if ( (typeId | 0xC5) == v19.typeId )
      v5 = (KProcess *)v9;
    else
      v9->DecrementRefcount(v9);
    v7 = v5;
  }
  if ( !v7 )
    goto LABEL_11;
  v11 = KProcess::DumpThreadIds(v7, args->outNumThreads, tidBuffer, args->maxNumThreads);
LABEL_27:
  args->result = v11;                           // they forget to decref the process!
  if ( v11 >= 0 )
  {
    for ( i = 0; args->maxNumThreads > i; ++i )
    {
      src = tidBuffer[i];
      if ( CopyWordToUser(&args->outThreadIds[i], &src) )
        v17 = 0;
      else
        v17 = 0xE0E01BF5;
      args->result = v17;
      if ( v17 < 0 )
        break;
    }
  }
}

//----- (FFF0FF30) --------------------------------------------------------
void __fastcall GetProcessListImpl(GetProcessListArgs *args, u32 *pidBuffer)
{
  int res; // r0
  int v5; // r5
  Result v6; // r0
  u32 v7; // [sp+0h] [bp-18h] BYREF

  res = KProcess::GetProcessList(args->outNumProcesses, pidBuffer, args->maxNumProcesses);
  args->result = res;
  if ( res >= 0 )
  {
    v5 = 0;
    if ( args->maxNumProcesses <= 0 )
    {
LABEL_8:
      args->result = 0;
    }
    else
    {
      while ( 1 )
      {
        v7 = pidBuffer[v5];
        v6 = CopyWordToUser(&args->outPids[v5], &v7) ? 0 : 0xE0E01BF5;
        args->result = v6;
        if ( v6 < 0 )
          break;
        if ( args->maxNumProcesses <= ++v5 )
          goto LABEL_8;
      }
    }
  }
}

//----- (FFF0FFB8) --------------------------------------------------------
Result __fastcall KDmaChannel::Restart(
        KDmaChannel *this,
        u32 dstAddr,
        u32 srcAddr,
        u32 size,
        DmaRestartFlags restartFlags)
{
  KLightMutex *p_mutex; // r0
  KLightMutex *v10; // r5
  unsigned int v11; // r2
  bool v12; // zf
  unsigned int v13; // r3
  int state; // r0
  bool v15; // zf
  bool v16; // zf
  s32 v17; // r0
  s32 minOffset; // r11
  int v19; // r1
  u32 maxVa; // r2
  u32 currentVa; // r3
  bool v22; // zf
  s32 v23; // r0
  s32 v24; // r11
  int v25; // r1
  u32 v26; // r2
  u32 v27; // r3
  bool v28; // zf
  BOOL dontReuseProgram; // r11
  s32 v30; // r2
  u32 currentPa; // r1
  BOOL v32; // r0
  BOOL v33; // r0
  KDmaProgram *p_programStorage; // r0
  Result v35; // r4
  KLightMutex *v36; // r0
  u32 v37; // r2
  u32 v38; // r1
  BOOL v39; // r1
  s32 maxOffset; // [sp+0h] [bp-48h]
  s32 maxOffseta; // [sp+0h] [bp-48h]
  KDmaAddress v43; // [sp+4h] [bp-44h] BYREF
  KDmaBufferSize v44; // [sp+18h] [bp-30h] BYREF

  p_mutex = &this->mutex;
  v10 = p_mutex;
  v11 = __ldrex((unsigned int *)p_mutex);
  v12 = v11 == 0;
  if ( v11 )
    v13 = __strex(v11, (unsigned int *)p_mutex);
  else
    v13 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)p_mutex);
  if ( !v11 )
    v12 = v13 == 0;
  if ( !v12 )
    KLightMutex::LockImpl(p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  state = (unsigned __int8)this->state;
  v15 = state == KDMACHANSTATE_STARTED;
  if ( state != KDMACHANSTATE_STARTED )
    v15 = state == KDMACHANSTATE_RESTARTED;
  if ( !v15 )
    v15 = !this->keepLocked;
  if ( !v15 )
  {
    if ( size | srcAddr )
    {
      v16 = size == 0;
      if ( size )
        v16 = this->dmaSize.size == size;
      if ( v16 )
      {
        v17 = this->dmaSize.srcBufferSize.maxOffset;
        minOffset = this->dmaSize.srcBufferSize.minOffset;
      }
      else
      {
        memset(&v44, 0, sizeof(v44));
        KDmaBufferSize::ComputeFromConfig(&v44, size, &this->dmaConfig.dstCfg);
        v17 = v44.maxOffset;
        minOffset = v44.minOffset;
      }
      maxOffset = v17;
      v19 = *(_DWORD *)&this->srcDmaAddress.isDevice;
      maxVa = this->srcDmaAddress.maxVa;
      currentVa = this->srcDmaAddress.currentVa;
      v43.currentPa = this->srcDmaAddress.currentPa;
      *(_DWORD *)&v43.isDevice = v19;
      v43.maxVa = maxVa;
      v43.currentVa = currentVa;
      v43.process = this->srcDmaAddress.process;
      KDmaAddress::ResetAddress(&v43, srcAddr);
      if ( !KDmaAddress::CheckBufferRangeValid(&v43, minOffset, maxOffset) )
      {
        v35 = 0xE0E01BF5;
        v36 = v10;
        __mcr(15, 0, 0, 7, 10, 5);
        v10->lockingThread = 0;
        if ( v10->numWaiters <= 0 )
          return v35;
        goto LABEL_56;
      }
      if ( !KDmaAddress::CheckVirtualAddressBlockUsable(&v43, minOffset, maxOffset, 0) )
      {
        v35 = 0xD9000402;
        v36 = v10;
        __mcr(15, 0, 0, 7, 10, 5);
        v10->lockingThread = 0;
        if ( v10->numWaiters <= 0 )
          return v35;
        goto LABEL_56;
      }
    }
    if ( size | dstAddr )
    {
      v22 = size == 0;
      if ( !size )
        v22 = this->dmaSize.size == 0;
      if ( v22 )
      {
        v23 = this->dmaSize.dstBufferSize.maxOffset;
        v24 = this->dmaSize.dstBufferSize.minOffset;
      }
      else
      {
        memset(&v44, 0, sizeof(v44));
        KDmaBufferSize::ComputeFromConfig(&v44, size, &this->dmaConfig.srcCfg);
        v23 = v44.maxOffset;
        v24 = v44.minOffset;
      }
      maxOffseta = v23;
      v25 = *(_DWORD *)&this->dstDmaAddress.isDevice;
      v26 = this->dstDmaAddress.maxVa;
      v27 = this->dstDmaAddress.currentVa;
      v43.currentPa = this->dstDmaAddress.currentPa;
      *(_DWORD *)&v43.isDevice = v25;
      v43.maxVa = v26;
      v43.currentVa = v27;
      v43.process = this->dstDmaAddress.process;
      KDmaAddress::ResetAddress(&v43, dstAddr);
      if ( !KDmaAddress::CheckBufferRangeValid(&v43, v24, maxOffseta) )
      {
        v35 = 0xE0E01BF5;
        v36 = v10;
        __mcr(15, 0, 0, 7, 10, 5);
        v10->lockingThread = 0;
        if ( v10->numWaiters <= 0 )
          return v35;
        goto LABEL_56;
      }
      if ( !KDmaAddress::CheckVirtualAddressBlockUsable(&v43, v24, maxOffseta, 1) )
      {
        v35 = 0xD9000402;
        v36 = v10;
        __mcr(15, 0, 0, 7, 10, 5);
        v10->lockingThread = 0;
        if ( v10->numWaiters <= 0 )
          return v35;
        goto LABEL_56;
      }
    }
    if ( !size )
      size = this->dmaSize.size;
    this->dmaObject->signaled = 0;
    this->keepLocked = (restartFlags & 1) == 0;
    v28 = !this->dmaConfig.dstIsContiguous;
    if ( this->dmaConfig.dstIsContiguous )
      v28 = !this->dmaConfig.srcIsContiguous;
    dontReuseProgram = v28 || this->needCodeRegen;
    if ( !KDmaAddress::ResetAddress(&this->dstDmaAddress, dstAddr) )
      dontReuseProgram = 1;
    v12 = !KDmaAddress::ResetAddress(&this->srcDmaAddress, srcAddr);
    v30 = this->dmaSize.size;
    currentPa = this->srcDmaAddress.currentPa;
    if ( v12 )
      dontReuseProgram = 1;
    this->dmaConfig.dstAddr = this->dstDmaAddress.currentPa;
    this->dmaConfig.srcAddr = currentPa;
    if ( v30 != size )
    {
      this->dmaSize.size = size;
      KDmaBufferSize::ComputeFromConfig(&this->dmaSize.dstBufferSize, size, &this->dmaConfig.srcCfg);
      KDmaBufferSize::ComputeFromConfig(&this->dmaSize.srcBufferSize, size, &this->dmaConfig.dstCfg);
      dontReuseProgram = 1;
    }
    if ( dstAddr )
    {
      v32 = KDmaAddress::CheckPhysicalMemContiguous(
              &this->dstDmaAddress,
              this->dmaSize.dstBufferSize.minOffset,
              this->dmaSize.dstBufferSize.maxOffset);
      if ( !v32 )
        dontReuseProgram = 1;
      this->dmaConfig.dstIsContiguous = v32;
    }
    if ( srcAddr )
    {
      v33 = KDmaAddress::CheckPhysicalMemContiguous(
              &this->srcDmaAddress,
              this->dmaSize.srcBufferSize.minOffset,
              this->dmaSize.srcBufferSize.maxOffset);
      if ( !v33 )
        dontReuseProgram = 1;
      this->dmaConfig.srcIsContiguous = v33;
      if ( !v33 )
        goto LABEL_87;
    }
    if ( dontReuseProgram )
    {
LABEL_87:
      p_programStorage = &this->programStorage;
      if ( this != (KDmaChannel *)-232 )
        p_programStorage = KDmaProgram::KDmaProgram(p_programStorage);
      this->program = p_programStorage;
      p_programStorage->Configure(p_programStorage, &this->dmaConfig, 0, KDMABLOCKTYPE_BODY);
      if ( dontReuseProgram )
      {
        this->transferredDmaSize.size = 0;
        KDmaBufferSize::operator=(&this->transferredDmaSize.dstBufferSize, 0);
        KDmaBufferSize::operator=(&this->transferredDmaSize.srcBufferSize, 0);
        this->needCodeRegen = 0;
        KDmaChannel::BuildProgramAndRun(this, (((unsigned int)restartFlags >> 1) & 1) == 0);// DMARSTFLAG_DONT_FLUSH_PERIPHERAL
        goto LABEL_83;
      }
    }
    do
    {
      if ( KDmaController::IsManagerFaulting() || KDmaController::IsChannelFaulting(this->channelId) )
        kernelpanic();
    }
    while ( KDmaController::GetChannelStatus(this->channelId) );
    if ( srcAddr )
      v37 = this->dmaConfig.srcAddr;
    else
      v37 = 0;
    if ( dstAddr )
      v38 = this->dmaConfig.dstAddr;
    else
      v38 = 0;
    KDmaInstructionFactory::MutateMovDarMovSarInsts(&this->instFactory, v38, v37);
    if ( (((unsigned int)restartFlags >> 1) & 1) != 0 )// DMARSTFLAG_DONT_FLUSH_PERIPHERAL
    {
      KDmaInstructionFactory::ReplaceFlushPByNop(&this->instFactory);
    }
    else if ( this->dmaConfig.dstIsDevice || this->dmaConfig.srcIsDevice )
    {
      v39 = 1;
LABEL_82:
      KDmaChannel::StartExecutingCode(this, v39);
LABEL_83:
      v35 = 0;
      v36 = v10;
      __mcr(15, 0, 0, 7, 10, 5);
      v10->lockingThread = 0;
      if ( v10->numWaiters <= 0 )
        return v35;
      goto LABEL_56;
    }
    v39 = 0;
    goto LABEL_82;
  }
  v35 = 0xD8E007E8;
  v36 = v10;
  __mcr(15, 0, 0, 7, 10, 5);
  v10->lockingThread = 0;
  if ( v10->numWaiters > 0 )
LABEL_56:
    KLightMutex::UnlockImpl(v36);
  return v35;
}

//----- (FFF10478) --------------------------------------------------------
KPort *__fastcall KPort::KPort(KPort *this)
{
  KPort *v1; // r0
  KServerPort *__shifted(KPort,8) v2; // r0
  KServerPort *__shifted(KPort,0x2C) v3; // r0

  v1 = (KPort *)KAutoObject::KAutoObject(this);
  v1->__vftable = &KPort::vt;
  v2 = (KServerPort *__shifted(KPort,8))KSynchronizationObject::KSynchronizationObject(&v1->server);
  ADJ(v2)->server.__vftable = &KServerPort::vt;
  ADJ(v2)->server.incomingServerSessions.link.next = (KServerSessionLinkedListNode *)&ADJ(v2)->server.incomingServerSessions.link;
  ADJ(v2)->server.incomingServerSessions.count = 0;
  ADJ(v2)->server.incomingServerSessions.link.prev = (KServerSessionLinkedListNode *)&ADJ(v2)->server.incomingServerSessions.link;
  v3 = (KServerPort *__shifted(KPort,0x2C))KSynchronizationObject::KSynchronizationObject(&ADJ(v2)->client);
  ADJ(v3)->client.__vftable = &KClientPort::vt;
  ADJ(v3)->client.currentSessionCount = 0;
  return ADJ(v3);
}

//----- (FFF104D4) --------------------------------------------------------
void __fastcall KEvent::Initialize(KEvent *this, KProcess *ownerProcess, ResetType resetType)
{
  u8 v4; // r4

  v4 = resetType;
  KAutoObject::IncrementRefcount(ownerProcess);
  this->ownerProcess = ownerProcess;
  this->signaled = 0;
  this->manualInterruptReenable = 0;
  this->resetType = v4;
}

//----- (FFF10504) --------------------------------------------------------
Result __fastcall KMutex::Initialize(KMutex *this, KProcess *owner, BOOL initiallyLocked)
{
  Result result; // r0

  KAutoObject::IncrementRefcount(owner);
  this->ownerProcess = owner;
  if ( initiallyLocked )
  {
    this->lockCount = 1;
    this->lockingThread = current.clc.current.thread;
    KThread::AcquireMutex(current.clc.current.thread, this);
  }
  else
  {
    this->lockCount = 0;
    this->lockingThread = 0;
  }
  result = 63;
  this->priority = 63;
  return result;
}

//----- (FFF10568) --------------------------------------------------------
void __fastcall KMutex::ForceUnlock(KMutex *this, KThread *thread)
{
  KSchedulerLock::Lock(&g_schedulerLock);
  if ( this->lockCount > 0 )
  {
    this->lockCount = 0;
    this->lockingThread = 0;
    KThread::RelinquishMutex(thread, this);
    KSynchronizationObject::NotifyWaiters(this, 0);
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
}

//----- (FFF105BC) --------------------------------------------------------
void __fastcall KTimer::Initialize(KTimer *this, KProcess *ownerProcess, ResetType resetType)
{
  u8 v4; // r4

  v4 = resetType;
  KAutoObject::IncrementRefcount(ownerProcess);
  this->ownerProcess = ownerProcess;
  this->signaled = 0;
  this->resetType = v4;
  this->allowedToRegister = 0;
}

//----- (FFF105EC) --------------------------------------------------------
Result __fastcall KTimer::Set(KTimer *this, s64 initialTimeoutNs, s64 intervalNs)
{
  __int64 v3; // r4
  s64 SystemTick; // r0
  signed __int64 currentTimeNs; // r6
  unsigned int v8; // r12
  unsigned int v9; // r1
  BOOL v11; // [sp+Ch] [bp-94h]
  __int64 thread; // [sp+28h] [bp-78h]
  int v13; // [sp+44h] [bp-5Ch]

  SystemTick = KHardwareTimer::GetSystemTick(&g_hardwareTimer);
  currentTimeNs = 0xBAD34AEELL * SHIDWORD(SystemTick)
                + 3LL * (unsigned int)SystemTick
                + __PAIR64__(3 * HIDWORD(SystemTick), (0xBAD34AEE * (unsigned __int64)(unsigned int)SystemTick) >> 32);
  thread = (unsigned int)current.clc.current.thread;
  v8 = __ldrex((unsigned int *)&g_timerOpsMutex);
  v9 = 1;
  if ( v8 == HIDWORD(thread) )
    v9 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_timerOpsMutex);
  else
    __strex(v8, (unsigned int *)&g_timerOpsMutex);
  if ( v9 )
    KLightMutex::LockImpl(&g_timerOpsMutex);
  __mcr(15, 0, 0, 7, 10, 5);
  this->intervalLo = intervalNs;
  this->intervalHi = HIDWORD(intervalNs);
  if ( ((((unsigned __int64)-initialTimeoutNs >> 32) & 0x80000000) != 0LL) != __OFSUB__(
                                                                                0,
                                                                                HIDWORD(initialTimeoutNs),
                                                                                (_DWORD)initialTimeoutNs == 0) )
  {
    v3 = currentTimeNs + initialTimeoutNs;
    if ( currentTimeNs + initialTimeoutNs < currentTimeNs )// clamp to INT64_MAX
      v3 = 0x7FFFFFFFFFFFFFFFLL;
    this->nextTimeLo = v3;
    this->nextTimeHi = HIDWORD(v3);
    this->signaled = 0;
    this->allowedToRegister = 1;
    v13 = 1;
  }
  else
  {
    this->nextTimeLo = currentTimeNs;           // clamp to 0
    this->nextTimeHi = HIDWORD(currentTimeNs);
    v13 = 0;
  }
  __mcr(15, 0, 0, 7, 10, 5);
  g_timerOpsMutex.lockingThread = 0;
  if ( g_timerOpsMutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_timerOpsMutex);
  if ( v13 )
  {
    KHardwareTimer::Sanitize(&g_hardwareTimer);
    KSchedulerLock::Lock(&g_hardwareTimer.lock);
    v11 = KHardwareTimer::RegisterTask(
            &g_hardwareTimer,
            &this->KTimerTask,
            __SPAIR64__(
              (0x44A2FA85LL * SHIDWORD(v3) + ((0x44A2FA85 * (unsigned __int64)(unsigned int)v3) >> 32)) >> 32,
              (unsigned __int64)(0x44A2FA85 * v3) >> 32));
    KSchedulerLock::UnlockSingleCoreResched(&g_hardwareTimer.lock);
    if ( !v11 )
      KAutoObject::IncrementRefcount(this);
  }
  else
  {
    this->allowedToRegister = 0;
    if ( KHardwareTimer::CancelTask(&g_hardwareTimer, &this->KTimerTask) )
      this->DecrementRefcount(this);
    this->signaled = 0;
    this->allowedToRegister = 1;
    KAutoObject::IncrementRefcount(this);
    this->OnTimeout(this);
  }
  return 0;
}
// FFF10890: variable 'v3' is possibly undefined

//----- (FFF109A0) --------------------------------------------------------
Result __fastcall KProcessPageTable::Initialize(KProcessPageTable *this, u32 pid, bool onlyUseSmallPages)
{
  unsigned int v5; // r2
  bool v6; // zf
  unsigned int v7; // r3
  unsigned int index; // r0
  int v9; // r0
  unsigned int v10; // r1
  u8 v11; // r10
  u32 *Contiguous; // r8
  unsigned int v14; // r2
  int v15; // r0
  char cfgr; // r1
  int v17; // r1

  this->translationTableSize = 0x1000;
  this->addressSpaceStart = 0;
  this->addressSpaceEnd = 0x40000000;
  this->linearAddressRangeStart = 0;
  v5 = __ldrex((unsigned int *)&g_asidManager.mutex);
  v6 = v5 == 0;
  if ( v5 )
    v7 = __strex(v5, (unsigned int *)&g_asidManager.mutex);
  else
    v7 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_asidManager.mutex);
  if ( !v5 )
    v6 = v7 == 0;
  if ( !v6 )
    KLightMutex::LockImpl(&g_asidManager.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  index = g_asidManager.index;
  if ( ((g_asidManager.map[index >> 5] >> (index & 0x1F)) & 1) != 0 )
  {
    v9 = 0;
    while ( 1 )
    {
      v10 = __clz((g_asidManager.map[v9] + 1) & ~g_asidManager.map[v9]);
      if ( v10 < 0x20 )
        break;
      if ( ++v9 >= 8 )
        kernelpanic();
    }
    index = (unsigned __int8)(31 - v10 + 32 * v9);
    g_asidManager.index = index;
  }
  g_asidManager.map[index >> 5] |= 1 << (index & 0x1F);
  v11 = index;
  ++g_asidManager.index;
  __mcr(15, 0, 0, 7, 10, 5);
  g_asidManager.mutex.lockingThread = 0;
  if ( g_asidManager.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_asidManager.mutex);
  this->asid = v11;
  this->onlyUseSmallPages = onlyUseSmallPages;
  this->isKernel = 0;
  Contiguous = (u32 *)KMemoryManager::AllocateContiguous(&g_memoryManager, 1u, 1u, MEMOP_REGION_BASE_KERNEL);
  if ( !Contiguous )
    return -664795149;
  v14 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
  if ( v14 )
  {
    __strex(v14, (unsigned int *)&g_memoryManager.pgMgr.mutex);
  }
  else if ( !__strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex) )
  {
    goto LABEL_23;
  }
  KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
LABEL_23:
  __mcr(15, 0, 0, 7, 10, 5);
  KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)Contiguous, 1u);
  __mcr(15, 0, 0, 7, 10, 5);
  g_memoryManager.pgMgr.mutex.lockingThread = 0;
  if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  KPageTable::InitizalizeL1Table(&this->L1Table, Contiguous);
  this->translationTableBase = ((unsigned int)(Contiguous + 0x10000000) >> 9 << 9) | 0x12;
  KMemoryBlockManager::Initialize(&this->memoryBlockMgr, this->addressSpaceStart, this->addressSpaceEnd);
  KPageTable::CleanDataCacheRange(
    (u32)&this->L1Table[this->addressSpaceStart >> 20],
    4 * (this->translationTableSize >> 2));
  KPageTable::InvalidateAllTlbEntries(this);    // tlbi
  v15 = (int)g_tlbMaintenanceHelper.currentProcPageTables[0];
  if ( !g_tlbMaintenanceHelper.currentProcPageTables[0] )
  {
    cfgr = MPCORE.scu.cfgr;
    v17 = (cfgr & 3) + 1;
    while ( v17 > v15 )
      g_tlbMaintenanceHelper.currentProcPageTables[v15++] = this;
  }
  return 0;
}

//----- (FFF10BDC) --------------------------------------------------------
Result __fastcall KProcessPageTable::ControlMemory(
        KProcessPageTable *this,
        u32 *outAddr,
        u32 addr0,
        u32 addr1,
        u32 size,
        u32 op,
        u32 perms)
{
  int v8; // r5
  u32 v10; // r0
  u32 numPages; // r6
  u32 v12; // r8
  u32 i; // r3
  Result baseAddress; // r0
  unsigned __int32 v15; // r1
  u32 linearAllocAddr; // r0
  void *v17; // r9
  u8 v18; // r2
  u32 linearAddressRangeStart; // r0
  Result *p_result; // r0
  bool v21; // zf
  KMemoryState state; // [sp+0h] [bp-60h] BYREF
  u32 region; // [sp+4h] [bp-5Ch] BYREF
  Result result; // [sp+8h] [bp-58h] BYREF
  KMemoryState newStateDst; // [sp+10h] [bp-50h]
  KMemoryPermission newPermsDst; // [sp+14h] [bp-4Ch]
  KMemoryUpdateFlags v27; // [sp+18h] [bp-48h]
  KMemoryInfo outMemoryInfo; // [sp+1Ch] [bp-44h] BYREF

  v8 = addr0;
  newStateDst = MEMSTATE_FREE;
  v10 = perms & KMEMPERM_RW;
  newPermsDst = v10 | KMEMPERM_KRW;             // always writable by kernel, remove X bit
  v27 = KMEMUPDATE_NONE;
  numPages = size >> 12;
  v12 = 0;
  region = op & 0xF00;
  switch ( (char)op )
  {
    case MEMOP_FREE:
      for ( i = addr0; ; i = baseAddress + v15 )
      {
        if ( i >= v8 + size )
        {
          newStateDst = MEMSTATE_FREE;
          goto LABEL_29;
        }
        baseAddress = KPageTable::QueryInfo(this, &outMemoryInfo, (u32 *)&state, i);
        v15 = baseAddress & 0x80000000;
        if ( baseAddress < 0 )
          break;
        if ( (outMemoryInfo.state & KMEMSTATE_FLAG_DEALLOCATABLE) != 0 )
        {
          baseAddress = outMemoryInfo.baseAddress;
          v15 = outMemoryInfo.size;
        }
        else
        {
          baseAddress = 0xE0A01BF5;
        }
        if ( (outMemoryInfo.state & KMEMSTATE_FLAG_DEALLOCATABLE) == 0 )
          break;
      }
      break;
    case MEMOP_ALLOC:
      if ( !addr0
        || (baseAddress = KPageTable::CheckAddressRangeSizeAndState(this, addr0, size, MEMSTATE_FREE), baseAddress >= 0) )
      {
        if ( (op & MEMOP_LINEAR_FLAG) == 0 )
        {
          newStateDst = KMEMSTATE_PRIVATE_DATA;
          goto LABEL_29;
        }
        linearAllocAddr = KMemoryManager::AllocateContiguous(&g_memoryManager, numPages, 0, (MemoryOperation)region);
        v17 = (void *)linearAllocAddr;
        if ( !linearAllocAddr )
        {
          v18 = 3;
          state = 0x3F3;
          goto LABEL_20;
        }
        v12 = linearAllocAddr + 0x40000000;     // - 0xC0000000
        linearAddressRangeStart = this->linearAddressRangeStart;
        v8 = (int)v17 + linearAddressRangeStart + 0x20000000;
        if ( linearAddressRangeStart == 0x14000000 && v8 + (numPages << 12) > 0x1C000000 )
        {                                       // oops, VA can't fit
          KLightMutex::Lock((KLightMutex **)&region, &g_memoryManager.pgMgr.mutex);
          KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)v17, numPages);
          KLightMutex::Unlock((KLightMutex *)region);
          KMemoryManager::FreeContiguousLocked(&g_memoryManager, (u32)v17, numPages);
          v18 = 3;
          p_result = &result;
          state = 0x3F3;
          goto LABEL_23;
        }
        v21 = addr0 == 0;
        if ( addr0 )
          v21 = v8 == addr0;
        if ( v21 )
        {
          newStateDst = KMEMSTATE_LINEAR;
          memset(v17, 0, numPages << 12);
          KPageTable::CleanInvalidateDataCacheRange((u32)v17, numPages << 12);
          goto LABEL_29;
        }
        KLightMutex::Lock((KLightMutex **)&state, &g_memoryManager.pgMgr.mutex);// linear alloc didn't match specified addr0 (!= 0), dealloc
        KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)v17, numPages);
        KLightMutex::Unlock((KLightMutex *)state);
        KMemoryManager::FreeContiguousLocked(&g_memoryManager, (u32)v17, numPages);
        baseAddress = 0xE0E01BF5;
      }
      break;
    case MEMOP_MAP:
      baseAddress = KPageTable::CreateAlias(
                      this,
                      addr1,
                      addr0,
                      size >> 12,
                      KMEMSTATE_PRIVATE_DATA,
                      KMEMPERM_RW,
                      KMEMSTATE_ALIASED,
                      KMEMPERM_KRW_RW,
                      KMEMSTATE_ALIAS,
                      (KMemoryPermission)(v10 | KMEMPERM_KRW));
      break;
    case MEMOP_UNMAP:
      baseAddress = KPageTable::DestroyAlias(
                      this,
                      addr1,
                      addr0,
                      size >> 12,
                      KMEMSTATE_ALIASED,
                      KMEMPERM_NONE,
                      KMEMSTATE_ALIAS,
                      KMEMPERM_NONE,
                      KMEMSTATE_PRIVATE_DATA,
                      (KMemoryPermission)(v10 | KMEMPERM_KRW),
                      v27);
      break;
    case MEMOP_PROT:
      baseAddress = KPageTable::CheckAddressRangeSizeAndStateFlags(
                      this,
                      addr0,
                      size,
                      KMEMSTATE_FLAG_PROTECTIBLE,
                      KMEMSTATE_FLAG_PROTECTIBLE);
      if ( baseAddress >= 0 )
      {
        BYTE1(v27) = 1;
LABEL_29:
        baseAddress = KPageTable::Operate(this, v8, numPages, v12, newStateDst, newPermsDst, v27, region);
        if ( baseAddress >= 0 )
        {
          if ( outAddr )
            *outAddr = v8;
        }
      }
      break;
    default:
      v18 = 7;
      state = KMEMSTATE_FLAG_PROTECTIBLE|KMEMSTATE_FLAG_DEALLOCATABLE|MEMSTATE_ALIAS|MEMSTATE_CODE|0xE0;
LABEL_20:
      p_result = (Result *)&region;
LABEL_23:
      baseAddress = *MakeResultCode(p_result, 0xFBu, v18, 1u, state);// 0x3ED
      break;
  }
  return baseAddress;
}
// FFF10BDC: using guessed type u32 size;
// FFF10BDC: using guessed type u32 op;

//----- (FFF10F14) --------------------------------------------------------
Result __fastcall KProcessPageTable::MapSharedConfigPages(KProcessPageTable *this, bool canWriteSharedUserPage)
{
  BOOL v3; // r6
  KMemoryPermission v4; // r6
  u32 mmuAttribs; // [sp+8h] [bp-20h] BYREF

  v3 = canWriteSharedUserPage;
  mmuAttribs = 0x5A5;                           // both uncacheable
  KPageTable::MapContiguousPhysicalAddressRange(
    this,
    0x1FF80000u,
    (u32)&g_kernelSharedConfigPagePtr[0x40000],
    1u,
    &mmuAttribs);
  KMemoryBlockManager::MutateRange(&this->memoryBlockMgr, 0x1FF80000u, 1u, KMEMSTATE_SHARED, KMEMPERM_KRW_R, 0);
  if ( v3 )
    mmuAttribs = 0xDB5;
  else
    mmuAttribs = 0xDA5;
  if ( v3 )
    v4 = KMEMPERM_KRW_RW;
  else
    v4 = KMEMPERM_KRW_R;
  KPageTable::MapContiguousPhysicalAddressRange(
    this,
    0x1FF81000u,
    g_userSharedConfigPagePtr - 0xC0000000,
    1u,
    &mmuAttribs);
  KMemoryBlockManager::MutateRange(&this->memoryBlockMgr, 0x1FF81000u, 1u, KMEMSTATE_SHARED, v4, 0);
  KPageTable::InvalidateAllTlbEntries(this);
  return 0;
}
// FFF2F0D4: using guessed type KernelSharedConfig *g_kernelSharedConfigPagePtr;

//----- (FFF11008) --------------------------------------------------------
Result __fastcall KPageTable::CheckAndUpdateAddrRangeMaskedStateAndPerms(
        KPageTable *this,
        u32 addr,
        u32 numPages,
        KMemoryState stateMask,
        KMemoryState expectedState,
        KMemoryPermission minPerms,
        KMemoryState newState,
        KMemoryPermission newPerms)
{
  Result result; // r0

  result = KPageTable::CheckAddrRangeMaskedStateAndPerms(this, addr, numPages << 12, stateMask, expectedState, minPerms);
  if ( result >= 0 )
    return KPageTable::Operate(this, addr, numPages, 0, newState, newPerms, KMEMUPDATE_STATE_AND_PERMS, 0x300u);
  return result;
}

//----- (FFF1107C) --------------------------------------------------------
Result __fastcall KInterruptManager::UnbindUserInterruptEventChecked(
        KInterruptManager *this,
        KInterruptEvent *interruptEvent,
        s32 irqId)
{
  KLightMutex *p_mutex; // r0
  KLightMutex *v7; // r4
  unsigned int v8; // r2
  bool v9; // zf
  unsigned int v10; // r3
  u32 v12; // r0
  KInterruptHandler *v13; // r1
  KInterruptEntry *v14; // r7
  bool v15; // zf
  int v16; // r0
  Result v17; // r7

  p_mutex = &this->mutex;
  v7 = p_mutex;
  v8 = __ldrex((unsigned int *)p_mutex);
  v9 = v8 == 0;
  if ( v8 )
    v10 = __strex(v8, (unsigned int *)p_mutex);
  else
    v10 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)p_mutex);
  if ( !v8 )
    v9 = v10 == 0;
  if ( !v9 )
    KLightMutex::LockImpl(p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  if ( (unsigned int)(irqId - 32) <= 0x5F )
  {
    v12 = irqId;
    if ( interruptEvent )
      v13 = &interruptEvent->KInterruptTask;
    else
      v13 = 0;
    v14 = &this->privateInterrupts[3][irqId];
    v15 = v13 == 0;
    if ( v13 )
      v15 = v14->handler == v13;
    if ( v15 )
    {
      KInterruptController::DisableInterrupt(v12);
      v16 = 0;
      v14->handler = 0;
    }
    else
    {
      v16 = 0xD8E007F0;
    }
    v17 = v16;
    if ( v16 >= 0 )
    {
      interruptEvent->irqId = -1;
      interruptEvent->DecrementRefcount(interruptEvent);
    }
    __mcr(15, 0, 0, 7, 10, 5);
    v7->lockingThread = 0;
    if ( v7->numWaiters > 0 )
      KLightMutex::UnlockImpl(v7);
    return v17;
  }
  else
  {
    __mcr(15, 0, 0, 7, 10, 5);
    v7->lockingThread = 0;
    if ( v7->numWaiters > 0 )
      KLightMutex::UnlockImpl(v7);
    return 0xD8E007FD;
  }
}

//----- (FFF11178) --------------------------------------------------------
Result __fastcall KInterruptManager::BindUserInterruptEvent(
        KInterruptManager *this,
        KInterruptEvent *interruptEvent,
        s32 irqId,
        s32 coreId,
        s32 priority,
        bool manualClear,
        bool levelSensitive)
{
  unsigned int *p_mutex; // r0
  KLightMutex *v11; // r4
  unsigned int v12; // r2
  bool v13; // zf
  unsigned int v14; // r3
  KInterruptTask *v16; // r1
  int v17; // r6

  p_mutex = (unsigned int *)&this->mutex;
  v11 = (KLightMutex *)p_mutex;
  v12 = __ldrex(p_mutex);
  v13 = v12 == 0;
  if ( v12 )
    v14 = __strex(v12, p_mutex);
  else
    v14 = __strex((unsigned int)current.clc.current.thread, p_mutex);
  if ( !v12 )
    v13 = v14 == 0;
  if ( !v13 )
    KLightMutex::LockImpl((KLightMutex *)p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  if ( (unsigned int)(irqId - 32) <= 0x5F )
  {
    KAutoObject::IncrementRefcount(interruptEvent);
    interruptEvent->irqId = irqId;
    if ( interruptEvent )
      v16 = &interruptEvent->KInterruptTask;
    if ( !interruptEvent )
      v16 = 0;
    v17 = KInterruptManager::BindSharedInterrupt(this, v16, irqId, coreId, priority, manualClear, levelSensitive);
    if ( v17 < 0 )
    {
      interruptEvent->irqId = -1;
      interruptEvent->DecrementRefcount(interruptEvent);
    }
    __mcr(15, 0, 0, 7, 10, 5);
    v11->lockingThread = 0;
    if ( v11->numWaiters > 0 )
      KLightMutex::UnlockImpl(v11);
    return v17;
  }
  else
  {
    __mcr(15, 0, 0, 7, 10, 5);
    v11->lockingThread = 0;
    if ( v11->numWaiters > 0 )
      KLightMutex::UnlockImpl(v11);
    return -656406531;
  }
}
// FFF11220: variable 'v16' is possibly undefined

//----- (FFF11274) --------------------------------------------------------
void __fastcall KMemoryBlockManager::Initialize(KMemoryBlockManager *this, u32 addrSpaceStart, u32 addrSpaceEnd)
{
  KMemoryBlock *v6; // r4
  KLinkedListNode *v7; // r0

  v6 = (KMemoryBlock *)KSlabHeap::Allocate(&g_memoryBlockSlabHeap);
  v6->perms = KMEMPERM_NONE;
  v6->numPages = (addrSpaceEnd - addrSpaceStart) >> 12;
  v6->baseAddr = addrSpaceStart;
  v6->state = MEMSTATE_FREE;
  v6->tag = 0;
  v7 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
  if ( v7 )
  {
    v7->link.next = 0;
    v7->link.prev = 0;
    v7->data = 0;
  }
  v7->data = v6;
  KLinkedList::InsertAfter((KLinkedList *)this, (KLinkedListLink *)&this->blocks.link, v7);
}
// FFF112EC: conditional instruction was optimized away because r0.4!=0

//----- (FFF1131C) --------------------------------------------------------
void __fastcall KInterruptController::EnableWithPriority(s32 irqId, u8 priority)
{
  *(_BYTE *)(irqId + 0xFFFEF400) = 16 * priority;
  if ( (unsigned int)(irqId - 16) <= 0x6F )
    MPCORE.gicd.isenabler[irqId / 32] = 1 << (irqId % 32);
}

//----- (FFF11364) --------------------------------------------------------
u32 KPerformanceCounterManager::GetOverflowFlags(void)
{
  unsigned int cpuEvtOvf; // r2
  u32 pmncr; // r1

  cpuEvtOvf = __mrc(15, 0, 15, 12, 0) & 0x700;
  pmncr = MPCORE.scu.pmncr;
  return (cpuEvtOvf >> 8) | pmncr & 0xFF0000;
}

//----- (FFF11388) --------------------------------------------------------
void __fastcall KPerformanceCounterManager::SetVirtualCounterEnabled(KPerformanceCounterManager *this, bool enable)
{
  int v3; // r7
  int i; // r4
  int v5; // r6
  int j; // r4
  int v7; // r1
  int v8; // r2
  KInterruptHandler_vtbl **v9; // r2
  int v10; // r2

  if ( this->virtualCounterEnabled != enable )
  {
    if ( enable )
    {
      KPerformanceCounterManager::BindInterrupts(this);
    }
    else
    {
      v3 = __mrc(15, 0, 0, 0, 5) & 3;
      for ( i = 0; i < 4; ++i )
        KInterruptManager::UnbindKernelInterruptForCore(&g_interruptManager, i + 120, v3);
      if ( KSystemControl::IsLgr2Capable() )
        v5 = 124;
      else
        v5 = 122;
      for ( j = 0; j < 8; ++j )
        KInterruptManager::UnbindKernelInterruptForCore(&g_interruptManager, v5 + j, v3);
      v7 = 0;
      this->virtualCounterEnabled = 0;
      while ( 1 )
      {
        v10 = (MPCORE.scu.cfgr & 3) + 1;
        if ( v10 <= v7 )
          break;
        v8 = 3 * v7++;
        v9 = &(&this->__vftable)[v8];
        v9[1] = 0;
        v9[2] = 0;
        v9[3] = 0;
      }
      this->scuCounterHi[0] = 0;
      this->scuCounterHi[1] = 0;
      this->scuCounterHi[2] = 0;
      this->scuCounterHi[3] = 0;
      this->scuCounterHi[4] = 0;
      this->scuCounterHi[5] = 0;
      this->scuCounterHi[6] = 0;
      this->scuCounterHi[7] = 0;
    }
  }
}

//----- (FFF11474) --------------------------------------------------------
void __fastcall KPerformanceCounterManager::ResetCounters(
        KPerformanceCounterManager *this,
        u32 valueMask,
        u32 overflowMask)
{
  KPerformanceCounterManager *reused; // r4
  unsigned int CPSR; // r12
  unsigned int v5; // r5
  bool v6; // zf
  signed __int32 v7; // r2
  u32 pmncr; // r12
  unsigned int v9; // r12
  KInterruptHandler_vtbl **v10; // r2

  if ( ((valueMask | overflowMask) & 7) != 0 )
  {
    CPSR = __get_CPSR();
    __disable_irq();
    reused = (KPerformanceCounterManager *)((char *)this + 12 * (__mrc(15, 0, 0, 0, 5) & 3));
    v5 = (overflowMask << 8) & 0x700 | __mrc(15, 0, 15, 12, 0) & 0xFFFFF8FF | valueMask & 4;
    reused->cp15CounterHi[0][2] = 0;
    if ( (~valueMask & 3) != 0 )
    {
      if ( (valueMask & 1) != 0 )
        __mcr(15, 0, 0, 15, 12, 2);
      if ( (valueMask & 1) != 0 )
        reused->cp15CounterHi[0][0] = 0;
      if ( (valueMask & 2) == 0 )
        goto LABEL_12;
      __mcr(15, 0, 0, 15, 12, 3);
    }
    else
    {
      v5 |= 2u;                                 // reset both using P bit
      reused->cp15CounterHi[0][0] = 0;
    }
    reused->cp15CounterHi[0][1] = 0;
LABEL_12:
    __mcr(15, 0, v5, 15, 12, 0);
    __set_CPSR(CPSR);
  }
  if ( (valueMask | overflowMask) << 8 >> 24 )
  {
    v6 = (unsigned __int8)~BYTE2(valueMask) == 0;
    v7 = overflowMask & 0xFF0000;
    pmncr = MPCORE.scu.pmncr;
    if ( BYTE2(valueMask) == 0xFF )
      valueMask = 0;
    else
      reused = (KPerformanceCounterManager *)MPCORE.scu.mnr;
    v9 = pmncr & 0xFF00FFFF | v7;
    if ( v6 )
      v9 |= 2u;
    else
      v7 = 0;                                   // similar thing, with "reset all" vs "reset some"
    if ( v6 )
    {
      do
      {
        v10 = &(&this->__vftable)[valueMask++];
        v10[13] = 0;
      }
      while ( (int)valueMask < 8 );
    }
    else
    {
      do
      {
        if ( ((valueMask >> (v7 + 16)) & 1) != 0 )
        {
          (&reused->__vftable)[v7] = 0;
          this->scuCounterHi[v7] = 0;
        }
        ++v7;
      }
      while ( v7 < 8 );
    }
    MPCORE.scu.pmncr = v9;
  }
}
// FFF1154C: variable 'reused' is possibly undefined

//----- (FFF1158C) --------------------------------------------------------
void __fastcall KPerformanceCounterManager::Enable(KPerformanceCounterManager *this)
{
  int i; // r1
  KPerformanceCounterControlHelper *v3; // r2
  int v4; // r12
  __int32 v5; // r0
  int j; // r2
  int k; // r1
  KPerformanceCounterManager *v8; // lr

  KPerformanceCounterManager::BindInterrupts(this);
  this->cp15CounterHi[0][0] = 0;
  this->cp15CounterHi[0][1] = 0;
  this->cp15CounterHi[0][2] = 0;
  this->cp15CounterHi[1][0] = 0;
  this->cp15CounterHi[1][1] = 0;
  this->cp15CounterHi[1][2] = 0;
  this->cp15CounterHi[2][0] = 0;
  this->cp15CounterHi[2][1] = 0;
  this->cp15CounterHi[2][2] = 0;
  this->cp15CounterHi[3][0] = 0;
  this->cp15CounterHi[3][1] = 0;
  this->cp15CounterHi[3][2] = 0;
  g_perfCounterControlHelper.pmncCp15Value = 0x777;// 
                                                // - Enable
                                                // - Reset Count Register on write
                                                // - Reset Cycle Count Register on write
                                                // - Enable all 3 interrupts
                                                // - Clear all 3 overflow flags
  for ( i = 0; ; ++i )
  {
    v4 = (MPCORE.scu.cfgr & 3) + 1;
    if ( v4 <= i )
      break;
    v3 = (KPerformanceCounterControlHelper *)((char *)&g_perfCounterControlHelper + i);
    v3->writeCompleted[0] = 0;
  }
  v5 = (((1 << ((MPCORE.scu.cfgr & 3) + 1)) - 1) << 16) & 0xFF0000 | KINTNAME_SGI_PERFCOUNTERCTRL;
  MPCORE.gicd.sgir = v5;
  for ( j = 0; v4 > j; ++j )
  {
    while ( !g_perfCounterControlHelper.writeCompleted[j] )
      ;
  }
  MPCORE.scu.pmncr = 0xFF0002;                  // reset counters, disable interrupt, clear overflow flags (by writing 1)
  for ( k = 0; k < 8; ++k )
  {
    v8 = (KPerformanceCounterManager *)((char *)this + 4 * k);
    *(_BYTE *)(((unsigned int)&MPCORE.scu.pmncr | 0x1FE0004) + k) = 0;// Monitor Counter Events
    *(_DWORD *)(((unsigned int)&MPCORE.scu.pmncr | 0x1FE0004) + 8 + 4 * k) = 0;// Monitor Counter registers
    v8->scuCounterHi[0] = 0;
  }
  MPCORE.scu.pmncr = 0xFFFF03;                  // enable, reset counters, enable interrupts, clear interrupt flags
}

//----- (FFF116B8) --------------------------------------------------------
void KPerformanceCounterManager::Disable(void)
{
  int v0; // r6
  int i; // r4
  int v2; // r5
  int j; // r4
  int k; // r1
  char *v5; // r3
  int v6; // r3
  int m; // r0

  v0 = __mrc(15, 0, 0, 0, 5) & 3;
  for ( i = 0; i < 4; ++i )
    KInterruptManager::UnbindKernelInterruptForCore(&g_interruptManager, i + 120, v0);
  if ( KSystemControl::IsLgr2Capable() )
    v2 = 124;
  else
    v2 = 122;
  for ( j = 0; j < 8; ++j )
    KInterruptManager::UnbindKernelInterruptForCore(&g_interruptManager, v2 + j, v0);
  g_perfCounterControlHelper.pmncCp15Value = 0x706;// 
                                                // - bit0 unset: disable all counters
                                                // - bit1: reset all counters
                                                // - bit2: Reserved SBZ but assigned to 1??? (might be related to  N3DS)
                                                // - bit7+: MN0, 1, 2 interrupts enabled
                                                // - bit16+ unset: overflow flags cleared
  for ( k = 0; ; ++k )
  {
    v6 = (MPCORE.scu.cfgr & 3) + 1;
    if ( v6 <= k )
      break;
    v5 = (char *)&g_perfCounterControlHelper + k;
    v5[4] = 0;
  }
  MPCORE.gicd.sgir = (((1 << ((MPCORE.scu.cfgr & 3) + 1)) - 1) << 16) & 0xFF0000 | 4;
  for ( m = 0; v6 > m; ++m )
  {
    while ( !g_perfCounterControlHelper.writeCompleted[m] )
      ;
  }
  MPCORE.scu.pmncr = 0xFF0002;                  // reset counters, disable interrupt, set overflow flags?????
}

//----- (FFF117D8) --------------------------------------------------------
PerformanceCounterEvent __fastcall KPerformanceCounterManager::GetEvent(
        KPerformanceCounterManager *this,
        PerformanceCounterName name)
{
  bool v2; // zf
  u32 cfgr; // r2

  if ( name == PERFCOUNTER_NAME_SCU_2 )
    goto LABEL_14;
  if ( name >= PERFCOUNTER_NAME_SCU_2 )
  {
    if ( (unsigned int)(name - PERFCOUNTER_NAME_SCU_3) > 4 )
      return 0;
LABEL_14:
    cfgr = MPCORE.scu.cfgr;
    if ( (int)(((2 * cfgr) & 7) + 2) > name - PERFCOUNTER_NAME_SCU_0 )
      return *((unsigned __int8 *)&MPCORE.scu.cfgr + name) + PERFCOUNTEREVENT_SCU_BASE;
    return 0;
  }
  if ( name == PERFCOUNTER_NAME_CORE_CYCLE_COUNTER )
  {
    if ( (__mrc(15, 0, 15, 12, 0) & 8) != 0 )
      return 4095;                              // fake event
    else
      return 255;
  }
  if ( name >= PERFCOUNTER_NAME_CORE_CYCLE_COUNTER )
  {
    v2 = name == PERFCOUNTER_NAME_SCU_0;
    if ( name != PERFCOUNTER_NAME_SCU_0 )
      v2 = name == PERFCOUNTER_NAME_SCU_1;
    if ( !v2 )
      return 0;
    goto LABEL_14;
  }
  if ( name )
  {
    if ( name == PERFCOUNTER_NAME_CORE_COUNT_REG_1 )
      return (__mrc(15, 0, 15, 12, 0) & 0xFF000u) >> 12;
    return 0;
  }
  return (__mrc(15, 0, 15, 12, 0) & 0xFF00000u) >> 20;
}

//----- (FFF11890) --------------------------------------------------------
u64 __fastcall KPerformanceCounterManager::GetCounterValue(
        KPerformanceCounterManager *this,
        PerformanceCounterName name)
{
  bool v3; // zf
  int v4; // r0
  u32 cfgr; // r1
  KPerformanceCounterManager *v6; // r1
  unsigned int CPSR; // r2
  unsigned int v8; // r2
  u64 result; // r0

  if ( name == PERFCOUNTER_NAME_SCU_2 )
    goto LABEL_14;
  if ( name > PERFCOUNTER_NAME_SCU_2 )
  {
    if ( (unsigned int)(name - PERFCOUNTER_NAME_SCU_3) > 4 )
      return 0LL;
LABEL_14:
    v4 = name - 16;
    cfgr = MPCORE.scu.cfgr;
    if ( (int)(((2 * cfgr) & 7) + 2) > v4 )
    {
      v6 = (KPerformanceCounterManager *)((char *)this + 4 * v4);
      LODWORD(result) = MPCORE.scu.mnr[v4];
      HIDWORD(result) = v6->scuCounterHi[0];
      return result;
    }
    return 0LL;
  }
  if ( name == PERFCOUNTER_NAME_CORE_CYCLE_COUNTER )
  {
    CPSR = __get_CPSR();
    __disable_irq();
    LODWORD(result) = __mrc(15, 0, 15, 12, 1);
    HIDWORD(result) = this->cp15CounterHi[__mrc(15, 0, 0, 0, 5) & 3][2];
    __set_CPSR(CPSR);
    return result;
  }
  if ( name > PERFCOUNTER_NAME_CORE_CYCLE_COUNTER )
  {
    v3 = name == PERFCOUNTER_NAME_SCU_0;
    if ( name != PERFCOUNTER_NAME_SCU_0 )
      v3 = name == PERFCOUNTER_NAME_SCU_1;
    if ( !v3 )
      return 0LL;
    goto LABEL_14;
  }
  if ( name == PERFCOUNTER_NAME_CORE_COUNT_REG_0 )
  {
    v8 = __get_CPSR();
    __disable_irq();
    LODWORD(result) = __mrc(15, 0, 15, 12, 2);
    HIDWORD(result) = this->cp15CounterHi[__mrc(15, 0, 0, 0, 5) & 3][0];
    goto LABEL_18;
  }
  if ( name == PERFCOUNTER_NAME_CORE_COUNT_REG_1 )
  {
    v8 = __get_CPSR();
    __disable_irq();
    LODWORD(result) = __mrc(15, 0, 15, 12, 3);
    HIDWORD(result) = this->cp15CounterHi[__mrc(15, 0, 0, 0, 5) & 3][1];
LABEL_18:
    __set_CPSR(v8);
    return result;
  }
  return 0LL;
}

//----- (FFF11994) --------------------------------------------------------
void __fastcall KPerformanceCounterManager::SetEvent(
        KPerformanceCounterManager *this,
        PerformanceCounterName name,
        PerformanceCounterEvent event)
{
  unsigned int v3; // r0
  bool v4; // zf
  u32 cfgr; // r3
  unsigned int CPSR; // r0
  unsigned int v7; // r1
  unsigned int v8; // r1

  if ( name == PERFCOUNTER_NAME_SCU_2 )
    goto LABEL_15;
  if ( name >= PERFCOUNTER_NAME_SCU_2 )
  {
    if ( (unsigned int)(name - 19) > 4 )
      return;
    goto LABEL_15;
  }
  if ( name == PERFCOUNTER_NAME_CORE_CYCLE_COUNTER )
  {
    CPSR = __get_CPSR();
    __disable_irq();
    v7 = __mrc(15, 0, 15, 12, 0) & 0xFFFFF8FF;
    if ( event == PERFCOUNTEREVENT_CORE_CYCLE_COUNT_64 )// fake event
      v8 = v7 | 8;                              // change the cycle divider according to the event
    else
      v8 = v7 & ~8u;
    __mcr(15, 0, v8, 15, 12, 0);
    __set_CPSR(CPSR);
    return;
  }
  if ( name >= PERFCOUNTER_NAME_CORE_CYCLE_COUNTER )
  {
    v4 = name == PERFCOUNTER_NAME_SCU_0;
    if ( name != PERFCOUNTER_NAME_SCU_0 )
      v4 = name == PERFCOUNTER_NAME_SCU_1;
    if ( !v4 )
      return;
LABEL_15:
    cfgr = MPCORE.scu.cfgr;
    if ( (int)(((2 * cfgr) & 7) + 2) > name - PERFCOUNTER_NAME_SCU_0 )
      *((_BYTE *)&MPCORE.scu.cfgr + name) = event;
    return;
  }
  if ( name )
  {
    if ( name != PERFCOUNTER_NAME_CORE_COUNT_REG_1 )
      return;
    v3 = __get_CPSR();
    __disable_irq();
    __mcr(15, 0, __mrc(15, 0, 15, 12, 0) & 0xFFF008FF | (event << 12) & 0xFF000, 15, 12, 0);
  }
  else
  {
    v3 = __get_CPSR();
    __disable_irq();
    __mcr(15, 0, __mrc(15, 0, 15, 12, 0) & 0xF00FF8FF | (event << 20) & 0xFF00000, 15, 12, 0);
  }
  __set_CPSR(v3);
}

//----- (FFF11A84) --------------------------------------------------------
void __fastcall KPerformanceCounterManager::SetCounterValue(
        KPerformanceCounterManager *this,
        PerformanceCounterName name,
        u64 value)
{
  unsigned int v3; // r1
  bool v4; // zf
  int v5; // r1
  u32 cfgr; // r12
  unsigned int CPSR; // r1

  if ( name == PERFCOUNTER_NAME_SCU_2 )
    goto LABEL_18;
  if ( name > PERFCOUNTER_NAME_SCU_2 )
  {
    if ( (unsigned int)(name - PERFCOUNTER_NAME_SCU_3) > 4 )
      return;
    goto LABEL_18;
  }
  if ( name == PERFCOUNTER_NAME_CORE_CYCLE_COUNTER )
  {
    CPSR = __get_CPSR();
    __disable_irq();
    if ( this->virtualCounterEnabled )
      this->cp15CounterHi[__mrc(15, 0, 0, 0, 5) & 3][PERFCOUNTER_NAME_CORE_CYCLE_COUNTER] = HIDWORD(value);
    __mcr(15, 0, value, 15, 12, 1);
    __set_CPSR(CPSR);
    return;
  }
  if ( name >= PERFCOUNTER_NAME_CORE_CYCLE_COUNTER )
  {
    v4 = name == PERFCOUNTER_NAME_SCU_0;
    if ( name != PERFCOUNTER_NAME_SCU_0 )
      v4 = name == PERFCOUNTER_NAME_SCU_1;
    if ( !v4 )
      return;
LABEL_18:
    v5 = name - PERFCOUNTER_NAME_SCU_0;
    cfgr = MPCORE.scu.cfgr;
    if ( (int)(((2 * cfgr) & 7) + 2) > v5 )
    {
      if ( this->virtualCounterEnabled )
        this->scuCounterHi[v5] = HIDWORD(value);
      MPCORE.scu.mnr[v5] = value;
    }
    return;
  }
  if ( name )
  {
    if ( name != PERFCOUNTER_NAME_CORE_COUNT_REG_1 )
      return;
    v3 = __get_CPSR();
    __disable_irq();
    if ( this->virtualCounterEnabled )
      this->cp15CounterHi[__mrc(15, 0, 0, 0, 5) & 3][1] = HIDWORD(value);
    __mcr(15, 0, value, 15, 12, 3);
  }
  else
  {
    v3 = __get_CPSR();
    __disable_irq();
    if ( this->virtualCounterEnabled )
      this->cp15CounterHi[__mrc(15, 0, 0, 0, 5) & 3][0] = HIDWORD(value);
    __mcr(15, 0, value, 15, 12, 2);
  }
  __set_CPSR(v3);
}

//----- (FFF11BA4) --------------------------------------------------------
void __fastcall KPageTable::InvalidateEntireInstructionCache()
{
  bool v0[8]; // [sp+0h] [bp-8h] BYREF

  KCacheMaintenanceHelper::RequestOtherCoresEntireCacheMaintenance(v0, KCACHEMAINTOP_INV_ICACHE);
  __mcr(15, 0, 0, 7, 5, 0);
  __mcr(15, 0, 0, 7, 5, 6);
  __mcr(15, 0, 0, 7, 10, 4);
  __mcr(15, 0, 0, 7, 5, 4);
  KCacheMaintenanceHelper::Join(v0);
}

//----- (FFF11BD4) --------------------------------------------------------
Result __fastcall KProcessPageTable::CopyMemoryForDebug(
        KProcessPageTable *this,
        u32 dstAddr,
        KProcessPageTable *srcPgTbl,
        u32 srcAddr,
        u32 size)
{
  unsigned int v9; // r2
  bool v10; // zf
  unsigned int v11; // r1
  bool v12; // zf
  unsigned int v13; // r2
  int v14; // r9
  bool v15; // zf
  Result result; // r0
  KCopyMemoryForDebugHelper *v17; // r4
  u32 v18; // r6
  u32 v19; // r8
  u32 v20; // r4
  u32 v21; // r1
  KProcessPageTable *pgTblPtr; // r6
  unsigned int v23; // r1
  bool v24; // zf
  unsigned int v25; // r2
  u32 v26; // r0
  u32 v27; // r0
  u32 v28; // r6
  u32 v29; // r1
  u32 v30; // r0
  u32 v31; // r1
  u32 v32; // r6
  unsigned int v33; // r0
  u32 v34; // r1
  u32 v35; // r6
  u32 v36; // r0
  u32 v37; // r1
  u32 v38; // r6
  u32 v39; // r1
  u32 v40; // r1
  u32 v41; // r0
  u32 v42; // r4
  u32 v43; // r6
  u32 v44; // r1
  u32 v45; // r4
  u32 v46; // r6
  const void *v47; // r1
  KTranslationTableIterator ttblIterator; // [sp+18h] [bp-88h] BYREF
  u32 pa; // [sp+20h] [bp-80h]
  u32 perms; // [sp+24h] [bp-7Ch]
  KMemoryUpdateFlags v51; // [sp+28h] [bp-78h]
  KTranslationTableIterator v52; // [sp+30h] [bp-70h] BYREF
  KCopyMemoryForDebugHelper v53; // [sp+38h] [bp-68h] BYREF
  u32 v54; // [sp+50h] [bp-50h]
  KCopyMemoryForDebugHelper v55; // [sp+58h] [bp-48h] BYREF
  u32 v56; // [sp+74h] [bp-2Ch]

  v55.pgTblPtr = this;
  v9 = __ldrex((unsigned int *)this);
  v10 = v9 == 0;
  if ( v9 )
    __strex(v9, (unsigned int *)this);
  else
    v9 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)this);
  if ( v10 )
    v10 = v9 == 0;
  if ( !v10 )
    KLightMutex::LockImpl(&this->mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  KTranslationTableIterator::CreateFromEntry(&this->L1Table, &ttblIterator, &v55.traversalContext, dstAddr);
  __mcr(15, 0, 0, 7, 10, 5);
  this->mutex.lockingThread = 0;
  if ( this->mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&this->mutex);
  v53.pgTblPtr = srcPgTbl;
  v55.pa = ttblIterator.pa;
  v55.size = ttblIterator.size - (ttblIterator.pa & (ttblIterator.size - 1));
  v11 = __ldrex((unsigned int *)srcPgTbl);
  v12 = v11 == 0;
  if ( v11 )
    v13 = __strex(v11, (unsigned int *)srcPgTbl);
  else
    v13 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)srcPgTbl);
  if ( !v11 )
    v12 = v13 == 0;
  if ( !v12 )
    KLightMutex::LockImpl(&srcPgTbl->mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  KTranslationTableIterator::CreateFromEntry(&srcPgTbl->L1Table, &ttblIterator, &v53.traversalContext, srcAddr);
  __mcr(15, 0, 0, 7, 10, 5);
  srcPgTbl->mutex.lockingThread = 0;
  if ( srcPgTbl->mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&srcPgTbl->mutex);
  v14 = 0;
  v53.pa = ttblIterator.pa;
  v53.size = ttblIterator.size - (ttblIterator.pa & (ttblIterator.size - 1));
  v15 = v55.pa == 0;
  if ( v55.pa )
    v15 = v53.pa == 0;
  if ( v15 )
  {
    if ( size )
      return 0xE0A01BF5;
    return 0;
  }
  while ( 1 )
  {
    if ( v55.size > v53.size )                  // check which block is smaller because of VA alignment
      v17 = &v53;
    else
      v17 = &v55;
    if ( v55.size <= v53.size )
      dstAddr = (u32)&v53;
    if ( v55.size > v53.size )
      dstAddr = (u32)&v55;
    if ( v17->size + v14 >= size )
      break;
    pgTblPtr = v17->pgTblPtr;
    v23 = __ldrex((unsigned int *)v17->pgTblPtr);
    v24 = v23 == 0;
    if ( v23 )
      v25 = __strex(v23, (unsigned int *)pgTblPtr);
    else
      v25 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)pgTblPtr);
    if ( !v23 )
      v24 = v25 == 0;
    if ( !v24 )
      KLightMutex::LockImpl(&pgTblPtr->mutex);
    __mcr(15, 0, 0, 7, 10, 5);
    KTranslationTableIterator::Advance(&pgTblPtr->L1Table, &v52, &v17->traversalContext);
    __mcr(15, 0, 0, 7, 10, 5);
    pgTblPtr->mutex.lockingThread = 0;
    if ( pgTblPtr->mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&pgTblPtr->mutex);
    v26 = v17->size;
    if ( v17->pa + v26 == v52.pa )
    {
      v27 = v26 + v52.size;
    }
    else
    {
      perms = v17->size;
      v28 = v53.pa;
      if ( v55.pa - 0x20000000 < 0x10000000 )
        goto LABEL_167;
      v29 = v55.pa >> 12 << 12;
      ttblIterator.pa = perms + v55.pa - v29;
      if ( v29 - 0x18000000 > 0x600000 )
      {
        if ( v29 - 0x1F000000 > 0x400000 )
        {
          if ( v29 - 0x10100000 > 0x1000000 )
          {
            if ( v29 - 0x1FF00000 > 0x80000 )
              v29 = 0;
          }
          else
          {
            v29 = (v55.pa >> 12 << 12) + 0xEB00000;
          }
        }
        else
        {
          v29 -= 0x800000;
        }
      }
      else
      {
        v29 += 0x7000000;
      }
      result = KProcessPageTable::MapStaticOrIo(srcPgTbl, v29, (ttblIterator.pa + 4095) >> 12, 1, KMEMPERM_RW);
      if ( result >= 0 )
      {
LABEL_167:
        if ( v28 - 0x20000000 < 0x10000000 )
          goto LABEL_75;
        v30 = v28 >> 12 << 12;
        v31 = v28 - v30;
        v32 = v30;
        v33 = v30 - 402653184;
        v34 = v31 + perms;
        if ( v33 <= 0x600000 )
          v32 += 117440512;
        if ( v33 > 0x600000 )
        {
          if ( v32 - 0x1F000000 > 0x400000 )
          {
            if ( v32 - 0x10100000 > 0x1000000 )
            {
              if ( v32 - 0x1FF00000 > 0x80000 )
                v32 = 0;
            }
            else
            {
              v32 += 0xEB00000;
            }
          }
          else
          {
            v32 -= 0x800000;
          }
        }
        result = KProcessPageTable::MapStaticOrIo(this, v32, (v34 + 4095) >> 12, 1, KMEMPERM_RW);
        if ( result >= 0 )
LABEL_75:
          result = 0;
      }
      if ( result < 0 )
        return result;
      v35 = v53.pa;
      if ( v55.pa - 0x20000000 >= 0x10000000 )
      {
        if ( v55.pa - 402653184 > 0x600000 )
        {
          if ( v55.pa - 520093696 > 0x400000 )
          {
            if ( v55.pa - 0x10100000 > 0x1000000 )
              v36 = v55.pa - 0x1FF00000 > 0x80000 ? 0 : v55.pa;
            else
              v36 = v55.pa + 0xEB00000;
          }
          else
          {
            v36 = v55.pa - 0x800000;
          }
        }
        else
        {
          v36 = v55.pa + 0x7000000;
        }
      }
      else
      {
        v36 = v55.pa - 0x40000000;
      }
      if ( v53.pa - 0x20000000 >= 0x10000000 )
      {
        if ( v53.pa - 0x18000000 > 0x600000 )
        {
          if ( v53.pa - 0x1F000000 > 0x400000 )
          {
            if ( v53.pa - 0x10100000 > 0x1000000 )
            {
              if ( v53.pa - 0x1FF00000 > 0x80000 )
                v35 = 0;
            }
            else
            {
              v35 = v53.pa + 0xEB00000;
            }
          }
          else
          {
            v35 = v53.pa - 0x800000;
          }
        }
        else
        {
          v35 = v53.pa + 0x7000000;
        }
        v37 = v35;
      }
      else
      {
        v37 = v53.pa + 0xC0000000;
      }
      memcpy((void *)v36, (const void *)v37, v17->size);
      v38 = v53.pa;
      v54 = v17->size;
      ttblIterator.size = 0;                    // unmap
      perms = 0;
      v51 = KMEMUPDATE_NONE;
      if ( v55.pa - 0x20000000 < 0x10000000 )
        goto LABEL_168;
      pa = v55.pa >> 12 << 12;
      v39 = pa;
      v56 = v54 + v55.pa - pa;
      if ( pa - 0x18000000 > 0x600000 )
      {
        if ( pa - 0x1F000000 > 0x400000 )
        {
          if ( pa - 0x10100000 > 0x1000000 )
          {
            if ( pa - 0x1FF00000 > 0x80000 )
              v39 = 0;
          }
          else
          {
            v39 = (v55.pa >> 12 << 12) + 0xEB00000;
          }
        }
        else
        {
          v39 = pa - 0x800000;
        }
      }
      else
      {
        v39 = pa + 0x7000000;
      }
      result = KPageTable::Operate(
                 srcPgTbl,
                 v39,
                 (v56 + 4095) >> 12,
                 pa,
                 (KMemoryState)ttblIterator.size,
                 (KMemoryPermission)perms,
                 v51,
                 MEMOP_REGION_BASE);
      if ( result >= 0 )
      {
LABEL_168:
        if ( v38 - 0x20000000 < 0x10000000
          || ((ttblIterator.pa = v38 >> 12 << 12,
               pa = v54 + v38 - ttblIterator.pa,
               ttblIterator.pa - 0x18000000 > 0x600000) ? (ttblIterator.pa - 0x1F000000 > 0x400000 ? (ttblIterator.pa - 0x10100000 > 0x1000000 ? (ttblIterator.pa - 0x1FF00000 > 0x80000 ? (v40 = 0) : (v40 = ttblIterator.pa)) : (v40 = ttblIterator.pa + 0xEB00000)) : (v40 = ttblIterator.pa - 0x800000)) : (v40 = ttblIterator.pa + 0x7000000),
              result = KPageTable::Operate(
                         this,
                         v40,
                         (pa + 4095) >> 12,
                         ttblIterator.pa,
                         (KMemoryState)ttblIterator.size,
                         (KMemoryPermission)perms,
                         v51,
                         0x300u),
              result >= 0) )
        {
          result = 0;
        }
      }
      if ( result < 0 )
        return result;
      v41 = v17->size;
      v14 += v41;
      *(_DWORD *)(dstAddr + 12) += v41;
      *(_DWORD *)(dstAddr + 16) -= v17->size;
      v17->pa = v52.pa;
      v27 = v52.size;
    }
    v17->size = v27;
  }
  v18 = v53.pa;
  v19 = size - v14;
  if ( v55.pa - 0x20000000 < 0x10000000
    || ((v20 = v55.pa >> 12 << 12, v20 - 0x18000000 > 0x600000) ? (v20 - 0x1F000000 > 0x400000 ? (v20 - 0x10100000 > 0x1000000 ? (v20 - 0x1FF00000 > 0x80000 ? (v21 = 0) : (v21 = v55.pa >> 12 << 12)) : (v21 = v20 + 0xEB00000)) : (v21 = v20 - 0x800000)) : (v21 = v20 + 0x7000000),
        result = KProcessPageTable::MapStaticOrIo(srcPgTbl, v21, (v55.pa - v20 + v19 + 4095) >> 12, 1, KMEMPERM_RW),
        result >= 0) )
  {
    if ( v18 - 0x20000000 < 0x10000000
      || ((v42 = v18 >> 12 << 12, v43 = v18 - v42 + v19, v42 - 402653184 > 0x600000) ? (v42 - 520093696 > 0x400000 ? (v42 - 269484032 > 0x1000000 ? (v42 - 535822336 > 0x80000 ? (v44 = 0) : (v44 = v42)) : (v44 = v42 + 246415360)) : (v44 = v42 - 0x800000)) : (v44 = v42 + 117440512),
          result = KProcessPageTable::MapStaticOrIo(this, v44, (v43 + 4095) >> 12, 1, KMEMPERM_RW),
          result >= 0) )
    {
      result = 0;
    }
  }
  if ( result >= 0 )
  {
    v45 = v55.pa;
    v46 = v53.pa;
    if ( v55.pa - 0x20000000 >= 0x10000000 )
    {
      if ( v55.pa - 0x18000000 > 0x600000 )
      {
        if ( v55.pa - 0x1F000000 > 0x400000 )
        {
          if ( v55.pa - 0x10100000 > 0x1000000 )
          {
            if ( v55.pa - 0x1FF00000 > 0x80000 )
              v45 = 0;
          }
          else
          {
            v45 = v55.pa + 246415360;
          }
        }
        else
        {
          v45 = v55.pa - 0x800000;
        }
      }
      else
      {
        v45 = v55.pa + 0x7000000;
      }
    }
    else
    {
      v45 = v55.pa - 0x40000000;
    }
    if ( v53.pa - 0x20000000 >= 0x10000000 )
    {
      if ( v53.pa - 0x18000000 > 0x600000 )
      {
        if ( v53.pa - 0x1F000000 > 0x400000 )
        {
          if ( v53.pa - 0x10100000 > 0x1000000 )
          {
            if ( v53.pa - 0x1FF00000 > 0x80000 )
              v46 = 0;
          }
          else
          {
            v46 = v53.pa + 246415360;
          }
        }
        else
        {
          v46 = v53.pa - 0x800000;
        }
      }
      else
      {
        v46 = v53.pa + 0x7000000;
      }
      v47 = (const void *)v46;
    }
    else
    {
      v47 = (const void *)(v53.pa + 0xC0000000);
    }
    memcpy((void *)v45, v47, size - v14);
    result = KProcessPageTable::UnmapStaticOrIoByPa(this, v55.pa, srcPgTbl, v53.pa, size - v14);
    if ( result >= 0 )
      return 0;
  }
  return result;
}

//----- (FFF1248C) --------------------------------------------------------
void __fastcall KDebug::Intialize(KDebug *this, KProcess *process)
{
  this->signalingSyncEvent = 0;
  this->process = process;                      // weak ref
  process->debug = this;                        // weak ref
  this->processAttached = 0;
  KDebug::IntializeDebugThreads(this);
  this->numExceptionEvents = 0;
  this->signalingSyncEventThread = 0;
  this->exceptionEventSignaled = 0;
  this->excCtx = 0;
  this->hasDebuggerBreak = 0;
  this->isFirstExceptionBreak = 0;
  this->hasAttachBreak = 0;
  this->deferredExceptionContinue = 0;
  this->deferredUserBreakContinue = 0;
  this->numBlockingEvents = 0;
  this->numAttachOrDetachEvents = 0;
  this->debugFlags = 0xFFFE;                    // inhibit user exception handling, report everything
  this->unk_24 = 0;
  this->processExitedNormally = 0;
  this->processTerminated = 0;
  this->hasBreakSvc = 0;
  this->outputStringAddr = 0;
  this->outputStringSize = 0;
  this->outputStringFlag = 0;
  this->breakThread = 0;
  this->userBreakThread = 0;
  this->userDebuggerThread = 0;
  this->userDebuggerCoreId = 0;
}

//----- (FFF12514) --------------------------------------------------------
Result __fastcall KThread::AttachNewToDebug(KThread *this)
{
  KDebug *debug; // r5

  debug = this->owner->debug;
  if ( !debug )
    return 0;
  KDebug::AttachNewThread(debug, this);
  if ( this->owner->mainThread == this )        // this is the main thread/first thread
                                                // 
                                                // Try to run the debugger thread
  {
    KSchedulerLock::Lock(&g_schedulerLock);
    KDebug::BuildOrderedListOfThreads(debug);
    KDebug::RequestPause(debug, this);
    if ( g_coreLocalRegions[this->coreId].clc.current.thread == this )
      KScheduler::TriggerSgi(current.clc.current.scheduler);
    KSchedulerLock::Unlock(&g_schedulerLock);
  }
  this->debugThread->creatorThreadId = current.clc.current.thread->threadId;
  return 0;
}

//----- (FFF125B0) --------------------------------------------------------
Result __fastcall KThread::SignalExitToDebug(KThread *this)
{
  KDebug *owner; // r1
  bool v2; // zf
  ExitThreadEventReason shallTerminate; // r2
  KDebug *process; // r0
  bool v5; // zf

  owner = (KDebug *)this->owner;
  v2 = owner == 0;
  if ( owner )
  {
    owner = *(KDebug **)&owner->isFirstExceptionBreak;// ->debug
    v2 = owner == 0;
  }
  if ( !v2 )
  {
    if ( owner->processExitedNormally )
    {
      shallTerminate = EXITTHREAD_EVENT_EXIT_PROCESS;
    }
    else if ( owner->processTerminated )
    {
      shallTerminate = EXITTHREAD_EVENT_TERMINATE_PROCESS;
    }
    else
    {
      shallTerminate = this->shallTerminate;
    }
    process = (KDebug *)current.clc.current.process;
    v5 = current.clc.current.process == 0;
    if ( current.clc.current.process )
    {
      process = current.clc.current.process->debug;
      v5 = process == 0;
    }
    if ( !v5 )
      KDebug::DispatchEvent(process, DBGEVENT_EXIT_THREAD, shallTerminate, 0);
  }
  return 0;
}

//----- (FFF12628) --------------------------------------------------------
Result __fastcall KProcess::SetDebugExitedNormallyFlag(KProcess *this)
{
  KDebug *result; // r0

  result = this->debug;
  if ( result )
  {
    result->processExitedNormally = 1;
    return 0;
  }
  return (Result)result;
}

//----- (FFF12644) --------------------------------------------------------
Result __fastcall KThread::SetDebugPauseOnInit(KThread *this)
{
  KDebug *debug; // r5
  KThread *volatile thread; // r4
  KDebugThread *debugThread; // r6
  bool v4; // zf
  unsigned __int8 *p_dpcFlags; // r1
  unsigned __int8 v6; // r2

  debug = this->owner->debug;
  if ( debug )
  {
    thread = current.clc.current.thread;
    debugThread = current.clc.current.thread->debugThread;
    v4 = debugThread == 0;
    if ( debugThread )
      v4 = !debugThread->debugPauseRequested;
    if ( !v4 )
    {
      KSchedulerLock::Lock(&g_schedulerLock);
      debugThread->debugPauseRequested = 0;
      p_dpcFlags = &ADJ(thread->kernelStackTop)->dpcFlags;
      do
        v6 = __ldrex(p_dpcFlags);
      while ( __strex(v6 & ~KDPCFLAG_DEBUG_PAUSE, p_dpcFlags) );
      KThread::SetDebugPauseState(thread, 1);
      KDebug::RequestReschedulingForDebugger(debug, __mrc(15, 0, 0, 0, 5) & 3);
      KSchedulerLock::Unlock(&g_schedulerLock);
    }
  }
  return 0;
}

//----- (FFF126E8) --------------------------------------------------------
Result __fastcall KThread::HandleDebugStopDpc(KThread *this)
{
  KDebug *debug; // r5
  KProcess *owner; // r1
  bool v3; // zf
  KDebugThread *debugThread; // r0

  owner = this->owner;
  v3 = owner == 0;
  if ( owner )
  {
    debug = owner->debug;
    v3 = debug == 0;
  }
  if ( !v3 )
  {
    debugThread = this->debugThread;
    if ( debugThread->debugPauseRequested )
    {
      debugThread->debugPauseRequested = 0;
      KThread::SetDebugPauseState(this, 1);
      KDebug::RequestReschedulingForDebugger(debug, this->coreId);
    }
  }
  return 0;
}
// FFF12730: variable 'debug' is possibly undefined

//----- (FFF1273C) --------------------------------------------------------
Result __fastcall KProcess::SetDebugTerminatedFlag(KProcess *this)
{
  KDebug *result; // r0

  result = this->debug;
  if ( result )
  {
    result->processTerminated = 1;
    return 0;
  }
  return (Result)result;
}

//----- (FFF12758) --------------------------------------------------------
Result __fastcall KDebug::BreakNoRo(KDebug *this, UserBreakType breakReason)
{
  KThread *volatile thread; // r5
  u32 kernelStackTop; // r0
  u32 v6; // r6
  bool v7; // zf
  int v8; // r0
  int v9; // r0
  int v10; // r9

  thread = current.clc.current.thread;
  kernelStackTop = (u32)ADJ(current.clc.current.thread->kernelStackTop)[1].svcAcl;
  v6 = kernelStackTop - 0x110;
  v7 = (*(_DWORD *)(kernelStackTop - 0xCC) & 0x20u) >> 5 == 0;
  v8 = *(_DWORD *)(kernelStackTop - 0xD0);
  if ( v7 )
    v9 = v8 - 4;                                // adjust PC
  else
    v9 = v8 - 2;
  *(_DWORD *)(v6 + 0x40) = v9;
  KSchedulerLock::Lock(&g_schedulerLock);
  this->hasBreakSvc = 1;
  this->userBreakThread = thread;
  thread->debugThread->isUserBreak = 1;
  KThread::SetDebugPauseState(thread, 1);
  KDebug::BreakCurrentProcess(this, thread);
  v10 = KDebug::EmplaceAysncEventInfo(this, DBGEVENT_EXCEPTION, 1, breakReason, 6u, 0, 0, 0, 0);
  if ( v10 >= 0 )
  {
    KSynchronizationObject::NotifyWaiters(this, 0);
    KDebug::RequestReschedulingForDebugger(this, this->userDebuggerCoreId);
    KDebug::RequestReschedulingForDebugger(this, __mrc(15, 0, 0, 0, 5) & 3);
    KSchedulerLock::Unlock(&g_schedulerLock);
    KSchedulerLock::Lock(&g_schedulerLock);
    this->userBreakThread = 0;
    thread->debugThread->isUserBreak = 0;
    KDebug::UnbreakCurrentProcess(this);
    KSchedulerLock::Unlock(&g_schedulerLock);
    *(_DWORD *)(v6 + 0x24) = 1;                 // set lr = reload regs flag
  }
  else
  {
    KSchedulerLock::Unlock(&g_schedulerLock);
  }
  return v10;
}

//----- (FFF12894) --------------------------------------------------------
Result __fastcall KDebug::GetThreadContext(
        KDebug *this,
        ThreadContext *outThreadContext,
        KThread *thread,
        ThreadContextControlFlags flags)
{
  KThread *signalingSyncEventThread; // r5
  u32 kernelStackTop; // r12
  ExceptionDispatchContext *v6; // r12
  u32 v7; // r6
  u32 v8; // r7
  u32 v9; // r8
  u32 v10; // r9
  u32 v11; // r10
  u32 v12; // r11
  u32 v13; // lr
  u32 v14; // r6
  u32 v15; // r7
  u32 v16; // r8
  u32 v17; // r9
  u32 *v18; // r12
  u32 cpsr; // r12
  ExceptionDispatchContext *v20; // r12
  u32 v21; // r6
  u32 v22; // r7
  u32 v23; // r8
  u32 v24; // r9
  u32 v25; // r10
  u32 v26; // r11
  u32 v27; // lr
  u32 v28; // r6
  u32 v29; // r7
  u32 v30; // r8
  u32 v31; // r9
  KDebug *v32; // r7
  KThreadContext *context; // r0

  signalingSyncEventThread = this->signalingSyncEventThread;
  kernelStackTop = (u32)ADJ(thread->kernelStackTop)[1].svcAcl;
  if ( signalingSyncEventThread == thread
    && this->signalingSyncEvent
    && this->lastSyncDebugEventType == DBGEVENT_ATTACH_THREAD
    && !thread->debugThread->attached )
  {
    v18 = (u32 *)(kernelStackTop - 0x10C);      // new thread, about to be actually attached
    if ( (flags & THREADCONTEXT_CONTROL_CPU_GPRS) != 0 )
    {
      outThreadContext->cpuRegisters.r[0] = *v18;
      outThreadContext->cpuRegisters.r[1] = v18[1];
      outThreadContext->cpuRegisters.r[2] = v18[2];
      outThreadContext->cpuRegisters.r[3] = v18[3];
      outThreadContext->cpuRegisters.r[4] = v18[4];
      outThreadContext->cpuRegisters.r[5] = v18[5];
      outThreadContext->cpuRegisters.r[6] = v18[6];
      outThreadContext->cpuRegisters.r[7] = v18[7];
      outThreadContext->cpuRegisters.r[8] = v18[8];
      outThreadContext->cpuRegisters.r[9] = v18[9];
      outThreadContext->cpuRegisters.r[10] = v18[10];
      outThreadContext->cpuRegisters.r[11] = v18[11];
      outThreadContext->cpuRegisters.r[12] = v18[12];
    }
    if ( (flags & THREADCONTEXT_CONTROL_CPU_SPRS) == 0 )
      return KDebug::GetThreadVfpContext(this, outThreadContext, thread, flags);
    outThreadContext->cpuRegisters.sp = v18[13];
    outThreadContext->cpuRegisters.lr = v18[14];
    outThreadContext->cpuRegisters.pc = v18[15];
    cpsr = v18[16];
    goto LABEL_21;
  }
  if ( this->excCtx && signalingSyncEventThread == thread )// exception
  {
    if ( this->exceptionEventType )             // not undef instruction
    {
      v6 = (ExceptionDispatchContext *)(kernelStackTop - 0x118);
      if ( (flags & THREADCONTEXT_CONTROL_CPU_GPRS) != 0 )
      {
        v7 = v6->r[1];
        v8 = v6->r[2];
        v9 = v6->r[3];
        v10 = v6->r[4];
        v11 = v6->r[5];
        v12 = v6->r[6];
        v13 = v6->r[7];
        outThreadContext->cpuRegisters.r[0] = v6->r[0];
        outThreadContext->cpuRegisters.r[1] = v7;
        outThreadContext->cpuRegisters.r[2] = v8;
        outThreadContext->cpuRegisters.r[3] = v9;
        outThreadContext->cpuRegisters.r[4] = v10;
        outThreadContext->cpuRegisters.r[5] = v11;
        outThreadContext->cpuRegisters.r[6] = v12;
        outThreadContext->cpuRegisters.r[7] = v13;
        v14 = v6->r[9];
        v15 = v6->r[10];
        v16 = v6->r[11];
        v17 = v6->r[12];
        outThreadContext->cpuRegisters.r[8] = v6->r[8];
        outThreadContext->cpuRegisters.r[9] = v14;
        outThreadContext->cpuRegisters.r[10] = v15;
        outThreadContext->cpuRegisters.r[11] = v16;
        outThreadContext->cpuRegisters.r[12] = v17;
      }
      if ( (flags & THREADCONTEXT_CONTROL_CPU_SPRS) != 0 )
      {
        outThreadContext->cpuRegisters.sp = v6->sp;
        outThreadContext->cpuRegisters.lr = v6->lr;
        outThreadContext->cpuRegisters.pc = v6->pc;
        outThreadContext->cpuRegisters.cpsr = v6->cpsr;
      }
      return KDebug::GetThreadVfpContext(this, outThreadContext, thread, flags);
    }
    v20 = (ExceptionDispatchContext *)(kernelStackTop - 0x118);// undefined instruction
    if ( (flags & THREADCONTEXT_CONTROL_CPU_GPRS) != 0 )
    {
      v21 = v20->r[1];
      v22 = v20->r[2];
      v23 = v20->r[3];
      v24 = v20->r[4];
      v25 = v20->r[5];
      v26 = v20->r[6];
      v27 = v20->r[7];
      outThreadContext->cpuRegisters.r[0] = v20->r[0];
      outThreadContext->cpuRegisters.r[1] = v21;
      outThreadContext->cpuRegisters.r[2] = v22;
      outThreadContext->cpuRegisters.r[3] = v23;
      outThreadContext->cpuRegisters.r[4] = v24;
      outThreadContext->cpuRegisters.r[5] = v25;
      outThreadContext->cpuRegisters.r[6] = v26;
      outThreadContext->cpuRegisters.r[7] = v27;
      v28 = v20->r[9];
      v29 = v20->r[10];
      v30 = v20->r[11];
      v31 = v20->r[12];
      outThreadContext->cpuRegisters.r[8] = v20->r[8];
      outThreadContext->cpuRegisters.r[9] = v28;
      outThreadContext->cpuRegisters.r[10] = v29;
      outThreadContext->cpuRegisters.r[11] = v30;
      outThreadContext->cpuRegisters.r[12] = v31;
    }
    if ( (flags & THREADCONTEXT_CONTROL_CPU_SPRS) == 0 )
      return KDebug::GetThreadVfpContext(this, outThreadContext, thread, flags);
    outThreadContext->cpuRegisters.sp = v20->sp;
    outThreadContext->cpuRegisters.lr = v20->lr;
    outThreadContext->cpuRegisters.pc = v20->pc;
    cpsr = v20->cpsr;
LABEL_21:
    outThreadContext->cpuRegisters.cpsr = cpsr;
    return KDebug::GetThreadVfpContext(this, outThreadContext, thread, flags);
  }
  if ( !*(_BYTE *)(kernelStackTop - 0xB5) )     // not in svc (so in irq)
  {
    v32 = this;
    context = thread->context;
    if ( (flags & THREADCONTEXT_CONTROL_CPU_GPRS) != 0 )
    {
      outThreadContext->cpuRegisters.r[0] = *(_DWORD *)(kernelStackTop - 0xF0);
      outThreadContext->cpuRegisters.r[1] = *(_DWORD *)(kernelStackTop - 0xEC);
      outThreadContext->cpuRegisters.r[2] = *(_DWORD *)(kernelStackTop - 0xE8);
      outThreadContext->cpuRegisters.r[3] = *(_DWORD *)(kernelStackTop - 0xE4);
      outThreadContext->cpuRegisters.r[4] = *(_DWORD *)(kernelStackTop - 0x10C);
      outThreadContext->cpuRegisters.r[5] = *(_DWORD *)(kernelStackTop - 0x108);
      outThreadContext->cpuRegisters.r[6] = *(_DWORD *)(kernelStackTop - 0x104);
      outThreadContext->cpuRegisters.r[7] = *(_DWORD *)(kernelStackTop - 0x100);
      outThreadContext->cpuRegisters.r[8] = *(_DWORD *)(kernelStackTop - 0xFC);
      outThreadContext->cpuRegisters.r[9] = *(_DWORD *)(kernelStackTop - 0xF8);
      outThreadContext->cpuRegisters.r[10] = context->r10;
      outThreadContext->cpuRegisters.r[11] = context->r11;
      outThreadContext->cpuRegisters.r[12] = *(_DWORD *)(kernelStackTop - 0xE0);
    }
    if ( (flags & THREADCONTEXT_CONTROL_CPU_SPRS) != 0 )
    {
      outThreadContext->cpuRegisters.sp = *(_DWORD *)(kernelStackTop - 216);
      outThreadContext->cpuRegisters.lr = *(_DWORD *)(kernelStackTop - 212);
      outThreadContext->cpuRegisters.pc = *(_DWORD *)(kernelStackTop - 208);
      outThreadContext->cpuRegisters.cpsr = *(_DWORD *)(kernelStackTop - 204);
    }
    this = v32;
    return KDebug::GetThreadVfpContext(this, outThreadContext, thread, flags);
  }
  return KDebug::GetThreadContextInSvc(this, outThreadContext, thread, flags);
}

//----- (FFF12B2C) --------------------------------------------------------
Result __fastcall KDebug::SetThreadContext(
        KDebug *this,
        ThreadContext *threadContext,
        KThread *thread,
        ThreadContextControlFlags flags)
{
  KThread *signalingSyncEventThread; // r7
  u32 kernelStackTop; // r12
  ExceptionDispatchContext *v6; // r0
  u32 v7; // r7
  u32 v8; // r8
  u32 v9; // r9
  u32 v10; // r10
  u32 v11; // r11
  u32 v12; // r12
  u32 v13; // lr
  u32 v14; // r7
  u32 v15; // r8
  u32 v16; // r9
  u32 v17; // r12
  _DWORD *v18; // r12
  u32 v19; // r7
  u32 v20; // r8
  u32 v21; // r9
  u32 v22; // r10
  u32 v23; // r11
  u32 v24; // r12
  u32 v25; // lr
  u32 v26; // r7
  u32 v27; // r8
  u32 v28; // r9
  u32 v29; // r12
  u32 *v30; // r12
  u32 v31; // r8
  KThreadContext *context; // [sp+0h] [bp-30h]
  KThread *v35; // [sp+4h] [bp-2Ch]

  signalingSyncEventThread = this->signalingSyncEventThread;
  kernelStackTop = (u32)ADJ(thread->kernelStackTop)[1].svcAcl;
  if ( signalingSyncEventThread == thread
    && this->signalingSyncEvent
    && this->lastSyncDebugEventType == DBGEVENT_ATTACH_THREAD
    && !thread->debugThread->attached )
  {
    v18 = (_DWORD *)(kernelStackTop - 0x10C);   // new thread, about to be actually attached
    if ( (flags & THREADCONTEXT_CONTROL_CPU_GPRS) != 0 )
    {
      *v18 = threadContext->cpuRegisters.r[0];
      v18[1] = threadContext->cpuRegisters.r[1];
      v18[2] = threadContext->cpuRegisters.r[2];
      v18[3] = threadContext->cpuRegisters.r[3];
      v18[4] = threadContext->cpuRegisters.r[4];
      v18[5] = threadContext->cpuRegisters.r[5];
      v18[6] = threadContext->cpuRegisters.r[6];
      v18[7] = threadContext->cpuRegisters.r[7];
      v18[8] = threadContext->cpuRegisters.r[8];
      v18[9] = threadContext->cpuRegisters.r[9];
      v18[10] = threadContext->cpuRegisters.r[10];
      v18[11] = threadContext->cpuRegisters.r[11];
      v18[12] = threadContext->cpuRegisters.r[12];
    }
    if ( (flags & THREADCONTEXT_CONTROL_CPU_SPRS) != 0 )
    {
      v18[13] = threadContext->cpuRegisters.sp;
      v18[14] = threadContext->cpuRegisters.lr;
      v18[15] = threadContext->cpuRegisters.pc;
      v18[16] = v18[16] & 0x7F0FDFF | threadContext->cpuRegisters.cpsr & 0xF80F0200;// force usermode etc
    }
  }
  else
  {
    if ( this->excCtx && signalingSyncEventThread == thread )// exception (not svc/irq)
    {
      if ( this->exceptionEventType )           // not undef
      {
        v35 = thread;
        v6 = (ExceptionDispatchContext *)(kernelStackTop - 0x118);
        if ( (flags & THREADCONTEXT_CONTROL_CPU_GPRS) != 0 )
        {
          v7 = threadContext->cpuRegisters.r[1];
          v8 = threadContext->cpuRegisters.r[2];
          v9 = threadContext->cpuRegisters.r[3];
          v10 = threadContext->cpuRegisters.r[4];
          v11 = threadContext->cpuRegisters.r[5];
          v12 = threadContext->cpuRegisters.r[6];
          v13 = threadContext->cpuRegisters.r[7];
          v6->r[0] = threadContext->cpuRegisters.r[0];
          v6->r[1] = v7;
          v6->r[2] = v8;
          v6->r[3] = v9;
          v6->r[4] = v10;
          v6->r[5] = v11;
          v6->r[6] = v12;
          v6->r[7] = v13;
          v14 = threadContext->cpuRegisters.r[9];
          v15 = threadContext->cpuRegisters.r[10];
          v16 = threadContext->cpuRegisters.r[11];
          v17 = threadContext->cpuRegisters.r[12];
          v6->r[8] = threadContext->cpuRegisters.r[8];
          v6->r[9] = v14;
          v6->r[10] = v15;
          v6->r[11] = v16;
          v6->r[12] = v17;
        }
        if ( (flags & THREADCONTEXT_CONTROL_CPU_SPRS) == 0 )
          goto LABEL_20;
      }
      else
      {
        v35 = thread;
        v6 = (ExceptionDispatchContext *)(kernelStackTop - 280);
        if ( (flags & THREADCONTEXT_CONTROL_CPU_GPRS) != 0 )
        {
          v19 = threadContext->cpuRegisters.r[1];
          v20 = threadContext->cpuRegisters.r[2];
          v21 = threadContext->cpuRegisters.r[3];
          v22 = threadContext->cpuRegisters.r[4];
          v23 = threadContext->cpuRegisters.r[5];
          v24 = threadContext->cpuRegisters.r[6];
          v25 = threadContext->cpuRegisters.r[7];
          v6->r[0] = threadContext->cpuRegisters.r[0];
          v6->r[1] = v19;
          v6->r[2] = v20;
          v6->r[3] = v21;
          v6->r[4] = v22;
          v6->r[5] = v23;
          v6->r[6] = v24;
          v6->r[7] = v25;
          v26 = threadContext->cpuRegisters.r[9];
          v27 = threadContext->cpuRegisters.r[10];
          v28 = threadContext->cpuRegisters.r[11];
          v29 = threadContext->cpuRegisters.r[12];
          v6->r[8] = threadContext->cpuRegisters.r[8];
          v6->r[9] = v26;
          v6->r[10] = v27;
          v6->r[11] = v28;
          v6->r[12] = v29;
        }
        if ( (flags & THREADCONTEXT_CONTROL_CPU_SPRS) == 0 )
          goto LABEL_20;
      }
      v6->sp = threadContext->cpuRegisters.sp;
      v6->lr = threadContext->cpuRegisters.lr;
      v6->pc = threadContext->cpuRegisters.pc;
      v6->cpsr = v6->cpsr & 0x7F0FDFF | threadContext->cpuRegisters.cpsr & 0xF80F0200;
LABEL_20:
      thread = v35;
      return KDebug::SetThreadVfpContext(this, threadContext, thread, flags);
    }
    if ( *(_BYTE *)(kernelStackTop - 0xB5) )    // in svc
    {
      v30 = (u32 *)(kernelStackTop - 0x110);
      if ( (flags & THREADCONTEXT_CONTROL_CPU_GPRS) != 0 )
      {
        *v30 = threadContext->cpuRegisters.r[0];
        v30[1] = threadContext->cpuRegisters.r[1];
        v30[2] = threadContext->cpuRegisters.r[2];
        v30[3] = threadContext->cpuRegisters.r[3];
        v30[4] = threadContext->cpuRegisters.r[4];
        v30[5] = threadContext->cpuRegisters.r[5];
        v30[6] = threadContext->cpuRegisters.r[6];
        v30[7] = threadContext->cpuRegisters.r[7];
        v30[10] = threadContext->cpuRegisters.r[8];
        v30[11] = threadContext->cpuRegisters.r[9];
        v30[12] = threadContext->cpuRegisters.r[10];
        v30[13] = threadContext->cpuRegisters.r[11];
        v31 = threadContext->cpuRegisters.r[12];
        v30[9] = 1;                             // set reload flag
        v30[8] = v31;
      }
      if ( (flags & THREADCONTEXT_CONTROL_CPU_SPRS) != 0 )
      {
        v30[14] = threadContext->cpuRegisters.sp;
        v30[15] = threadContext->cpuRegisters.lr;
        v30[16] = threadContext->cpuRegisters.pc;
        v30[17] = v30[17] & 0x7F0FDFF | threadContext->cpuRegisters.cpsr & 0xF80F0200;
      }
    }
    else                                        // irq
    {
      context = thread->context;
      if ( (flags & THREADCONTEXT_CONTROL_CPU_GPRS) != 0 )
      {
        *(_DWORD *)(kernelStackTop - 0xF0) = threadContext->cpuRegisters.r[0];
        *(_DWORD *)(kernelStackTop - 0xEC) = threadContext->cpuRegisters.r[1];
        *(_DWORD *)(kernelStackTop - 0xE8) = threadContext->cpuRegisters.r[2];
        *(_DWORD *)(kernelStackTop - 0xE4) = threadContext->cpuRegisters.r[3];
        *(_DWORD *)(kernelStackTop - 0x10C) = threadContext->cpuRegisters.r[4];
        *(_DWORD *)(kernelStackTop - 0x108) = threadContext->cpuRegisters.r[5];
        *(_DWORD *)(kernelStackTop - 0x104) = threadContext->cpuRegisters.r[6];
        *(_DWORD *)(kernelStackTop - 0x100) = threadContext->cpuRegisters.r[7];
        *(_DWORD *)(kernelStackTop - 0xFC) = threadContext->cpuRegisters.r[8];
        *(_DWORD *)(kernelStackTop - 0xF8) = threadContext->cpuRegisters.r[9];
        context->r10 = threadContext->cpuRegisters.r[10];
        context->r11 = threadContext->cpuRegisters.r[11];
        *(_DWORD *)(kernelStackTop - 0xE0) = threadContext->cpuRegisters.r[12];
      }
      if ( (flags & THREADCONTEXT_CONTROL_CPU_SPRS) != 0 )
      {
        *(_DWORD *)(kernelStackTop - 0xD8) = threadContext->cpuRegisters.sp;
        *(_DWORD *)(kernelStackTop - 0xD4) = threadContext->cpuRegisters.lr;
        *(_DWORD *)(kernelStackTop - 0xD0) = threadContext->cpuRegisters.pc;
        *(_DWORD *)(kernelStackTop - 0xCC) = *(_DWORD *)(kernelStackTop - 204) & 0x7F0FDFF | threadContext->cpuRegisters.cpsr & 0xF80F0200;
      }
    }
  }
  return KDebug::SetThreadVfpContext(this, threadContext, thread, flags);
}

//----- (FFF12EC4) --------------------------------------------------------
Result __fastcall KDebug::Attach(KDebug *this, KProcess *process)
{
  KDebugThreadLinkedListNode *nd; // r1
  Result v5; // r0
  KDebugThreadLinkedListNode *node; // r7
  KThread *thread; // r8
  Result v8; // r0
  Result v9; // r9
  KProcess *v11; // r0
  KThread *mainThread; // r1
  ExceptionDispatchContext *excCtx; // r0
  bool v14; // zf
  u32 baseUserVa; // r0
  Result v16; // r4

  KSchedulerLock::Lock(&g_schedulerLock);
  this->processAttached = 1;
  KDebug::PauseProcess(this, 0);
  for ( nd = this->debugThreads.link.next; nd != (KDebugThreadLinkedListNode *)&this->debugThreads.link; nd = nd->link.next )
    nd->debugThread->thread->debugThread->attached = 1;
  v5 = KDebug::EmplaceAysncEventInfo(this, DBGEVENT_ATTACH_PROCESS, 1, (u32)process, 0, 0, 0, 0, 0);
  if ( v5 < 0 )
    goto LABEL_17;
  ++this->numAttachOrDetachEvents;
  for ( node = this->debugThreads.link.next;
        node != (KDebugThreadLinkedListNode *)&this->debugThreads.link;
        node = node->link.next )
  {
    thread = node->debugThread->thread;
    v8 = KDebug::EmplaceAysncEventInfo(this, DBGEVENT_ATTACH_THREAD, 1, (u32)thread, 0, 0, 0, 0, 0);
    if ( v8 < 0 )
    {
      v9 = v8;
      KSchedulerLock::Unlock(&g_schedulerLock);
      return v9;
    }
    ++this->numAttachOrDetachEvents;
    thread->debugThread->scheduledOut = 1;
  }
  v11 = this->process;
  mainThread = v11->mainThread;
  if ( mainThread )
  {
    excCtx = this->excCtx;                      // process has already been created
    v14 = excCtx == 0;
    if ( !excCtx )
      excCtx = (ExceptionDispatchContext *)&ADJ(mainThread->kernelStackTop)[1];
    baseUserVa = v14 ? excCtx[-3].r[8] : excCtx->pc;// get PC, either from the main thread or for the thread in exception
  }
  else
  {
    baseUserVa = v11->codeSet->text.baseUserVa;
  }
  v5 = KDebug::EmplaceAysncEventInfo(this, DBGEVENT_EXCEPTION, 1, baseUserVa, 4u, 0, 0, 0, 0);
  if ( v5 >= 0 )
  {
    this->isFirstExceptionBreak = 1;
    this->hasAttachBreak = 1;
    KSchedulerLock::Unlock(&g_schedulerLock);
    return 0;
  }
  else
  {
LABEL_17:
    v16 = v5;
    KSchedulerLock::Unlock(&g_schedulerLock);
    return v16;
  }
}

//----- (FFF130A0) --------------------------------------------------------
Result __fastcall KDebug::QueryProcessMemory(KDebug *this, MemoryInfo *outMemInfo, u32 *pgInfo, u32 addr)
{
  Result result; // r0
  u32 baseAddress; // r2
  u32 size; // r3
  u32 state_low; // r12
  KMemoryInfo v9; // [sp+0h] [bp-18h] BYREF

  result = KPageTable::QueryInfo(&this->process->pgTable, &v9, pgInfo, addr);
  baseAddress = v9.baseAddress;
  size = v9.size;
  state_low = LOBYTE(v9.state);
  outMemInfo->perms = v9.perms & 3;
  outMemInfo->state = state_low;
  outMemInfo->baseAddress = baseAddress;
  outMemInfo->size = size;
  return result;
}

//----- (FFF130E4) --------------------------------------------------------
KThread *__fastcall KThread::FindById(u32 id)
{
  unsigned int v2; // r2
  bool v3; // zf
  unsigned int v4; // r3
  KThreadLinkedListNode *next; // r0
  KThread *thread; // r4

  v2 = __ldrex((unsigned int *)&g_threadAllocator.container.mutex);
  v3 = v2 == 0;
  if ( v2 )
    v4 = __strex(v2, (unsigned int *)&g_threadAllocator.container.mutex);
  else
    v4 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_threadAllocator.container.mutex);
  if ( !v2 )
    v3 = v4 == 0;
  if ( !v3 )
    KLightMutex::LockImpl(&g_threadAllocator.container.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  next = (KThreadLinkedListNode *)g_threadAllocator.container.list.link.next;
  if ( (KAutoObjectLinkedListLink *)g_threadAllocator.container.list.link.next == &g_threadAllocator.container.list.link )
  {
LABEL_14:
    __mcr(15, 0, 0, 7, 10, 5);
    g_threadAllocator.container.mutex.lockingThread = 0;
    if ( g_threadAllocator.container.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_threadAllocator.container.mutex);
    return 0;
  }
  else
  {
    while ( 1 )
    {
      thread = next->thread;
      if ( thread->threadId == id )
        break;
      next = next->link.next;
      if ( next == (KThreadLinkedListNode *)&g_threadAllocator.container.list.link )
        goto LABEL_14;
    }
    KAutoObject::IncrementRefcount(next->thread);
    __mcr(15, 0, 0, 7, 10, 5);
    g_threadAllocator.container.mutex.lockingThread = 0;
    if ( g_threadAllocator.container.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_threadAllocator.container.mutex);
    return thread;
  }
}

//----- (FFF1319C) --------------------------------------------------------
void __fastcall KThread::SetSleepPriority(KThread *this, s32 priority)
{
  s32 basePriority; // r2

  this->dynamicPriority = priority;
  basePriority = this->basePriority;
  this->basePriority = priority;
  this->priorityToRestoreAfterSleep = basePriority;
  if ( priority != basePriority )
    KScheduler::AdjustThreadPriorityChanged(current.clc.current.scheduler, this, basePriority);
}

//----- (FFF131D0) --------------------------------------------------------
void __fastcall KThread::RestorePriorityAfterSleep(KThread *this)
{
  s32 priorityToRestoreAfterSleep; // r1
  s32 dynamicPriority; // r2

  priorityToRestoreAfterSleep = this->priorityToRestoreAfterSleep;
  this->priorityToRestoreAfterSleep = -1;
  if ( priorityToRestoreAfterSleep == 64 )
  {
    KSchedulerLock::Lock(&g_schedulerLock);
    dynamicPriority = this->dynamicPriority;
    this->basePriority = 64;
    this->dynamicPriority = 64;
    KScheduler::AdjustThreadPriorityChanged(current.clc.current.scheduler, this, dynamicPriority);
    KSchedulerLock::Unlock(&g_schedulerLock);
  }
  else
  {
    KThread::SetPriority(this, priorityToRestoreAfterSleep);
  }
}

//----- (FFF13230) --------------------------------------------------------
void __fastcall __noreturn KThread::Exit(KThread *this)
{
  u8 schedulingMask; // r2
  KMutex *p_link; // r0
  bool v4; // zf

  KThread::SignalExitToDebug(this);
  KHardwareTimer::CancelTask(&g_hardwareTimer, &this->KTimerTask);// inlined part 1, used in interrupt callbacks
  KSchedulerLock::Lock(&g_schedulerLock);
  KSchedulerLock::Lock(&g_schedulerLock);
  schedulingMask = this->schedulingMask;
  this->schedulingMask = schedulingMask & 0xF0 | KTHREADSCHEDSTAT_TERMINATED;
  KScheduler::AdjustThreadScheduling(current.clc.current.scheduler, this, schedulingMask);
  KSchedulerLock::Unlock(&g_schedulerLock);
  KScheduler::RemoveTerminatingThread(current.clc.current.scheduler, this);
  this->signaled = 1;
  KSynchronizationObject::NotifyWaiters(this, 0);
  while ( 1 )
  {
    p_link = (KMutex *)&ADJ(this->heldMutexListRootNode)->link;
    v4 = p_link == 0;
    if ( p_link )
    {
      p_link = (KMutex *)((char *)p_link - 20);
      v4 = p_link == 0;
    }
    if ( v4 )
    {
      KThread::RemoveVfpUsageFromCurrentContext(this);
      KWorkerTaskManager::AddTask(KWORKERTYPE_LOW_PRIO, &this->KWorkerTask);
      KSchedulerLock::Unlock(&g_schedulerLock);
      kernelpanic();
    }
    KMutex::ForceUnlock(p_link, this);
  }
}

//----- (FFF132FC) --------------------------------------------------------
Result __fastcall KCodeSet::Initialize(
        KCodeSet *this,
        const CodeSetInfo *codeSetInfo,
        KProcessPageTable *pgTable,
        u32 textPtr,
        u32 rodataPtr,
        u32 dataPtr)
{
  KCodeSegment::Initialize(&this->text, &codeSetInfo->text, pgTable, textPtr);
  KCodeSegment::Initialize(&this->rodata, &codeSetInfo->rodata, pgTable, rodataPtr);
  KCodeSegment::Initialize(&this->data, &codeSetInfo->rwdata, pgTable, dataPtr);
  KCodeSegment::EnsureCacheCoherencyForCode(&this->text);
  this->numCodePages = codeSetInfo->text_size_total;
  this->numConstPages = codeSetInfo->ro_size_total;
  this->numDataPages = codeSetInfo->rw_size_total;
  *(_QWORD *)this->processName = codeSetInfo->name;
  this->processName[8] = 0;
  this->unk1_from_codesetinfo = codeSetInfo->unk1;
  this->titleId = codeSetInfo->program_id;
  return 0;
}

//----- (FFF13390) --------------------------------------------------------
Result __fastcall KCodeSet::CheckAndMap(
        KCodeSet *this,
        KProcessPageTable *pgTable,
        u32 memoryRegion,
        bool specialArrange)
{
  u32 baseUserVa; // r0
  Result v8; // r12
  Result result; // r0
  u32 v10; // r0
  Result v11; // r3
  u32 v12; // r0
  u32 rwStart; // r3
  KCodeSegment *__shifted(KCodeSet,0x30) p_data; // r4
  u32 v15; // t1
  u32 totalRwSize; // r1
  signed __int32 bssExtraNumPages; // r2
  bool v18; // zf
  u32 v19; // r1

  if ( specialArrange )
    goto LABEL_16;
  baseUserVa = this->text.baseUserVa;
  v8 = 0xE0E01BF5;
  if ( baseUserVa < 0x100000 || baseUserVa + (this->text.totalNumPages << 12) > 0x4000000 )// note that it doesn't check if the sections are contiguous, however
    result = 0xE0E01BF5;
  else
    result = 0;
  if ( result >= 0 )
  {
    v10 = this->rodata.baseUserVa;
    if ( v10 < 0x100000 || v10 + (this->rodata.totalNumPages << 12) > 0x4000000 )
      v11 = 0xE0E01BF5;
    else
      v11 = 0;
    result = v11;
    if ( v11 >= 0 )
    {
      v12 = this->data.baseUserVa;
      if ( v12 >= 0x100000 && v12 + (this->data.totalNumPages << 12) <= 0x4000000 )
        v8 = 0;
      result = v8;
      if ( v8 >= 0 )
      {
LABEL_16:
        result = KCodeSegment::Map(&this->text, pgTable, KMEMSTATE_PRIVATE_CODE, KMEMPERM_RX);
        if ( result >= 0 )
        {
          result = KCodeSegment::Map(&this->rodata, pgTable, KMEMSTATE_PRIVATE_CODE, KMEMPERM_R);
          if ( result >= 0 )
          {
            result = KCodeSegment::Map(&this->data, pgTable, KMEMSTATE_PRIVATE_DATA, KMEMPERM_RW);
            if ( result >= 0 )
            {
              v15 = this->data.baseUserVa;
              p_data = &this->data;
              rwStart = v15;
              totalRwSize = ADJ(p_data)->data.totalNumPages;
              bssExtraNumPages = ADJ(p_data)->numDataPages - totalRwSize;// allocate extra pages for bss
              v18 = ADJ(p_data)->numDataPages == totalRwSize;
              if ( bssExtraNumPages < 0 )
                result = 136315904;
              v19 = rwStart + (totalRwSize << 12);
              if ( bssExtraNumPages >= 0 && !v18 )
                return KPageTable::Operate(
                         pgTable,
                         v19,
                         bssExtraNumPages,
                         0,
                         KMEMSTATE_PRIVATE_DATA,
                         KMEMPERM_KRW_RW,
                         KMEMUPDATE_NONE,
                         memoryRegion);
            }
          }
        }
      }
    }
  }
  return result;
}

//----- (FFF134EC) --------------------------------------------------------
bool __fastcall KProcess::IsTerminated(KProcess *this)
{
  return this->state == KPROCSTATE_TERMINATED;
}

//----- (FFF13500) --------------------------------------------------------
Result __fastcall KProcess::DumpThreadIds(KProcess *this, s32 *outNumThreads, u32 *threadIdList, s32 threadIdListSize)
{
  unsigned int v8; // r2
  bool v9; // zf
  unsigned int v10; // r3
  KThreadLinkedListNode *next; // r12
  s32 i; // r1
  KThread *thread; // r4

  v8 = __ldrex((unsigned int *)&g_threadAllocator.container.mutex);
  v9 = v8 == 0;
  if ( v8 )
    v10 = __strex(v8, (unsigned int *)&g_threadAllocator.container.mutex);
  else
    v10 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_threadAllocator.container.mutex);
  if ( !v8 )
    v9 = v10 == 0;
  if ( !v9 )
    KLightMutex::LockImpl(&g_threadAllocator.container.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  next = (KThreadLinkedListNode *)g_threadAllocator.container.list.link.next;
  for ( i = 0; next != (KThreadLinkedListNode *)&g_threadAllocator.container.list.link; next = next->link.next )
  {
    thread = next->thread;
    if ( thread->owner == this )
    {
      if ( i < threadIdListSize )
        threadIdList[i] = thread->threadId;
      ++i;
    }
  }
  *outNumThreads = i;
  __mcr(15, 0, 0, 7, 10, 5);
  g_threadAllocator.container.mutex.lockingThread = 0;
  if ( g_threadAllocator.container.mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&g_threadAllocator.container.mutex);
  return 0;
}

//----- (FFF135B8) --------------------------------------------------------
bool __fastcall KProcess::TerminateImpl1(KProcess *this)
{
  unsigned __int8 *p_state; // r1
  unsigned __int8 v2; // r2
  bool v3; // zf
  s32 i; // r4

  p_state = (unsigned __int8 *)&this->state;
  do
  {
    v2 = __ldrex(p_state);
    v3 = v2 == KPROCSTATE_CREATED;
    if ( v2 )
      v3 = v2 == KPROCSTATE_RUNNING;
    if ( !v3 )
    {
      __clrex();
      return 0;
    }
  }
  while ( __strex(KPROCSTATE_TERMINATING, p_state) );
  KProcess::ForceAllThreadsToTerminate(this, current.clc.current.thread);
  for ( i = 0; i < 128; ++i )
  {
    if ( (this->boundIrqIds[(unsigned int)i >> 5] & (1 << (i & 0x1F))) != 0 )
      KInterruptManager::UnbindUserInterruptEvent(&g_interruptManager, i);
  }
  KHandleTable::Destroy(&this->handleTable);
  return 1;
}

//----- (FFF13654) --------------------------------------------------------
KProcess *__fastcall KProcess::OpenById(u32 pid)
{
  unsigned int v2; // r2
  bool v3; // zf
  unsigned int v4; // r3
  KProcessLinkedListNode *next; // r0
  KProcess *process; // r4

  v2 = __ldrex((unsigned int *)&g_processAllocator.container.mutex);
  v3 = v2 == 0;
  if ( v2 )
    v4 = __strex(v2, (unsigned int *)&g_processAllocator.container.mutex);
  else
    v4 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_processAllocator.container.mutex);
  if ( !v2 )
    v3 = v4 == 0;
  if ( !v3 )
    KLightMutex::LockImpl(&g_processAllocator.container.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  next = (KProcessLinkedListNode *)g_processAllocator.container.list.link.next;
  if ( (KAutoObjectLinkedListLink *)g_processAllocator.container.list.link.next == &g_processAllocator.container.list.link )
  {
LABEL_15:
    __mcr(15, 0, 0, 7, 10, 5);
    g_processAllocator.container.mutex.lockingThread = 0;
    if ( g_processAllocator.container.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_processAllocator.container.mutex);
    return 0;
  }
  else
  {
    while ( 1 )
    {
      process = next->process;
      if ( process->codeSet )
      {
        if ( process->pid == pid )
          break;
      }
      next = next->link.next;
      if ( next == (KProcessLinkedListNode *)&g_processAllocator.container.list.link )
        goto LABEL_15;
    }
    KAutoObject::IncrementRefcount(next->process);
    __mcr(15, 0, 0, 7, 10, 5);
    g_processAllocator.container.mutex.lockingThread = 0;
    if ( g_processAllocator.container.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_processAllocator.container.mutex);
    return process;
  }
}

//----- (FFF13718) --------------------------------------------------------
bool __fastcall KProcess::ReserveResource(KProcess *this, ResourceLimitType type, s32 amount)
{
  KResourceLimit *reslimit; // r0
  BOOL v4; // r0

  reslimit = this->reslimit;
  if ( !reslimit || (v4 = KResourceLimit::Reserve(reslimit, type, amount)) )
    LOBYTE(v4) = 1;
  return v4;
}

//----- (FFF1373C) --------------------------------------------------------
BOOL __fastcall KProcess::CheckThreadPriority(KProcess *this, s32 priority)
{
  KResourceLimit *reslimit; // r0

  reslimit = this->reslimit;
  return !reslimit || KResourceLimit::GetLimitValue(reslimit, RESLIMIT_PRIORITY) <= priority;
}

//----- (FFF1376C) --------------------------------------------------------
void __fastcall KProcess::IncrementThreadCount(KProcess *this)
{
  unsigned __int16 *p_threadCount; // r0
  unsigned __int16 v2; // r1

  p_threadCount = (unsigned __int16 *)&this->threadCount;
  do
    v2 = __ldrex(p_threadCount);
  while ( __strex(v2 + 1, p_threadCount) );
}

//----- (FFF137A8) --------------------------------------------------------
Result __fastcall KProcess::AllocateTls(KProcess *this, u32 *outTlsUserAddr)
{
  KThreadLocalPageLinkedListNode *node; // r8
  KThreadLocalPage *tlsPage; // r4
  int v6; // r0
  u32 v7; // r4
  Result result; // r0
  KThreadLocalPage *v9; // r4
  int i; // r0
  u32 v11; // r10
  Result v12; // r10
  int v13; // r0
  u32 v14; // r9
  KThreadLocalPageLinkedList *p_threadLocalPages; // r8
  KThreadLocalPageLinkedListLink *p_link; // r5
  KLinkedListNode *v17; // r0

  KSchedulerLock::Lock(&g_schedulerLock);
  for ( node = this->threadLocalPages.link.next;
        node != (KThreadLocalPageLinkedListNode *)&this->threadLocalPages.link;
        node = node->link.next )
  {
    tlsPage = node->threadLocalPage;
    KSchedulerLock::Lock(&g_schedulerLock);
    v6 = 0;
    while ( !tlsPage->freeSlots[v6] )
    {
      if ( ++v6 >= 8 )
      {
        KSchedulerLock::Unlock(&g_schedulerLock);
        goto LABEL_9;
      }
    }
    tlsPage->freeSlots[v6] = 0;
    ++tlsPage->numThreads;
    v7 = tlsPage->page + (v6 << 9);
    KSchedulerLock::Unlock(&g_schedulerLock);
    if ( v7 )
    {
      *outTlsUserAddr = v7;                     // ok, we found a free slot in an existing page
      KSchedulerLock::Unlock(&g_schedulerLock);
      return 0;
    }
LABEL_9:
    ;
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
  v9 = (KThreadLocalPage *)KSlabHeap::Allocate(&g_threadLocalPageSlabHeap);
  if ( !v9 )
    return 0xD86007F3;
  KSchedulerLock::Lock(&g_schedulerLock);
  if ( !g_threadLocalPageTrackerInitialized )
  {
    memset(g_isThreadLocalPageVaFree, 0x7Eu, 1u);
    g_threadLocalPageTrackerInitialized = 1;
  }
  for ( i = 0; i < 0x7E; ++i )
  {
    if ( g_isThreadLocalPageVaFree[i] )
    {
      g_isThreadLocalPageVaFree[i] = 0;
      v11 = (i << 12) + 0x1FF82000;
      KSchedulerLock::Unlock(&g_schedulerLock);
      goto LABEL_19;
    }
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
  v11 = 0;
LABEL_19:
  v9->page = v11;
  v9->parent = this;
  v9->numThreads = 0;
  result = KPageTable::Operate(
             &this->pgTable,
             v9->page,
             1u,
             0,
             KMEMSTATE_LOCKED,
             KMEMPERM_KRW_RW,
             KMEMUPDATE_NONE,
             MEMOP_REGION_BASE);
  v12 = result;
  if ( result >= 0 )
  {
    SetEightBytesTo1(v9->freeSlots, 1);
    result = v12;
  }
  if ( result >= 0 )
  {
    KSchedulerLock::Lock(&g_schedulerLock);
    v13 = 0;
    while ( !v9->freeSlots[v13] )
    {
      if ( ++v13 >= 8 )
      {
        KSchedulerLock::Unlock(&g_schedulerLock);
        return 0xD86007F3;
      }
    }
    v9->freeSlots[v13] = 0;
    ++v9->numThreads;
    v14 = v9->page + (v13 << 9);
    KSchedulerLock::Unlock(&g_schedulerLock);
    if ( !v14 )
      return 0xD86007F3;
    *outTlsUserAddr = v14;
    KSchedulerLock::Lock(&g_schedulerLock);
    p_threadLocalPages = &this->threadLocalPages;
    p_link = &this->threadLocalPages.link;
    v17 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
    if ( v17 )
    {
      v17->link.next = 0;
      v17->link.prev = 0;
      v17->data = 0;
    }
    v17->data = v9;
    KLinkedList::InsertAfter((KLinkedList *)p_threadLocalPages, (KLinkedListLink *)p_link, v17);
    KSchedulerLock::Unlock(&g_schedulerLock);
    return 0;
  }
  return result;
}
// FFF13A00: conditional instruction was optimized away because r0.4!=0

//----- (FFF13A7C) --------------------------------------------------------
Result *__fastcall MakeResultCode(Result *result, u8 level, u8 summary, u8 module, u16 description)
{
  *result = (summary << 21) & 0x7E00000 | (level << 27) | (module << 10) | description & 0x3FF;
  return result;
}

//----- (FFF13AAC) --------------------------------------------------------
u32 __fastcall KHandleTable::GetTotalAllocatedSize(KHandleTable *this)
{
  unsigned int handleTableSize; // r0

  handleTableSize = this->handleTableSize;
  if ( handleTableSize > 0x28 )
    return (8 * handleTableSize + 4095) >> 12 << 12;
  else
    return 0;
}

//----- (FFF13AD4) --------------------------------------------------------
DmaState __fastcall KDmaChannel::GetDmaState(KDmaChannel *this)
{
  KLightMutex *p_mutex; // r0
  KLightMutex *v3; // r4
  unsigned int v4; // r2
  bool v5; // zf
  unsigned int v6; // r3
  u32 cpc; // r7
  u32 lc0; // r8
  u32 lc1; // r9
  int state; // r3
  u32 numIter0; // r1
  u32 numIter1; // r2
  u32 firstWfpPa; // r0
  KLightMutex *v15; // r0
  bool v16; // cc
  bool v17; // cc
  int v18; // r1
  bool v19; // zf
  int numWaiters; // r1

  p_mutex = &this->mutex;
  v3 = p_mutex;
  v4 = __ldrex((unsigned int *)p_mutex);
  v5 = v4 == 0;
  if ( v4 )
    v6 = __strex(v4, (unsigned int *)p_mutex);
  else
    v6 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)p_mutex);
  if ( !v4 )
    v5 = v6 == 0;
  if ( !v5 )
    KLightMutex::LockImpl(p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  cpc = KDmaController::GetChannelProgramCounter(this->channelId);
  lc0 = KDmaController::GetLoopCounter(this->channelId, 0);
  lc1 = KDmaController::GetLoopCounter(this->channelId, 1);
  KDmaController::GetDestinationAddress(this->channelId);// unused, stubbed logging instr perhaps?
  KDmaController::GetSourceAddress(this->channelId);
  KDmaController::GetChannelStatus(this->channelId);
  state = (unsigned __int8)this->state;
  numIter0 = this->instFactory.lpNumIterations[0];
  numIter1 = this->instFactory.lpNumIterations[1];
  firstWfpPa = this->codeBufferPa + this->instFactory.firstWfpInstPtr - this->codeBuffer;
  if ( state == KDMACHANSTATE_RESTARTED )
  {
    v15 = v3;
    __mcr(15, 0, 0, 7, 10, 5);
    v3->lockingThread = 0;
    if ( v3->numWaiters > 0 )
      goto LABEL_14;
    return DMASTATE_RUNNING;
  }
  if ( state != 1 )
  {
    __mcr(15, 0, 0, 7, 10, 5);
    v3->lockingThread = 0;
    if ( v3->numWaiters > 0 )
      KLightMutex::UnlockImpl(v3);
    return 4;
  }
  if ( !firstWfpPa )
  {
    v15 = v3;
    __mcr(15, 0, 0, 7, 10, 5);
    v3->lockingThread = 0;
    if ( v3->numWaiters <= 0 )
      return DMASTATE_RUNNING;
    goto LABEL_14;
  }
  v16 = numIter0 != 0;
  if ( this->instFactory.lpNumIterations[0] )   // check if we've done one loop iteration with wfp (erratum related?)
                                                // 
                                                // "running" if not reached second wfp... (erratum-related?)
    v16 = numIter0 > lc0;
  if ( v16 )
    goto LABEL_23;
  v17 = numIter1 != 0;
  if ( this->instFactory.lpNumIterations[1] )
    v17 = numIter1 > lc1;
  if ( v17 )
  {
LABEL_23:
    v15 = v3;
    __mcr(15, 0, 0, 7, 10, 5);
    v3->lockingThread = 0;
    if ( v3->numWaiters <= 0 )
      return DMASTATE_RUNNING;
    goto LABEL_14;
  }
  if ( cpc < firstWfpPa )
  {
    __mcr(15, 0, 0, 7, 10, 5);
    v3->lockingThread = 0;
    if ( v3->numWaiters > 0 )
      KLightMutex::UnlockImpl(v3);
    return DMASTATE_STARTING;
  }
  if ( cpc != firstWfpPa )
  {
    if ( cpc != firstWfpPa + 2 )
    {
      v15 = v3;
      __mcr(15, 0, 0, 7, 10, 5);
      v3->lockingThread = 0;
      if ( v3->numWaiters <= 0 )
        return DMASTATE_RUNNING;
      goto LABEL_14;
    }
    v19 = !this->dmaConfig.dstIsDevice;         // else
    if ( this->dmaConfig.dstIsDevice )
      v19 = !this->dmaConfig.srcIsDevice;
    v15 = v3;
    __mcr(15, 0, 0, 7, 10, 5);
    v3->lockingThread = 0;
    numWaiters = v3->numWaiters;
    if ( !v19 )
    {
      if ( numWaiters <= 0 )
        return DMASTATE_WFP_SRC;
      goto LABEL_37;
    }
    if ( numWaiters > 0 )
LABEL_14:
      KLightMutex::UnlockImpl(v15);
    return DMASTATE_RUNNING;
  }
  v5 = !this->dmaConfig.dstIsDevice;
  v15 = v3;
  __mcr(15, 0, 0, 7, 10, 5);
  v3->lockingThread = 0;
  v18 = v3->numWaiters;
  if ( v5 )
  {
    if ( v18 <= 0 )
      return DMASTATE_WFP_SRC;
LABEL_37:
    KLightMutex::UnlockImpl(v15);
    return DMASTATE_WFP_SRC;
  }
  if ( v18 > 0 )
    KLightMutex::UnlockImpl(v3);
  return DMASTATE_WFP_DST;
}

//----- (FFF13D0C) --------------------------------------------------------
s64 __fastcall KMemoryBlockManger::GetTotalPrivateMemSize(KMemoryBlockManager *this)
{
  KMemoryBlockLinkedListNode *next; // r5
  KMemoryBlockLinkedListLink *p_link; // r4
  unsigned int v3; // r6
  KMemoryInfo v5; // [sp+0h] [bp-20h] BYREF

  next = this->blocks.link.next;
  p_link = &this->blocks.link;
  v3 = 0;
  while ( next != (KMemoryBlockLinkedListNode *)p_link )
  {
    KMemoryBlock::GetInfo(&v5, next->block);
    next = next->link.next;
    if ( (v5.state & KMEMSTATE_FLAG_PRIVATE) != 0 )
      v3 += v5.size;
  }
  return v3;
}

//----- (FFF13D60) --------------------------------------------------------
s64 __fastcall KMemoryBlockManager::GetTotalCommittedMemory(KMemoryBlockManager *this)
{
  KMemoryBlockLinkedListNode *next; // r5
  KMemoryBlockLinkedListLink *p_link; // r4
  unsigned int i; // r6
  KMemoryInfo v5; // [sp+0h] [bp-20h] BYREF

  next = this->blocks.link.next;
  p_link = &this->blocks.link;
  for ( i = 0; next != (KMemoryBlockLinkedListNode *)p_link; next = next->link.next )
  {
    KMemoryBlock::GetInfo(&v5, next->block);    // if (baseAddr >= 0x20000000)
    if ( v5.baseAddress - 0x1C000000 >= 0x4000000 && (v5.state & KMEMSTATE_FLAG_PRIVATE) != 0 )
      i += v5.size;
  }
  return i;
}

//----- (FFF13DC4) --------------------------------------------------------
s64 __fastcall KMemoryBlockManger::GetTotalPrivateOrSharedMemSize(KMemoryBlockManager *this)
{
  KMemoryBlockLinkedListNode *next; // r5
  KMemoryBlockLinkedListLink *p_link; // r4
  unsigned int v3; // r6
  KMemoryInfo v5; // [sp+0h] [bp-20h] BYREF

  next = this->blocks.link.next;
  p_link = &this->blocks.link;
  v3 = 0;
  while ( next != (KMemoryBlockLinkedListNode *)p_link )
  {
    KMemoryBlock::GetInfo(&v5, next->block);
    next = next->link.next;
    if ( (v5.state & KMEMSTATE_FLAGS_PRIVATE_OR_SHARED) != 0 )
      v3 += v5.size;
  }
  return v3;
}

//----- (FFF13E18) --------------------------------------------------------
u32 __fastcall KThread::GetProcessId(KThread *this)
{
  KProcess *owner; // r0

  owner = this->owner;
  if ( owner )
    return owner->pid;
  else
    return -1;
}

//----- (FFF13E2C) --------------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn KThread::UserThreadStarter(int a1, int a2, int a3, int a4, int a5)
{
  SignalNewThreadEntry();
  __asm { RFEFD           SP! }
}
// FFF13E3C: positive sp value 3C has been found
// FFF13E3C: control flows out of bounds to FFF13E40

//----- (FFF13E44) --------------------------------------------------------
// positive sp value has been detected, the output may be wrong!
int KThread::SupervisorThreadStarter()
{
  int (__fastcall *v5)(); // [sp-4h] [bp-4h]

  __asm { CPSIE           AIF }
  return v5();
}
// FFF13E48: positive sp value 8 has been found
// FFF13E4C: variable 'v5' is possibly undefined
// FFF13E44: using guessed type int KThread::SupervisorThreadStarter();

//----- (FFF13E50) --------------------------------------------------------
void __fastcall CallFuncWithStackAllocImpl(void *args, u32 stackAllocSize, FuncWithStackAlloc func)
{
  int v3; // [sp+8h] [bp+0h] BYREF

  func(args, &v3);
}

//----- (FFF13E70) --------------------------------------------------------
void __fastcall memset(void *a1, size_t a2, unsigned __int8 a3)
{
  memset(a1, a3 | (a3 << 8) | ((a3 | (a3 << 8)) << 16), a2);
}

//----- (FFF13E80) --------------------------------------------------------
char *__fastcall strncpy(char *dstStr, const char *srcStr, u32 count)
{
  bool v3; // zf
  char *v4; // r4
  bool v5; // cc
  int v6; // r3
  int v7; // t1
  int v8; // t1

  v3 = ((unsigned __int8)dstStr & 3) == 0;
  v4 = dstStr;
  if ( ((unsigned __int8)dstStr & 3) == 0 )
    v3 = ((unsigned __int8)srcStr & 3) == 0;
  if ( v3 )
  {
    while ( 1 )
    {
      v5 = (int)count < 4;
      count -= 4;
      if ( v5 )
        goto LABEL_9;
      v7 = *(_DWORD *)srcStr;
      srcStr += 4;
      v6 = v7;
      if ( ((v7 - 16843009) & ~v7 & 0x80808080) != 0 )
        break;
      *(_DWORD *)dstStr = v6;
      dstStr += 4;
    }
    srcStr -= 4;
LABEL_9:
    count += 4;
  }
  while ( 1 )
  {
    v5 = (int)count-- < 1;
    if ( v5 )
      break;
    v8 = *(unsigned __int8 *)srcStr++;
    *dstStr++ = v8;
    if ( !v8 )
    {
      memset(dstStr, 0, count);
      return v4;
    }
  }
  return v4;
}

//----- (FFF13F1C) --------------------------------------------------------
void __fastcall KResourceLimit::Initialize(KResourceLimit *this)
{
  KCpuTimeLimit *p_timeLimit; // r4

  this->limitValues[0] = 0;
  this->limitValues[1] = 0;
  this->limitValues[2] = 0;
  this->limitValues[3] = 0;
  this->limitValues[4] = 0;
  this->limitValues[5] = 0;
  this->limitValues[6] = 0;
  this->limitValues[7] = 0;
  this->limitValues[8] = 0;
  this->limitValues[9] = 0;
  this->currentValues[0] = 0;
  this->currentValues[1] = 0;
  this->currentValues[2] = 0;
  this->currentValues[3] = 0;
  this->currentValues[4] = 0;
  this->currentValues[5] = 0;
  this->currentValues[6] = 0;
  this->currentValues[7] = 0;
  this->currentValues[8] = 0;
  this->currentValues[9] = 0;
  p_timeLimit = &this->timeLimit;
  KSchedulerLock::Lock(&g_schedulerLock);
  p_timeLimit->next = g_cpuTimeLimitListHead;
  g_cpuTimeLimitListHead = p_timeLimit;
  KSchedulerLock::Unlock(&g_schedulerLock);
}

//----- (FFF13FAC) --------------------------------------------------------
Result __fastcall KCapability::Initialize(KCapability *this, u32 *caps, s32 numCaps, KProcessPageTable *pgTable)
{
  s32 i; // r4
  u32 cap; // r1
  int j; // r0
  u32 v10; // r2
  u32 v11; // r9
  u32 v12; // r0
  KMemoryPermission perms; // r11
  int v14; // r10
  bool v15; // zf
  unsigned int v16; // r0
  Result result; // r0
  int v18; // r3
  unsigned int v19; // r3
  int v20; // r0
  unsigned int v21; // r12
  int v22; // r1
  KProcessPageTable *v23; // r9
  u32 v24; // r10
  bool v25; // zf
  unsigned int v26; // r0
  KMemoryInfo userPerms; // [sp+0h] [bp-60h] BYREF
  u32 size; // [sp+10h] [bp-50h] BYREF
  u32 addr; // [sp+14h] [bp-4Ch]
  KMemoryInfo outMemoryInfo; // [sp+18h] [bp-48h] BYREF
  u32 pageInfo[4]; // [sp+28h] [bp-38h] BYREF

  this->svcAcl[0] = 0;
  this->svcAcl[1] = 0;
  this->svcAcl[2] = 0;
  this->svcAcl[3] = 0;
  this->irqAcl[0] = 0;
  this->irqAcl[1] = 0;
  this->irqAcl[2] = 0;
  this->irqAcl[3] = 0;
  this->handleTableSize = 0;
  pageInfo[1] = (u32)this;
  pageInfo[2] = (u32)caps;
  pageInfo[3] = numCaps;
  for ( i = 0; i < numCaps; ++i )
  {
    cap = caps[i];
    if ( (cap & 0xF0000000) == 0xE0000000 )
    {                                           // irq caps
      for ( j = 0; j < 4; ++j )
      {
        v18 = (cap >> (7 * j)) & 0x7F;
        if ( v18 != 127 )
        {
          if ( ((this->irqAcl[((cap >> (7 * j)) & 0x7F) >> 5] >> ((cap >> (7 * j)) & 0x1F)) & 1) != 0 )
          {
            result = 0xD900140E;
            goto LABEL_33;
          }
          if ( (unsigned int)v18 <= 0xE )
            v18 += 127;
          if ( v18 >= 128 )
          {
            result = 0xD9001412;
            goto LABEL_33;
          }
          this->irqAcl[v18 / 32] |= 1 << (v18 % 32);
        }
      }
      result = 0;
LABEL_33:
      if ( result < 0 )
        return result;
    }
    else if ( (cap & 0xF8000000) == 0xF0000000 )
    {                                           // svc ACL
      v19 = cap & 0xFFFFFF;
      v20 = 0;
      v21 = 3 * ((cap & 0x7000000) >> 24);
      do
      {
        if ( ((v19 >> v20) & 1) != 0 )
        {
          v22 = v20 + 8 * v21;
          if ( v22 < 128 )
            *((_BYTE *)this->svcAcl + v22 / 8) |= 1 << (v22 % 8);
        }
        ++v20;
      }
      while ( v20 < 24 );
    }
    else if ( (cap & 0xFF000000) == 0xFE000000 )
    {
      this->handleTableSize = cap & 0x3FF;
    }
    else if ( cap >> 23 == 510 )
    {
      this->kernelFlags = cap;
    }
    else if ( cap >> 21 == 0x7FC )
    {                                           // static pages or io page
      if ( i + 1 >= numCaps )
        return 0xD9001412;
      v10 = caps[i + 1];
      if ( v10 >> 21 != 0x7FC )
        return 0xD9001412;
      v11 = cap << 12;
      userPerms.size = (u32)pgTable;
      userPerms.perms = ((v10 << 12) - (cap << 12) + 4095) >> 12;
      if ( (cap & 0x100000) != 0 )
        v12 = 1;
      else
        v12 = 3;
      userPerms.baseAddress = v12;
      userPerms.state = ((v10 >> 20) & 1) == 0;
      addr = cap << 12;
      perms = userPerms.perms;
      v14 = 0;
      size = userPerms.size;
      if ( userPerms.perms <= KMEMPERM_NONE )
      {
LABEL_42:
        result = KProcessPageTable::MapStaticOrIoExheaderRange(
                   (KProcessPageTable *)userPerms.size,
                   addr,
                   userPerms.perms,
                   userPerms.state,
                   (KMemoryPermission)userPerms.baseAddress);// overlapping stack args, urgh
      }
      else
      {
        while ( 1 )
        {
          v16 = (unsigned int)KPageTable::QueryInfo((KPageTable *)size, &outMemoryInfo, pageInfo, v11 + (v14 << 12)) >> 31;
          v15 = v16 == 0;
          if ( !v16 )
            v15 = outMemoryInfo.state == MEMSTATE_FREE;// check if all the pages we want are free
          if ( !v15 )
            break;
          if ( ++v14 >= perms )
            goto LABEL_42;
        }
        result = -654306288;
      }
      if ( result < 0 )
        return result;
      ++i;
    }
    else if ( cap >> 20 == 0xFFE )
    {                                           // io pages
      v23 = pgTable;
      v24 = cap << 12;
      v26 = (unsigned int)KPageTable::QueryInfo(pgTable, &userPerms, &size, cap << 12) >> 31;
      v25 = v26 == 0;
      if ( !v26 )
        v25 = userPerms.state == MEMSTATE_FREE;
      if ( v25 )
        result = KProcessPageTable::MapStaticOrIoExheaderRange(v23, v24, 1u, 1, KMEMPERM_RW);
      else
        result = 0;
      if ( result < 0 )
        return result;
    }
    else if ( (cap & 0xFE000000) == 0xFC000000 )
    {
      this->intendedKernelVersion = cap;
      if ( (unsigned __int16)cap > 0x239u )     // current kernel ver: 2.55
        return 0xD9001413;
    }
    else if ( cap != 0xFFFFFFFF )
    {
      return 0xD9001412;
    }
  }
  return 0;
}

//----- (FFF142F8) --------------------------------------------------------
void __fastcall KPort::Initialize(KPort *this, s32 maxSessionCount)
{
  s16 v2; // r5
  unsigned __int16 *p_currentSessionCount; // r3

  v2 = maxSessionCount;
  KAutoObject::IncrementRefcount(this);
  KAutoObject::Initialize(&this->server);
  KAutoObject::Initialize(&this->client);
  this->server.parent = this;
  p_currentSessionCount = (unsigned __int16 *)&this->client.currentSessionCount;
  do
    __ldrex(p_currentSessionCount);
  while ( __strex(0, p_currentSessionCount) );
  this->client.parent = this;
  this->client.maxSessionCount = v2;
}

//----- (FFF14368) --------------------------------------------------------
Result __fastcall KDmaManager::ValidateUserParameters(
        u32 dstAddr,
        u32 srcAddr,
        u32 size,
        DmaConfig *dmaCfg,
        KProcess *process,
        KProcess *srcProcess)
{
  Result result; // r0
  unsigned int channelId; // r1
  int endianSwapSize; // r2
  bool v11; // zf
  bool v12; // zf
  u8 flags; // r0
  int dstIsDevice; // r7
  int useDstCfg; // r5
  bool srcIsDevice; // r8
  BOOL useSrcCfg; // r6
  int transferSize; // r10
  int v19; // r11
  bool v20; // zf
  s32 v21; // r0
  KDmaBufferSize v22; // [sp+0h] [bp-78h] BYREF
  KDmaAddress dmaAddr; // [sp+Ch] [bp-6Ch] BYREF
  s32 alignment; // [sp+24h] [bp-54h]
  int outMinAlgnSrc[4]; // [sp+2Ch] [bp-4Ch] BYREF
  int outMinAlgnDst[2]; // [sp+3Ch] [bp-3Ch] BYREF
  u32 dstAddra; // [sp+44h] [bp-34h]
  u32 v28; // [sp+48h] [bp-30h]
  u32 v29; // [sp+4Ch] [bp-2Ch]
  DmaConfig *v30; // [sp+50h] [bp-28h]

  if ( !size )
    return -656406548;
  dstAddra = dstAddr;
  v28 = srcAddr;
  v29 = size;
  v30 = dmaCfg;
  channelId = dmaCfg->channelId;
  result = -656406552;
  if ( channelId == -1 || channelId < 8 )
  {
    endianSwapSize = dmaCfg->endianSwapSize;
    v11 = endianSwapSize == 0;
    if ( dmaCfg->endianSwapSize )
      v11 = endianSwapSize == 2;
    if ( v11 )
      goto LABEL_58;
    v12 = endianSwapSize == 4;
    if ( endianSwapSize != 4 )
      v12 = endianSwapSize == 8;
    if ( v12 )
    {
LABEL_58:
      flags = dmaCfg->flags;                    // usage of subcfg is forced for devices
      outMinAlgnDst[0] = 1;
      outMinAlgnSrc[0] = 1;
      dstIsDevice = (unsigned __int8)(flags & DMACFGFLAG_DST_IS_DEVICE) >> 1;
      useDstCfg = (flags & (unsigned __int8)DMACFGFLAG_USE_DST_CONFIG) != 0 ? 1 : (unsigned __int8)(flags & DMACFGFLAG_DST_IS_DEVICE) >> 1;
      srcIsDevice = flags & DMACFGFLAG_SRC_IS_DEVICE;
      useSrcCfg = (flags & DMACFGFLAG_USE_SRC_CONFIG) != 0 || flags & DMACFGFLAG_SRC_IS_DEVICE;
      if ( !useDstCfg
        || (result = KDmaManager::CheckDeviceConfig(
                       outMinAlgnDst,
                       &dmaCfg->dstCfg,
                       endianSwapSize,
                       (unsigned __int8)(flags & DMACFGFLAG_DST_IS_DEVICE) >> 1),
            result >= 0) )
      {
        if ( !useSrcCfg
          || (result = KDmaManager::CheckDeviceConfig(
                         outMinAlgnSrc,
                         &dmaCfg->srcCfg,
                         dmaCfg->endianSwapSize,
                         srcIsDevice),
              result >= 0) )
        {
          if ( (useDstCfg & useSrcCfg) != 0 )
          {
            transferSize = dmaCfg->dstCfg.transferSize;
            v19 = dmaCfg->srcCfg.transferSize;
            v20 = transferSize == 0;
            if ( dmaCfg->dstCfg.transferSize )
              v20 = v19 == 0;
            if ( !v20 && v19 % transferSize && transferSize % v19 )
              return 0xD90007EE;
          }
          v21 = outMinAlgnDst[0];
          if ( outMinAlgnDst[0] <= outMinAlgnSrc[0] )
            v21 = outMinAlgnSrc[0];
          alignment = v21;
          KDmaAddress::KDmaAddress(&dmaAddr);
          memset(&v22, 0, sizeof(v22));
          KDmaAddress::Initialize(&dmaAddr, dstAddra, dstIsDevice, process);
          if ( useSrcCfg )
            KDmaBufferSize::ComputeFromConfig(&v22, size, &dmaCfg->srcCfg);
          else
            KDmaBufferSize::operator=(&v22, size);
          if ( !KDmaAddress::CheckBufferRangeValid(&dmaAddr, v22.minOffset, v22.maxOffset) )
            return 0xE0E01BF5;
          if ( KDmaAddress::CheckVirtualAddressBlockUsable(&dmaAddr, v22.minOffset, v22.maxOffset, 1) )
          {
            if ( !KDmaAddress::CheckAlignment(&dmaAddr, alignment) )
              return 0xD8E007F1;
            if ( useSrcCfg
              && (dmaCfg->srcCfg.burstSize > dmaCfg->srcCfg.burstStride
               || dmaCfg->srcCfg.transferSize > dmaCfg->srcCfg.transferStride)
              && !KDmaAddress::CheckPhysicalMemContiguous(&dmaAddr, v22.minOffset, v22.maxOffset) )
            {
              return 0xE0E01BF5;
            }
            KDmaAddress::Initialize(&dmaAddr, v28, srcIsDevice, srcProcess);
            if ( useDstCfg )
              KDmaBufferSize::ComputeFromConfig(&v22, size, &dmaCfg->dstCfg);
            else
              KDmaBufferSize::operator=(&v22, size);
            if ( !KDmaAddress::CheckBufferRangeValid(&dmaAddr, v22.minOffset, v22.maxOffset) )
              return 0xE0E01BF5;
            if ( KDmaAddress::CheckVirtualAddressBlockUsable(&dmaAddr, v22.minOffset, v22.maxOffset, 0) )
            {
              if ( KDmaAddress::CheckAlignment(&dmaAddr, alignment) )
              {
                if ( !useDstCfg
                  || dmaCfg->dstCfg.burstSize <= dmaCfg->dstCfg.burstStride
                  && dmaCfg->dstCfg.transferSize <= dmaCfg->dstCfg.transferStride
                  || KDmaAddress::CheckPhysicalMemContiguous(&dmaAddr, v22.minOffset, v22.maxOffset) )
                {
                  return 0;
                }
                return 0xE0E01BF5;
              }
              return 0xD8E007F1;
            }
          }
          return 0xD9000402;
        }
      }
    }
  }
  return result;
}
// FFF14368: using guessed type s32 outMinAlgnDst;
// FFF14368: using guessed type s32 outMinAlgnSrc;

//----- (FFF146B8) --------------------------------------------------------
Result __fastcall KDmaManager::InitializeChannel(
        KDmaManager *this,
        Handle *outDmaObjectHandle,
        KDmaChannel **outDmaChannel,
        s8 channelId,
        u8 cfgFlags)
{
  int v8; // r0
  int selectedChannelId; // r5
  int v10; // r0
  KDmaObject *v12; // r0
  KDmaObject *dmaObject; // r4
  KDmaObject *v14; // r0
  int v15; // r6
  KHandleTable *p_handleTable; // r6
  int v17; // r6
  KDmaChannel *v18; // r5
  KTypeObj v19; // [sp+0h] [bp-40h] BYREF
  int channelId_; // [sp+18h] [bp-28h]

  channelId_ = channelId;
  if ( (cfgFlags & DMACFGFLAG_WAIT_AVAILABLE) != 0 )
  {
    while ( 1 )
    {
      v8 = KDmaManager::TryLockChannel(this, channelId);
      if ( v8 >= 0 )
        break;
      KThread::Sleep(current.clc.current.thread, 100000LL);// 100 us
    }
    selectedChannelId = v8;
  }
  else
  {
    v10 = KDmaManager::TryLockChannel(this, channelId);
    selectedChannelId = v10;
    if ( v10 < 0 )
      return 0xD04007F0;
  }
  while ( 1 )
  {
    v12 = (KDmaObject *)KSlabHeap::Allocate(&g_dmaObjectAllocator.slabHeap);
    dmaObject = v12;
    if ( v12 )
    {
      v14 = (KDmaObject *)KSynchronizationObject::KSynchronizationObject(v12);
      v14->__vftable = &KDmaObject::vt;
      v14->channelId = -1;
      v14->signaled = 1;
      KAutoObject::Initialize(dmaObject);
    }
    if ( dmaObject )
      break;
    KThread::Sleep(current.clc.current.thread, 100000LL);
  }
  dmaObject->channelId = selectedChannelId;
  v15 = KObjectAllocator::Register(&g_dmaObjectAllocator, dmaObject);
  if ( v15 >= 0 )
  {
    p_handleTable = &current.clc.current.process->handleTable;
    dmaObject->GetTypeObj(&v19, dmaObject);
    v17 = KHandleTable::Add(p_handleTable, outDmaObjectHandle, dmaObject, v19.typeId);
    if ( v17 >= 0 )
    {
      v18 = &g_dmaChannels[selectedChannelId];
      KDmaChannel::Initialize(v18, &this->KDmaChannelEventHandler, dmaObject);
      *outDmaChannel = v18;
    }
    else
    {
      dmaObject->DecrementRefcount(dmaObject);
    }
    return v17;
  }
  else
  {
    dmaObject->DecrementRefcount(dmaObject);
    return v15;
  }
}
// FFF14768: conditional instruction was optimized away because r0.4!=0

//----- (FFF14894) --------------------------------------------------------
void __fastcall KSlabHeap::Initialize(KSlabHeap *this, u32 elementSize, void *addr, u32 totalSize)
{
  KSlabHeap *first; // r4
  signed __int32 i; // r2

  this->first = (KSlabHeap *)addr;
  this->totalSize = totalSize;
  this->elementSize = elementSize;
  do
    __ldrex((unsigned int *)this);
  while ( __strex((unsigned int)addr, (unsigned int *)this) );
  first = this->first;
  for ( i = 0; (int)(totalSize / elementSize) > i; first = (KSlabHeap *)((char *)first + elementSize) )
  {
    ++i;
    first->currentHead = (KSlabHeapNode *)((char *)first + elementSize);
  }
  *(KSlabHeapNode **)((char *)&first->currentHead - elementSize) = 0;
}

//----- (FFF148F8) --------------------------------------------------------
void __fastcall KPageHeap::Initialize(KPageHeap *this, u32 regionStart, u32 regionSize)
{
  u32 *p_regionStart; // r0
  u32 *key; // r5
  int v6; // r6
  int i; // r4
  u32 v8; // r0
  KPageHeapBlock *firstBlock; // r0
  u32 v10; // r3

  p_regionStart = &this->regionStart;
  *p_regionStart = regionStart;
  p_regionStart[1] = regionSize;
  memset((void *)regionStart, 0, regionSize);
  this->key[0] = 0;
  this->key[1] = 0;
  this->key[2] = 0;
  key = this->key;
  v6 = 0;
  this->key[3] = 0;
  do
  {
    for ( i = 0; i < 4; ++i )
    {
      v8 = key[i] - KHardwareTimer::GetSystemTick(&g_hardwareTimer);
      key[i] = v8;
      key[i] = v8 ^ (__ROR4__(v8, 7) - __ROR4__(key[((_BYTE)v6 + (_BYTE)i) & 3], 17));
    }
    ++v6;
  }
  while ( v6 < 64 );
  firstBlock = (KPageHeapBlock *)this->regionStart;
  this->link.next = firstBlock;                 // next is first
  if ( firstBlock )
  {
    v10 = this->regionSize;
    firstBlock->link.next = 0;
    firstBlock->numPages = v10 >> 12;
    firstBlock->link.prev = 0;
    firstBlock->current = firstBlock;
    firstBlock->nonce = 0;
    firstBlock->mac = 0;
    KPageHeap::UpdateBlockMac(this, this->link.next);
    if ( this->link.next->numPages != this->regionSize >> 12 )
      kernelpanic();
  }
  this->link.prev = this->link.next;
}

//----- (FFF149E4) --------------------------------------------------------
void *__fastcall _aeabi_vec_ctor_nocookie_nodtor(
        void *user_array,
        void *(__fastcall *constructor)(void *),
        u32 element_size,
        u32 element_count)
{
  char *i; // r5

  if ( constructor )
  {
    for ( i = (char *)user_array; element_count-- != 0; i += element_size )
      constructor(i);
  }
  return user_array;
}

//----- (FFF14A08) --------------------------------------------------------
s32 __fastcall Ncch::ConvertSize(s32 size, u32 unused, s32 unitSize)
{
  if ( unitSize - 32 >= 0 )
    return 0;
  else
    return size << unitSize;
}

//----- (FFF14A30) --------------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn DispatchExceptionWithRegdump(int a1, int a2, int a3, int a4, int a5)
{
  int v5; // lr
  _DWORD v10[15]; // [sp-8h] [bp-48h] BYREF
  int v11; // [sp+34h] [bp-Ch]
  void (__fastcall *v12)(_DWORD *); // [sp+38h] [bp-8h] BYREF

  v10[14] = &v12;
  v11 = v5;
  v10[0] = a1;
  v10[1] = a2;
  v10[2] = a3;
  v10[3] = a4;
  __asm { CPSIE           AF }
  v12(v10);
  __asm
  {
    CPSID           AIF
    RFEFD           SP!
  }
}
// FFF14A5C: positive sp value 8 has been found
// FFF14A30: variable 'v5' is possibly undefined

//----- (FFF14A60) --------------------------------------------------------
Result __fastcall DispatchDebugEventFromException(DebugEventType type, u32 param1, u32 param2)
{
  KProcess *volatile *var; // r0
  KProcess *volatile process; // r2
  bool v8; // r5
  Result result; // r0
  bool v10; // zf

  var = &current.clc.current.process;
  process = current.clc.current.process;
  if ( type == DBGEVENT_SCHEDULE_IN )
  {
    result = g_scheduledOut[__mrc(15, 0, 0, 0, 5) & 3];
    if ( !result )
      return result;
    var = (KProcess *volatile *)(__mrc(15, 0, 0, 0, 5) & 3);
    v8 = 0;
    goto LABEL_6;
  }
  if ( type == DBGEVENT_SCHEDULE_OUT )
  {
    var = (KProcess *volatile *)(__mrc(15, 0, 0, 0, 5) & 3);
    v8 = 1;
LABEL_6:
    g_scheduledOut[(_DWORD)var] = v8;
  }
  v10 = process == 0;
  if ( process )
  {
    var = (KProcess *volatile *)process->debug;
    v10 = var == 0;
  }
  if ( v10 )
    return 0;
  else
    return KDebug::DispatchEvent((KDebug *)var, type, param1, param2);
}
// FFF2F058: using guessed type bool g_scheduledOut[8];

//----- (FFF14AF0) --------------------------------------------------------
Result __fastcall KDebug::CheckMemoryAddressRange(KDebug *this, u32 addr, u32 size, bool isDstProcess, bool write)
{
  u32 endAddr; // r0
  KProcess *process; // r5
  int v8; // r2
  u32 v10; // r1
  KProcess *volatile *p_process; // r0
  KThread *v12; // r0
  unsigned __int8 *p_dpcFlags; // r2
  unsigned __int8 v14; // r3
  int v15; // r1
  _DWORD regions[2]; // [sp+0h] [bp-48h]
  u32 addrs[2]; // [sp+8h] [bp-40h]
  KMemoryInfo outMemoryInfo; // [sp+10h] [bp-38h] BYREF
  int pageInfo[10]; // [sp+20h] [bp-28h] BYREF

  endAddr = addr + size - 1;
  process = (KProcess *)isDstProcess;
  v8 = 0;
  addrs[1] = endAddr;
  addrs[0] = addr;
  do
  {
    regions[v8] = 0;
    v10 = addrs[v8];
    if ( v10 < 0x100000 )
      return 0xD86007F3;
    if ( v10 >= 0x4000000 )
    {
      if ( v10 >= 0x40000000 )
        return 0xD86007F3;
      regions[v8] = 2;
    }
    else
    {
      regions[v8] = 1;
    }
    ++v8;
  }
  while ( v8 < 2 );
  p_process = (KProcess *volatile *)regions[0];
  if ( regions[0] == regions[1] )               // if we cross regions, return an error
  {
    if ( isDstProcess )
      process = this->process;
    else
      p_process = &current.clc.current.process;
    if ( !isDstProcess )
      process = *p_process;
    v12 = (KThread *)__ldrex((unsigned int *)&process->pgTable);// avoid deadlock on the processpagetable?
                                                // 
                                                // but uh, we don't lock the mutex here, do we?
    if ( v12 && v12->owner == this->process )
    {
      v12->debugThread->debugPauseRequested = 1;
      p_dpcFlags = &ADJ(v12->kernelStackTop)->dpcFlags;
      do
        v14 = __ldrex(p_dpcFlags);
      while ( __strex(v14 | KDPCFLAG_DEBUG_PAUSE, p_dpcFlags) );// that one is bugged
      KThread::SetDebugPauseState(v12, 0);      // unpause the thread for now but pause it later
                                                // ... without signaling any event?
    }
    v15 = KPageTable::QueryInfo(&process->pgTable, &outMemoryInfo, (u32 *)pageInfo, addr);
    if ( v15 < 0 )
      return v15;
    if ( write )
    {
      if ( (outMemoryInfo.perms & KMEMPERM_KW_W) != 0 )
        return 0;
    }
    else if ( (outMemoryInfo.perms & KMEMPERM_KR_R) != 0 )
    {
      return 0;                                 // but uh, kernel read perms are set everywhere?
    }
  }
  return 0xD86007F3;
}
// FFF14AF0: using guessed type u32 pageInfo[10];

//----- (FFF14C48) --------------------------------------------------------
void __fastcall KProcess::TerminateCurrentProcess(KProcess *this)
{
  KThread *thread; // r6

  thread = current.clc.current.thread;
  KProcess::SetDebugExitedNormallyFlag(this);
  if ( KProcess::TerminateImpl1(this) )
  {
    KWorkerTaskManager::AddTask(KWORKERTYPE_HIGH_PRIO, &this->KWorkerTask);
    KThread::Exit(thread);
  }
  KThread::SetPriority(thread, 63);
  while ( 1 )
    KScheduler::YieldCurrentThread(current.clc.current.scheduler);
}

//----- (FFF14CAC) --------------------------------------------------------
u32 __fastcall KPageHeap::GetTotalNumPages(KPageHeap *this)
{
  KPageHeapBlock *next; // r4
  u32 v3; // r5
  bool v4; // zf
  u32 numPages; // r0

  next = this->link.next;
  v3 = 0;
  v4 = this->link.next == 0;
  if ( this->link.next )
    v4 = this->link.prev == 0;
  if ( !v4 )
  {
    do
    {
      KPageHeap::ValidateBlock(this, next);
      numPages = next->numPages;
      next = next->link.next;
      v3 += numPages;
    }
    while ( next );
  }
  return v3;
}

//----- (FFF14CF0) --------------------------------------------------------
bool __fastcall CallFuncWithStackAlloc(FuncWithStackAlloc func, void *args, u32 stackAllocSize)
{
  u32 v5; // r1
  bool v6; // cc
  bool result; // r0

  v5 = (stackAllocSize + 7) & ~7u;
  v6 = v5 > 0x400;
  if ( v5 <= 0x400 )
    v6 = stackAllocSize > v5;
  if ( !v6 || (result = 0, !v6) )
  {
    CallFuncWithStackAllocImpl(args, v5, func);
    return 1;
  }
  return result;
}

//----- (FFF14D28) --------------------------------------------------------
KThread *__fastcall KHandleTable::ConvertToThreadAllowPseudoHandle(KHandleTable *this, Handle handle)
{
  KThread *thread; // r4
  KAutoObject *v4; // r0
  KThread *v5; // r4
  KThread *v6; // r5
  u8 typeId; // r7
  KTypeObj v8; // [sp+0h] [bp-28h] BYREF
  KTypeObj v9; // [sp+8h] [bp-20h] BYREF

  if ( handle == CUR_THREAD_HANDLE )
  {
    thread = current.clc.current.thread;
    KAutoObject::IncrementRefcount(current.clc.current.thread);
    return thread;
  }
  else
  {
    v4 = KHandleTable::ConvertToAutoObject(this, handle);
    v5 = (KThread *)v4;
    v6 = 0;
    if ( v4 )
    {
      v4->GetTypeObj(&v8, v4);
      typeId = v8.typeId;
      v5->GetTypeObj(&v9, v5);
      if ( (typeId | 0x8D) == v9.typeId )
        return v5;
      else
        v5->DecrementRefcount(v5);
    }
    return v6;
  }
}

//----- (FFF14DE8) --------------------------------------------------------
KDebug *__fastcall KHandleTable::ConvertCurProcHandleToDebug(Handle debugHandle)
{
  KAutoObject *v1; // r0
  KDebug *v2; // r4
  KDebug *v3; // r5
  unsigned __int8 v4; // r7
  _BYTE v6[8]; // [sp+0h] [bp-28h] BYREF
  char v7[32]; // [sp+8h] [bp-20h] BYREF

  v1 = KHandleTable::ConvertToAutoObject(&current.clc.current.process->handleTable, debugHandle);
  v2 = (KDebug *)v1;
  v3 = 0;
  if ( v1 )
  {
    v1->GetTypeObj((KTypeObj *)v6, v1);
    v4 = v6[4];
    v2->GetTypeObj((KTypeObj *)v7, v2);
    if ( (v4 | 0x4D) == (unsigned __int8)v7[4] )
      return v2;
    else
      v2->DecrementRefcount(v2);
  }
  return v3;
}

//----- (FFF14E88) --------------------------------------------------------
BOOL __fastcall KDebug::IsProcessTerminated(KDebug *this)
{
  KProcess *process; // r0
  BOOL result; // r0

  process = this->process;
  if ( !process )
    return 1;
  result = KProcess::IsTerminated(process);
  if ( result )
    return 1;
  return result;
}

//----- (FFF14EAC) --------------------------------------------------------
KResourceLimit *__fastcall KHandleTable::ConvertToResourceLimit(KHandleTable *this, Handle reslimitHandle)
{
  KResourceLimit *result; // r0
  KResourceLimit *v3; // r4
  u8 typeId; // r6
  int v5; // r1
  KResourceLimit *v6; // r5
  KTypeObj v7; // [sp+0h] [bp-20h] BYREF
  KTypeObj v8; // [sp+8h] [bp-18h] BYREF

  result = (KResourceLimit *)KHandleTable::ConvertToAutoObject(this, reslimitHandle);
  v3 = result;
  if ( result )
  {
    result->GetTypeObj(&v7, result);
    typeId = v7.typeId;
    v3->GetTypeObj(&v8, v3);
    v5 = typeId | 0xC8;
    if ( v5 == v8.typeId )
      v6 = v3;
    else
      v6 = 0;
    if ( v5 != v8.typeId )
      v3->DecrementRefcount(v3);
    return v6;
  }
  return result;
}

//----- (FFF14F34) --------------------------------------------------------
KProcess *__fastcall KHandleTable::ConvertToProcessAllowPseudoHandle(KHandleTable *this, Handle handle)
{
  KProcess *process; // r4
  KAutoObject *v4; // r0
  KProcess *v5; // r4
  KProcess *v6; // r5
  u8 typeId; // r7
  KTypeObj v8; // [sp+0h] [bp-28h] BYREF
  KTypeObj v9; // [sp+8h] [bp-20h] BYREF

  if ( handle == CUR_PROCESS_HANDLE )
  {
    process = current.clc.current.process;
    KAutoObject::IncrementRefcount(current.clc.current.process);
    return process;
  }
  else
  {
    v4 = KHandleTable::ConvertToAutoObject(this, handle);
    v5 = (KProcess *)v4;
    v6 = 0;
    if ( v4 )
    {
      v4->GetTypeObj(&v8, v4);
      typeId = v8.typeId;
      v5->GetTypeObj(&v9, v5);
      if ( (typeId | 0xC5) == v9.typeId )
        return v5;
      else
        v5->DecrementRefcount(v5);
    }
    return v6;
  }
}

//----- (FFF14FF4) --------------------------------------------------------
void __fastcall KDebug::UnpauseAllThreads(KDebug *this, BOOL checkBreak)
{
  KThreadLinkedListNode *nd; // r4
  KThread *thread; // r0
  KThreadLinkedListNode *v6; // r10
  KLinkedListLink *v7; // r0
  KLinkedListLink *v8; // r8
  KDebugThreadLinkedListNode *i; // r4
  KThread *v10; // r0
  u8 schedulingMask; // r1
  bool v12; // zf
  KDebugThread *debugThread; // r1
  unsigned __int8 *p_dpcFlags; // r1
  unsigned __int8 v15; // r2
  KThreadLinkedListNode *nd2; // [sp+0h] [bp-28h] BYREF

  for ( nd = this->orderedThreadListForBreak.link.next;
        nd != (KThreadLinkedListNode *)&this->orderedThreadListForBreak.link;
        nd = nd->link.next )
  {
    thread = nd->thread;
    if ( !checkBreak || (thread->schedulingMask & (unsigned __int8)KTHREADSCHEDSTAT_DEBUG_PAUSE_FLAG) != 0 )
    {
      thread->debugThread->debugPauseRequested = 0;
      KThread::SetDebugPauseState(thread, 0);
    }
  }
  nd2 = this->orderedThreadListForBreak.link.next;
  if ( nd2 != (KThreadLinkedListNode *)&this->orderedThreadListForBreak.link )
  {
    do
    {
      v6 = nd2;
      KLinkedList::EraseNode((KLinkedList *)&this->orderedThreadListForBreak, (KLinkedListLink **)&nd2);
      v8 = v7;                                  // ????
      KSlabHeap::Free(&g_linkedListNodeSlabHeap, v6);
      nd2 = (KThreadLinkedListNode *)v8;
    }
    while ( v8 != (KLinkedListLink *)&this->orderedThreadListForBreak.link );
  }
  for ( i = this->debugThreads.link.next; i != (KDebugThreadLinkedListNode *)&this->debugThreads.link; i = i->link.next )
  {
    v10 = i->debugThread->thread;
    schedulingMask = v10->schedulingMask;
    if ( (schedulingMask & 0xF) != KTHREADSCHEDSTAT_TERMINATED )
    {
      v12 = (unsigned __int8)(schedulingMask & KTHREADSCHEDSTAT_DEBUG_PAUSE_FLAG) == 0;
      debugThread = v10->debugThread;
      if ( v12 )
      {
        if ( debugThread->debugPauseRequested )
        {
          p_dpcFlags = &ADJ(v10->kernelStackTop)->dpcFlags;
          do
            v15 = __ldrex(p_dpcFlags);
          while ( __strex(v15 & ~KDPCFLAG_DEBUG_PAUSE, p_dpcFlags) );// again, dpc handler is bugged
          v10->debugThread->debugPauseRequested = 0;
        }
      }
      else
      {
        debugThread->debugPauseRequested = 0;
        KThread::SetDebugPauseState(v10, 0);
      }
    }
  }
}
// FFF1507C: variable 'v7' is possibly undefined

//----- (FFF15138) --------------------------------------------------------
u32 __fastcall KProcess::GetLinearAddrRangeBase(KProcess *this)
{
  if ( (this->capability.kernelFlags & 0xF00) == MEMOP_REGION_BASE || this->capability.intendedKernelVersion >= 0x22Cu )// 
                                                // base sysmodules, or 8.x+ titles.
                                                // 
                                                // This code is common to O3DS/N3DS
    return 0x30000000;
  else
    return 0x14000000;
}

//----- (FFF15160) --------------------------------------------------------
u32 __fastcall KObjectAllocator::CountObjectsOwnedByProcess(KObjectAllocator *this, KProcess *process)
{
  KLightMutex *p_mutex; // r0
  KLightMutex *v5; // r6
  unsigned int v6; // r2
  bool v7; // zf
  unsigned int v8; // r3
  KProcessLinkedListNode *next; // r4
  u32 v10; // r7
  KProcess *owner; // r0

  p_mutex = &this->container.mutex;
  v5 = p_mutex;
  v6 = __ldrex((unsigned int *)p_mutex);
  v7 = v6 == 0;
  if ( v6 )
    v8 = __strex(v6, (unsigned int *)p_mutex);
  else
    v8 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)p_mutex);
  if ( !v6 )
    v7 = v8 == 0;
  if ( !v7 )
    KLightMutex::LockImpl(p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  next = (KProcessLinkedListNode *)this->container.list.link.next;
  v10 = 0;
  while ( next != (KProcessLinkedListNode *)&this->container.list.link )
  {
    owner = next->process->GetOwnerProcess(next->process);
    next = next->link.next;
    if ( owner == process )
      ++v10;
  }
  __mcr(15, 0, 0, 7, 10, 5);
  v5->lockingThread = 0;
  if ( v5->numWaiters > 0 )
    KLightMutex::UnlockImpl(v5);
  return v10;
}

//----- (FFF15200) --------------------------------------------------------
void __fastcall KThread::PrepareToRun(KThread *this)
{
  if ( this->owner )
    KThread::SetDebugPauseOnInit(this);
  KSchedulerLock::Lock(&g_schedulerLock);
  KScheduler::InitializeNewThread(current.clc.current.scheduler, this);
  if ( this->owner )
    KThread::AttachNewToDebug(this);
  KSchedulerLock::Unlock(&g_schedulerLock);
}

//----- (FFF15254) --------------------------------------------------------
Result __fastcall KThread::Initialize(
        KThread *this,
        u32 ep,
        u32 arg,
        u32 kernelStackTop,
        u32 stackTop,
        s32 priority,
        s32 idealCore,
        KProcess *parentProcess,
        KThreadType threadType)
{
  KResourceLimit *reslimit; // r11
  bool v12; // zf
  bool *p_shallTerminate; // r0
  int v14; // r0
  bool v15; // zf
  bool v16; // cc
  u32 v17; // r0
  bool v18; // zf
  unsigned int v19; // r2
  bool v20; // zf
  KThreadLinkedListNode *next; // r0
  KThread *thread; // r2
  KProcess *owner; // r3
  bool v24; // zf
  s32 LimitValue; // r0
  int v27; // r0
  bool v28; // zf
  bool v29; // zf
  u32 v30; // r0
  KThreadStackParametersPtr v31; // r0
  KProcess *v32; // r1
  KThreadStackParameters *v33; // r0
  u32 v34; // r2
  u32 v35; // r3
  u32 v36; // r12
  unsigned __int8 *p_dpcFlags; // r1
  u32 v38; // r1
  u32 arg_; // [sp+14h] [bp-2Ch]

  arg_ = arg;
  this->tlsUserAddr = 0;
  v12 = threadType == KTHREAD_TYPE_IDLE;
  if ( threadType )
    v12 = threadType == KTHREAD_TYPE_KERNEL;
  if ( !v12 )
    v12 = threadType == KTHREAD_TYPE_KERNEL_CRITICAL;
  if ( v12 )
    goto LABEL_25;
  if ( threadType != KTHREAD_TYPE_USER )
    kernelpanic();
  if ( idealCore == -2 )
  {
    this->idealProcessor = parentProcess->idealProcessor;
    this->affinityMask = parentProcess->affinityMask;
    goto LABEL_8;
  }
  if ( idealCore == -1 )
  {
    this->idealProcessor = -1;
    KAffinityMask::MakeAllCoresMask(&this->affinityMask);
  }
  else
  {
LABEL_25:
    this->idealProcessor = idealCore;
    KProcess::ChangeAffinityMask(&this->affinityMask, idealCore, 1);
  }
LABEL_8:
  this->tlsUserAddr = 0;
  this->owner = 0;
  this->context = 0;
  this->alive = 0;
  this->signaled = 0;
  this->schedulingMask = 1;
  this->ipcClosedByRemote = 0;
  p_shallTerminate = &this->shallTerminate;
  this->debugThread = 0;
  do
    __ldrex((unsigned __int8 *)p_shallTerminate);
  while ( __strex(0, (unsigned __int8 *)p_shallTerminate) );
  this->kernelStackTop = (KThreadStackParametersPtr)kernelStackTop;
  this->dynamicPriority = priority;
  this->basePriority = priority;
  if ( threadType == KTHREAD_TYPE_KERNEL_CRITICAL )
    v14 = __mrc(15, 0, 0, 0, 5) & 3;
  else
    v14 = -1;
  this->coreId = v14;
  this->signaledObject = 0;
  this->synchronizationResult = 0xF960060A;
  this->wantedLightMutex = 0;
  this->timeLimit = 0;
  this->link.prev = 0;
  this->link.next = 0;
  this->priorityToRestoreAfterSleep = -1;
  v15 = parentProcess == 0;
  v16 = (int)parentProcess <= 0;
  this->waiterList = 0;
  if ( parentProcess )
  {
    reslimit = parentProcess->reslimit;
    v15 = reslimit == 0;
    v16 = (int)reslimit <= 0;
  }
  if ( !v15 )
    v16 = priority <= 15;
  if ( !v16 )
  {                                             // user process with a thread priority of >= 15?
    v17 = parentProcess->capability.kernelFlags & 0xF00;
    v18 = v17 == 256;
    if ( v17 == 256 )
      v18 = this->idealProcessor == 1;
    if ( !v18 )
    {
      if ( __PAIR64__(priority, stackTop) == 0x3010000000LL )
      {
        v27 = ((__int64)parentProcess->codeSet->titleId >> 8) & 0xFFFFF;
        v28 = v27 == 0x69F;                     // Tekken 3D Prime Edition (jp, us, eu, kor)
        if ( v27 != 0x69F )
          v28 = v27 == 0x7E9;
        if ( v28 )
          goto LABEL_59;
        v29 = v27 == 0x803;
        if ( v27 != 0x803 )
          v29 = v27 == 0x91E;
        if ( v29 )
        {
LABEL_59:
          this->dynamicPriority = 49;
          this->basePriority = 49;
        }
      }
      goto LABEL_60;
    }
    if ( !KResourceLimit::GetLimitValue(reslimit, RESLIMIT_CPUTIME) )
    {
      if ( parentProcess->capability.intendedKernelVersion > 0x21Eu )// 2.1+ titles and above
        return 0xE0A01839;
      KResourceLimit::SetLimitValue(reslimit, RESLIMIT_CPUTIME, 25);// 1.0 titles
    }
    if ( g_schedulerAppPreemptionMode != 1 )
    {
LABEL_60:
      this->timeLimit = KResourceLimit::GetTimeLimit(reslimit);
      goto LABEL_61;
    }
    v19 = __ldrex((unsigned int *)&g_threadAllocator.container.mutex);
    v20 = v19 == 0;
    if ( v19 )
      __strex(v19, (unsigned int *)&g_threadAllocator.container.mutex);
    else
      v19 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_threadAllocator.container.mutex);
    if ( v20 )
      v20 = v19 == 0;
    if ( !v20 )
      KLightMutex::LockImpl(&g_threadAllocator.container.mutex);
    __mcr(15, 0, 0, 7, 10, 5);
    next = (KThreadLinkedListNode *)g_threadAllocator.container.list.link.next;
    if ( (KAutoObjectLinkedListLink *)g_threadAllocator.container.list.link.next == &g_threadAllocator.container.list.link )
    {
LABEL_44:
      __mcr(15, 0, 0, 7, 10, 5);
      g_threadAllocator.container.mutex.lockingThread = 0;
      if ( g_threadAllocator.container.mutex.numWaiters > 0 )
        KLightMutex::UnlockImpl(&g_threadAllocator.container.mutex);
      LimitValue = KResourceLimit::GetLimitValue(reslimit, RESLIMIT_PRIORITY);// set priority = Highest(prio-8, highest prio in reslimit)
      if ( priority - 8 >= LimitValue )         // priority gets bumped
        LimitValue = priority - 8;
      this->dynamicPriority = LimitValue;
      this->basePriority = LimitValue;
      goto LABEL_60;
    }
    while ( 1 )
    {
      thread = next->thread;                    // preemption mode 1 (the bugged one?) doesn't allow for more than 1 app thread on core 1
      owner = thread->owner;
      v24 = owner == parentProcess;
      if ( owner == parentProcess )
        v24 = thread->coreId == 1;
      if ( v24 )
        break;
      next = next->link.next;
      if ( next == (KThreadLinkedListNode *)&g_threadAllocator.container.list.link )
        goto LABEL_44;
    }
    __mcr(15, 0, 0, 7, 10, 5);
    g_threadAllocator.container.mutex.lockingThread = 0;
    if ( g_threadAllocator.container.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_threadAllocator.container.mutex);
    return 0xE0A01839;
  }
LABEL_61:
  if ( threadType == KTHREAD_TYPE_USER )
  {
    if ( KProcess::AllocateTls(parentProcess, &this->tlsUserAddr) < 0 )
      return 0xD86007F3;
    v30 = KPageTable::ConvertVaToPa(&parentProcess->pgTable.L1Table, this->tlsUserAddr);
    if ( v30 )
      v30 -= -0xC0000000;
    this->tls = (u32 *)v30;
  }
  if ( parentProcess )
  {
    KProcess::IncrementThreadCount(parentProcess);
    KAutoObject::IncrementRefcount(parentProcess);
    this->owner = parentProcess;
  }
  v31 = ADJ(this->kernelStackTop) + 1;
  if ( threadType == KTHREAD_TYPE_USER )
    arg = 1;
  this->context = &ADJ(v31)->ctx;
  if ( threadType != KTHREAD_TYPE_USER )
    arg = 0;
  KThreadContext::Initialize(&ADJ(v31)->ctx, ep, (u32)ADJ(v31)->svcAcl, stackTop, arg_, arg);
  v32 = this->owner;
  v33 = ADJ(this->kernelStackTop);
  if ( v32 )
  {
    v34 = v32->capability.svcAcl[0];
    v35 = v32->capability.svcAcl[1];
    v36 = v32->capability.svcAcl[2];
    ADJ(this->kernelStackTop)->svcAcl[3] = v32->capability.svcAcl[3];
    v33->svcAcl[0] = v34;
    v33->svcAcl[1] = v35;
    v33->svcAcl[2] = v36;
    v33->allowDebug = this->owner->capability.kernelFlags & 1;
  }
  else
  {
    v33->svcAcl[0] = 0;
    v33->svcAcl[1] = 0;
    v33->svcAcl[2] = 0;
    v33->svcAcl[3] = 0;
    v33->allowDebug = 0;
  }
  p_dpcFlags = &v33->dpcFlags;
  do
    __ldrex(p_dpcFlags);
  while ( __strex(0, p_dpcFlags) );
  v33->unk = 0;
  do
    v38 = __ldrex(&g_threadIdCounter);
  while ( __strex(v38 + 1, &g_threadIdCounter) );
  this->threadId = v38;
  return 0;
}
// FFF153B8: variable 'reslimit' is possibly undefined
// FFF155A0: variable 'arg' is possibly undefined

//----- (FFF15664) --------------------------------------------------------
void __fastcall _aeabi_memset4(void *data, u8 value, u32 size)
{
  bool v3; // cf
  unsigned int v4; // r1
  u32 *v5; // r0
  int v6; // r1
  int v7; // r1

  v3 = value >= 0x20u;
  v4 = value - 32;
  do
  {
    if ( !v3 )
      break;
    *(_DWORD *)data = size;
    *((_DWORD *)data + 1) = size;
    *((_DWORD *)data + 2) = size;
    *((_DWORD *)data + 3) = size;
    v5 = (u32 *)((char *)data + 16);
    *v5 = size;
    v5[1] = size;
    v5[2] = size;
    v5[3] = size;
    data = v5 + 4;
    v3 = v4 >= 0x20;
    v4 -= 32;
  }
  while ( v3 );
  v3 = __CFSHL__(v4, 28);
  v6 = v4 << 28;
  if ( v3 )
  {
    *(_DWORD *)data = size;
    *((_DWORD *)data + 1) = size;
    *((_DWORD *)data + 2) = size;
    *((_DWORD *)data + 3) = size;
    data = (char *)data + 16;
  }
  if ( v6 < 0 )
  {
    *(_DWORD *)data = size;
    *((_DWORD *)data + 1) = size;
    data = (char *)data + 8;
  }
  v3 = __CFSHL__(v6, 2);
  v7 = 4 * v6;
  if ( v3 )
  {
    *(_DWORD *)data = size;
    data = (char *)data + 4;
  }
  if ( v7 )
  {
    if ( v7 < 0 )
    {
      *(_WORD *)data = size;
      data = (char *)data + 2;
    }
    if ( (v7 & 0x40000000) != 0 )
      *(_BYTE *)data = size;
  }
}

//----- (FFF156B4) --------------------------------------------------------
BOOL __fastcall CopyBytesFromUser(void *dst, const void *src, u32 size)
{
  bool v3; // zf
  char *v5; // r3
  char v6; // r2

  v3 = size == 0;
  if ( !size )
    return 1;
  v5 = (char *)src + size;
  do
  {
    src = (char *)src + 1;
    v6 = __ldrt((unsigned int *)src);
    if ( !v3 )
      v3 = src == v5;
    *(_BYTE *)dst = v6;
    dst = (char *)dst + 1;
  }
  while ( !v3 );
  return 1;
}

//----- (FFF156E4) --------------------------------------------------------
BOOL __fastcall CopyWordsFromUser(void *dst, const void *src, u32 size)
{
  bool v3; // zf
  char *v5; // r3
  unsigned int v6; // r2

  v3 = size == 0;
  if ( !size )
    return 1;
  v5 = (char *)src + size;
  do
  {
    src = (char *)src + 4;
    v6 = __ldrt((unsigned int *)src);
    if ( !v3 )
      v3 = src == v5;
    *(_DWORD *)dst = v6;
    dst = (char *)dst + 4;
  }
  while ( !v3 );
  return 1;
}

//----- (FFF15714) --------------------------------------------------------
BOOL __fastcall CopyWordFromUser(void *dst, const void *src)
{
  unsigned int v2; // r2

  v2 = __ldrt((unsigned int *)src);
  *(_DWORD *)dst = v2;
  return 1;
}

//----- (FFF1572C) --------------------------------------------------------
int __fastcall CopyStringFromUser(char *dstStr, const char *srcStr, u32 size)
{
  bool v3; // zf
  const char *v5; // r4
  const char *v6; // r3
  unsigned int v7; // r2

  v3 = size == 0;
  if ( !size )
    return 0;
  v5 = srcStr;
  v6 = &srcStr[size];
  do
  {
    v7 = __ldrt((unsigned int *)++srcStr);
    if ( !v3 )
      v3 = srcStr == v6;
    *dstStr++ = v7;
    if ( v3 )
      break;
    v3 = v7 == 0;
  }
  while ( v7 );
  return srcStr - v5;
}

//----- (FFF1576C) --------------------------------------------------------
BOOL __fastcall CopyBytesToUser(void *dst, const void *src, u32 size)
{
  char *v4; // r3
  unsigned __int8 v5; // t1

  if ( !size )
    return 1;
  v4 = (char *)src + size;
  do
  {
    v5 = *(_BYTE *)src;
    src = (char *)src + 1;
    __strt(v5, (unsigned __int8 *)dst);
    dst = (char *)dst + 1;
  }
  while ( src != v4 );
  return 1;
}

//----- (FFF1579C) --------------------------------------------------------
BOOL __fastcall CopyWordsToUser(void *dst, const void *src, u32 dataSize)
{
  char *v4; // r3
  unsigned int v5; // t1

  if ( !dataSize )
    return 1;
  v4 = (char *)src + dataSize;
  do
  {
    v5 = *(_DWORD *)src;
    src = (char *)src + 4;
    __strt(v5, (unsigned int *)dst);
    dst = (char *)dst + 4;
  }
  while ( src != v4 );
  return 1;
}

//----- (FFF157CC) --------------------------------------------------------
BOOL __fastcall CopyWordToUser(void *dst, const void *src)
{
  __strt(*(_DWORD *)src, (unsigned int *)dst);
  return 1;
}

//----- (FFF157E4) --------------------------------------------------------
int __fastcall CopyStringToUser(char *dstStr, const char *srcStr, u32 size)
{
  char *v4; // r4
  const char *v5; // r3
  int v6; // r2
  int v7; // t1
  bool v8; // zf

  if ( !size )
    return 0;
  v4 = dstStr;
  v5 = &srcStr[size];
  do
  {
    v7 = *(unsigned __int8 *)srcStr++;
    v6 = v7;
    v8 = srcStr == v5;
    __strt(v7, (unsigned __int8 *)dstStr++);
    if ( srcStr != v5 )
      v8 = v6 == 0;
  }
  while ( !v8 );
  return srcStr - v4;
}

//----- (FFF15824) --------------------------------------------------------
BOOL __fastcall ClearUserBytes(void *userBuffer, u32 size)
{
  bool v2; // zf
  char *v4; // r3

  v2 = size == 0;
  if ( !size )
    return 1;
  v4 = (char *)userBuffer + size;
  do
  {
    __strt(0, (unsigned __int8 *)userBuffer);
    userBuffer = (char *)userBuffer + 1;
    if ( v2 )
      break;
    v2 = userBuffer == v4;
  }
  while ( userBuffer != v4 );
  return 1;
}

//----- (FFF15854) --------------------------------------------------------
BOOL __fastcall ClearUserWords(void *userBuffer, u32 size)
{
  bool v2; // zf
  char *v4; // r3

  v2 = size == 0;
  if ( !size )
    return 1;
  v4 = (char *)userBuffer + size;
  do
  {
    __strt(0, (unsigned int *)userBuffer);
    userBuffer = (char *)userBuffer + 4;
    if ( v2 )
      break;
    v2 = userBuffer == v4;
  }
  while ( userBuffer != v4 );
  return 1;
}

//----- (FFF15884) --------------------------------------------------------
BOOL __fastcall ClearUserWord(void *userBuffer)
{
  __strt(0, (unsigned int *)userBuffer);
  return 1;
}

//----- (FFF1589C) --------------------------------------------------------
bool __fastcall KDmaAddress::ResetAddress(KDmaAddress *this, u32 newAddr)
{
  int align1; // r5
  int newAlign; // r4
  u32 maxVa; // r0
  u32 v6; // r1
  u32 **p_L1Table; // r0
  bool v8; // cc

  align1 = 0;                                   // check if old alignment can still be used
  newAlign = 0;
  if ( newAddr )
  {
    maxVa = this->maxVa;
    if ( maxVa )
    {
      for ( align1 = 1; (maxVa & align1) == 0; align1 *= 2 )
        ;
    }
    else
    {
      align1 = 0;
    }
    for ( newAlign = 1; (newAddr & newAlign) == 0; newAlign *= 2 )
      ;
    this->maxVa = newAddr;
  }
  v6 = this->maxVa;
  p_L1Table = &this->process->pgTable.L1Table;
  this->currentVa = v6;
  this->currentPa = KPageTable::ConvertVaToPa(p_L1Table, v6);
  if ( align1 == newAlign )
    return 1;
  v8 = align1 < 8;
  if ( align1 >= 8 )
    v8 = newAlign < 8;
  return !v8;                                   // misaligned
}
// FFF158E4: conditional instruction was optimized away because r1.4!=0

//----- (FFF1593C) --------------------------------------------------------
KAutoObject *__fastcall KAutoObject::KAutoObject(KAutoObject *this)
{
  this->__vftable = &KAutoObject::vt;
  this->refcount = 0;
  return this;
}

//----- (FFF15950) --------------------------------------------------------
Result __fastcall KProcessPageTable::MapStaticOrIo(
        KProcessPageTable *this,
        u32 addr,
        u32 size,
        BOOL isIo,
        KMemoryPermission userPerms)
{
  bool v6; // cf
  u32 v7; // r3
  u32 v8; // r3
  bool v9; // cf
  bool v10; // cf
  KMemoryState v12; // r4

  v6 = addr >= 0x1F000000;                      // this function is extremely similar to KProcessPageTable::MapStaticOrIoExheaderRange
  v7 = addr + (size << 12);
  if ( addr >= 0x1F000000 )
    v6 = v7 <= 0x1F600000;
  if ( v6 )
  {
    v8 = addr - 0x7000000;
  }
  else if ( addr < 0x1EC00000 || v7 > 0x1FC00000 )
  {
    v9 = addr >= 0x1FF00000;
    if ( addr >= 0x1FF00000 )
      v9 = v7 <= 0x1FF80000;
    if ( v9 )
    {
      v8 = addr;
    }
    else
    {
      v10 = addr >= 0x1E800000;
      if ( addr >= 0x1E800000 )
        v10 = v7 <= 0x1EBE0000;
      if ( v10 )
        v8 = addr + 0x800000;
      else
        v8 = 0;
    }
  }
  else
  {
    v8 = addr - 0xEB00000;
  }
  if ( !v8 )
    return 0xE0E01BF5;
  if ( isIo )
    v12 = KMEMSTATE_IO;
  else
    v12 = KMEMSTATE_STATIC;
  return KPageTable::Operate(
           this,
           addr,
           size,
           v8,
           v12,
           (KMemoryPermission)(userPerms | KMEMPERM_KRW),
           KMEMUPDATE_NONE,
           MEMOP_REGION_BASE);
}

//----- (FFF15A0C) --------------------------------------------------------
Result __fastcall KDebug::SetThreadVfpContext(
        KDebug *this,
        ThreadContext *threadContext,
        KThread *thread,
        ThreadContextControlFlags flags)
{
  unsigned int CPSR; // r4
  __int32 v6; // r6
  KThreadContext *context; // r7
  s32 v8; // r0
  char cfgr; // r1
  Result result; // r0

  CPSR = __get_CPSR();
  __disable_irq();
  v6 = flags & 0xFFFFF;
  if ( (flags & THREADCONTEXT_CONTROL_FPU_REGS) != 0 )
  {
    context = thread->context;
    v8 = 0;
    cfgr = MPCORE.scu.cfgr;
    while ( (cfgr & 3) + 1 > v8 )
    {
      if ( thread == *(KThread **)(0x9000 * v8 + 0xFFFD1010) )
      {
        KVfpRegisterDumpHelper::DumpAndDisableVfpRegsForCore(v8);// current thread with vfp enabled
        break;
      }
      ++v8;
    }
    if ( (v6 & THREADCONTEXT_CONTROL_FPU_SPRS_ALLFLAGS) != 0 )
    {
      context->fpexc = threadContext->fpuRegisters.fpexc & ~0x40000000u;// clear the enable bit
      context->fpscr = threadContext->fpuRegisters.fpscr;
    }
    if ( (v6 & THREADCONTEXT_CONTROL_FPU_GPRS_ALLFLAGS) != 0 )
      KThreadContext::SetVfpGprs(context, threadContext->fpuRegisters.d);
  }
  result = 0;
  __set_CPSR(CPSR);
  return result;
}

//----- (FFF15ACC) --------------------------------------------------------
bool __fastcall KResourceLimit::Reserve(KResourceLimit *this, ResourceLimitType category, s32 amount)
{
  unsigned int *p_mutex; // r0
  KLightMutex *v7; // r4
  unsigned int v8; // r2
  bool v9; // zf
  unsigned int v10; // r3
  KAutoObject_vtbl **v11; // r0
  s32 v12; // r2

  p_mutex = (unsigned int *)&this->mutex;
  v7 = (KLightMutex *)p_mutex;
  v8 = __ldrex(p_mutex);
  v9 = v8 == 0;
  if ( v8 )
    v10 = __strex(v8, p_mutex);
  else
    v10 = __strex((unsigned int)current.clc.current.thread, p_mutex);
  if ( !v8 )
    v9 = v10 == 0;
  if ( !v9 )
    KLightMutex::LockImpl((KLightMutex *)p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  v11 = &this->__vftable + category;
  v12 = (s32)v11[12] + amount;
  if ( v12 > (int)v11[2] )
  {
    __mcr(15, 0, 0, 7, 10, 5);
    v7->lockingThread = 0;
    if ( v7->numWaiters > 0 )
      KLightMutex::UnlockImpl(v7);
    return 0;
  }
  else
  {
    v11[12] = (KAutoObject_vtbl *)v12;
    __mcr(15, 0, 0, 7, 10, 5);
    v7->lockingThread = 0;
    if ( v7->numWaiters > 0 )
      KLightMutex::UnlockImpl(v7);
    return 1;
  }
}

//----- (FFF15B6C) --------------------------------------------------------
bool __fastcall KDmaAddress::CheckBufferRangeValid(KDmaAddress *this, s32 minOffset, s32 maxOffset)
{
  u32 currentVa; // r3

  currentVa = this->currentVa;                  // if isDevice any va !=0 is valid (why?????)
                                                // 
                                                // otherwise check for overflow/underflow
                                                // 
                                                // arm9: only check if != 0
  return currentVa
      && (this->isDevice || (maxOffset <= 0 || currentVa - 1 <= ~maxOffset)
                         && (minOffset >= 0 || currentVa > -minOffset));
}

//----- (FFF15BC0) --------------------------------------------------------
bool __fastcall KDmaAddress::CheckVirtualAddressBlockUsable(
        KDmaAddress *this,
        s32 minOffset,
        s32 maxOffset,
        BOOL writePerms)
{
  u32 startCheckVa; // r5
  unsigned __int32 totalSize; // r6
  bool result; // r0
  KMemoryInfo info; // [sp+0h] [bp-28h] BYREF
  u32 pageInfo; // [sp+10h] [bp-18h] BYREF

  startCheckVa = this->currentVa + minOffset;
  totalSize = maxOffset - minOffset;            // lgy_firm k11 walks the translation table directly, iirc (need to check)
  if ( KPageTable::QueryInfo(&this->process->pgTable, &info, &pageInfo, startCheckVa) < 0
    || !this->isDevice && totalSize && info.baseAddress + info.size - startCheckVa < totalSize )
  {
    return 0;
  }
  result = MEMSTATE_FREE;                       // 0
  if ( (info.state & KMEMSTATE_FLAG_MAPPED) != 0 )
  {
    if ( writePerms )
    {
      result = info.perms & KMEMPERM_W;
      if ( (info.perms & KMEMPERM_W) != 0 )
        return 1;
    }
    else
    {
      result = info.perms & KMEMPERM_R;
      if ( (info.perms & KMEMPERM_R) != 0 )
        return 1;
    }
  }
  return result;
}

//----- (FFF15C68) --------------------------------------------------------
KSynchronizationObject *__fastcall KSynchronizationObject::KSynchronizationObject(KSynchronizationObject *this)
{
  KSynchronizationObject *result; // r0

  result = (KSynchronizationObject *)KAutoObject::KAutoObject(this);
  result->waiters.count = 0;
  result->__vftable = &KSynchronizationObject::vt;
  result->waiters.link.next = (KThreadLinkedListNode *)&result->waiters.link;
  result->waiters.link.prev = (KThreadLinkedListNode *)&result->waiters.link;
  return result;
}

//----- (FFF15C94) --------------------------------------------------------
Result __fastcall KObjectAllocator::Register(KObjectAllocator *this, KAutoObject *obj)
{
  KLightMutex *p_mutex; // r0
  KLightMutex *v5; // r4
  unsigned int v6; // r2
  bool v7; // zf
  unsigned int v8; // r3
  KLinkedListNode *v9; // r0

  p_mutex = &this->container.mutex;
  v5 = p_mutex;
  v6 = __ldrex((unsigned int *)p_mutex);
  v7 = v6 == 0;
  if ( v6 )
    v8 = __strex(v6, (unsigned int *)p_mutex);
  else
    v8 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)p_mutex);
  if ( !v6 )
    v7 = v8 == 0;
  if ( !v7 )
    KLightMutex::LockImpl(p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  v9 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
  if ( v9 )
  {
    v9->link.next = 0;
    v9->link.prev = 0;
    v9->data = 0;
  }
  v9->data = obj;
  KLinkedList::InsertAfter((KLinkedList *)this, (KLinkedListLink *)&this->container.list.link, v9);
  if ( this->container.list.count > this->count )
    this->count = this->container.list.count;
  __mcr(15, 0, 0, 7, 10, 5);
  v5->lockingThread = 0;
  if ( v5->numWaiters > 0 )
    KLightMutex::UnlockImpl(v5);
  return 0;
}
// FFF15CF8: conditional instruction was optimized away because r0.4!=0

//----- (FFF15D58) --------------------------------------------------------
void __fastcall KPageGroup::IncrefPages(KPageGroup *this)
{
  KBlockInfoLinkedListNode *node; // r5
  KBlockInfo *blockInfo; // r3
  unsigned int v4; // r2
  u32 baseAddress; // r9
  u32 numPages; // r10
  bool v7; // zf
  unsigned int v8; // r3

  for ( node = this->list.link.next; node != (KBlockInfoLinkedListNode *)&this->list.link; node = node->link.next )
  {
    blockInfo = node->blockInfo;
    v4 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
    baseAddress = blockInfo->baseAddress;
    numPages = blockInfo->numPages;
    v7 = v4 == 0;
    if ( v4 )
      v8 = __strex(v4, (unsigned int *)&g_memoryManager.pgMgr.mutex);
    else
      v8 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
    if ( !v4 )
      v7 = v8 == 0;
    if ( !v7 )
      KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
    __mcr(15, 0, 0, 7, 10, 5);
    KPageManager::IncrefPages(&g_memoryManager.pgMgr, baseAddress, numPages);
    __mcr(15, 0, 0, 7, 10, 5);
    g_memoryManager.pgMgr.mutex.lockingThread = 0;
    if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  }
}

//----- (FFF15DE4) --------------------------------------------------------
Result __fastcall KPageTable::CheckAndMapPageGroup(
        KProcessPageTable *this,
        u32 addr,
        KPageGroup *pgGroup,
        KMemoryState state,
        KMemoryPermission perms)
{
  u32 TotalNumPages; // r0
  Result result; // r0

  TotalNumPages = KPageGroup::GetTotalNumPages(pgGroup);
  result = KPageTable::CheckMemoryBlockAttributes(this, addr, TotalNumPages << 12, MEMSTATE_FREE, KMEMPERM_NONE);
  if ( result >= 0 )
    return KPageTable::OperateOnGroup(this, addr, pgGroup, state, (KMemoryPermission)(perms | 0x18), KMEMUPDATE_NONE);
  return result;
}

//----- (FFF15E54) --------------------------------------------------------
void __fastcall KPageHeap::FreeBlock(KPageHeap *this, u32 addr, u32 numPages)
{
  KPageHeapBlock *next; // r4
  KPageHeapBlock *nextBlock; // r5
  KPageHeapBlock *i; // r4

  if ( numPages && !KPageHeap::TryInsert(this, addr, numPages, 0, this->link.next) )
  {
    next = this->link.next;
    if ( !this->link.next )
    {
LABEL_6:
      for ( i = this->link.next; i; i = i->link.next )
        KPageHeap::ValidateBlock(this, i);
      kernelpanic();
    }
    while ( 1 )
    {
      KPageHeap::ValidateBlock(this, next);
      nextBlock = next->link.next;
      KPageHeap::ValidateBlock(this, nextBlock);
      if ( KPageHeap::TryInsert(this, addr, numPages, next, nextBlock) )
        break;
      next = next->link.next;
      if ( !next )
        goto LABEL_6;
    }
  }
}

//----- (FFF15F14) --------------------------------------------------------
Result __fastcall ControlSystem(SystemOperation op, u32 arg1, u64 arg2)
{
  u32 param2Lo; // r5
  unsigned int param2Hi; // r6
  unsigned int v7; // r2
  bool v8; // zf
  unsigned int v9; // r3
  char cfgr; // r0
  char v11; // r0
  Result v12; // r5
  Result v13; // r0
  KProcessPageTable *p_pgTable; // r6
  u32 v15; // r0
  char v16; // r0
  char v17; // r0
  char v18; // r0

  param2Hi = HIDWORD(arg2);
  param2Lo = arg2;
  v7 = __ldrex((unsigned int *)&g_systemControl.mutex);
  v8 = v7 == 0;
  if ( v7 )
    v9 = __strex(v7, (unsigned int *)&g_systemControl.mutex);
  else
    v9 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_systemControl.mutex);
  if ( !v7 )
    v8 = v9 == 0;
  if ( !v8 )
    KLightMutex::LockImpl(&g_systemControl.mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  switch ( op )
  {
    case SYSTEMOP_FIRMLAUNCH:
      g_systemControl.operation = op;
      if ( !(param2Lo ^ 2 | param2Hi) )         // if ((titleId ^ 2) == 0) (native firm)
        param2Lo = param2Lo & 0xFFFFFFF | 0x20000000;
      LODWORD(g_systemControl.firmlaunchTitleId) = param2Lo;
      HIDWORD(g_systemControl.firmlaunchTitleId) = 0x40138;
      KDmaManager::AbortAll(&g_dmaManager);
      cfgr = MPCORE.scu.cfgr;
      MPCORE.gicd.sgir = (((1 << ((cfgr & 3) + 1)) - 1) << 16) & 0xFF0000 | 6;
      goto LABEL_13;
    case SYSTEMOP_UNIMPLEMENTED_1:
      v12 = 0;
      __mcr(15, 0, 0, 7, 10, 5);
      g_systemControl.mutex.lockingThread = 0;
      if ( g_systemControl.mutex.numWaiters > 0 )
        goto LABEL_20;
      return v12;
    case SYSTEMOP_SLEEP:
      g_systemControl.operation = op;
      g_systemControl.srcCoreId = __mrc(15, 0, 0, 0, 5) & 3;
      KDmaManager::AbortAll(&g_dmaManager);
      v16 = MPCORE.scu.cfgr;
      MPCORE.gicd.sgir = (((1 << ((v16 & 3) + 1)) - 1) << 16) & 0xFF0000 | 6;
      v12 = 0;
      __mcr(15, 0, 0, 7, 10, 5);
      g_systemControl.mutex.lockingThread = 0;
      if ( g_systemControl.mutex.numWaiters > 0 )
        goto LABEL_20;
      return v12;
    case SYSTEMOP_DELIVER_PARAMETERS:
      if ( arg1 )
      {
        if ( arg1 == 1 )
        {
          qmemcpy((void *)0xE0000000, (const void *)g_systemControl.deliverParamsPage, 0x1000u);
          v13 = 0;
        }
        else
        {
          v13 = 0xF8C007F4;
        }
      }
      else if ( __PAIR64__(param2Hi, param2Lo) < 0x10000000 || __PAIR64__(param2Hi, param2Lo) >= 0x14000000 )
      {
        v13 = 0xE0E01BF5;                       // 11.14 security fix
                                                // you could map the NULL page before
      }
      else
      {
        p_pgTable = &current.clc.current.process->pgTable;
        v15 = KPageTable::ConvertVaToPa(&g_supervisorPageTable.L1Table, g_systemControl.deliverParamsPage);
        v13 = KPageTable::Operate(
                p_pgTable,
                param2Lo,
                1u,
                v15,
                KMEMSTATE_SHARED,
                KMEMPERM_KRW_RW,
                KMEMUPDATE_NONE,
                0x300u);
      }
      v12 = v13;
      __mcr(15, 0, 0, 7, 10, 5);
      g_systemControl.mutex.lockingThread = 0;
      if ( g_systemControl.mutex.numWaiters > 0 )
        goto LABEL_20;
      return v12;
    case SYSTEMOP_POWER_STATE_CHANGE_SCHEDULING:
      g_systemControl.param1 = arg1;
      g_systemControl.operation = op;
      LOBYTE(g_systemControl.srcCoreId) = __mrc(15, 0, 0, 0, 5) & 3;
      g_systemControl.srcCoreId = LOBYTE(g_systemControl.srcCoreId);
      v18 = MPCORE.scu.cfgr;
      MPCORE.gicd.sgir = (((1 << ((v18 & 3) + 1)) - 1) << 16) & 0xFF0000 | 6;
      v12 = 0;
      __mcr(15, 0, 0, 7, 10, 5);
      g_systemControl.mutex.lockingThread = 0;
      if ( g_systemControl.mutex.numWaiters <= 0 )
        return v12;
      goto LABEL_20;
    case SYSTEMOP_MISC:
      if ( !g_systemControl.unitInfo )
        goto LABEL_28;
      if ( arg1 == 1 )
      {
        g_systemControl.targetSystem.userExceptionHandlersEnabled = (param2Lo | param2Hi) != 0;
      }
      else if ( arg1 == 2 )
      {
        g_systemControl.targetSystem.kernelPanicOnUserBreak = (param2Lo | param2Hi) != 0;
      }
      else
      {
LABEL_28:
        if ( arg1 == 3 )
        {
          v12 = KScheduler::ChangeAppPreemptionMode(param2Lo);
          __mcr(15, 0, 0, 7, 10, 5);
          g_systemControl.mutex.lockingThread = 0;
          if ( g_systemControl.mutex.numWaiters > 0 )
            goto LABEL_20;
          return v12;
        }
      }
      v12 = 0;
      __mcr(15, 0, 0, 7, 10, 5);
      g_systemControl.mutex.lockingThread = 0;
      if ( g_systemControl.mutex.numWaiters > 0 )
LABEL_20:
        KLightMutex::UnlockImpl(&g_systemControl.mutex);
      return v12;
    case SYSTEMOP_HARDWARE_RESET:
      g_systemControl.operation = op;
      g_systemControl.srcCoreId = __mrc(15, 0, 0, 0, 5) & 3;
      KDmaManager::AbortAll(&g_dmaManager);
      v11 = MPCORE.scu.cfgr;
      MPCORE.gicd.sgir = (((1 << ((v11 & 3) + 1)) - 1) << 16) & 0xFF0000 | 6;
      goto LABEL_13;
    case SYSTEMOP_HANG_ARM9:
      if ( !arg1 )
      {
        *g_systemControl.pxi.send = 0x348E43;
        *g_systemControl.pxi.sync = 0x80;
        while ( (*g_systemControl.pxi.cnt & 0x100) != 0 )
          ;
        if ( *g_systemControl.pxi.recv != 0xAEE97647 )
          kernelpanic();
      }
      v12 = 0;
      __mcr(15, 0, 0, 7, 10, 5);
      g_systemControl.mutex.lockingThread = 0;
      if ( g_systemControl.mutex.numWaiters > 0 )
        goto LABEL_20;
      return v12;
    case SYSTEMOP_SET_TITLEID_FOR_SMALL_PAGES_WORKAROUND:
      LODWORD(g_systemControl.titleIdForSmallPageWorkaround) = param2Lo;
      HIDWORD(g_systemControl.titleIdForSmallPageWorkaround) = param2Hi;
      v12 = 0;
      __mcr(15, 0, 0, 7, 10, 5);
      g_systemControl.mutex.lockingThread = 0;
      if ( g_systemControl.mutex.numWaiters > 0 )
        goto LABEL_20;
      return v12;
    case SYSTEMOP_CONFIGURE_N3DS_CPU_L2C:
      g_systemControl.param1 = arg1;
      g_systemControl.operation = op;
      LOBYTE(g_systemControl.srcCoreId) = __mrc(15, 0, 0, 0, 5) & 3;
      g_systemControl.srcCoreId = LOBYTE(g_systemControl.srcCoreId);
      v17 = MPCORE.scu.cfgr;
      MPCORE.gicd.sgir = (((1 << ((v17 & 3) + 1)) - 1) << 16) & 0xFF0000 | 6;
      v12 = 0;
      __mcr(15, 0, 0, 7, 10, 5);
      g_systemControl.mutex.lockingThread = 0;
      if ( g_systemControl.mutex.numWaiters > 0 )
        goto LABEL_20;
      return v12;
    default:
LABEL_13:
      v12 = 0xF8C007F4;
      __mcr(15, 0, 0, 7, 10, 5);
      g_systemControl.mutex.lockingThread = 0;
      if ( g_systemControl.mutex.numWaiters > 0 )
        goto LABEL_20;
      return v12;
  }
}
// FFF15F64: control flows out of bounds to FFF15F68
// FFF2E000: using guessed type int dword_FFF2E000;

//----- (FFF1642C) --------------------------------------------------------
void __fastcall KDmaAddress::Initialize(KDmaAddress *this, u32 dstAddr, bool isDevice, KProcess *process)
{
  this->isDevice = isDevice;
  this->process = process;
  this->maxVa = dstAddr;
  this->currentVa = dstAddr;
  this->currentPa = KPageTable::ConvertVaToPa(&process->pgTable.L1Table, dstAddr);
}

//----- (FFF16454) --------------------------------------------------------
void __fastcall KDmaBufferSize::ComputeFromConfig(KDmaBufferSize *this, s32 size, DmaDeviceConfig *cfg)
{
  s32 transferSize; // r8
  s32 burstSize; // r7
  int burstStride; // r1
  __int64 intervals; // r10
  bool v9; // cc
  s32 maxOffset; // r0
  s32 v11; // r1
  s32 minOffset; // r2
  s32 v13; // r0
  s32 v14; // r2
  s32 v15; // r3
  s32 v16; // r3
  s32 v17; // r2
  s32 v18; // r0
  int v19; // r0
  s32 v20; // r1
  s32 v21; // r0
  s32 v22; // r0
  s32 v23; // r3
  s32 v24; // r3
  s32 v25; // r2
  s32 v26; // r0
  int v27; // r6
  int v28; // r5
  int v29; // r0
  int v30; // r0
  __int64 v31; // r0
  s32 pos; // r3
  s32 v33; // r0
  s32 v34; // r1
  s32 v35; // r0
  int v36; // r1
  s32 v37; // r1
  s32 v38; // r2
  s32 v39; // r2
  s32 v40; // r3
  __int64 v41; // r0
  s32 v42; // r1
  s32 v43; // r0
  s32 v44; // r2
  s32 v45; // r0
  int v46; // r0
  int v47; // r0
  s32 v48; // r3
  s32 v49; // r12
  s32 v50; // lr
  s32 v51; // r3
  s32 v52; // r2
  s32 v53; // r12
  s32 v54; // r2
  s32 v55; // r0
  KDmaBufferSize *v56; // r1
  int v57; // r2
  s32 v58; // [sp+0h] [bp-28h]

  transferSize = cfg->transferSize;
  burstSize = cfg->burstSize;
  burstStride = cfg->burstStride;
  LODWORD(intervals) = cfg->transferStride - transferSize;
  this->pos = 0;
  v9 = burstSize <= 0;
  this->minOffset = 0;
  if ( burstSize <= 0 )
    v9 = transferSize <= 0;
  HIDWORD(intervals) = burstStride - burstSize;
  this->maxOffset = 0;
  if ( !v9 && intervals )
  {
    if ( burstSize <= 0 || burstSize == transferSize )// (burstSize <= 0 && transferUnit <= 0) || (transferInterval == 0 && burstInterval == 0)
                                                // 
                                                // with interval = stride - size (or unit)
                                                // 
                                                // "no stride" case
    {
      maxOffset = size / transferSize;
      v11 = size / transferSize;
      if ( size / transferSize <= 0 )
        goto LABEL_107;
      this->pos = transferSize;
      if ( transferSize >= 0 )
        maxOffset = this->maxOffset;
      if ( transferSize > 0 )
        maxOffset = transferSize;
      if ( transferSize >= 0 )
        this->maxOffset = maxOffset;
      else
        this->minOffset = transferSize;
      minOffset = this->minOffset;
      v13 = transferSize + intervals;
      this->pos = transferSize + intervals;
      if ( transferSize + (int)intervals >= minOffset )
      {
        if ( this->maxOffset >= v13 )
          v13 = this->maxOffset;
        this->maxOffset = v13;
      }
      else
      {
        this->minOffset = v13;
      }
      if ( v11 - 1 > 0 )
      {
        v14 = this->pos * (v11 - 1);
        if ( this->pos > 0 )
          v15 = this->maxOffset;
        else
          v15 = this->minOffset;
        v16 = v15 + v14 - this->pos;
        if ( this->pos > 0 )
          this->maxOffset = v16;
        else
          this->minOffset = v16;
        this->pos = v14;
      }
      else
      {
        this->pos = 0;
        this->minOffset = 0;
        this->maxOffset = 0;
      }
      v17 = this->minOffset;
      v18 = this->pos + transferSize;
      this->pos = v18;
      if ( v18 >= v17 )
      {
        if ( this->maxOffset >= v18 )
          v18 = this->maxOffset;
        this->maxOffset = v18;
      }
      else
      {
        this->minOffset = v18;
      }
      v19 = transferSize * v11;
      goto LABEL_106;
    }
    if ( transferSize > 0 )
    {
      v58 = size / transferSize;
      v27 = 0;
      v28 = burstSize;
      if ( burstStride >= 0 )
      {
        if ( burstSize < burstStride )
          v28 = burstStride;
      }
      else
      {
        v27 = burstStride;
      }
      v29 = transferSize / burstSize - 1;
      if ( v29 > 0 )
      {
        v30 = burstStride * v29;
        v9 = burstStride <= 0;
        v36 = v30 - burstStride;
        if ( v9 )
          v27 += v36;
        else
          v28 += v36;
      }
      else
      {
        v27 = 0;
        v30 = 0;
        v28 = 0;
      }
      HIDWORD(intervals) = v30 + burstSize;
      if ( v30 + burstSize >= v27 )
      {
        if ( v28 < SHIDWORD(intervals) )
          v28 = v30 + burstSize;
      }
      else
      {
        v27 = v30 + burstSize;
      }
      if ( v58 > 0 )
      {
        v31 = *(_QWORD *)&this->pos;
        pos = this->pos;
        if ( this->minOffset >= this->pos + v27 )
          HIDWORD(v31) = this->pos + v27;
        LODWORD(v31) = this->maxOffset;
        this->minOffset = HIDWORD(v31);
        HIDWORD(v31) = pos + v28;
        if ( (int)v31 >= pos + v28 )
          v34 = v33;
        this->maxOffset = v34;
        v35 = this->pos + HIDWORD(intervals) + intervals;
        this->pos = v35;
        if ( v35 >= this->minOffset )
        {
          if ( this->maxOffset >= v35 )
            v35 = this->maxOffset;
          this->maxOffset = v35;
        }
        else
        {
          this->minOffset = v35;
        }
        if ( v58 - 1 > 0 )
        {
          v37 = this->pos * (v58 - 1);
          if ( this->pos > 0 )
            v38 = this->maxOffset;
          else
            v38 = this->minOffset;
          v39 = v38 + v37 - this->pos;
          if ( this->pos > 0 )
            this->maxOffset = v39;
          else
            this->minOffset = v39;
          this->pos = v37;
        }
        else
        {
          this->pos = 0;
          this->minOffset = 0;
          this->maxOffset = 0;
        }
        v41 = *(_QWORD *)&this->pos;
        v40 = this->pos;
        LODWORD(v41) = this->pos + v27;
        if ( this->minOffset < (int)v41 )
          LODWORD(v41) = HIDWORD(v41);
        HIDWORD(v41) = this->maxOffset;
        this->minOffset = v41;
        LODWORD(v41) = v40 + v28;
        v44 = this->pos;
        if ( SHIDWORD(v41) >= v40 + v28 )
          v43 = v42;
        this->maxOffset = v43;
        this->pos = v44 + HIDWORD(intervals);
        size %= transferSize;
      }
      v45 = size / burstSize;
      if ( size / burstSize > 0 )
      {
        if ( v45 - 1 > 0 )
        {
          v46 = HIDWORD(intervals) * (v45 - 1);
          v57 = v46 - HIDWORD(intervals);
          if ( SHIDWORD(intervals) > 0 )
            v28 += v57;
          else
            v27 += v57;
        }
        else
        {
          v46 = 0;
          v27 = 0;
          v28 = 0;
        }
        v47 = v46 + burstSize;
        if ( v27 > v47 )
          v27 = v47;
        v48 = this->pos;
        if ( v28 < v47 )
          v28 = v47;
        v49 = v48 + v27;
        v50 = this->pos;
        if ( this->minOffset < v48 + v27 )
          v49 = this->minOffset;
        v51 = this->maxOffset;
        v52 = v50 + v28;
        this->minOffset = v49;
        v53 = this->pos;
        if ( v51 >= v50 + v28 )
          v52 = v51;
        this->maxOffset = v52;
        v54 = v53 + v47;
        v19 = burstSize * (size / burstSize);
        this->pos = v54;
LABEL_106:
        size -= v19;
      }
    }
    else
    {
      v20 = size / burstSize;
      if ( size / burstSize > 0 )
      {
        v21 = burstSize + HIDWORD(intervals);
        this->maxOffset = burstSize;
        this->pos = burstSize + HIDWORD(intervals);
        if ( burstSize + HIDWORD(intervals) >= 0 )
        {
          if ( this->maxOffset >= v21 )
            v21 = this->maxOffset;
          this->maxOffset = v21;
        }
        else
        {
          this->minOffset = v21;
        }
        if ( v20 - 1 > 0 )
        {
          v22 = this->pos * (v20 - 1);
          if ( this->pos > 0 )
            v23 = this->maxOffset;
          else
            v23 = this->minOffset;
          v24 = v23 + v22 - this->pos;
          if ( this->pos > 0 )
            this->maxOffset = v24;
          else
            this->minOffset = v24;
          this->pos = v22;
        }
        else
        {
          v22 = 0;
          this->pos = 0;
          this->minOffset = 0;
          this->maxOffset = 0;
        }
        v25 = this->minOffset;
        v26 = v22 + burstSize;
        this->pos = v26;
        if ( v26 >= v25 )
        {
          if ( this->maxOffset >= v26 )
            v26 = this->maxOffset;
          this->maxOffset = v26;
        }
        else
        {
          this->minOffset = v26;
        }
        size %= burstSize;
      }
    }
  }
LABEL_107:
  v55 = this->pos + size;
  v9 = this->minOffset <= v55;
  this->pos = v55;
  if ( v9 )
  {
    if ( v55 <= this->maxOffset )
      v55 = this->maxOffset;
    v56 = this;
    this->maxOffset = v55;
  }
  else
  {
    v56 = this;
    this->minOffset = v55;
  }
  v56->pos = 0;
}

//----- (FFF1689C) --------------------------------------------------------
bool __fastcall KDmaAddress::CheckPhysicalMemContiguous(KDmaAddress *this, s32 minOffset, s32 maxOffset)
{
  return KDmaAddress::GetPhysicalChunkSize(this, minOffset) == minOffset
      && KDmaAddress::GetPhysicalChunkSize(this, maxOffset) == maxOffset;
}

//----- (FFF168D8) --------------------------------------------------------
Result __fastcall KPageTable::CheckMemoryBlockAttributes(
        KPageTable *this,
        u32 addr,
        u32 size,
        KMemoryState state,
        KMemoryPermission perms)
{
  Result result; // r0
  u32 endAddr; // r1
  KMemoryInfo info; // [sp+0h] [bp-28h] BYREF
  u32 pageInfo[6]; // [sp+10h] [bp-18h] BYREF

  result = KPageTable::QueryInfo(this, &info, pageInfo, addr);
  if ( result >= 0 )
  {
    result = 0xE0A01BF5;
    if ( info.state == state && (perms & ~info.perms) == 0 )
    {
      endAddr = addr + size;
      if ( (!size || addr <= endAddr - 1) && endAddr <= info.baseAddress + info.size )
        return 0;
    }
  }
  return result;
}

//----- (FFF16958) --------------------------------------------------------
Result __fastcall KPageTable::MapL2Entries(
        KPageTable *this,
        u32 va,
        u32 pa,
        u32 numPages_reused,
        u32 *attribsPtr,
        bool isLarge)
{
  _DWORD *p_lockingThread; // r9
  unsigned int v9; // r5
  u32 v10; // r0
  unsigned int v11; // r2
  KLevel2TranslationTable *rootNode; // r2
  char *Contiguous; // r11
  u32 v14; // r1
  unsigned int v15; // r2
  bool v16; // zf
  unsigned int v17; // r2
  unsigned int v18; // r1
  unsigned int i; // r7
  KLevel2TranslationTable *v20; // r0
  KLevel2TranslationTable *v21; // r1
  u32 v22; // r0
  u32 v23; // r7
  u32 *v24; // r2
  u32 v25; // r3
  u32 *v26; // r1
  unsigned int j; // r2
  u32 k; // r10
  unsigned int *v29; // r0
  unsigned int v30; // r1
  bool v31; // zf
  _DWORD *v32; // r8
  _WORD *v33; // r3
  u32 *v34; // r0
  u32 v35; // r1
  u32 v37; // [sp+4h] [bp-7Ch]
  u32 v38; // [sp+14h] [bp-6Ch]
  int v39; // [sp+2Ch] [bp-54h]
  u32 v40; // [sp+34h] [bp-4Ch]
  u32 v41; // [sp+38h] [bp-48h]
  u32 v42; // [sp+3Ch] [bp-44h]

  if ( isLarge )
  {
    v9 = 0x10000;
    v10 = *attribsPtr & 0xE30 | 1 | *attribsPtr & 0xC | ((*attribsPtr & 1) << 15) | ((*attribsPtr & 0x1C0) << 6);
  }
  else
  {
    v9 = 4096;
    v10 = *attribsPtr | 2;
  }
  v37 = numPages_reused;
  v40 = v10;
  if ( numPages_reused )
  {
    while ( 1 )
    {
      v41 = va;
      v38 = va >> 20;
      v39 = 0;
      if ( (this->L1Table[va >> 20] & 3) == 1 )
      {
        Contiguous = (char *)((this->L1Table[va >> 20] >> 10 << 10) - 0x40000000);
        v42 = this->L1Table[va >> 20] >> 10 << 10;
        goto LABEL_52;
      }
      v11 = __ldrex((unsigned int *)&g_level2TtblAllocator.mutex);
      p_lockingThread = &g_level2TtblAllocator.mutex.lockingThread;
      if ( v11 )
        break;
      if ( __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_level2TtblAllocator.mutex) )
        goto LABEL_8;
LABEL_9:
      __mcr(15, 0, 0, 7, 10, 5);
      rootNode = g_level2TtblAllocator.rootNode;
      if ( !g_level2TtblAllocator.rootNode )
      {
        v15 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
        v16 = v15 == 0;
        if ( v15 )
          __strex(v15, (unsigned int *)&g_memoryManager.pgMgr.mutex);
        else
          v15 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
        if ( v16 )
          v16 = v15 == 0;
        if ( !v16 )
          KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
        __mcr(15, 0, 0, 7, 10, 5);
        do
          v17 = __ldrex(&g_memoryManager.pgMgr.kernelMemoryUsage);
        while ( __strex(v17 + 4096, &g_memoryManager.pgMgr.kernelMemoryUsage) );
        Contiguous = (char *)KPageHeap::AllocateContiguous(&g_memoryManager.baseHeap, 1u, 0);
        __mcr(15, 0, 0, 7, 10, 5);
        g_memoryManager.pgMgr.mutex.lockingThread = 0;
        if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
          KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
        if ( !Contiguous )
        {
          __mcr(15, 0, 0, 7, 10, 5);
          g_level2TtblAllocator.mutex.lockingThread = 0;
          if ( g_level2TtblAllocator.mutex.numWaiters > 0 )
            KLightMutex::UnlockImpl(&g_level2TtblAllocator.mutex);
LABEL_50:
          kernelpanic();
        }
        v18 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
        if ( v18 )
        {
          __strex(v18, (unsigned int *)&g_memoryManager.pgMgr.mutex);
          goto LABEL_33;
        }
        if ( __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex) )
LABEL_33:
          KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
        __mcr(15, 0, 0, 7, 10, 5);
        KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)Contiguous, 1u);
        __mcr(15, 0, 0, 7, 10, 5);
        g_memoryManager.pgMgr.mutex.lockingThread = 0;
        if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
          KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
        for ( i = 1; i < 4; ++i )
        {
          v20 = (KLevel2TranslationTable *)&Contiguous[1024 * i];
          if ( v20 )
          {
            v20->next = 0;
            v20->prev = 0;
          }
          v21 = g_level2TtblAllocator.rootNode;
          if ( g_level2TtblAllocator.rootNode )
          {
            v20->prev = g_level2TtblAllocator.rootNode;
            v21->next->prev = v20;
            v20->next = v21->next;
            v21->next = v20;
          }
          else
          {
            v20->prev = v20;
            v20->next = v20;
          }
          g_level2TtblAllocator.rootNode = v20;
        }
        v14 = g_level2TtblAllocator.numAvailable + 3;
        goto LABEL_44;
      }
      if ( g_level2TtblAllocator.rootNode->next == g_level2TtblAllocator.rootNode )
      {
        g_level2TtblAllocator.rootNode = 0;
      }
      else
      {
        g_level2TtblAllocator.rootNode = g_level2TtblAllocator.rootNode->prev;
        rootNode->prev->next = rootNode->next;
        rootNode->next->prev = rootNode->prev;
      }
      rootNode->prev = 0;
      rootNode->next = 0;
      Contiguous = (char *)rootNode;
      v14 = g_level2TtblAllocator.numAvailable - 1;
LABEL_44:
      g_level2TtblAllocator.numAvailable = v14;
      __mcr(15, 0, 0, 7, 10, 5);
      g_level2TtblAllocator.mutex.lockingThread = 0;
      if ( g_level2TtblAllocator.mutex.numWaiters > 0 )
        KLightMutex::UnlockImpl(&g_level2TtblAllocator.mutex);
      if ( !Contiguous )
        goto LABEL_50;
      memset(Contiguous, 0, 0x400u);
      v39 = 1;
      v42 = (u32)(Contiguous + 0x40000000);
LABEL_52:
      v22 = (0x100000 - (va & 0xFFFFF)) >> 12;
      if ( v22 > v37 )
        v22 = v37;
      v23 = v22;
      for ( v37 -= v22; v22; pa += v9 )
      {
        v24 = (u32 *)&Contiguous[(va & 0xFF000) >> 10];
        v25 = v40 | pa;
        if ( v9 >> 12 )
        {
          v26 = v24 - 1;
          if ( (v9 & 0x1000) != 0 )
          {
            *v24 = v25;
            v26 = (u32 *)&Contiguous[(va & 0xFF000) >> 10];
          }
          for ( j = v9 >> 13; j; v26 += 2 )
          {
            v26[1] = v25;
            --j;
            v26[2] = v25;
          }
        }
        v22 -= v9 >> 12;
        va += v9;
      }
      if ( v42 - 0x20000000 < 0x10000000 )
      {
        if ( v23 )
          p_lockingThread = &g_level2TtblAllocator;
        for ( k = 0; k < v23; ++k )
        {
          v29 = p_lockingThread + 4;
          v30 = __ldrex(p_lockingThread + 4);
          v31 = v30 == 0;
          v32 = p_lockingThread + 4;
          if ( v30 )
            __strex(v30, v29);
          else
            v30 = __strex((unsigned int)current.clc.current.thread, v29);
          if ( v31 )
            v31 = v30 == 0;
          if ( !v31 )
            KLightMutex::LockImpl((KLightMutex *)v29);
          __mcr(15, 0, 0, 7, 10, 5);
          v33 = (_WORD *)(p_lockingThread[1] + 2 * ((unsigned int)&Contiguous[-p_lockingThread[2]] >> 10));
          ++*v33;
          __mcr(15, 0, 0, 7, 10, 5);
          *v32 = 0;
          if ( *((__int16 *)v32 + 2) > 0 )
            KLightMutex::UnlockImpl((KLightMutex *)p_lockingThread + 2);
        }
      }
      if ( v39 )
      {
        KPageTable::CleanDataCacheRange((u32)Contiguous, 0x400u);
        this->L1Table[v38] = (v42 >> 10 << 10) | 1;
        v34 = &this->L1Table[v38];
        v35 = 4;
      }
      else
      {
        v35 = 4 * v23;
        v34 = (u32 *)&Contiguous[(v41 & 0xFF000) >> 10];
      }
      KPageTable::CleanDataCacheRange((u32)v34, v35);
      if ( !v37 )
        return 0;
    }
    __strex(v11, (unsigned int *)&g_level2TtblAllocator.mutex);
LABEL_8:
    KLightMutex::LockImpl(&g_level2TtblAllocator.mutex);
    goto LABEL_9;
  }
  return 0;
}
// FFF16B14: conditional instruction was optimized away because r0.4==300
// FFF16B1C: conditional instruction was optimized away because r0.4==300
// FFF16DB0: variable 'p_lockingThread' is possibly undefined

//----- (FFF16ECC) --------------------------------------------------------
Result __fastcall KPageTable::MapL1Entries(
        KPageTable *this,
        u32 va,
        u32 pa,
        u32 numPages,
        u32 *attribsPtr,
        bool isLarge)
{
  u32 v6; // r11
  unsigned int v7; // r10
  u32 v8; // r12
  u32 v9; // r4
  u32 **p_L1Table; // r5
  u32 v11; // r6
  unsigned int v12; // r0
  int v13; // lr
  u32 v14; // r8
  int v15; // lr
  u32 v16; // r9
  u32 v19; // [sp+8h] [bp-40h]
  unsigned int v20; // [sp+Ch] [bp-3Ch]

  v6 = 0;
  if ( isLarge )
    v7 = 0x1000000;
  else
    v7 = 0x100000;
  v8 = *attribsPtr & 0xC;
  if ( isLarge )
    v8 |= 0x40002u;
  if ( !isLarge )
    v8 |= 2u;
  v19 = v8 | ((*attribsPtr & 0xFF0) << 6) | (16 * (*attribsPtr & 1));
  if ( numPages )
  {
    v20 = v7 >> 20;
    do
    {
      v9 = va >> 20;
      p_L1Table = &this->L1Table;
      v11 = pa | v19;
      if ( v20 )
      {
        v12 = (v7 & 0x100000) != 0;
        v13 = 0;
        if ( v12 == 1 )
        {
          v13 = 1;
          (*p_L1Table)[v9] = v11;
        }
        for ( ; v12 < v20; (*p_L1Table)[v16] = v11 )
        {
          v14 = v9 + v13;
          v15 = v13 + 1;
          v16 = v9 + v15;
          (*p_L1Table)[v14] = v11;
          v12 += 2;
          v13 = v15 + 1;
        }
      }
      v6 += v7 >> 12;
      pa += v7;
      va += v7;
    }
    while ( v6 < numPages );
  }
  KPageTable::CleanDataCacheRange((u32)&this->L1Table[va >> 20], 4 * (numPages >> 8));
  return 0;
}

//----- (FFF16FD8) --------------------------------------------------------
Result __fastcall KPageTable::MergeContiguousEntries(KPageTable *this, u32 va)
{
  Result v4; // r3
  unsigned int L1Entry; // r1
  int L1EntryType; // r0
  u32 v7; // r5
  unsigned int v8; // r0
  int v9; // r1
  bool v10; // zf
  unsigned int v11; // r4
  int v12; // r1
  int v13; // r8
  int v14; // r2
  u32 v15; // r0
  int v16; // r1
  unsigned int v17; // r9
  int v18; // r1
  __int16 v19; // r0
  unsigned int v20; // r2
  bool v21; // zf
  unsigned int v22; // r3
  u32 v23; // r0
  unsigned int v24; // r2
  bool v25; // zf
  unsigned int v26; // r3
  KLevel2TranslationTable *rootNode; // r2
  u32 v28; // r2
  unsigned int v29; // r12
  int v30; // r0
  __int16 v31; // r0
  unsigned int v32; // r3
  u32 v33; // r0
  int v34; // r2
  unsigned int i; // r1
  u32 v36; // r5
  int v37; // r2
  u32 v38; // r6
  int v40; // [sp+0h] [bp-28h]

  v4 = 0xE0A01BF5;
  if ( this->onlyUseSmallPages )
    return v4;
  L1Entry = this->L1Table[va >> 20];
  L1EntryType = L1Entry & 0x40003;
  if ( (L1Entry & 0x40003) != 1 )
  {
    if ( L1EntryType == 2 )
    {
LABEL_48:
      v28 = va & 0xFF000000;
      v29 = L1Entry & 0xFF000000;
      v30 = 0;
      while ( ((v29 + (v30 << 20)) | L1Entry & 0xFFFFF) == this->L1Table[(v28 + (v30 << 20)) >> 20] )
      {
        if ( (unsigned int)++v30 >= 0x10 )
        {
          v31 = L1Entry & 0xC | ((unsigned __int16)(L1Entry & 0x7000) >> 6) | ((L1Entry & 0x38C00) >> 6) | ((unsigned __int8)(L1Entry & 0x10) >> 4);
          v32 = v29 | v31 & 0xC | 0x40002 | ((((unsigned __int16)(L1Entry & 0x7000) >> 6) & 0xFF0 | ((L1Entry & 0x38C00) >> 6) & 0xFF0 | ((unsigned __int8)(L1Entry & 0x10) >> 4) & 0xF0) << 6) | (16 * (v31 & 1));
          v33 = v28 >> 20;
          v34 = 0;
          for ( i = 0; i < 0x10; i += 2 )
          {
            v36 = v33 + v34;
            v37 = v34 + 1;
            v38 = v33 + v37;
            this->L1Table[v36] = v32;
            v34 = v37 + 1;
            this->L1Table[v38] = v32;
          }
          KPageTable::CleanDataCacheRange((u32)&this->L1Table[v33], 0x40u);
          return 0;
        }
      }
      return v4;
    }
    if ( L1EntryType != 262145 )
      return v4;
  }
  v7 = (L1Entry >> 10 << 10) + 0xC0000000;
  v8 = *(_DWORD *)(v7 + ((va & 0xFF000) >> 10));
  v9 = v8 & 3;
  if ( v9 == 1 )
  {
LABEL_16:
    va = va >> 20 << 20;
    v17 = v8 >> 20 << 20;
    v18 = 0;
    while ( ((v17 + (v18 << 16)) | (unsigned __int16)v8) == *(_DWORD *)(v7 + (((va + (v18 << 16)) & 0xFF000) >> 10)) )
    {
      if ( (unsigned int)++v18 >= 0x10 )
      {
        v19 = v8 & 0xE3C | ((unsigned __int16)(v8 & 0x7000) >> 6) | ((unsigned __int16)(v8 & 0x8000) >> 15);
        v40 = v19 & 0xC | 2 | ((v19 & 0xFF0) << 6) | (16 * (v19 & 1));
        this->L1Table[va >> 20] = v17 | v40;
        KPageTable::CleanDataCacheRange((u32)&this->L1Table[va >> 20], 4u);
        KPageTable::InvalidateAllTlbEntries(this);
        if ( v7 + 0x20000000 < 0x10000000 )
        {
          while ( 1 )
          {
            v20 = __ldrex((unsigned int *)&g_level2TtblAllocator.mutex);
            v21 = v20 == 0;
            if ( v20 )
              v22 = __strex(v20, (unsigned int *)&g_level2TtblAllocator.mutex);
            else
              v22 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_level2TtblAllocator.mutex);
            if ( !v20 )
              v21 = v22 == 0;
            if ( !v21 )
              KLightMutex::LockImpl(&g_level2TtblAllocator.mutex);
            __mcr(15, 0, 0, 7, 10, 5);
            v23 = (v7 - g_level2TtblAllocator.baseRegionStart) >> 10;
            if ( !--g_level2TtblAllocator.refcounts[v23] )
              break;
            __mcr(15, 0, 0, 7, 10, 5);
            g_level2TtblAllocator.mutex.lockingThread = 0;
            if ( g_level2TtblAllocator.mutex.numWaiters > 0 )
              KLightMutex::UnlockImpl(&g_level2TtblAllocator.mutex);
          }
          __mcr(15, 0, 0, 7, 10, 5);
          g_level2TtblAllocator.mutex.lockingThread = 0;
          if ( g_level2TtblAllocator.mutex.numWaiters > 0 )
            KLightMutex::UnlockImpl(&g_level2TtblAllocator.mutex);
          v24 = __ldrex((unsigned int *)&g_level2TtblAllocator.mutex);
          v25 = v24 == 0;
          if ( v24 )
            v26 = __strex(v24, (unsigned int *)&g_level2TtblAllocator.mutex);
          else
            v26 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_level2TtblAllocator.mutex);
          if ( !v24 )
            v25 = v26 == 0;
          if ( !v25 )
            KLightMutex::LockImpl(&g_level2TtblAllocator.mutex);
          __mcr(15, 0, 0, 7, 10, 5);
          if ( v7 )
          {
            *(_DWORD *)v7 = 0;
            *(_DWORD *)(v7 + 4) = 0;
          }
          rootNode = g_level2TtblAllocator.rootNode;
          if ( g_level2TtblAllocator.rootNode )
          {
            *(_DWORD *)(v7 + 4) = g_level2TtblAllocator.rootNode;
            rootNode->next->prev = (KLevel2TranslationTable *)v7;
            *(_DWORD *)v7 = rootNode->next;
            rootNode->next = (KLevel2TranslationTable *)v7;
          }
          else
          {
            *(_DWORD *)(v7 + 4) = v7;
            *(_DWORD *)v7 = v7;
          }
          g_level2TtblAllocator.rootNode = (KLevel2TranslationTable *)v7;
          ++g_level2TtblAllocator.numAvailable;
          __mcr(15, 0, 0, 7, 10, 5);
          g_level2TtblAllocator.mutex.lockingThread = 0;
          if ( g_level2TtblAllocator.mutex.numWaiters > 0 )
            KLightMutex::UnlockImpl(&g_level2TtblAllocator.mutex);
        }
        v4 = 0;
        L1Entry = v17 | v40;
        goto LABEL_48;
      }
    }
  }
  else
  {
    v10 = v9 == 2;
    if ( v9 != 2 )
      v10 = v9 == 3;
    if ( v10 )
    {
      va = HIWORD(va) << 16;
      v11 = HIWORD(v8) << 16;
      v12 = 0;
      while ( ((v11 + (v12 << 12)) | v8 & 0xFFF) == *(_DWORD *)(v7 + (((va + (v12 << 12)) & 0xFF000) >> 10)) )
      {
        if ( (unsigned int)++v12 >= 0x10 )
        {
          v13 = v8 & 0xC | v8 & 0xE30 | 1 | ((v8 & 1) << 15) | ((v8 & 0x1C0) << 6);
          v14 = v11 | v13;
          v15 = v7 + ((va & 0xFF000) >> 10) - 4;
          v16 = 8;
          do
          {
            *(_DWORD *)(v15 + 4) = v14;
            --v16;
            *(_DWORD *)(v15 + 8) = v14;
            v15 += 8;
          }
          while ( v16 );
          KPageTable::CleanDataCacheRange(v7 + ((va & 0xFF000) >> 10), 0x40u);
          v8 = v11 | v13;
          v4 = 0;
          goto LABEL_16;
        }
      }
    }
  }
  return v4;
}
/* Orphan comments:
can't merge if we only use small pages
{points at temple}
*/

//----- (FFF173D0) --------------------------------------------------------
Result __fastcall KPageTable::MapContiguousPhysicalAddressRange(
        KPageTable *this,
        u32 va,
        u32 pa,
        u32 numPages,
        u32 *mmuAttribs)
{
  u32 v5; // r5
  u32 v6; // r7
  u32 v9; // r4
  unsigned int i; // r6
  Result result; // r0
  unsigned int v12; // r10
  unsigned int v13; // r2
  unsigned int v14; // r3
  Result v15; // r0
  int v16; // r10
  Result v17; // r0
  unsigned int v18; // r2
  bool v19; // zf
  u32 *attribsPtr; // [sp+0h] [bp-38h]

  v5 = va;
  v6 = pa;
  v9 = numPages;
  if ( this->onlyUseSmallPages || numPages < 0x10 )
  {
    result = KPageTable::MapL2Entries(this, va, pa, numPages, mmuAttribs, 0);
    if ( result < 0 )
      return result;
  }
  else
  {
    for ( i = 0x10000; i <= 0x1000000; i *= 16 )
    {
      if ( (v5 & (i - 1)) != (v6 & (i - 1)) )
        break;
      v12 = ((i - 1) & (i - v5)) >> 12;
      if ( v12 + (i >> 12) > v9 )
        break;
      if ( v12 )
      {
        v13 = i >> 4;
        v14 = ((i - 1) & (i - v5)) >> 12;
        if ( i >> 4 == 4096 )
        {
          v15 = KPageTable::MapL2Entries(this, v5, v6, v14, mmuAttribs, 0);
        }
        else
        {
          switch ( v13 )
          {
            case 0x10000u:
              v15 = KPageTable::MapL2Entries(this, v5, v6, v14, mmuAttribs, 1);
              break;
            case 0x100000u:
              v15 = KPageTable::MapL1Entries(this, v5, v6, v14, mmuAttribs, 0);
              break;
            case 0x1000000u:
              v15 = KPageTable::MapL1Entries(this, v5, v6, v14, mmuAttribs, 1);
              break;
            default:
              v15 = -656406531;
              break;
          }
        }
        attribsPtr = (u32 *)v15;
        if ( v15 < 0 )
        {
LABEL_28:
          if ( numPages != v9 )
            KPageTable::UnmapEntries(this, va, numPages - v9, 0);
          return (Result)attribsPtr;
        }
        v9 -= v12;
        v5 += v12 << 12;
        v6 += v12 << 12;
      }
    }
    while ( 1 )
    {
      i >>= 4;
      if ( !v9 || i < 0x1000 )
        break;
      v16 = v9 & ~((i >> 12) - 1);
      if ( v16 )
      {
        switch ( i )
        {
          case 0x1000u:
            v17 = KPageTable::MapL2Entries(this, v5, v6, v16, mmuAttribs, 0);
            break;
          case 0x10000u:
            v17 = KPageTable::MapL2Entries(this, v5, v6, v16, mmuAttribs, 1);
            break;
          case 0x100000u:
            v17 = KPageTable::MapL1Entries(this, v5, v6, v16, mmuAttribs, 0);
            break;
          case 0x1000000u:
            v17 = KPageTable::MapL1Entries(this, v5, v6, v9 & 0xFFFFF000, mmuAttribs, 1);
            break;
          default:
            v17 = -656406531;
            break;
        }
        attribsPtr = (u32 *)v17;
        if ( v17 < 0 )
          goto LABEL_28;
        v9 -= v16;
        v5 += v16 << 12;
        v6 += v16 << 12;
      }
    }
  }
  KPageTable::MergeContiguousEntries(this, va);
  if ( numPages > 1 )
    KPageTable::MergeContiguousEntries(this, va + (numPages << 12) - 4096);
  if ( pa - 0x20000000 < 0x10000000 )
  {
    v18 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
    v19 = v18 == 0;
    if ( v18 )
      __strex(v18, (unsigned int *)&g_memoryManager.pgMgr.mutex);
    else
      v18 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
    if ( v19 )
      v19 = v18 == 0;
    if ( !v19 )
      KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
    __mcr(15, 0, 0, 7, 10, 5);
    KPageManager::IncrefPages(&g_memoryManager.pgMgr, pa - 0x40000000, numPages);
    __mcr(15, 0, 0, 7, 10, 5);
    g_memoryManager.pgMgr.mutex.lockingThread = 0;
    if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
  }
  return 0;
}

//----- (FFF17718) --------------------------------------------------------
KPageHeapBlock *__fastcall KPageHeap::AllocateBackwards(KPageHeap *this, u32 size)
{
  KPageHeapBlock *curBlkRev; // r4
  KPageHeapBlock *next; // r0
  bool v5; // zf
  u32 remaining; // r5
  KPageHeapBlock *v7; // r8
  u32 regionSize; // r0
  u32 numPages; // r6
  u32 v10; // r8
  KPageHeapBlock *v11; // r6
  KPageHeapBlock *prev; // r4
  KPageHeapBlock *i; // r4

  next = this->link.next;
  v5 = next == 0;
  if ( next )
  {
    curBlkRev = this->link.prev;
    v5 = curBlkRev == 0;
  }
  if ( !v5 && size )
  {
    remaining = size;
    v7 = 0;
    do
    {
      KPageHeap::ValidateBlock(this, curBlkRev);
      regionSize = this->regionSize;
      numPages = curBlkRev->numPages;
      if ( curBlkRev->numPages > regionSize >> 12
        || regionSize + this->regionStart < (unsigned int)curBlkRev + 4096 * numPages )
      {
        kernelpanic();
      }
      if ( curBlkRev->link.next != v7 )
        kernelpanic();
      if ( numPages >= remaining )
      {
        v10 = numPages - remaining;
        v11 = KPageHeap::SplitBlock(this, curBlkRev, numPages - remaining);
        if ( v11 )
        {
          if ( curBlkRev->numPages != v10 )
            kernelpanic();
        }
        else
        {
          v11 = curBlkRev;
        }
        prev = v11->link.prev;
        KPageHeap::ValidateBlock(this, prev);
        KPageHeap::SetLastBlock(this, prev);
        v11->link.prev = 0;
        KPageHeap::UpdateBlockMac(this, v11);
        if ( v11->numPages != remaining )
          kernelpanic();
        return v11;
      }
      v7 = curBlkRev;
      curBlkRev = curBlkRev->link.prev;
      remaining -= numPages;
    }
    while ( curBlkRev );
    for ( i = this->link.next; i; i = i->link.next )
      KPageHeap::ValidateBlock(this, i);
  }
  return 0;
}
// FFF1774C: variable 'curBlkRev' is possibly undefined

//----- (FFF17844) --------------------------------------------------------
Result __fastcall KMemoryBlockManager::MutateRange(
        KMemoryBlockManager *this,
        u32 va,
        u32 numPages,
        KMemoryState state,
        KMemoryPermission perms,
        u32 tag)
{
  KMemoryBlockLinkedListNode *next; // r0
  int numBlocks; // r9
  KMemoryBlockLinkedListNode *it2; // r0
  KMemoryBlockLinkedListNode *v13; // r0
  KMemoryBlock *block; // r9
  KMemoryBlockLinkedListNode *v15; // r11
  KMemoryBlockLinkedListNode *v16; // r0
  KMemoryBlockLinkedListNode *v17; // r10
  KMemoryBlock *v18; // r3
  KMemoryPermission v19; // r1
  bool v20; // zf
  KMemoryBlockLinkedListNode *v21; // r5
  KMemoryBlock *v22; // r0
  KMemoryBlock *v23; // r6
  KMemoryBlock *v24; // r1
  KMemoryPermission v25; // r2
  bool v26; // zf
  KMemoryBlock *v27; // r0
  KMemoryBlock *v28; // r9
  KLinkedListNode *v29; // r0
  u32 v30; // r10
  KMemoryBlock *v31; // r9
  KLinkedListNode *v32; // r0
  KMemoryBlockLinkedListNode *v33; // r0
  KMemoryBlock *v34; // r5
  KMemoryState v35; // r1
  u32 baseAddress; // r2
  KLinkedListNode *v37; // r0
  KMemoryBlock *v38; // r0
  KMemoryPermission v39; // r2
  bool v40; // zf
  KMemoryBlockLinkedListNode *v41; // r6
  KMemoryBlock *v42; // r5
  KMemoryBlockLinkedListNode *v43; // r11
  KMemoryBlock *v44; // r9
  KMemoryBlockLinkedListNode *v45; // r0
  KMemoryBlockLinkedListNode *v46; // r10
  KMemoryBlockLinkedListNode *v47; // r11
  KMemoryBlock *v48; // r9
  KMemoryBlockLinkedListNode *v49; // r0
  KMemoryBlockLinkedListNode *v50; // r10
  KMemoryBlock *v51; // r9
  KLinkedListNode *v52; // r0
  KMemoryBlockLinkedListNode *nodeContainingVa; // [sp+0h] [bp-68h] BYREF
  KMemoryBlockLinkedListNode *blockContainingVaNode; // [sp+10h] [bp-58h] BYREF
  KMemoryInfo result; // [sp+20h] [bp-48h] BYREF
  u32 endVa; // [sp+38h] [bp-30h]
  KMemoryBlockLinkedListNode *blockContainingEndVaNode; // [sp+3Ch] [bp-2Ch] BYREF

  endVa = va + (numPages << 12) - 1;
  blockContainingEndVaNode = 0;
  next = this->blocks.link.next;
  numBlocks = 0;
  while ( 1 )
  {
    blockContainingVaNode = next;
    if ( next == (KMemoryBlockLinkedListNode *)&this->blocks.link || KMemoryBlock::Contains(next->block, va) )
      break;
    next = blockContainingVaNode->link.next;
  }
  for ( it2 = blockContainingVaNode; ; it2 = blockContainingEndVaNode->link.next )
  {
    blockContainingEndVaNode = it2;
    if ( it2 == (KMemoryBlockLinkedListNode *)&this->blocks.link )
      break;
    ++numBlocks;
    if ( KMemoryBlock::Contains(it2->block, endVa) )
      break;
  }
  if ( numBlocks != 1 )
  {
    if ( numBlocks > 2 )
    {                                           // erase nodes
      nodeContainingVa = blockContainingVaNode;
      v13 = blockContainingVaNode->link.next;
      for ( nodeContainingVa = v13; nodeContainingVa != blockContainingEndVaNode; v13 = nodeContainingVa )
      {
        block = v13->block;
        v15 = v13;
        KLinkedList::EraseNode((KLinkedList *)this, (KLinkedListLink **)&nodeContainingVa);
        v17 = v16;
        KSlabHeap::Free(&g_linkedListNodeSlabHeap, v15);
        nodeContainingVa = v17;
        KSlabHeap::Free(&g_memoryBlockSlabHeap, block);
      }
    }
    v18 = blockContainingVaNode->block;
    v19 = v18->perms;
    v20 = v19 == perms;
    if ( v19 == perms )
      v20 = v18->state == state;
    if ( v20 )
      v20 = v18->tag == tag;
    if ( v20 )
    {
      KMemoryBlock::GrowBlock(blockContainingVaNode->block, va, numPages);
      v21 = blockContainingEndVaNode;
      v22 = blockContainingEndVaNode->block;
      if ( v22->baseAddr + (v22->numPages << 12) - 1 == endVa )
      {
        v23 = blockContainingEndVaNode->block;
        KLinkedList::EraseNode((KLinkedList *)this, (KLinkedListLink **)&blockContainingEndVaNode);
        KSlabHeap::Free(&g_linkedListNodeSlabHeap, v21);
        KSlabHeap::Free(&g_memoryBlockSlabHeap, v23);
        goto coalesce;
      }
    }
    else
    {                                           // not same/mergeable, delete and recreate or insert new
      v38 = blockContainingEndVaNode->block;
      v39 = v38->perms;
      v40 = v39 == perms;
      if ( v39 == perms )
        v40 = v38->state == state;
      if ( v40 )
        v40 = v38->tag == tag;
      if ( !v40 )
      {
        if ( KMemoryBlock::IncludesRange(blockContainingVaNode->block, va, numPages) )
        {
          v43 = blockContainingVaNode;
          v44 = blockContainingVaNode->block;
          KLinkedList::EraseNode((KLinkedList *)this, (KLinkedListLink **)&blockContainingVaNode);
          v46 = v45;
          KSlabHeap::Free(&g_linkedListNodeSlabHeap, v43);
          blockContainingVaNode = v46;
          KSlabHeap::Free(&g_memoryBlockSlabHeap, v44);
          blockContainingVaNode = blockContainingVaNode->link.prev;
        }
        else
        {
          KMemoryBlock::ShrinkBlock(blockContainingVaNode->block, va, numPages);
        }
        if ( KMemoryBlock::IncludesRange(blockContainingEndVaNode->block, va, numPages) )
        {
          v47 = blockContainingEndVaNode;
          v48 = blockContainingEndVaNode->block;
          KLinkedList::EraseNode((KLinkedList *)this, (KLinkedListLink **)&blockContainingEndVaNode);
          v50 = v49;
          KSlabHeap::Free(&g_linkedListNodeSlabHeap, v47);
          blockContainingEndVaNode = v50;
          KSlabHeap::Free(&g_memoryBlockSlabHeap, v48);
        }
        else
        {
          KMemoryBlock::ShrinkBlock(blockContainingEndVaNode->block, va, numPages);
        }
        v51 = (KMemoryBlock *)KSlabHeap::Allocate(&g_memoryBlockSlabHeap);
        v51->tag = 0;
        v51->state = state;
        v51->perms = perms;
        v51->baseAddr = va;
        v51->numPages = numPages;
        v52 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
        if ( v52 )
        {
          v52->link.next = 0;
          v52->link.prev = 0;
          v52->data = 0;
        }
        v52->data = v51;
        KLinkedList::InsertAfter((KLinkedList *)this, (KLinkedListLink *)blockContainingEndVaNode, v52);
        goto coalesce;
      }
      KMemoryBlock::GrowBlock(v38, va, numPages);// grow block containing end va
      v41 = blockContainingVaNode;
      v22 = blockContainingVaNode->block;       // etc.
      if ( v22->baseAddr == va )
      {
        v42 = blockContainingVaNode->block;
        KLinkedList::EraseNode((KLinkedList *)this, (KLinkedListLink **)&blockContainingVaNode);
        KSlabHeap::Free(&g_linkedListNodeSlabHeap, v41);
        KSlabHeap::Free(&g_memoryBlockSlabHeap, v42);
        goto coalesce;
      }
    }
    KMemoryBlock::ShrinkBlock(v22, va, numPages);// shrink the block containing the start va
    goto coalesce;
  }
  v24 = blockContainingVaNode->block;           // else if (numBlocks == 1)
  v25 = v24->perms;
  v26 = v25 == perms;
  if ( v25 == perms )
    v26 = v24->state == state;
  if ( !v26 || v24->tag != tag )
  {
    KMemoryBlock::GetInfo(&result, v24);
    if ( result.baseAddress == va )
    {
      v27 = blockContainingVaNode->block;
      if ( result.size == numPages << 12 )
      {
        v27->tag = tag;
        v27->state = state;
        v27->perms = perms;
        v27->baseAddr = va;
        v27->numPages = numPages;
        goto coalesce;
      }
      KMemoryBlock::ShrinkBlock(v27, va, numPages);
      v28 = (KMemoryBlock *)KSlabHeap::Allocate(&g_memoryBlockSlabHeap);
      v28->tag = tag;
      v28->state = state;
      v28->perms = perms;
      v28->baseAddr = va;
      v28->numPages = numPages;
      v29 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
      if ( v29 )
      {
        v29->link.next = 0;
        v29->link.prev = 0;
        v29->data = 0;
      }
LABEL_30:
      v29->data = v28;
      KLinkedList::InsertAfter((KLinkedList *)this, (KLinkedListLink *)blockContainingVaNode, v29);
      goto coalesce;
    }
    if ( result.baseAddress + result.size == endVa + 1 )// same end address, different base addr
    {
      KMemoryBlock::ShrinkBlock(blockContainingVaNode->block, va, numPages);
      blockContainingVaNode = blockContainingVaNode->link.next;
      v28 = (KMemoryBlock *)KSlabHeap::Allocate(&g_memoryBlockSlabHeap);
      v28->tag = tag;
      v28->state = state;
      v28->perms = perms;
      v28->baseAddr = va;
      v28->numPages = numPages;
      v29 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
      if ( v29 )
      {
        v29->link.next = 0;
        v29->link.prev = 0;
        v29->data = 0;
      }
      goto LABEL_30;
    }
    v30 = (va - result.baseAddress) >> 12;
    KMemoryBlock::ShrinkBlock(blockContainingVaNode->block, 0, numPages + (va >> 12));
    v31 = (KMemoryBlock *)KSlabHeap::Allocate(&g_memoryBlockSlabHeap);
    v31->tag = tag;
    v31->state = state;
    v31->perms = perms;
    v31->baseAddr = va;
    v31->numPages = numPages;
    v32 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
    if ( v32 )
    {
      v32->link.next = 0;
      v32->link.prev = 0;
      v32->data = 0;
    }
    v32->data = v31;
    KLinkedList::InsertAfter((KLinkedList *)this, (KLinkedListLink *)blockContainingVaNode, v32);
    blockContainingVaNode = v33;
    v34 = (KMemoryBlock *)KSlabHeap::Allocate(&g_memoryBlockSlabHeap);
    v35 = result.state;
    baseAddress = result.baseAddress;
    v34->perms = result.perms;
    v34->state = v35;
    v34->tag = 0;
    v34->baseAddr = baseAddress;
    v34->numPages = v30;
    v37 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
    if ( v37 )
    {
      v37->link.next = 0;
      v37->link.prev = 0;
      v37->data = 0;
    }
    v37->data = v34;
    KLinkedList::InsertAfter((KLinkedList *)this, (KLinkedListLink *)blockContainingVaNode, v37);
  }
coalesce:
  KMemoryBlockManager::CoalesceBlocks(this);
  return 0;
}
// FFF17AD0: conditional instruction was optimized away because r0.4!=0
// FFF17B9C: conditional instruction was optimized away because r0.4!=0
// FFF17C50: conditional instruction was optimized away because r0.4!=0
// FFF17CE0: conditional instruction was optimized away because r0.4!=0
// FFF17EF0: conditional instruction was optimized away because r0.4!=0
// FFF17938: variable 'v16' is possibly undefined
// FFF17C78: variable 'v33' is possibly undefined
// FFF17DD4: variable 'v45' is possibly undefined
// FFF17E54: variable 'v49' is possibly undefined

//----- (FFF17F34) --------------------------------------------------------
void __fastcall KInterruptController::DisableInterrupt(u32 irqId)
{
  MPCORE.gicd.icenabler[(int)irqId / 32] = 1 << ((int)irqId % 32);
}

//----- (FFF17F64) --------------------------------------------------------
void __fastcall KMemoryBlock::ShrinkBlock(KMemoryBlock *this, u32 va, u32 numPages)
{
  u32 baseAddr; // r12
  u32 endAddr; // r3
  bool v5; // cf
  u32 v6; // r2
  bool v7; // cf

  baseAddr = this->baseAddr;
  endAddr = va + (numPages << 12) - 1;
  v5 = this->baseAddr >= endAddr;
  v6 = this->baseAddr + (this->numPages << 12) - 1;
  if ( this->baseAddr < endAddr )
    v5 = endAddr >= v6;
  if ( v5 )
  {
    v7 = baseAddr >= va;
    if ( baseAddr < va )
      v7 = va >= v6;
    if ( !v7 )
      this->numPages = (va - baseAddr) >> 12;
  }
  else
  {
    this->baseAddr = endAddr + 1;
    this->numPages = (v6 - endAddr) >> 12;
  }
}

//----- (FFF17FCC) --------------------------------------------------------
Result __fastcall KInterruptManager::UnbindKernelInterruptForCore(KInterruptManager *this, s32 irqId, s32 coreId)
{
  KLightMutex *p_mutex; // r0
  KLightMutex *v7; // r4
  unsigned int v8; // r2
  bool v9; // zf
  unsigned int v10; // r3
  KInterruptEntry *v11; // r7
  Result v12; // r6
  KLightMutex *v13; // r0

  p_mutex = &this->mutex;
  v7 = p_mutex;
  v8 = __ldrex((unsigned int *)p_mutex);
  v9 = v8 == 0;
  if ( v8 )
    v10 = __strex(v8, (unsigned int *)p_mutex);
  else
    v10 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)p_mutex);
  if ( !v8 )
    v9 = v10 == 0;
  if ( !v9 )
    KLightMutex::LockImpl(p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  if ( (unsigned int)irqId > 0x1F )
  {
    if ( (unsigned int)(irqId - 32) > 0x5F )
    {
      v12 = 0xD8E007FD;
      v13 = v7;
      __mcr(15, 0, 0, 7, 10, 5);
      v7->lockingThread = 0;
      if ( v7->numWaiters <= 0 )
        return v12;
    }
    else
    {
      KInterruptController::DisableInterrupt(irqId);
      this->privateInterrupts[3][irqId].handler = 0;// global interrupt[irqId - 32]
      v12 = 0;
      v13 = v7;
      __mcr(15, 0, 0, 7, 10, 5);
      v7->lockingThread = 0;
      if ( v7->numWaiters <= 0 )
        return v12;
    }
    goto LABEL_13;
  }
  v11 = &this->privateInterrupts[coreId][irqId];
  if ( v11->handler )
  {
    KInterruptController::DisablePeripheralInterrupt(irqId);
    v12 = 0;
    v11->handler = 0;
  }
  else
  {
    v12 = 0xD9600602;
  }
  v13 = v7;
  __mcr(15, 0, 0, 7, 10, 5);
  v7->lockingThread = 0;
  if ( v7->numWaiters > 0 )
LABEL_13:
    KLightMutex::UnlockImpl(v13);
  return v12;
}

//----- (FFF180DC) --------------------------------------------------------
Result __fastcall KInterruptManager::BindInterrupt(
        KInterruptManager *this,
        KInterruptHandler *handler,
        u32 irqId,
        s32 coreId,
        s32 priority,
        bool autoDisable,
        bool levelSensitive)
{
  KLightMutex *p_mutex; // r0
  KLightMutex *v11; // r4
  unsigned int v12; // r2
  bool v13; // zf
  unsigned int v14; // r3
  KInterruptEntry *v15; // r1
  Result v16; // r6
  KLightMutex *v17; // r0

  p_mutex = &this->mutex;
  v11 = p_mutex;
  v12 = __ldrex((unsigned int *)p_mutex);
  v13 = v12 == 0;
  if ( v12 )
    v14 = __strex(v12, (unsigned int *)p_mutex);
  else
    v14 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)p_mutex);
  if ( !v12 )
    v13 = v14 == 0;
  if ( !v13 )
    KLightMutex::LockImpl(p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  if ( irqId > 0x1F )
  {
    if ( irqId - 32 <= 0x5F )
    {
      v16 = KInterruptManager::BindSharedInterrupt(this, handler, irqId, coreId, priority, autoDisable, levelSensitive);
      v17 = v11;
      __mcr(15, 0, 0, 7, 10, 5);
      v11->lockingThread = 0;
      if ( v11->numWaiters <= 0 )
        return v16;
      goto LABEL_15;
    }
    v16 = 0xD8E007FD;
    __mcr(15, 0, 0, 7, 10, 5);
    v11->lockingThread = 0;
    if ( v11->numWaiters > 0 )
      KLightMutex::UnlockImpl(v11);
  }
  else
  {
    v15 = &this->privateInterrupts[coreId][irqId];
    if ( (unsigned int)priority < 0xF )
    {
      if ( v15->handler )
      {
        v16 = 0xD8E007F0;
      }
      else
      {
        v15->autoDisable_ManualClear = autoDisable;
        v15->disabled = 0;
        v15->priority = priority;
        v15->handler = handler;
        KInterruptController::ClearInterruptPendingStatus(irqId);
        KInterruptController::EnableWithPriority(irqId, priority);
        v16 = 0;
      }
    }
    else
    {
      v16 = 0xD8E007FD;
    }
    v17 = v11;
    __mcr(15, 0, 0, 7, 10, 5);
    v11->lockingThread = 0;
    if ( v11->numWaiters > 0 )
LABEL_15:
      KLightMutex::UnlockImpl(v17);
  }
  return v16;
}

//----- (FFF18228) --------------------------------------------------------
Result __fastcall KDebug::DispatchEvent(KDebug *this, DebugEventType type, u32 param1, u32 param2)
{
  KThread *currentThread; // r2
  KDebugThread *currentDebugThread; // r0
  KDebugThread *debugThread; // r0
  bool v11; // zf
  int v12; // r1
  bool v13; // zf
  u32 debugFlags; // r1
  bool v15; // zf
  bool v16; // zf
  KThread *volatile thread; // r8
  u32 userDebuggerCoreId; // r1
  Result result; // r0
  Result v20; // r7
  KThread *volatile v21; // r0
  unsigned int numExceptionEvents; // r0
  int v23; // r0
  bool v24; // zf
  Result v25; // r6
  u32 v26; // r1

  currentThread = current.clc.current.thread;
  currentDebugThread = current.clc.current.thread->debugThread;
  if ( currentDebugThread )
  {
    switch ( type )
    {
      case DBGEVENT_ATTACH_PROCESS:
      case DBGEVENT_ATTACH_THREAD:
      case DBGEVENT_EXIT_THREAD:
      case DBGEVENT_EXIT_PROCESS:
      case DBGEVENT_EXCEPTION:
      case DBGEVENT_OUTPUT_STRING:
        if ( currentDebugThread->debugPauseRequested )// this can deref nullptr when the KDebug is being destroyed/detached!
                                                // (use rosalina's "kill" gdbstub command and see for yourself)
        {
          currentDebugThread->debugPauseRequested = 0;
          KThread::SetDebugPauseState(currentThread, 1);// pause
        }
        break;
      default:
        break;
    }
  }
  switch ( type )
  {
    case DBGEVENT_ATTACH_PROCESS:
      if ( this->processAttached )
        return 0;
      goto LABEL_31;
    case DBGEVENT_ATTACH_THREAD:
      debugThread = current.clc.current.thread->debugThread;
      v11 = debugThread == 0;
      if ( debugThread )
        v11 = !debugThread->attached;
      if ( !v11 )
        return 0;
      goto LABEL_31;
    case DBGEVENT_SCHEDULE_IN:
      if ( (this->debugFlags & DBG_SIGNAL_SCHEDULE_EVENTS) != 0 )
      {
        v12 = current.clc.current.thread->schedulingMask & 0xF;
        v13 = v12 == KTHREADSCHEDSTAT_TERMINATED;
        if ( v12 != KTHREADSCHEDSTAT_TERMINATED )
          v13 = current.clc.current.thread->debugThread == 0;
        if ( !v13 )
          goto label_scheduleInOut;
      }
      return 0;
    case DBGEVENT_SCHEDULE_OUT:
      debugFlags = this->debugFlags;
      v15 = (debugFlags & DBG_SIGNAL_SCHEDULE_EVENTS) == 0;
      if ( (debugFlags & DBG_SIGNAL_SCHEDULE_EVENTS) != 0 )
      {
        debugFlags = (u32)current.clc.current.thread->debugThread;
        v15 = debugFlags == 0;
      }
      if ( !v15
        && !*(_BYTE *)(debugFlags + 7)          // scheduledOut
        && (current.clc.current.thread->schedulingMask & 0xF) != KTHREADSCHEDSTAT_TERMINATED )
      {
        goto label_scheduleInOut;
      }
      return 0;
    case DBGEVENT_SYSCALL_IN:
      if ( current.clc.current.thread->debugThread
        && (current.clc.current.thread->schedulingMask & 0xF) != KTHREADSCHEDSTAT_TERMINATED
        && (this->debugFlags & DBG_SIGNAL_SYSCALL_EVENTS) != 0 )
      {
        goto LABEL_31;
      }
      return 0;
    case DBGEVENT_SYSCALL_OUT:
      if ( (this->debugFlags & DBG_SIGNAL_SYSCALL_EVENTS) != 0
        && (current.clc.current.thread->schedulingMask & 0xF) != KTHREADSCHEDSTAT_TERMINATED )
      {
        goto LABEL_31;
      }
      return 0;
    case DBGEVENT_MAP:
      if ( (this->debugFlags & 0x10) != 0 )
        goto LABEL_31;
      return 0;
    default:
      v16 = type == DBGEVENT_SCHEDULE_OUT;
      if ( type != DBGEVENT_SCHEDULE_OUT )
        v16 = type == DBGEVENT_SCHEDULE_IN;
      if ( v16 )
      {
label_scheduleInOut:
        thread = current.clc.current.thread;
        if ( type == DBGEVENT_SCHEDULE_IN )
        {
          v20 = KDebug::EmplaceAysncEventInfo(this, DBGEVENT_SCHEDULE_IN, 0, 0, 0, 0, 0, 0, 0);
          thread->debugThread->scheduledOut = 0;
          if ( this->eventsToFetch.count > 0x10 )
          {
            KSchedulerLock::Lock(&g_schedulerLock);
            KSynchronizationObject::NotifyWaiters(this, 0);// too many events in the queue already for these events
                                                // 
                                                // Signal ourselves and try to schedule the debugger (the thread using ContinueDebugEvent)
            userDebuggerCoreId = this->userDebuggerCoreId;
            if ( g_coreLocalRegions[userDebuggerCoreId].clc.current.thread != this->userDebuggerThread )
              KDebug::RequestReschedulingForDebugger(this, userDebuggerCoreId);
            KSchedulerLock::Unlock(&g_schedulerLock);
          }
          return v20;
        }
        else
        {
          if ( type != DBGEVENT_SCHEDULE_OUT )
            kernelpanic();
          result = KDebug::EmplaceAysncEventInfo(this, DBGEVENT_SCHEDULE_OUT, 0, param1, 0, 0, 0, 0, 0);
          thread->debugThread->scheduledOut = 1;
        }
      }
      else
      {
LABEL_31:
        switch ( type )
        {
          case DBGEVENT_EXIT_PROCESS:
          case DBGEVENT_SCHEDULE_IN:
          case DBGEVENT_SCHEDULE_OUT:
          case DBGEVENT_SYSCALL_IN:
          case DBGEVENT_SYSCALL_OUT:
          case DBGEVENT_MAP:
            return KDebug::ProcessAsyncEventAndEmplaceInfo(this, type, param1);
          default:
            KSchedulerLock::Lock(&this->lock);
            while ( (current.clc.current.thread->schedulingMask & (unsigned __int8)KTHREADSCHEDSTAT_DEBUG_PAUSE_FLAG) != 0 )
            {
              KSchedulerLock::Unlock(&this->lock);
              KSchedulerLock::Lock(&this->lock);
            }
            if ( this->signalingSyncEvent )
              kernelpanic();
            KDebug::BreakCurrentProcess(this, current.clc.current.thread);
            v21 = current.clc.current.thread;
            this->signalingSyncEventThread = current.clc.current.thread;
            this->signalingSyncEvent = STOPPOINT_BREAKPOINT;
            this->lastSyncDebugEventType = type;
            if ( type == DBGEVENT_EXIT_THREAD )
            {
              v21->debugThread->exitReason = param1;
              goto skip_exception;
            }
            if ( type < DBGEVENT_EXIT_THREAD )  //   DBGEVENT_ATTACH_PROCESS = 0x0,
                                                //   DBGEVENT_ATTACH_THREAD = 0x1,
                                                //   DBGEVENT_EXIT_THREAD = 0x2,
            {
              if ( type )
              {
                if ( type == DBGEVENT_ATTACH_THREAD )
                  v21->debugThread->scheduledOut = STOPPOINT_BREAKPOINT;
              }
              else
              {
                this->processAttached = STOPPOINT_BREAKPOINT;
                v21->debugThread->scheduledOut = STOPPOINT_BREAKPOINT;
              }
              goto skip_exception;
            }
            if ( type != DBGEVENT_EXCEPTION )
            {
              if ( type == DBGEVENT_OUTPUT_STRING )
              {
                this->outputStringFlag = (param2 & 0x80000000) != 0;
                this->outputStringSize = param2 & 0x7FFFFFFF;
                this->outputStringAddr = param1;
              }
              goto skip_exception;
            }
            if ( (this->debugFlags & DBG_SIGNAL_FAULT_EXCEPTION_EVENTS) == 0 && param1 != EXCEVENT_STOP_POINT )
            {
              KSchedulerLock::Lock(&g_schedulerLock);
              this->signalingSyncEvent = 0;
              KDebug::UnbreakCurrentProcess(this);
              KSchedulerLock::Unlock(&this->lock);
              KSchedulerLock::Unlock(&g_schedulerLock);
              return 0;
            }
            v21->debugThread->dfar = __mrc(15, 0, 6, 0, 0);
            numExceptionEvents = this->numExceptionEvents;
            if ( numExceptionEvents < 2 )
              this->numExceptionEvents = numExceptionEvents + 1;
            switch ( param1 )
            {
              case EXCEVENT_PREFETCH_ABORT:
                if ( (__mrc(15, 0, 5, 0, 1) & 0x40F) == 2 )// check ifsr
                  this->stopPointType = STOPPOINT_BREAKPOINT;
                break;
              case EXCEVENT_DATA_ABORT:
                v23 = __mrc(15, 0, 5, 0, 0) & 0x40F;// check dfsr
                if ( v23 == 1 )
                {
                  param1 = EXCEVENT_UNALIGNED_DATA_ACCESS;
                  break;
                }
                if ( v23 == STOPPOINT_WATCHPOINT )
                  goto LABEL_82;
                break;
              case EXCEVENT_STOP_POINT:
                v23 = STOPPOINT_SVC_FF;
LABEL_82:
                this->stopPointType = v23;
                break;
              case EXCEVENT_UNDEFINED_SYSCALL:
                this->excCtx = 0;
                this->svcId = param2;
                goto LABEL_84;
            }
            this->excCtx = (ExceptionDispatchContext *)param2;
LABEL_84:
            this->exceptionEventType = param1;
            this->exceptionEventSignaled = STOPPOINT_BREAKPOINT;
            v24 = (this->debugFlags & DBG_SIGNAL_FAULT_EXCEPTION_EVENTS) == 0;
            if ( (this->debugFlags & 2) == 0 )
              v24 = param1 == EXCEVENT_STOP_POINT;
            if ( v24 )                          // stop point (svc 0xFF) bypasses this check
            {
              KSchedulerLock::Lock(&g_schedulerLock);
              this->signalingSyncEvent = 0;
              this->exceptionEventSignaled = 0;
              this->excCtx = 0;
              this->signalingSyncEventThread->debugThread->dfar = 0;
              this->isFirstExceptionBreak = 0;
              KDebug::UnbreakCurrentProcess(this);
              KSchedulerLock::Unlock(&this->lock);
              KSchedulerLock::Unlock(&g_schedulerLock);
              return 0;
            }
            if ( !this->excCtx )
              HIDWORD(ADJ(this->signalingSyncEventThread->kernelStackTop)[-1].ctx.d[12]) = STOPPOINT_BREAKPOINT;// set lr & ask to reload user regs
skip_exception:
            KDebug::EmplaceSyncEventInfo(this);
            result = KDebug::PauseSignalingThread(this, this->signalingSyncEventThread);
            v25 = result;
            if ( result >= 0 )
            {
              switch ( type )
              {
                case DBGEVENT_ATTACH_THREAD:
                  current.clc.current.thread->debugThread->attached = STOPPOINT_BREAKPOINT;
                  break;
                case DBGEVENT_EXIT_THREAD:
                  KDebug::DetachThread(this, current.clc.current.thread);
                  break;
                case DBGEVENT_EXCEPTION:
                  v26 = this->debugFlags;
                  this->isFirstExceptionBreak = 0;
                  if ( (v26 & 1) != 0 )
                    v25 = 0x96007F9;
                  break;
              }
              result = v25;
            }
            break;
        }
      }
      return result;
  }
}
// FFF1825C: control flows out of bounds to FFF18260
// FFF182B8: control flows out of bounds to FFF182BC
// FFF18400: control flows out of bounds to FFF18404

//----- (FFF18834) --------------------------------------------------------
void __fastcall KScheduler::TrySwitchingThread(KScheduler *this)
{
  this->reschedule = 1;
  if ( !this->disableCount )
    KScheduler::SwitchThread(this, 0);
}

//----- (FFF18854) --------------------------------------------------------
Result __fastcall KDebug::BuildOrderedListOfThreads(KDebug *this)
{
  int i; // r5
  KThread *volatile thread; // r4
  KLinkedListNode *v4; // r0
  int v5; // r0
  int j; // r9
  KThread *k; // r4
  KLinkedListNode *v8; // r0
  char cfgr; // r0

  for ( i = 0; ; ++i )
  {
    v5 = (MPCORE.scu.cfgr & 3) + 1;
    if ( v5 <= i )
      break;
    thread = g_coreLocalRegions[i].clc.current.thread;
    if ( thread->owner == this->process )       // if the owner is the attached process & the thread is in the KCurrentContext, then we can safely report it's the current thread
                                                // 
                                                // Put them first in the list
    {
      v4 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
      if ( v4 )
      {
        v4->link.next = 0;
        v4->link.prev = 0;
        v4->data = 0;
      }
      v4->data = thread;
      KLinkedList::InsertAfter(
        (KLinkedList *)&this->orderedThreadListForBreak,
        (KLinkedListLink *)&this->orderedThreadListForBreak.link,
        v4);
    }
  }
  for ( j = 0; ; ++j )
  {
    cfgr = MPCORE.scu.cfgr;                     // then all the other threads, per core then per dynamic priority
    if ( (cfgr & 3) + 1 <= j )
      break;
    for ( k = KScheduler::GetNextQueuedThread(&g_coreLocalRegions[j].clc.schedulerInstance, 0);
          k;
          k = KScheduler::GetNextQueuedThread(&g_coreLocalRegions[j].clc.schedulerInstance, k) )
    {
      if ( k->owner == this->process )
      {
        v8 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
        if ( v8 )
        {
          v8->link.next = 0;
          v8->link.prev = 0;
          v8->data = 0;
        }
        v8->data = k;
        KLinkedList::InsertAfter(
          (KLinkedList *)&this->orderedThreadListForBreak,
          (KLinkedListLink *)&this->orderedThreadListForBreak.link,
          v8);
      }
    }
  }
  return 0;
}
// FFF188B4: conditional instruction was optimized away because r0.4!=0
// FFF18968: conditional instruction was optimized away because r0.4!=0

//----- (FFF189D4) --------------------------------------------------------
Result __fastcall KDebug::RequestPause(KDebug *this, KThread *thread)
{
  KThread *v3; // r1
  KThreadStackParameters *v4; // r0
  unsigned __int8 *p_dpcFlags; // r0
  unsigned __int8 v6; // r2

  v3 = (KThread *)__ldrex((unsigned int *)&g_eventSignalMutex);
  if ( v3 && v3 == thread )                     // if we hold the mutex, don't pause here
  {
    thread->debugThread->debugPauseRequested = 1;
    v4 = ADJ(thread->kernelStackTop) + 1;
    if ( v4[-1].svcId )
    {
      p_dpcFlags = &v4[-1].dpcFlags;
      do
        v6 = __ldrex(p_dpcFlags);
      while ( __strex(v6 | KDPCFLAG_DEBUG_PAUSE, p_dpcFlags) );// the check in post-svc is broken, in reality
    }
    return 0;
  }
  else
  {
    KThread::SetDebugPauseState(thread, 1);
    return 0;
  }
}

//----- (FFF18A54) --------------------------------------------------------
Result __fastcall KDebug::GetThreadVfpContext(
        KDebug *this,
        ThreadContext *outThreadContext,
        KThread *thread,
        ThreadContextControlFlags flags)
{
  unsigned int CPSR; // r4
  __int32 v6; // r5
  KThreadContext *context; // r7
  s32 v8; // r0
  char cfgr; // r1
  Result result; // r0

  CPSR = __get_CPSR();
  __disable_irq();
  v6 = flags & THREADCONTEXT_CONTROL_MAX;
  if ( (flags & THREADCONTEXT_CONTROL_FPU_REGS) != 0 )
  {
    context = thread->context;
    v8 = 0;
    cfgr = MPCORE.scu.cfgr;
    while ( (cfgr & 3) + 1 > v8 )
    {
      if ( thread == *(KThread **)(0x9000 * v8 + 0xFFFD1010) )// current thread with vfp enabled?
      {
        KVfpRegisterDumpHelper::DumpAndDisableVfpRegsForCore(v8);
        break;
      }
      ++v8;
    }
    if ( (v6 & 0x100008) != 0 )
    {
      outThreadContext->fpuRegisters.fpexc = context->fpexc | 0x40000000;// set "vfp initialized" flag
      outThreadContext->fpuRegisters.fpscr = context->fpscr;
    }
    if ( (v6 & THREADCONTEXT_CONTROL_FPU_GPRS_ALLFLAGS) != 0 )
      qmemcpy(&outThreadContext->fpuRegisters, context->d, 0x80u);
  }
  result = 0;
  __set_CPSR(CPSR);
  return result;
}

//----- (FFF18B20) --------------------------------------------------------
Result __fastcall KAutoObject::Initialize(KAutoObject *this)
{
  unsigned int *p_refcount; // r2
  unsigned int v3; // r0

  p_refcount = (unsigned int *)&this->refcount;
  do
    v3 = __ldrex(p_refcount);
  while ( __strex(v3 + 1, p_refcount) );
  if ( !this->refcount )
    kernelpanic();
  return (Result)this;
}

//----- (FFF18B58) --------------------------------------------------------
KMemoryBlock *__fastcall KMemoryBlockManager::GetMemoryBlockContainingAddr(KMemoryBlockManager *this, u32 addr)
{
  KMemoryBlockLinkedListNode *i; // r4

  for ( i = this->blocks.link.next; i != (KMemoryBlockLinkedListNode *)&this->blocks.link; i = i->link.next )
  {
    if ( KMemoryBlock::Contains(i->block, addr) )
      return i->block;
  }
  return 0;
}

//----- (FFF18B9C) --------------------------------------------------------
void __fastcall KMemoryBlockManager::DumpInfoMaybe_stubbed(KMemoryBlockManager *this)
{
  KMemoryBlockLinkedListNode *it; // r4
  KMemoryInfo v3; // [sp+0h] [bp-20h] BYREF

  for ( it = this->blocks.link.next; it != (KMemoryBlockLinkedListNode *)&this->blocks.link; it = it->link.next )
    KMemoryBlock::GetInfo(&v3, it->block);
}

//----- (FFF18BD4) --------------------------------------------------------
void __fastcall KScheduler::RemoveThread(KScheduler *this, KThread *thread, s32 prio)
{
  KScheduler *p_schedulerInstance; // r3
  KThreadIntrusiveLink *p_link; // r12
  KThread *next; // r4
  KThread *prev; // r2
  KThread *v7; // r4
  KThreadIntrusiveLink *v8; // r6

  p_schedulerInstance = &g_coreLocalRegions[thread->coreId].clc.schedulerInstance;
  p_link = &p_schedulerInstance->threadsByPrio[prio].link;
  next = p_schedulerInstance->threadsByPrio[prio].link.next;
  if ( next && next == p_link->prev )           // v4->next = first thread, ie no more threads in the list
    g_coreLocalRegions[thread->coreId].clc.schedulerInstance.prioBitfield[(unsigned int)prio >> 5] &= ~(0x80000000 >> (prio & 0x1F));
  __mcr(15, 0, 0, 7, 10, 5);
  prev = thread->link.prev;
  v7 = thread->link.next;
  if ( prev )
    v8 = &prev->link;
  else
    v8 = p_link;
  if ( v7 )
    p_link = &v7->link;
  v8->next = v7;
  p_link->prev = prev;
  --p_schedulerInstance->numThreads;
  if ( g_coreLocalRegions[p_schedulerInstance->coreId].clc.current.thread == thread )
  {
    p_schedulerInstance->reschedule = 1;
    this->triggerSgi = 1;
  }
}

//----- (FFF18C8C) --------------------------------------------------------
void __fastcall KScheduler::TriggerSgi(KScheduler *this)
{
  int v1; // r1
  char cfgr; // r2

  v1 = 0;
  this->triggerSgi = 0;
  cfgr = MPCORE.scu.cfgr;
  while ( (cfgr & 3) + 1 > v1 )
  {
    if ( this->coreId != v1 )
    {
      if ( *(_BYTE *)(0x9000 * v1 + 0xFFFD10D4) )// KCoreLocalContext.schedulerInstance.reschedule
        MPCORE.gicd.sgir = (1 << v1 << 16) & 0xFF0000 | KINTNAME_SGI_SCHEDULER;
    }
    ++v1;
  }
}

//----- (FFF18D08) --------------------------------------------------------
KDmaBlockBase *__fastcall KDmaBlockBase::KDmaBlockBase(KDmaBlockBase *this)
{
  this->prologueChild = 0;
  this->__vftable = &KDmaBlockBase::vt;
  this->bodyChild = 0;
  this->epilogueChild = 0;
  this->mainSize = 0;
  this->dstInterval = 0;
  this->srcInterval = 0;
  this->blockType = KDMABLOCKTYPE_BODY;
  this->direction = KDMADIRECTION_NONE;
  this->wfpDirection = KDMADIRECTION_NONE;
  this->notificationDirection = 0;
  this->strideDirection = 0;
  this->channelId = -1;
  this->loopDepth = 0;
  this->dmaSize.size = 0;
  this->dmaSize.dstBufferSize.pos = 0;
  this->dmaSize.dstBufferSize.minOffset = 0;
  this->dmaSize.dstBufferSize.maxOffset = 0;
  this->dmaSize.srcBufferSize.pos = 0;
  this->dmaSize.srcBufferSize.minOffset = 0;
  this->dmaSize.srcBufferSize.maxOffset = 0;
  this->numBlocks = 0;
  return this;
}

//----- (FFF18D78) --------------------------------------------------------
void SignalNewThreadEntry(void)
{
  DispatchDebugEvent(DBGEVENT_ATTACH_PROCESS, 0, 0);
}

//----- (FFF18DB0) --------------------------------------------------------
Result __fastcall DispatchDebugEvent(DebugEventType type, u32 param1, u32 param2)
{
  int debug; // r12
  KProcess *volatile process; // r2
  bool v6; // r5
  bool v7; // zf

  process = current.clc.current.process;
  if ( type == DBGEVENT_SCHEDULE_IN )
  {
    if ( !g_scheduledOut[__mrc(15, 0, 0, 0, 5) & 3] )
      return 0;
    debug = __mrc(15, 0, 0, 0, 5) & 3;
    v6 = 0;
  }
  else
  {
    if ( type != DBGEVENT_SCHEDULE_OUT )
      goto LABEL_7;
    debug = __mrc(15, 0, 0, 0, 5) & 3;
    v6 = 1;
  }
  g_scheduledOut[debug] = v6;
LABEL_7:
  v7 = process == 0;
  if ( process )
  {
    debug = (int)process->debug;
    v7 = debug == 0;
  }
  if ( !v7 )
    return KDebug::DispatchEvent((KDebug *)debug, type, param1, param2);
  return 0;
}
// FFF18E2C: variable 'debug' is possibly undefined
// FFF2F058: using guessed type bool g_scheduledOut[8];

//----- (FFF18E44) --------------------------------------------------------
void __fastcall KAutoObject::IncrementRefcount(KAutoObject *this)
{
  unsigned int *p_refcount; // r2
  unsigned int v2; // r1

  p_refcount = (unsigned int *)&this->refcount;
  do
    v2 = __ldrex(p_refcount);
  while ( __strex(v2 + 1, p_refcount) );
  if ( !this->refcount )
    kernelpanic();
}

//----- (FFF18E80) --------------------------------------------------------
KAutoObject *__fastcall KHandleTable::ConvertToAutoObject(KHandleTable *this, Handle handle)
{
  unsigned int *p_mutex; // r0
  KLightMutex *v5; // r4
  unsigned int v6; // r2
  bool v7; // zf
  KLightMutex *v8; // r0
  signed __int32 v9; // r0
  Handle v10; // r1
  bool v11; // cc
  KHandleTableEntry *v12; // r5
  KAutoObject *object; // r0
  KAutoObject *v14; // r5

  p_mutex = (unsigned int *)&this->mutex;
  v5 = (KLightMutex *)p_mutex;
  v6 = __ldrex(p_mutex);
  v7 = v6 == 0;
  if ( v6 )
    __strex(v6, p_mutex);
  else
    v6 = __strex((unsigned int)current.clc.current.thread, p_mutex);
  if ( v7 )
    v7 = v6 == 0;
  if ( !v7 )
    KLightMutex::LockImpl((KLightMutex *)p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  if ( (handle & 0xC0000000) != 0 )
  {
    v8 = v5;
    __mcr(15, 0, 0, 7, 10, 5);
    v5->lockingThread = 0;
    if ( v5->numWaiters <= 0 )
      return 0;
LABEL_10:
    KLightMutex::UnlockImpl(v8);
    return 0;
  }
  v9 = handle & 0x7FFF;
  v10 = handle >> 15;
  if ( !handle )
    goto LABEL_20;
  v11 = v10 == 0;
  if ( v10 )
    v11 = this->handleTableSize <= v9;
  if ( v11 || (v12 = &this->entries[v9], (object = v12->used.object) == 0) || LOWORD(v12->free.next) != v10 )
  {
LABEL_20:
    v8 = v5;
    __mcr(15, 0, 0, 7, 10, 5);
    v5->lockingThread = 0;
    if ( v5->numWaiters <= 0 )
      return 0;
    goto LABEL_10;
  }
  KAutoObject::IncrementRefcount(object);
  v14 = v12->used.object;
  __mcr(15, 0, 0, 7, 10, 5);
  v5->lockingThread = 0;
  if ( v5->numWaiters > 0 )
    KLightMutex::UnlockImpl(v5);
  return v14;
}

//----- (FFF18F80) --------------------------------------------------------
Result __fastcall KHandleTable::Add(KHandleTable *this, Handle *outHandle, KAutoObject *obj, u8 typeId)
{
  unsigned int *p_mutex; // r0
  KLightMutex *v9; // r5
  unsigned int v10; // r2
  bool v11; // zf
  unsigned int v12; // r3
  Result v13; // r4
  KLightMutex *v14; // r0
  KHandleTableEntry *firstFreeEntry; // r0
  unsigned int v16; // r2
  int nextId; // r1
  int v18; // r9
  int v19; // r0
  unsigned int v20; // r0

  p_mutex = (unsigned int *)&this->mutex;
  v9 = (KLightMutex *)p_mutex;
  v10 = __ldrex(p_mutex);
  v11 = v10 == 0;
  if ( v10 )
    v12 = __strex(v10, p_mutex);
  else
    v12 = __strex((unsigned int)current.clc.current.thread, p_mutex);
  if ( !v10 )
    v11 = v12 == 0;
  if ( !v11 )
    KLightMutex::LockImpl((KLightMutex *)p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  if ( this->count < this->handleTableSize )
  {
    firstFreeEntry = this->firstFreeEntry;
    this->firstFreeEntry = (KHandleTableEntry *)firstFreeEntry->used.info;
    v16 = ((char *)firstFreeEntry - (char *)this->entries) << 14;
    nextId = this->nextId;
    firstFreeEntry->used.object = obj;
    LOWORD(firstFreeEntry->free.next) = nextId;
    BYTE2(firstFreeEntry->used.info) = typeId;
    v18 = (v16 >> 17) | (nextId << 15);
    v19 = (__int16)(this->count + 1);
    this->count = v19;
    if ( this->maxCount >= v19 )
      LOWORD(v19) = this->maxCount;
    this->maxCount = v19;
    KAutoObject::IncrementRefcount(obj);
    v20 = (unsigned __int16)(this->nextId + 1);
    this->nextId = v20;
    if ( v20 >= 0x8000 )
      this->nextId = 1;
    v13 = 0;
    v14 = v9;
    *outHandle = v18;
    __mcr(15, 0, 0, 7, 10, 5);
    v9->lockingThread = 0;
    if ( v9->numWaiters > 0 )
      goto LABEL_10;
  }
  else
  {
    v13 = -664796141;
    v14 = v9;
    __mcr(15, 0, 0, 7, 10, 5);
    v9->lockingThread = 0;
    if ( v9->numWaiters > 0 )
LABEL_10:
      KLightMutex::UnlockImpl(v14);
  }
  return v13;
}

//----- (FFF190A8) --------------------------------------------------------
Result __fastcall KPageTable::CheckAddrRangeMaskedStateAndPerms(
        KPageTable *this,
        u32 addr,
        u32 size,
        KMemoryState stateMask,
        KMemoryState expectedState,
        KMemoryPermission minPerms)
{
  Result result; // r0
  u32 v11; // r1
  u32 v12[4]; // [sp+0h] [bp-40h] BYREF
  KMemoryInfo outMemoryInfo; // [sp+10h] [bp-30h] BYREF

  if ( size && addr > addr + size - 1 )
    return 0xE0A01BF5;
  while ( 1 )
  {
    result = KPageTable::QueryInfo(this, &outMemoryInfo, v12, addr);
    if ( result < 0 )
      break;
    if ( (outMemoryInfo.state & stateMask) != expectedState || (minPerms & ~outMemoryInfo.perms) != 0 )
      return 0xE0A01BF5;
    if ( outMemoryInfo.baseAddress + outMemoryInfo.size >= addr + size )
      return 0;
    v11 = outMemoryInfo.baseAddress + outMemoryInfo.size - addr;
    addr = outMemoryInfo.baseAddress + outMemoryInfo.size;
    size -= v11;
  }
  return result;
}

//----- (FFF1915C) --------------------------------------------------------
bool KDmaController::IsManagerFaulting(void)
{
  char fsrd; // r0

  fsrd = CDMA.fsrd;
  return (fsrd & 1) != 0;
}

//----- (FFF19174) --------------------------------------------------------
bool __fastcall KDmaController::IsChannelFaulting(s8 channelId)
{
  u32 fsrc; // r2

  fsrc = CDMA.fsrc;
  return (fsrc & (1 << channelId)) != 0;
}

//----- (FFF19190) --------------------------------------------------------
u32 __fastcall KDmaController::GetChannelStatus(s8 channelId)
{
  return CDMA.chan_stat[channelId].csr & 0xF;
}

//----- (FFF191A8) --------------------------------------------------------
Result __fastcall KPageTable::OperateOnGroup(
        KPageTable *this,
        u32 addr,
        KPageGroup *pgGroup,
        KMemoryState state,
        KMemoryPermission perms,
        KMemoryUpdateFlags updateFlags)
{
  int v9; // r1
  KBlockInfoLinkedListNode *next; // r4
  KBlockInfo *blockInfo; // r0

  v9 = 0x82007FF;
  next = pgGroup->list.link.next;
  while ( next != (KBlockInfoLinkedListNode *)&pgGroup->list.link )
  {
    v9 = KPageTable::Operate(
           this,
           addr,
           next->blockInfo->numPages,
           next->blockInfo->baseAddress - 0xC0000000,
           state,
           perms,
           updateFlags,
           MEMOP_REGION_BASE);
    if ( v9 < 0 )
      break;
    blockInfo = next->blockInfo;
    next = next->link.next;
    addr += blockInfo->numPages << 12;
  }
  return v9;
}

//----- (FFF1922C) --------------------------------------------------------
u32 __fastcall KMemoryManager::AllocateContiguous(
        KMemoryManager *this,
        u32 numPages,
        u32 pageAlignment,
        MemoryOperation op)
{
  unsigned int *p_mutex; // r0
  KLightMutex *v9; // r4
  unsigned int v10; // r2
  bool v11; // zf
  unsigned int v12; // r3
  unsigned int *p_kernelMemoryUsage; // r0
  unsigned int v14; // r1
  __int32 v15; // r0
  void *addr; // r6
  KLightMutex *v17; // r0

  p_mutex = (unsigned int *)&this->pgMgr.mutex;
  v9 = (KLightMutex *)p_mutex;
  v10 = __ldrex(p_mutex);
  v11 = v10 == 0;
  if ( v10 )
    v12 = __strex(v10, p_mutex);
  else
    v12 = __strex((unsigned int)current.clc.current.thread, p_mutex);
  if ( !v10 )
    v11 = v12 == 0;
  if ( !v11 )
    KLightMutex::LockImpl((KLightMutex *)p_mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  if ( op < MEMOP_NONE )
  {
    p_kernelMemoryUsage = &this->pgMgr.kernelMemoryUsage;
    do
      v14 = __ldrex(p_kernelMemoryUsage);
    while ( __strex(v14 + (numPages << 12), p_kernelMemoryUsage) );
  }
  v15 = op & 0xF00;
  if ( v15 == 256 )
  {
    addr = KPageHeap::AllocateContiguous(&this->applicationHeap, numPages, pageAlignment);
    v17 = v9;
    __mcr(15, 0, 0, 7, 10, 5);
    v9->lockingThread = 0;
    if ( v9->numWaiters <= 0 )
      return (u32)addr;
    goto LABEL_17;
  }
  if ( v15 == 512 )
  {
    addr = KPageHeap::AllocateContiguous(&this->systemHeap, numPages, pageAlignment);
    v17 = v9;
    __mcr(15, 0, 0, 7, 10, 5);
    v9->lockingThread = 0;
    if ( v9->numWaiters <= 0 )
      return (u32)addr;
    goto LABEL_17;
  }
  if ( v15 != 768 )
    kernelpanic();
  addr = KPageHeap::AllocateContiguous(&this->baseHeap, numPages, pageAlignment);
  v17 = v9;
  __mcr(15, 0, 0, 7, 10, 5);
  v9->lockingThread = 0;
  if ( v9->numWaiters > 0 )
LABEL_17:
    KLightMutex::UnlockImpl(v17);
  return (u32)addr;
}

//----- (FFF1937C) --------------------------------------------------------
void *__fastcall KPageHeap::AllocateContiguous(KPageHeap *this, u32 size, u32 pageAlignment)
{
  KPageHeapBlock *currentNode; // r4
  bool v7; // zf
  u32 misalignment; // r6
  u32 regionSize; // r0
  u32 numPages; // r8
  u32 v11; // r1
  KPageHeapBlock *next; // r6
  KPageHeapBlock *v13; // r1
  KPageHeap *v14; // r0
  u32 v15; // r1
  u32 v16; // r2
  u32 v17; // r8
  u32 v18; // r3
  int i; // lr
  int v20; // r12
  int v21; // r0
  KPageHeapBlock *j; // r4
  KPageHeapBlock *prev; // [sp+0h] [bp-30h]
  KPageHeapBlock *block; // [sp+4h] [bp-2Ch]

  currentNode = this->link.next;
  v7 = this->link.next == 0;
  if ( this->link.next )
    v7 = this->link.prev == 0;
  if ( !v7 )
    v7 = size == 0;
  if ( v7 )
    return 0;
  do
  {
    misalignment = 0;
    KPageHeap::ValidateBlock(this, currentNode);
    regionSize = this->regionSize;
    numPages = currentNode->numPages;
    if ( currentNode->numPages > regionSize >> 12
      || regionSize + this->regionStart < (unsigned int)currentNode + 4096 * numPages )
    {
      kernelpanic();
    }
    if ( pageAlignment > 1 )
    {
      v11 = ((unsigned int)currentNode >> 12) % pageAlignment;
      if ( v11 )
        misalignment = pageAlignment - v11;
    }
    if ( size + misalignment <= numPages )
    {
      block = currentNode;
      if ( misalignment )
        block = KPageHeap::SplitBlock(this, currentNode, misalignment);
      KPageHeap::SplitBlock(this, block, size);
      KPageHeap::ValidateBlock(this, block);
      prev = block->link.prev;
      next = block->link.next;
      KPageHeap::ValidateBlock(this, prev);
      KPageHeap::ValidateBlock(this, next);
      if ( prev )
      {
        prev->link.next = next;
        v13 = prev;
        v14 = this;
      }
      else
      {
        this->link.next = next;
        if ( !next )
        {
          this->link.prev = 0;
          goto LABEL_28;
        }
        v15 = this->key[0];
        v16 = this->key[1];
        v17 = this->key[2];
        v18 = this->key[3];
        for ( i = 0; i < 2; ++i )
        {
          v20 = 0;
          do
          {
            v21 = *(u32 *)((char *)&next->numPages + v20);
            v20 += 4;
            v15 -= v21 - __ROR4__(v16, 3);
            v16 -= __ROR4__(v17, (v18 & 0xF) + 3) ^ __ROR4__(v18, (v15 & 0xF) + 13);
            v17 -= __ROR4__(v18, v15) * v16;
            v18 -= __ROR4__(v15, v16) * v17;
          }
          while ( v20 < 20 );
        }
        if ( (v15 ^ v16) != next->mac )
          kernelpanic();
        this->link.next->link.prev = 0;
        v13 = this->link.next;
        v14 = this;
      }
      KPageHeap::UpdateBlockMac(v14, v13);
      if ( next )
      {
        next->link.prev = prev;
        KPageHeap::UpdateBlockMac(this, next);
LABEL_29:
        if ( block->numPages != size )
          kernelpanic();
        return block;
      }
LABEL_28:
      KPageHeap::SetLastBlock(this, prev);
      goto LABEL_29;
    }
    currentNode = currentNode->link.next;
  }
  while ( currentNode );
  for ( j = this->link.next; j; j = j->link.next )
    KPageHeap::ValidateBlock(this, j);
  return 0;
}

//----- (FFF195C0) --------------------------------------------------------
void __fastcall KPageManager::IncrefPages(KPageManager *this, u32 addr, u32 numPages)
{
  u32 v3; // r1
  unsigned int endOff; // r2
  char v5; // cc
  int v6; // r12
  int v7; // r2
  int v8; // r3
  u32 v9; // r5
  int v10; // r3
  u32 v11; // r6

  v3 = (addr - this->memoryStartAddr) >> 12;
  endOff = numPages + v3;
  v5 = (endOff != 0x7FFFFFFF) & __CFADD__(endOff, 0x80000001);// if (endOff < 0 || startOff < 0)
                                                // 
                                                // ... what?
  if ( endOff <= 0x7FFFFFFF )
    v5 = (v3 != 0x7FFFFFFF) & __CFADD__(v3, 0x80000001);
  if ( v5 )
  {
    for ( ; v3 < endOff; ++v3 )
      ++this->pageRefcounts[v3];
  }
  else
  {
    v6 = endOff - v3;
    if ( (int)(endOff - v3) > 0 )
    {
      v7 = v6 & 1;
      v8 = 0;
      if ( v7 == 1 )
      {
        v8 = 1;
        ++this->pageRefcounts[v3];
      }
      for ( ; v6 > v7; ++this->pageRefcounts[v11] )
      {
        v9 = v3 + v8;
        v10 = v8 + 1;
        v11 = v3 + v10;
        v7 += 2;
        ++this->pageRefcounts[v9];
        v8 = v10 + 1;
      }
    }
  }
}

//----- (FFF19688) --------------------------------------------------------
Result __fastcall KPageTable::SplitContiguousEntries(KPageTable *this, u32 va, u32 size)
{
  unsigned int L1Entry; // r7
  int L1EntryType; // r0
  int v7; // r0
  unsigned int v8; // r4
  u32 v9; // r1
  __int16 v10; // r0
  unsigned int v11; // r7
  unsigned int m; // r0
  int v13; // r3
  unsigned int v14; // r2
  unsigned int v15; // r2
  bool v16; // zf
  unsigned int v17; // r3
  KLevel2TranslationTable *rootNode; // r4
  unsigned int v19; // r1
  bool v20; // zf
  unsigned int v21; // r2
  unsigned int i; // r11
  KLevel2TranslationTable *v23; // r0
  KLevel2TranslationTable *v24; // r1
  __int16 v25; // r0
  unsigned int v26; // r12
  unsigned int j; // r3
  int v28; // r2
  char *v29; // r0
  int v30; // r1
  unsigned int k; // r11
  unsigned int v32; // r1
  bool v33; // zf
  int v34; // r3
  unsigned int v35; // r2
  u32 v36; // r1
  int v37; // r4
  int v38; // r0
  int v39; // r12

  L1Entry = this->L1Table[va >> 20];
  L1EntryType = L1Entry & 0x40003;
  if ( (L1Entry & 0x40003) != 1 )
  {
    if ( L1EntryType == 2 )
    {
sectionOnly:
      if ( size >= 0x100000 )
        return 0;
      v15 = __ldrex((unsigned int *)&g_level2TtblAllocator.mutex);
      v16 = v15 == 0;
      if ( v15 )
        v17 = __strex(v15, (unsigned int *)&g_level2TtblAllocator.mutex);
      else
        v17 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_level2TtblAllocator.mutex);
      if ( !v15 )
        v16 = v17 == 0;
      if ( !v16 )
        KLightMutex::LockImpl(&g_level2TtblAllocator.mutex);
      __mcr(15, 0, 0, 7, 10, 5);
      rootNode = g_level2TtblAllocator.rootNode;
      if ( g_level2TtblAllocator.rootNode )
      {
        if ( g_level2TtblAllocator.rootNode->next == g_level2TtblAllocator.rootNode )
        {
          g_level2TtblAllocator.rootNode = 0;
        }
        else
        {
          g_level2TtblAllocator.rootNode = g_level2TtblAllocator.rootNode->prev;
          rootNode->prev->next = rootNode->next;
          rootNode->next->prev = rootNode->prev;
        }
        rootNode->prev = 0;
        rootNode->next = 0;
        --g_level2TtblAllocator.numAvailable;
      }
      else
      {
        rootNode = (KLevel2TranslationTable *)KMemoryManager::AllocateContiguous(
                                                &g_memoryManager,
                                                1u,
                                                0,
                                                MEMOP_REGION_BASE_KERNEL);
        if ( !rootNode )
        {
          __mcr(15, 0, 0, 7, 10, 5);
          g_level2TtblAllocator.mutex.lockingThread = 0;
          if ( g_level2TtblAllocator.mutex.numWaiters > 0 )
            KLightMutex::UnlockImpl(&g_level2TtblAllocator.mutex);
LABEL_46:
          kernelpanic();
        }
        v19 = __ldrex((unsigned int *)&g_memoryManager.pgMgr.mutex);
        v20 = v19 == 0;
        if ( v19 )
          v21 = __strex(v19, (unsigned int *)&g_memoryManager.pgMgr.mutex);
        else
          v21 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_memoryManager.pgMgr.mutex);
        if ( !v19 )
          v20 = v21 == 0;
        if ( !v20 )
          KLightMutex::LockImpl(&g_memoryManager.pgMgr.mutex);
        __mcr(15, 0, 0, 7, 10, 5);
        KPageManager::IncrefPages(&g_memoryManager.pgMgr, (u32)rootNode, 1u);
        __mcr(15, 0, 0, 7, 10, 5);
        g_memoryManager.pgMgr.mutex.lockingThread = 0;
        if ( g_memoryManager.pgMgr.mutex.numWaiters > 0 )
          KLightMutex::UnlockImpl(&g_memoryManager.pgMgr.mutex);
        for ( i = 1; i < 4; ++i )
        {
          v23 = &rootNode[128 * i];
          if ( v23 )
          {
            v23->next = 0;
            v23->prev = 0;
          }
          v24 = g_level2TtblAllocator.rootNode;
          if ( g_level2TtblAllocator.rootNode )
          {
            v23->prev = g_level2TtblAllocator.rootNode;
            v24->next->prev = v23;
            v23->next = v24->next;
            v24->next = v23;
          }
          else
          {
            v23->prev = v23;
            v23->next = v23;
          }
          g_level2TtblAllocator.rootNode = v23;
        }
        g_level2TtblAllocator.numAvailable += 3;
      }
      __mcr(15, 0, 0, 7, 10, 5);
      g_level2TtblAllocator.mutex.lockingThread = 0;
      if ( g_level2TtblAllocator.mutex.numWaiters > 0 )
        KLightMutex::UnlockImpl(&g_level2TtblAllocator.mutex);
      if ( !rootNode )
        goto LABEL_46;
      v25 = L1Entry & 0xC | ((unsigned __int16)(L1Entry & 0x7000) >> 6) | ((L1Entry & 0x38C00) >> 6) | ((unsigned __int8)(L1Entry & 0x10) >> 4);
      v26 = ((unsigned __int16)(L1Entry & 0x7000) >> 6) & 0x30 | ((L1Entry & 0x38C00) >> 6) & 0xE30 | ((unsigned __int8)(L1Entry & 0x10) >> 4) & 0x30 | 1 | v25 & 0xC | ((v25 & 1) << 15) | ((((unsigned __int16)(L1Entry & 0x7000) >> 6) & 0x1C0 | ((L1Entry & 0x38C00) >> 6) & 0xC0 | ((unsigned __int8)(L1Entry & 0x10) >> 4) & 0xC0) << 6);
      for ( j = 0; j < 0x10; ++j )
      {
        v28 = ((L1Entry >> 20 << 20) + (j << 16)) | v26;
        v29 = (char *)rootNode + ((((va >> 20 << 20) + (j << 16)) & 0xFF000) >> 10) - 4;
        v30 = 8;
        do
        {
          *((_DWORD *)v29 + 1) = v28;
          --v30;
          *((_DWORD *)v29 + 2) = v28;
          v29 += 8;
        }
        while ( v30 );
      }
      for ( k = 0; k < 0x100; ++k )
      {
        v32 = __ldrex((unsigned int *)&g_level2TtblAllocator.mutex);
        v33 = v32 == 0;
        if ( v32 )
          __strex(v32, (unsigned int *)&g_level2TtblAllocator.mutex);
        else
          v32 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)&g_level2TtblAllocator.mutex);
        if ( v33 )
          v33 = v32 == 0;
        if ( !v33 )
          KLightMutex::LockImpl(&g_level2TtblAllocator.mutex);
        __mcr(15, 0, 0, 7, 10, 5);
        ++g_level2TtblAllocator.refcounts[((unsigned int)rootNode - g_level2TtblAllocator.baseRegionStart) >> 10];
        __mcr(15, 0, 0, 7, 10, 5);
        g_level2TtblAllocator.mutex.lockingThread = 0;
        if ( g_level2TtblAllocator.mutex.numWaiters > 0 )
          KLightMutex::UnlockImpl(&g_level2TtblAllocator.mutex);
      }
      KPageTable::CleanDataCacheRange((u32)rootNode, 0x400u);
      L1Entry = ((unsigned int)&rootNode[0x8000000] >> 10 << 10) | 1;
      this->L1Table[va >> 20] = L1Entry;
      KPageTable::CleanDataCacheRange((u32)&this->L1Table[va >> 20], 4u);
      goto LABEL_63;
    }
    v7 = L1EntryType - 262145;
    if ( v7 )
    {
      if ( v7 != 1 || size >= 0x1000000 )
        return 0;
      v8 = L1Entry & 0xFF000000;
      v9 = va & 0xFF000000;
      v10 = L1Entry & 0xC | ((unsigned __int16)(L1Entry & 0x7000) >> 6) | ((L1Entry & 0x38C00) >> 6) | ((unsigned __int8)(L1Entry & 0x10) >> 4);
      v11 = v10 & 0xC | 2 | ((((unsigned __int16)(L1Entry & 0x7000) >> 6) & 0xFF0 | ((L1Entry & 0x38C00) >> 6) & 0xFF0 | ((unsigned __int8)(L1Entry & 0x10) >> 4) & 0xF0) << 6) | (16 * (v10 & 1));
      for ( m = 0; m < 0x10; ++m )
      {
        v13 = (v8 + (m << 20)) | v11;
        v14 = (v9 + (m << 20)) >> 20;
        this->L1Table[v14] = v13;
      }
      KPageTable::CleanDataCacheRange((u32)&this->L1Table[v9 >> 20], 0x40u);
      L1Entry = v11 | va & 0xF00000 | v8;
      goto sectionOnly;
    }
  }
LABEL_63:
  if ( size < 0x10000 )
  {
    v34 = (L1Entry >> 10 << 10) - 0x40000000;
    if ( (*(_DWORD *)(v34 + ((va & 0xFF000) >> 10)) & 3) == 1 )
    {
      v35 = *(_DWORD *)(v34 + ((va & 0xFF000) >> 10)) & 0xE3C | ((*(_DWORD *)(v34 + ((va & 0xFF000) >> 10)) & 0x7000u) >> 6) | ((*(_DWORD *)(v34 + ((va & 0xFF000) >> 10)) & 0x8000u) >> 15) | 2;
      v36 = HIWORD(va) << 16;
      v37 = HIWORD(*(_DWORD *)(v34 + ((va & 0xFF000) >> 10))) << 16;
      v38 = 0;
      v39 = 16;
      do
      {
        *(_DWORD *)(v34 + (((v36 + (v38 << 12)) & 0xFF000) >> 10)) = (v37 + (v38 << 12)) | v35;
        --v39;
        ++v38;
      }
      while ( v39 );
      KPageTable::CleanDataCacheRange(v34 + ((v36 & 0xFF000) >> 10), 0x40u);
    }
  }
  return 0;
}

//----- (FFF19B3C) --------------------------------------------------------
void __fastcall KPageTable::InvalidateAllTlbEntries(KPageTable *this)
{
  KTlbMaintenanceHelper *v1; // r9
  int coreId; // r12
  int i; // r1
  KTlbMaintenanceHelperImpl *v4; // r5
  unsigned __int8 *p_op; // r2
  unsigned __int8 v6; // r6
  int v7; // r2
  KTlbMaintenanceHelperImpl *v8; // r5
  unsigned __int8 *v9; // r2
  unsigned __int8 v10; // r6
  int v11; // r2

  coreId = __mrc(15, 0, 0, 0, 5) & 3;
  if ( !this->isKernel )
    v1 = &g_tlbMaintenanceHelper;
  i = 0;
  if ( this->isKernel )
  {
    while ( 1 )
    {
      v7 = (MPCORE.scu.cfgr & 3) + 1;
      if ( v7 <= i )
        break;
      if ( i != coreId )
      {
        v4 = &g_tlbMaintenanceHelper.impls[i];
        while ( 1 )
        {
          while ( v4->op )
            ;
          __disable_irq();
          p_op = (unsigned __int8 *)&v4->op;
          v6 = __ldrex((unsigned __int8 *)&v4->op);
          if ( v6 )
          {
            __strex(v6, p_op);
          }
          else if ( !__strex(KTLBMAINTOP_INV_ENTIRE_TLB, p_op) )
          {
            v4->pgTable = this;
            __mcr(15, 0, 0, 7, 10, 5);
            MPCORE.gicd.sgir = (1 << i << 16) & 0xFF0000 | 0xA;
            __enable_irq();
            break;
          }
          __enable_irq();
        }
      }
      ++i;
    }
    __mcr(15, 0, 0, 8, 7, 0);
    __mcr(15, 0, 0, 7, 10, 4);
  }
  else
  {
    while ( 1 )
    {
      v11 = (MPCORE.scu.cfgr & 3) + 1;
      if ( v11 <= i )                           // user
        break;
      LOBYTE(this->tlbNeedsInvalidating[i]) = 1;// we can postpone the invalidation of TLB of processes that are not currently running
      if ( v1->currentProcPageTables[i] == this && i != coreId )// if we're the current process
      {
        v8 = &g_tlbMaintenanceHelper.impls[i];
        while ( 1 )
        {
          while ( v8->op )
            ;
          __disable_irq();
          v9 = (unsigned __int8 *)&v8->op;
          v10 = __ldrex((unsigned __int8 *)&v8->op);
          if ( v10 )
          {
            __strex(v10, v9);
          }
          else if ( !__strex(KTLBMAINTOP_INV_ON_ASID_MATCH, v9) )
          {
            g_tlbMaintenanceHelper.impls[i].pgTable = this;
            __mcr(15, 0, 0, 7, 10, 5);
            MPCORE.gicd.sgir = (1 << i << 16) & 0xFF0000 | KINTNAME_SGI_TLB_MAINTENANCE;
            __enable_irq();
            break;
          }
          __enable_irq();
        }
      }
      ++i;
    }
    if ( v1->currentProcPageTables[coreId] == this )
    {                                           // if we're the current process and this is the current core
      LOBYTE(this->tlbNeedsInvalidating[coreId]) = 0;
      __mcr(15, 0, this->asid, 8, 7, 2);
      __mcr(15, 0, 0, 7, 5, 6);
      __mcr(15, 0, 0, 7, 10, 4);
      __mcr(15, 0, 0, 7, 5, 4);
    }
  }
}
// FFF19C18: variable 'v1' is possibly undefined

//----- (FFF19CF4) --------------------------------------------------------
KMemoryInfo *__fastcall KMemoryBlock::GetInfo(KMemoryInfo *result, KMemoryBlock *this)
{
  u32 baseAddr; // r2
  u32 numPages; // r3
  KMemoryPermission perms; // r12

  baseAddr = this->baseAddr;
  numPages = this->numPages;
  perms = this->perms;
  result->state = this->state;
  result->baseAddress = baseAddr;
  result->size = numPages << 12;
  result->perms = perms;
  return result;
}

//----- (FFF19D0C) --------------------------------------------------------
void __fastcall KVfpRegisterDumpHelper::DumpAndDisableVfpRegsForCore(s32 coreId)
{
  KCoreLocalContext *p_clc; // r4
  unsigned int *p_threadWithVfp; // r4
  KThread *volatile v3; // r5
  KThread *volatile threadWithVfp; // t1
  KVfpRegisterDumpHelperImpl *v5; // r1

  p_clc = &g_coreLocalRegions[coreId].clc;
  threadWithVfp = p_clc->current.threadWithVfp;
  p_threadWithVfp = (unsigned int *)&p_clc->current.threadWithVfp;
  v3 = threadWithVfp;
  if ( threadWithVfp )
  {
    if ( (__mrc(15, 0, 0, 0, 5) & 3) == coreId )
    {
      KThreadContext::EnableCurrentThreadVfp();
      KThreadContext::StoreVfpRegsAndDisable(v3->context);
      KThreadContext::DisableCurrentThreadVfp();
      do
        __ldrex(p_threadWithVfp);
      while ( __strex(0, p_threadWithVfp) );
    }
    else
    {
      v5 = &g_vfpRegisterDumpHelper.impls[coreId];
      v5->threadToDumpTo = v3;
      __mcr(15, 0, 0, 7, 10, 5);
      MPCORE.gicd.sgir = (1 << coreId << 16) & 0xFF0000 | KINTNAME_SGI_DUMP_VFP_REGS;
      while ( v5->threadToDumpTo )
        __yield();
    }
  }
}

//----- (FFF19DCC) --------------------------------------------------------
void __fastcall KDebug::RequestReschedulingForDebugger(KDebug *this, s32 coreId)
{
  unsigned int CPSR; // r4

  KSchedulerLock::Lock(&g_schedulerLock);
  if ( (__mrc(15, 0, 0, 0, 5) & 3) == coreId )
  {
    CPSR = __get_CPSR();
    __disable_irq();
    KScheduler::TrySwitchingThread(current.clc.current.scheduler);
    __set_CPSR(CPSR);
  }
  else
  {
    g_coreLocalRegions[coreId].clc.schedulerInstance.reschedule = 1;
    current.clc.current.scheduler->triggerSgi = 1;
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
}

//----- (FFF19E38) --------------------------------------------------------
Result __fastcall KDebug::EmplaceAysncEventInfo(
        KDebug *this,
        DebugEventType type,
        BOOL needsToBeContinued,
        u32 param1,
        u32 param2,
        u32 param3,
        u32 param4,
        u32 param5,
        u32 param6)
{
  KEventInfo *info; // r0
  KEventInfo *v11; // r4
  Result result; // r0
  KLinkedListNode *v13; // r0
  KLinkedListNode *v14; // r0

  info = (KEventInfo *)KSlabHeap::Allocate(&g_eventInfoSlabHeap);
  v11 = info;
  if ( info )
  {
    info->isAttachEvent = 0;
    info->needsToBeContinued = 0;
    info->ignoreContinue = 0;
  }
  result = KDebug::InitalizeAsyncEventInfo(this, type, info, param1, param2, param3, param4, param5, param6);
  if ( result >= 0 )
  {
    KSchedulerLock::Lock(&g_schedulerLock);
    v13 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
    if ( v13 )
    {
      v13->link.next = 0;
      v13->link.prev = 0;
      v13->data = 0;
    }
    v13->data = v11;
    KLinkedList::InsertAfter((KLinkedList *)&this->eventsToFetch, (KLinkedListLink *)&this->eventsToFetch.link, v13);
    KSchedulerLock::Unlock(&g_schedulerLock);
    if ( (v11->flags & 1) != 0 )
      ++this->numBlockingEvents;
    result = needsToBeContinued;
    if ( needsToBeContinued )
    {
      v11->needsToBeContinued = 1;
      v11->isProcessed = 0;
      KSchedulerLock::Lock(&g_schedulerLock);
      v14 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
      if ( v14 )
      {
        v14->link.next = 0;
        v14->link.prev = 0;
        v14->data = 0;
      }
      v14->data = v11;
      KLinkedList::InsertAfter(
        (KLinkedList *)&this->eventsToContinue,
        (KLinkedListLink *)&this->eventsToContinue.link,
        v14);
      KSchedulerLock::Unlock(&g_schedulerLock);
      return 0;
    }
  }
  return result;
}
// FFF19E70: conditional instruction was optimized away because r0.4!=0
// FFF19EDC: conditional instruction was optimized away because r0.4!=0
// FFF19F84: conditional instruction was optimized away because r0.4!=0

//----- (FFF19FCC) --------------------------------------------------------
Result __fastcall KDebug::BreakCurrentProcess(KDebug *this, KThread *thread)
{
  int pausingCurrentThreads; // r7
  KDebugThreadLinkedListNode *node; // r4
  KDebugThread *breakThread; // r2
  KThread *v7; // r1
  bool v8; // zf
  KDebugThreadLinkedListNode *i; // r4
  KThread *v10; // r1
  KDebugThread *debugThread; // r0

  KSchedulerLock::Lock(&g_schedulerLock);
  pausingCurrentThreads = 0;
  this->breakThread = thread;
  KDebug::BuildOrderedListOfThreads(this);
  for ( node = this->debugThreads.link.next;
        node != (KDebugThreadLinkedListNode *)&this->debugThreads.link;
        node = node->link.next )
  {
    breakThread = (KDebugThread *)this->breakThread;
    v7 = node->debugThread->thread;
    v8 = breakThread == (KDebugThread *)v7;
    if ( breakThread != (KDebugThread *)v7 )    // not attached or not the break thread
    {
      breakThread = v7->debugThread;
      v8 = breakThread == 0;
    }
    if ( !v8 )
    {
      if ( *(KThread **)(0x9000 * v7->coreId + 0xFFFD1000) == v7 )// don't pause the current threads now
      {
        pausingCurrentThreads = 1;
      }
      else
      {
        breakThread->debugBreakPauseRequested = 1;
        KDebug::RequestPause(this, v7);
      }
    }
  }
  if ( pausingCurrentThreads )                  // pause them now
  {
    for ( i = this->debugThreads.link.next; i != (KDebugThreadLinkedListNode *)&this->debugThreads.link; i = i->link.next )
    {
      v10 = i->debugThread->thread;
      if ( (v10->schedulingMask & 0x80) == 0 && this->breakThread != v10 )
      {
        debugThread = v10->debugThread;
        if ( debugThread )
        {
          debugThread->debugBreakPauseRequested = 1;
          KDebug::RequestPause(this, v10);
        }
      }
    }
    KScheduler::TriggerSgi(current.clc.current.scheduler);
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
  return 0;
}

//----- (FFF1A0E8) --------------------------------------------------------
Result __fastcall KDebug::UnbreakCurrentProcess(KDebug *this)
{
  KDebug *node; // r4
  KThread *count; // r0
  KDebugThread *debugThread; // r1
  bool v5; // zf
  KThreadLinkedListNode *v6; // r10
  KLinkedListLink *v7; // r0
  KLinkedListLink *v8; // r8
  KDebugThreadLinkedListNode *i; // r4
  KThread *thread; // r0
  KDebugThread *schedulingMask; // r1
  bool v12; // zf
  KDebugThreadLinkedListNode *j; // r0
  KDebugThread *v14; // r1
  bool v15; // zf
  KThreadLinkedListNode *next; // [sp+0h] [bp-28h] BYREF

  KSchedulerLock::Lock(&g_schedulerLock);
  if ( this->breakThread )
  {
    for ( node = (KDebug *)this->orderedThreadListForBreak.link.next;
          node != (KDebug *)&this->orderedThreadListForBreak.link;
          node = (KDebug *)node->KSynchronizationObject::KAutoObject::__vftable )
    {
      count = (KThread *)node->waiters.count;
      debugThread = count->debugThread;
      v5 = debugThread == 0;
      if ( debugThread )
        v5 = !debugThread->debugBreakPauseRequested;
      if ( !v5 )
      {
        debugThread->debugBreakPauseRequested = 0;
        count->debugThread->debugPauseRequested = 0;
        KThread::SetDebugPauseState(count, 0);
      }
    }
    next = this->orderedThreadListForBreak.link.next;
    if ( next != (KThreadLinkedListNode *)&this->orderedThreadListForBreak.link )
    {
      do
      {
        v6 = next;
        KLinkedList::EraseNode((KLinkedList *)&this->orderedThreadListForBreak, (KLinkedListLink **)&next);
        v8 = v7;
        KSlabHeap::Free(&g_linkedListNodeSlabHeap, v6);
        next = (KThreadLinkedListNode *)v8;
      }
      while ( v8 != (KLinkedListLink *)&this->orderedThreadListForBreak.link );
    }
    for ( i = this->debugThreads.link.next; i != (KDebugThreadLinkedListNode *)&this->debugThreads.link; i = i->link.next )// also inspect new threads
    {
      thread = i->debugThread->thread;
      schedulingMask = (KDebugThread *)thread->schedulingMask;
      v12 = (unsigned __int8)((unsigned __int8)schedulingMask & KTHREADSCHEDSTAT_DEBUG_PAUSE_FLAG) == 0;
      if ( ((unsigned __int8)schedulingMask & (unsigned __int8)KTHREADSCHEDSTAT_DEBUG_PAUSE_FLAG) != 0 )
      {
        schedulingMask = thread->debugThread;
        v12 = schedulingMask == 0;
      }
      if ( !v12 )
        v12 = !schedulingMask->debugBreakPauseRequested;
      if ( !v12 )
      {
        schedulingMask->debugPauseRequested = 0;
        KThread::SetDebugPauseState(thread, 0);
      }
    }
    for ( j = this->debugThreads.link.next; j != (KDebugThreadLinkedListNode *)&this->debugThreads.link; j = j->link.next )
    {
      v14 = j->debugThread->thread->debugThread;
      v15 = v14 == 0;
      if ( v14 )
        v15 = !v14->debugBreakPauseRequested;
      if ( !v15 )
        v14->debugBreakPauseRequested = 0;
    }
    this->breakThread = 0;
  }
  KSchedulerLock::Unlock(&g_schedulerLock);
  return 0;
}
// FFF1A184: variable 'v7' is possibly undefined

//----- (FFF1A254) --------------------------------------------------------
Result __fastcall KThread::SetPriority(KThread *this, s32 priority)
{
  KMutexIntrusiveLinkPtr p_link; // r0
  s32 basePriority; // r0
  s32 dynamicPriority; // r2
  KMutexLinkedListNode *node; // r4
  KMutexLinkedListLink *v9; // r5
  KMutexLinkedListNode *next; // t1

  KSchedulerLock::Lock(&g_schedulerLock);
  if ( (unsigned int)priority < 0x40 )
  {
    if ( this->priorityToRestoreAfterSleep == -1 )
    {
      this->basePriority = priority;
      p_link = &ADJ(this->heldMutexListRootNode)->link;// thread is holding 1 or more KMutex
      if ( p_link )
        basePriority = ADJ(p_link)->priority;
      else
        basePriority = 63;
      dynamicPriority = this->dynamicPriority;
      if ( this->basePriority <= basePriority )
        basePriority = this->basePriority;
      if ( dynamicPriority != basePriority )
      {
        this->dynamicPriority = basePriority;
        KScheduler::AdjustThreadPriorityChanged(current.clc.current.scheduler, this, dynamicPriority);
      }
      next = this->mutexTryingToAcquireList.link.next;
      v9 = &this->mutexTryingToAcquireList.link;
      for ( node = next; node != (KMutexLinkedListNode *)v9; node = node->link.next )
        KMutex::RecalculatePriority(node->mutex);
    }
    else
    {
      this->priorityToRestoreAfterSleep = priority;
    }
    KSchedulerLock::Unlock(&g_schedulerLock);
    return 0;
  }
  else
  {
    KSchedulerLock::Unlock(&g_schedulerLock);
    return 0xD8E007FD;
  }
}

//----- (FFF1A318) --------------------------------------------------------
s32 __fastcall KResourceLimit::GetLimitValue(KResourceLimit *this, ResourceLimitType type)
{
  return this->limitValues[type];
}

//----- (FFF1A324) --------------------------------------------------------
s32 __fastcall KDmaAddress::GetPhysicalChunkSize(KDmaAddress *this, s32 size)
{
  u32 currentPa; // r9
  s32 chunkSize; // r8
  KProcess *process; // r1
  u32 currentVa; // r6
  KProcessPageTable *p_pgTable; // r4
  unsigned int v8; // r2
  bool v9; // zf
  unsigned int v11; // r2
  bool v12; // zf
  int v13; // r5
  u32 v14; // r0
  KProcessPageTable *pgTable; // [sp+0h] [bp-40h]
  KTranslationTableTraversalContext v16; // [sp+8h] [bp-38h] BYREF
  KTranslationTableIterator it; // [sp+10h] [bp-30h] BYREF
  KTranslationTableIterator node; // [sp+18h] [bp-28h]
  int v19; // [sp+20h] [bp-20h]

  chunkSize = 0;
  if ( this->isDevice || !size )                // "device" bypass checks again
    return size;
  currentVa = this->currentVa;
  if ( size <= 0 )
    currentPa = this->currentPa;
  process = this->process;
  p_pgTable = &process->pgTable;
  if ( size <= 0 )
  {
    while ( 1 )
    {
      v13 = ((currentPa - 1) & 0xFFF) + 1;
      chunkSize -= v13;
      if ( size >= chunkSize )
        break;
      v14 = KPageTable::ConvertVaToPa(&p_pgTable->L1Table, currentVa + chunkSize);
      if ( currentPa - v13 != v14 )
        return chunkSize;
      currentPa = v14;
    }
    return size;
  }
  else
  {
    v19 = 0;
    pgTable = &process->pgTable;
    v8 = __ldrex((unsigned int *)p_pgTable);
    v9 = v8 == 0;
    if ( v8 )
      __strex(v8, (unsigned int *)p_pgTable);
    else
      v8 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)p_pgTable);
    if ( v9 )
      v9 = v8 == 0;
    if ( !v9 )
      KLightMutex::LockImpl(&p_pgTable->mutex);
    __mcr(15, 0, 0, 7, 10, 5);
    KTranslationTableIterator::CreateFromEntry(&p_pgTable->L1Table, &it, &v16, currentVa);
    __mcr(15, 0, 0, 7, 10, 5);
    p_pgTable->mutex.lockingThread = 0;
    if ( p_pgTable->mutex.numWaiters > 0 )
      KLightMutex::UnlockImpl(&p_pgTable->mutex);
    node.size = 0;
    if ( !it.pa )
      return 0;
    it.size -= (it.size - 1) & currentVa;
    for ( node = it; node.size + v19 < size; node.size += it.size )
    {
      v11 = __ldrex((unsigned int *)pgTable);
      v12 = v11 == 0;
      if ( v11 )
        __strex(v11, (unsigned int *)pgTable);
      else
        v11 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)pgTable);
      if ( v12 )
        v12 = v11 == 0;
      if ( !v12 )
        KLightMutex::LockImpl(&pgTable->mutex);
      __mcr(15, 0, 0, 7, 10, 5);
      KTranslationTableIterator::Advance(&pgTable->L1Table, &it, &v16);
      __mcr(15, 0, 0, 7, 10, 5);
      pgTable->mutex.lockingThread = 0;
      if ( pgTable->mutex.numWaiters > 0 )
        KLightMutex::UnlockImpl(&pgTable->mutex);
      if ( !it.pa )
      {
        v19 = 0;
        return node.size;
      }
      if ( node.pa + node.size != it.pa )
        return node.size;
    }
    if ( v19 != size )
      node.size = size - v19;
    return node.size;
  }
}
// FFF1A3F8: conditional instruction was optimized away because %var_3C.4>=1
// FFF1A4E4: variable 'currentPa' is possibly undefined

//----- (FFF1A530) --------------------------------------------------------
void __fastcall KPageGroup::AddRange(KPageGroup *this, u32 addr, u32 numPages)
{
  bool v6; // zf
  KBlockInfo *blockInfo; // r0
  u32 v8; // r1
  KBlockInfo *v9; // r4
  KLinkedListNode *v10; // r0

  KSchedulerLock::Lock(&g_schedulerLock);
  v6 = numPages == 0;
  if ( numPages )
    v6 = addr + (numPages << 12) == 0;
  if ( v6 )
    goto LABEL_9;
  if ( this->list.count )
  {
    blockInfo = this->list.link.prev->blockInfo;// coaelse with last, otherwise append
    v8 = blockInfo->numPages;
    if ( blockInfo->baseAddress + (v8 << 12) == addr )
    {
      if ( addr )
      {
        blockInfo->numPages = v8 + numPages;
LABEL_9:
        KSchedulerLock::Unlock(&g_schedulerLock);
        return;
      }
    }
  }
  v9 = (KBlockInfo *)KSlabHeap::Allocate(&g_blockInfoSlabHeap);
  v9->numPages = numPages;
  v9->baseAddress = addr;
  v10 = (KLinkedListNode *)KSlabHeap::Allocate(&g_linkedListNodeSlabHeap);
  if ( v10 )
  {
    v10->link.next = 0;
    v10->link.prev = 0;
    v10->data = 0;
  }
  v10->data = v9;
  KLinkedList::InsertAfter((KLinkedList *)this, (KLinkedListLink *)&this->list.link, v10);
  KSchedulerLock::Unlock(&g_schedulerLock);
}
// FFF1A5F0: conditional instruction was optimized away because r0.4!=0

//----- (FFF1A62C) --------------------------------------------------------
Result __fastcall KPageTable::QueryInfo(KPageTable *this, KMemoryInfo *outMemoryInfo, u32 *pageInfo, u32 addr)
{
  unsigned int v8; // r2
  bool v9; // zf
  unsigned int v10; // r3
  KMemoryBlock *MemoryBlockContainingAddr; // r0
  bool v12; // zf
  u32 size; // r1
  KMemoryPermission perms; // r2
  KMemoryState state; // r3
  Result v16; // r5
  KMemoryInfo v18; // [sp+0h] [bp-30h] BYREF

  v8 = __ldrex((unsigned int *)this);
  v9 = v8 == 0;
  if ( v8 )
    v10 = __strex(v8, (unsigned int *)this);
  else
    v10 = __strex((unsigned int)current.clc.current.thread, (unsigned int *)this);
  if ( !v8 )
    v9 = v10 == 0;
  if ( !v9 )
    KLightMutex::LockImpl(&this->mutex);
  __mcr(15, 0, 0, 7, 10, 5);
  MemoryBlockContainingAddr = KMemoryBlockManager::GetMemoryBlockContainingAddr(&this->memoryBlockMgr, addr);
  v12 = outMemoryInfo == 0;
  if ( outMemoryInfo )
    v12 = MemoryBlockContainingAddr == 0;
  if ( v12 )
  {
    KMemoryBlockManager::DumpInfoMaybe_stubbed(&this->memoryBlockMgr);
    v16 = 0xE0E01BF5;
  }
  else
  {
    KMemoryBlock::GetInfo(&v18, MemoryBlockContainingAddr);
    size = v18.size;
    perms = v18.perms;
    state = v18.state;
    outMemoryInfo->baseAddress = v18.baseAddress;
    outMemoryInfo->size = size;
    outMemoryInfo->perms = perms;
    outMemoryInfo->state = state;
    v16 = 0;
    *pageInfo = 0;
  }
  __mcr(15, 0, 0, 7, 10, 5);
  this->mutex.lockingThread = 0;
  if ( this->mutex.numWaiters > 0 )
    KLightMutex::UnlockImpl(&this->mutex);
  return v16;
}

//----- (FFF1A6E0) --------------------------------------------------------
void __fastcall KScheduler::AddThread(KScheduler *this, KThread *thread)
{
  int coreId; // r5
  s32 prio; // r3
  KScheduler *sched; // r2
  KThreadIntrusiveLink *p_link; // r12
  KThread *prev; // r4
  BOOL v7; // r7
  KThreadIntrusiveLink *v8; // r8
  int v9; // r12
  int v10; // r3

  coreId = this->coreId;                        // next = first, prev = last
  prio = thread->dynamicPriority;
  sched = &g_coreLocalRegions[thread->coreId].clc.schedulerInstance;
  p_link = &sched->threadsByPrio[prio].link;
  prev = p_link->prev;
  v7 = sched->threadsByPrio[prio].link.next == 0;
  if ( p_link->prev )
    v8 = &prev->link;
  else
    v8 = &sched->threadsByPrio[prio].link;
  thread->link.prev = prev;
  thread->link.next = 0;
  v8->next = thread;
  p_link->prev = thread;
  __mcr(15, 0, 0, 7, 10, 5);
  if ( v7 )
    sched->prioBitfield[(unsigned int)prio >> 5] |= 0x80000000 >> (prio & 0x1F);
  v9 = sched->coreId;
  ++sched->numThreads;
  if ( v9 != coreId || current.clc.current.thread->dynamicPriority > prio )
  {
    v10 = sched->coreId;
    sched->reschedule = 1;
    if ( v10 != coreId )
      this->triggerSgi = 1;
  }
}

//----- (FFF1A7B4) --------------------------------------------------------
void __fastcall KScheduler::RescheduleByForce(KScheduler *this, KThread *forcedThread)
{
  this->reschedule = 1;
  KScheduler::SwitchThread(this, forcedThread);
}

//----- (FFF1A7C0) --------------------------------------------------------
void __fastcall KScheduler::SwitchThread(KScheduler *this, KThread *forcedThread)
{
  int v2; // r4
  int v3; // r5
  int v4; // r6
  int v5; // r7
  int v6; // r8
  int v7; // r9
  int v8; // r10
  int v9; // r11
  int v10; // lr
  _DWORD *v11; // r2
  KThreadContext *v17; // r0
  KScheduler *v18; // r2
  KScheduler *v19; // [sp-8h] [bp-8h]
  int v20; // [sp+0h] [bp+0h] BYREF

  if ( this->reschedule )
  {
    this->reschedule = 0;
    this->disableCount = 1;
    __enable_irq();
    v11 = (_DWORD *)(((((unsigned int)&v20 >> 12) + 1) << 12) - 176);
    *v11 = v2;
    v11[1] = v3;
    v11[2] = v4;
    v11[3] = v5;
    v11[4] = v6;
    v11[5] = v7;
    v11[6] = v8;
    v11[7] = v9;
    v11[8] = &v20;
    v11[9] = v10;
    __asm { VMRS            R3, FPEXC }
    v11[42] = _R3;
    v19 = this;
    while ( 1 )
    {
      v17 = KScheduler::Reschedule(this, forcedThread);
      v18 = v19;
      if ( v17 )
        KThreadContext::Load(v17);
      __disable_irq();
      if ( !v18->reschedule )
        break;
      v18->reschedule = 0;
      __enable_irq();
      v19 = v18;
      this = v18;
      forcedThread = 0;
    }
    v18->disableCount = 0;
  }
}
// FFF1A7EC: variable 'v2' is possibly undefined
// FFF1A7EC: variable 'v3' is possibly undefined
// FFF1A7EC: variable 'v4' is possibly undefined
// FFF1A7EC: variable 'v5' is possibly undefined
// FFF1A7EC: variable 'v6' is possibly undefined
// FFF1A7EC: variable 'v7' is possibly undefined
// FFF1A7EC: variable 'v8' is possibly undefined
// FFF1A7EC: variable 'v9' is possibly undefined
// FFF1A7EC: variable 'v10' is possibly undefined
// FFF1A810: variable 'v18' is possibly undefined

//----- (FFF1A83C) --------------------------------------------------------
Result __fastcall KPageTable::CopyMemoryInterprocessForIpc(
        KPageTable *this,
        u32 dstAddr,
        KPageTable *srcPgTbl,
        u32 srcAddr,
        u32 size)
{
  int v7; // r6
  bool v8; // zf
  KCopyMemoryForIpcHelper *p_srcHelper; // r4
  u32 v11; // r2
  u32 v12; // r0
  KTranslationTableIterator v13; // [sp+0h] [bp-50h] BYREF
  KCopyMemoryForIpcHelper srcHelper; // [sp+Ch] [bp-44h] BYREF
  KTranslationTableIterator ttblIterator; // [sp+20h] [bp-30h] BYREF
  KCopyMemoryForIpcHelper dstHelper; // [sp+28h] [bp-28h] BYREF

  dstHelper.pgTblPtr = this;
  KTranslationTableIterator::CreateFromEntry(&this->L1Table, &v13, &dstHelper.traversalContext, dstAddr);
  dstHelper.pa = v13.pa;
  dstHelper.size = v13.size - ((v13.size - 1) & v13.pa);
  srcHelper.pgTblPtr = srcPgTbl;
  KTranslationTableIterator::CreateFromEntry(&srcPgTbl->L1Table, &v13, &srcHelper.traversalContext, srcAddr);
  v7 = 0;
  srcHelper.pa = v13.pa;
  srcHelper.size = v13.size - (v13.pa & (v13.size - 1));
  v8 = dstHelper.pa == 0;
  if ( dstHelper.pa )
    v8 = srcHelper.pa == 0;
  if ( v8 )
  {
    if ( size )
      return 0xE0A01BF5;
    else
      return 0;
  }
  else
  {
    while ( 1 )
    {
      if ( dstHelper.size > srcHelper.size )
        p_srcHelper = &srcHelper;
      else
        p_srcHelper = &dstHelper;
      if ( dstHelper.size <= srcHelper.size )
        srcAddr = (u32)&srcHelper;
      if ( dstHelper.size > srcHelper.size )
        srcAddr = (u32)&dstHelper;
      if ( p_srcHelper->size + v7 >= size )
        break;
      KTranslationTableIterator::Advance(&p_srcHelper->pgTblPtr->L1Table, &ttblIterator, &p_srcHelper->traversalContext);
      v11 = p_srcHelper->size;
      if ( p_srcHelper->pa + v11 == ttblIterator.pa )
      {
        p_srcHelper->size = ttblIterator.size + v11;
      }
      else
      {
        memcpy((void *)(dstHelper.pa + 0xC0000000), (const void *)(srcHelper.pa + 0xC0000000), v11);
        v12 = p_srcHelper->size;
        *(_DWORD *)(srcAddr + 12) += v12;
        v7 += v12;
        *(_DWORD *)(srcAddr + 16) -= p_srcHelper->size;
        *(KTranslationTableIterator *)&p_srcHelper->pa = ttblIterator;
      }
    }
    memcpy((void *)(dstHelper.pa + 0xC0000000), (const void *)(srcHelper.pa + 0xC0000000), size - v7);
    return 0;
  }
}

//----- (FFF1A9CC) --------------------------------------------------------
void *__fastcall memcpy(void *dst, const void *src, u32 size)
{
  int v3; // r3
  unsigned int v4; // r12
  char v5; // r3
  char v6; // t1
  bool v7; // cf
  bool v8; // cc
  u32 v9; // r2
  char v10; // t1
  char v11; // t1
  bool v12; // cf
  u32 v13; // r2
  int *v14; // r1
  int v15; // t1
  int v16; // t1
  int v17; // t1
  bool v18; // cf
  bool v19; // nf
  signed __int32 v20; // r2
  char *v21; // r1
  char v22; // t1
  char v23; // t1
  char *v24; // r0

  if ( size > 3 )
  {
    v4 = (unsigned __int8)dst & 3;
    if ( ((unsigned __int8)dst & 3) != 0 )
    {
      v6 = *(_BYTE *)src;
      src = (char *)src + 1;
      v5 = v6;
      v7 = v4 >= 2;
      v8 = v4 > 2;
      v9 = size + v4;
      if ( ((unsigned __int8)dst & 3) != 3 )
      {
        v10 = *(_BYTE *)src;
        src = (char *)src + 1;
        LOBYTE(v4) = v10;
      }
      *(_BYTE *)dst = v5;
      dst = (char *)dst + 1;
      if ( !v7 )
      {
        v11 = *(_BYTE *)src;
        src = (char *)src + 1;
        v5 = v11;
      }
      if ( !v8 )
      {
        *(_BYTE *)dst = v4;
        dst = (char *)dst + 1;
      }
      size = v9 - 4;
      if ( !v7 )
      {
        *(_BYTE *)dst = v5;
        dst = (char *)dst + 1;
      }
    }
    LOBYTE(v3) = (unsigned __int8)src & 3;
    if ( ((unsigned __int8)src & 3) == 0 )
      return qmemcpy(dst, src, size);
    v12 = size >= 8;
    v13 = size - 8;
    while ( v12 )
    {
      v15 = *(_DWORD *)src;
      v14 = (int *)((char *)src + 4);
      v3 = v15;
      v12 = v13 >= 8;
      v13 -= 8;
      v16 = *v14;
      src = v14 + 1;
      LOBYTE(v4) = v16;
      *(_DWORD *)dst = v3;
      *((_DWORD *)dst + 1) = v16;
      dst = (char *)dst + 8;
    }
    size = v13 + 4;
    if ( (size & 0x80000000) == 0 )
    {
      v17 = *(_DWORD *)src;
      src = (char *)src + 4;
      LOBYTE(v3) = v17;
      *(_DWORD *)dst = v17;
      dst = (char *)dst + 4;
    }
  }
  v18 = __CFSHL__(size, 31);
  v20 = size << 31;
  v19 = v20 < 0;
  if ( v18 )
  {
    v22 = *(_BYTE *)src;
    v21 = (char *)src + 1;
    LOBYTE(v3) = v22;
    v23 = *v21;
    src = v21 + 1;
    LOBYTE(v4) = v23;
  }
  if ( v20 < 0 )
    LOBYTE(v20) = *(_BYTE *)src;
  if ( v18 )
  {
    *(_BYTE *)dst = v3;
    v24 = (char *)dst + 1;
    *v24 = v4;
    dst = v24 + 1;
  }
  if ( v19 )
  {
    *(_BYTE *)dst = v20;
    return (char *)dst + 1;
  }
  return dst;
}
// FFF1AA44: variable 'v3' is possibly undefined
// FFF1AA48: variable 'v4' is possibly undefined

//----- (FFF1AA54) --------------------------------------------------------
void __fastcall KCacheMaintenanceHelper::RequestOtherCoresCacheMaintenanceByMva(
        bool *outAsync,
        KCacheMaintenanceOperation op,
        u32 addr,
        u32 size)
{
  __int64 v4; // r8
  bool v5; // cc
  bool v6; // r10
  KThread *volatile thread; // r5
  KThreadIntrusiveList *p_waitList; // r7
  KThreadIntrusiveList *p_link; // r1
  KThreadIntrusiveLink link; // r0
  KThreadIntrusiveList *v11; // r2
  char cfgr; // r1
  unsigned __int8 v13; // r1
  int v14; // r3
  KCacheMaintenanceOperation v15; // [sp+0h] [bp-38h]

  LODWORD(v4) = addr;
  HIDWORD(v4) = size;
  v5 = (unsigned __int8)g_kernelState > KSTATE_INITIALIZING;
  if ( g_kernelState != KSTATE_INITIALIZING )
    v5 = size - addr > 0x200;
  v6 = v5;
  *outAsync = v6;
  v15 = op | 4;
  thread = current.clc.current.thread;
  while ( 1 )
  {
    KSchedulerLock::Lock(&g_schedulerLock);
    if ( g_cacheMaintenanceHelper.op == KCACHEMAINTOP_NONE )
      break;
    p_waitList = &g_cacheMaintenanceHelper.waitList;
    thread->waiterList = &g_cacheMaintenanceHelper.waitList;
    KThread::SetSchedulingState(thread, KTHREADSCHEDSTAT_PAUSED);
    if ( g_cacheMaintenanceHelper.waitList.link.prev )
      p_link = (KThreadIntrusiveList *)&g_cacheMaintenanceHelper.waitList.link.prev->link;
    else
      p_link = &g_cacheMaintenanceHelper.waitList;
    thread->link.prev = g_cacheMaintenanceHelper.waitList.link.prev;
    thread->link.next = 0;
    p_link->link.next = thread;
    g_cacheMaintenanceHelper.waitList.link.prev = thread;
    if ( thread->shallTerminate )
    {
      link = thread->link;
      if ( link.prev )
        v11 = (KThreadIntrusiveList *)&link.prev->link;
      else

k11_latest_n3ds_memmap.txt

k11_latest_n3ds_symbols.map

k11_latest_n3ds_types.hpp