reset state

2024-11-23 05:19:52 +00:00 · 2021-08-04 22:04:25 -04:00 · 2021-08-04 22:04:25 -04:00 · 122e4b2f33
commit 122e4b2f33
parent 46812a3a5e
490 changed files with 874 additions and 231875 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -1,9 +0,0 @@
 [submodule "include/sead"]
 	path = include/sead
 	url = https://github.com/open-ead/sead
 [submodule "include/NintendoSDK"]
 	path = include/NintendoSDK
 	url = https://github.com/MonsterDruide1/nnheaders
 [submodule "include/agl"]
 	path = include/agl
 	url = https://github.com/MonsterDruide1/agl
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,39 +0,0 @@
 cmake_minimum_required(VERSION 3.13)
 project(odyssey CXX)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_NINJA_FORCE_RESPONSE_FILE ON)
 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
  add_compile_options(-fdiagnostics-color=always)
 elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
  add_compile_options(-fcolor-diagnostics)
  # Required to silence "unused argument" warnings for -stdlib=libc++ when using distcc
  add_compile_options(-Wno-unused-command-line-argument)
  # Required to fix source paths in debug info when using distcc
  add_compile_options(-fdebug-prefix-map=/tmp=${CMAKE_CURRENT_BINARY_DIR})
 endif()
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 add_executable(odyssey)
 target_include_directories(odyssey PRIVATE src)
 target_compile_options(odyssey PRIVATE -fno-rtti -fno-exceptions)
 target_compile_options(odyssey PRIVATE -Wall -Wextra -Wdeprecated)
 target_compile_options(odyssey PRIVATE -Wno-unused-parameter -Wno-unused-private-field)
 target_compile_options(odyssey PRIVATE -fno-strict-aliasing)
 target_compile_options(odyssey PRIVATE -Wno-invalid-offsetof)
 add_subdirectory(src)
 include_directories(include)
 include_directories(include/aarch64)
 add_subdirectory(include/NintendoSDK)
 target_link_libraries(odyssey PUBLIC NintendoSDK)
 add_subdirectory(include/sead)
 target_link_libraries(odyssey PUBLIC sead)
 add_subdirectory(include/agl)
 target_link_libraries(odyssey PUBLIC agl)
--- a/ToolchainNX64.cmake
+++ b/ToolchainNX64.cmake
@ -1,46 +0,0 @@
 if (NOT DEFINED ENV{ODYSSEY_CLANG})
    message(FATAL_ERROR "Please define the ODYSSEY_CLANG env variable. It should point to a path such that $ODYSSEY_CLANG/bin/clang exists")
 endif()
 if (NOT DEFINED ENV{DEVKITA64})
    message(FATAL_ERROR "Please define the DEVKITA64 env variable.")
 endif()
 set(ODYSSEY_CLANG "$ENV{ODYSSEY_CLANG}")
 set(DEVKITA64 "$ENV{DEVKITA64}")
 set(NX64_OPT_FLAGS "-O3 -g")
 set(triple aarch64-none-elf)
 set(CMAKE_SYSTEM_NAME Generic)
 set(CMAKE_SYSTEM_VERSION 1)
 set(CMAKE_SYSTEM_PROCESSOR aarch64)
 set(CMAKE_SYSROOT ${ODYSSEY_CLANG})
 set(CMAKE_C_COMPILER "${ODYSSEY_CLANG}/bin/clang")
 set(CMAKE_C_COMPILER_TARGET ${triple})
 set(CMAKE_CXX_COMPILER "${ODYSSEY_CLANG}/bin/clang++")
 set(CMAKE_CXX_COMPILER_TARGET ${triple})
 set(CMAKE_C_FLAGS_RELEASE ${NX64_OPT_FLAGS})
 set(CMAKE_CXX_FLAGS_RELEASE ${NX64_OPT_FLAGS})
 set(CMAKE_C_FLAGS_RELWITHDEBINFO ${NX64_OPT_FLAGS})
 set(CMAKE_CXX_FLAGS_RELWITHDEBINFO ${NX64_OPT_FLAGS})
 set(ARCH "-mcpu=cortex-a57+fp+simd+crypto+crc")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARCH} -isystem ${DEVKITA64}/aarch64-none-elf/include")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem ${ODYSSEY_CLANG}/include/c++/v1 -D _LIBCPP_HAS_THREAD_API_PTHREAD ${CMAKE_C_FLAGS}")
 set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -x assembler-with-cpp ${ARCH}")
 add_compile_options(-fPIC -stdlib=libc++ -mno-implicit-float)
 add_link_options(-B ${DEVKITA64}/bin -fPIC -Wl,-Bsymbolic-functions -shared -nodefaultlibs)
 if(EXISTS "${DEVKITA64}/bin/ld.lld")
    add_link_options(-fuse-ld=lld -Wl,-z,notext)
 endif()
 add_definitions(-D SWITCH -D __DEVKITA64__ -D __ELF__)
 add_definitions(-D NNSDK)
 add_definitions(-D MATCHING_HACK_NX_CLANG)
 add_definitions(-D VER_120)
 # Helps with matching as this causes Clang to emit debug type info even for dynamic classes
 # with undefined vtables.
 add_compile_options(-fstandalone-debug)
--- a/data/data_symbols.csv
+++ b/data/data_symbols.csv
@ -1,499 +0,0 @@
 0x00000071023556B0,_ZTVN4sead14SafeStringBaseIcEE
 0x0000007102356AF0,_ZTVN4sead22BufferedSafeStringBaseIcEE
 0x000000710246F9E0,_ZN4ksys3gdt6detail13sCommonFlags0E
 0x00000071024709E0,_ZN4ksys3gdt6detail13sCommonFlags1E
 0x00000071024719E0,_ZN4ksys3gdt6detail13sCommonFlags2E
 0x00000071024729E0,_ZN4ksys3gdt6detail13sCommonFlags3E
 0x00000071024C0F18,_ZTVN3agl3utl13ParameterBaseE
 0x00000071024C1060,_ZTVN3agl3utl9ParameterIbEE
 0x00000071024C1100,_ZTVN3agl3utl9ParameterIfEE
 0x00000071024C11A0,_ZTVN3agl3utl9ParameterIiEE
 0x00000071024C1240,_ZTVN3agl3utl9ParameterIjEE
 0x00000071024C12E0,_ZTVN3agl3utl9ParameterIN4sead7Vector2IfEEEE
 0x00000071024C1380,_ZTVN3agl3utl9ParameterIN4sead7Vector3IfEEEE
 0x00000071024C1420,_ZTVN3agl3utl9ParameterIN4sead7Vector4IfEEEE
 0x00000071024C14C0,_ZTVN3agl3utl9ParameterIN4sead7Color4fEEE
 0x00000071024C1560,_ZTVN3agl3utl9ParameterIN4sead4QuatIfEEEE
 0x00000071024C1600,_ZTVN3agl3utl9ParameterIN4sead15FixedSafeStringILi64EEEEE
 0x00000071024C16A0,_ZTVN3agl3utl9ParameterIN4sead15FixedSafeStringILi256EEEEE
 0x00000071024C1740,_ZTVN3agl3utl9ParameterIN4sead14SafeStringBaseIcEEEE
 0x00000071024D8D58,_ZTVN4ksys3act2ai10ActionBaseE
 0x00000071025129E0,_ZTVN4ksys3act2ai6ActionE
 0x0000007102513268,_ZTVN4ksys3act2ai2AiE
 0x00000071025F75B0,pfnc_nvnDeviceBuilderSetDefaults
 0x00000071025F75B8,pfnc_nvnDeviceBuilderSetFlags
 0x00000071025F75C0,pfnc_nvnDeviceInitialize
 0x00000071025F75C8,pfnc_nvnDeviceFinalize
 0x00000071025F75D0,pfnc_nvnDeviceSetDebugLabel
 0x00000071025F75D8,pfnc_nvnDeviceGetProcAddress
 0x00000071025F75E0,pfnc_nvnDeviceGetInteger
 0x00000071025F75E8,pfnc_nvnDeviceGetCurrentTimestampInNanoseconds
 0x00000071025F75F0,pfnc_nvnDeviceSetIntermediateShaderCache
 0x00000071025F75F8,pfnc_nvnDeviceGetTextureHandle
 0x00000071025F7600,pfnc_nvnDeviceGetTexelFetchHandle
 0x00000071025F7608,pfnc_nvnDeviceGetImageHandle
 0x00000071025F7610,pfnc_nvnDeviceInstallDebugCallback
 0x00000071025F7618,pfnc_nvnDeviceGenerateDebugDomainId
 0x00000071025F7620,pfnc_nvnDeviceSetWindowOriginMode
 0x00000071025F7628,pfnc_nvnDeviceSetDepthMode
 0x00000071025F7630,pfnc_nvnDeviceRegisterFastClearColor
 0x00000071025F7638,pfnc_nvnDeviceRegisterFastClearColori
 0x00000071025F7640,pfnc_nvnDeviceRegisterFastClearColorui
 0x00000071025F7648,pfnc_nvnDeviceRegisterFastClearDepth
 0x00000071025F7650,pfnc_nvnDeviceGetWindowOriginMode
 0x00000071025F7658,pfnc_nvnDeviceGetDepthMode
 0x00000071025F7660,pfnc_nvnDeviceGetTimestampInNanoseconds
 0x00000071025F7668,pfnc_nvnDeviceApplyDeferredFinalizes
 0x00000071025F7670,pfnc_nvnDeviceFinalizeCommandHandle
 0x00000071025F7678,pfnc_nvnDeviceWalkDebugDatabase
 0x00000071025F7680,pfnc_nvnDeviceGetSeparateTextureHandle
 0x00000071025F7688,pfnc_nvnDeviceGetSeparateSamplerHandle
 0x00000071025F7690,pfnc_nvnDeviceIsExternalDebuggerAttached
 0x00000071025F7698,pfnc_nvnQueueGetError
 0x00000071025F76A0,pfnc_nvnQueueGetTotalCommandMemoryUsed
 0x00000071025F76A8,pfnc_nvnQueueGetTotalControlMemoryUsed
 0x00000071025F76B0,pfnc_nvnQueueGetTotalComputeMemoryUsed
 0x00000071025F76B8,pfnc_nvnQueueResetMemoryUsageCounts
 0x00000071025F76C0,pfnc_nvnQueueBuilderSetDevice
 0x00000071025F76C8,pfnc_nvnQueueBuilderSetDefaults
 0x00000071025F76D0,pfnc_nvnQueueBuilderSetFlags
 0x00000071025F76D8,pfnc_nvnQueueBuilderSetCommandMemorySize
 0x00000071025F76E0,pfnc_nvnQueueBuilderSetComputeMemorySize
 0x00000071025F76E8,pfnc_nvnQueueBuilderSetControlMemorySize
 0x00000071025F76F0,pfnc_nvnQueueBuilderGetQueueMemorySize
 0x00000071025F76F8,pfnc_nvnQueueBuilderSetQueueMemory
 0x00000071025F7700,pfnc_nvnQueueBuilderSetCommandFlushThreshold
 0x00000071025F7708,pfnc_nvnQueueInitialize
 0x00000071025F7710,pfnc_nvnQueueFinalize
 0x00000071025F7718,pfnc_nvnQueueSetDebugLabel
 0x00000071025F7720,pfnc_nvnQueueSubmitCommands
 0x00000071025F7728,pfnc_nvnQueueFlush
 0x00000071025F7730,pfnc_nvnQueueFinish
 0x00000071025F7738,pfnc_nvnQueuePresentTexture
 0x00000071025F7740,pfnc_nvnQueueAcquireTexture
 0x00000071025F7748,pfnc_nvnWindowBuilderSetDevice
 0x00000071025F7750,pfnc_nvnWindowBuilderSetDefaults
 0x00000071025F7758,pfnc_nvnWindowBuilderSetNativeWindow
 0x00000071025F7760,pfnc_nvnWindowBuilderSetTextures
 0x00000071025F7768,pfnc_nvnWindowBuilderSetPresentInterval
 0x00000071025F7770,pfnc_nvnWindowBuilderGetNativeWindow
 0x00000071025F7778,pfnc_nvnWindowBuilderGetPresentInterval
 0x00000071025F7780,pfnc_nvnWindowInitialize
 0x00000071025F7788,pfnc_nvnWindowFinalize
 0x00000071025F7790,pfnc_nvnWindowSetDebugLabel
 0x00000071025F7798,pfnc_nvnWindowAcquireTexture
 0x00000071025F77A0,pfnc_nvnWindowGetNativeWindow
 0x00000071025F77A8,pfnc_nvnWindowGetPresentInterval
 0x00000071025F77B0,pfnc_nvnWindowSetPresentInterval
 0x00000071025F77B8,pfnc_nvnWindowSetCrop
 0x00000071025F77C0,pfnc_nvnWindowGetCrop
 0x00000071025F77C8,pfnc_nvnProgramInitialize
 0x00000071025F77D0,pfnc_nvnProgramFinalize
 0x00000071025F77D8,pfnc_nvnProgramSetDebugLabel
 0x00000071025F77E0,pfnc_nvnProgramSetShaders
 0x00000071025F77E8,pfnc_nvnMemoryPoolBuilderSetDevice
 0x00000071025F77F0,pfnc_nvnMemoryPoolBuilderSetDefaults
 0x00000071025F77F8,pfnc_nvnMemoryPoolBuilderSetStorage
 0x00000071025F7800,pfnc_nvnMemoryPoolBuilderSetFlags
 0x00000071025F7808,pfnc_nvnMemoryPoolBuilderGetMemory
 0x00000071025F7810,pfnc_nvnMemoryPoolBuilderGetSize
 0x00000071025F7818,pfnc_nvnMemoryPoolBuilderGetFlags
 0x00000071025F7820,pfnc_nvnMemoryPoolInitialize
 0x00000071025F7828,pfnc_nvnMemoryPoolSetDebugLabel
 0x00000071025F7830,pfnc_nvnMemoryPoolFinalize
 0x00000071025F7838,pfnc_nvnMemoryPoolMap
 0x00000071025F7840,pfnc_nvnMemoryPoolFlushMappedRange
 0x00000071025F7848,pfnc_nvnMemoryPoolInvalidateMappedRange
 0x00000071025F7850,pfnc_nvnMemoryPoolGetBufferAddress
 0x00000071025F7858,pfnc_nvnMemoryPoolMapVirtual
 0x00000071025F7860,pfnc_nvnMemoryPoolGetSize
 0x00000071025F7868,pfnc_nvnMemoryPoolGetFlags
 0x00000071025F7870,pfnc_nvnTexturePoolInitialize
 0x00000071025F7878,pfnc_nvnTexturePoolSetDebugLabel
 0x00000071025F7880,pfnc_nvnTexturePoolFinalize
 0x00000071025F7888,pfnc_nvnTexturePoolRegisterTexture
 0x00000071025F7890,pfnc_nvnTexturePoolRegisterImage
 0x00000071025F7898,pfnc_nvnTexturePoolGetMemoryPool
 0x00000071025F78A0,pfnc_nvnTexturePoolGetMemoryOffset
 0x00000071025F78A8,pfnc_nvnTexturePoolGetSize
 0x00000071025F78B0,pfnc_nvnSamplerPoolInitialize
 0x00000071025F78B8,pfnc_nvnSamplerPoolSetDebugLabel
 0x00000071025F78C0,pfnc_nvnSamplerPoolFinalize
 0x00000071025F78C8,pfnc_nvnSamplerPoolRegisterSampler
 0x00000071025F78D0,pfnc_nvnSamplerPoolRegisterSamplerBuilder
 0x00000071025F78D8,pfnc_nvnSamplerPoolGetMemoryPool
 0x00000071025F78E0,pfnc_nvnSamplerPoolGetMemoryOffset
 0x00000071025F78E8,pfnc_nvnSamplerPoolGetSize
 0x00000071025F78F0,pfnc_nvnBufferBuilderSetDevice
 0x00000071025F78F8,pfnc_nvnBufferBuilderSetDefaults
 0x00000071025F7900,pfnc_nvnBufferBuilderSetStorage
 0x00000071025F7908,pfnc_nvnBufferBuilderGetMemoryPool
 0x00000071025F7910,pfnc_nvnBufferBuilderGetMemoryOffset
 0x00000071025F7918,pfnc_nvnBufferBuilderGetSize
 0x00000071025F7920,pfnc_nvnBufferInitialize
 0x00000071025F7928,pfnc_nvnBufferSetDebugLabel
 0x00000071025F7930,pfnc_nvnBufferFinalize
 0x00000071025F7938,pfnc_nvnBufferMap
 0x00000071025F7940,pfnc_nvnBufferGetAddress
 0x00000071025F7948,pfnc_nvnBufferFlushMappedRange
 0x00000071025F7950,pfnc_nvnBufferInvalidateMappedRange
 0x00000071025F7958,pfnc_nvnBufferGetMemoryPool
 0x00000071025F7960,pfnc_nvnBufferGetMemoryOffset
 0x00000071025F7968,pfnc_nvnBufferGetSize
 0x00000071025F7970,pfnc_nvnBufferGetDebugID
 0x00000071025F7978,pfnc_nvnTextureBuilderSetDevice
 0x00000071025F7980,pfnc_nvnTextureBuilderSetDefaults
 0x00000071025F7988,pfnc_nvnTextureBuilderSetFlags
 0x00000071025F7990,pfnc_nvnTextureBuilderSetTarget
 0x00000071025F7998,pfnc_nvnTextureBuilderSetWidth
 0x00000071025F79A0,pfnc_nvnTextureBuilderSetHeight
 0x00000071025F79A8,pfnc_nvnTextureBuilderSetDepth
 0x00000071025F79B0,pfnc_nvnTextureBuilderSetSize1D
 0x00000071025F79B8,pfnc_nvnTextureBuilderSetSize2D
 0x00000071025F79C0,pfnc_nvnTextureBuilderSetSize3D
 0x00000071025F79C8,pfnc_nvnTextureBuilderSetLevels
 0x00000071025F79D0,pfnc_nvnTextureBuilderSetFormat
 0x00000071025F79D8,pfnc_nvnTextureBuilderSetSamples
 0x00000071025F79E0,pfnc_nvnTextureBuilderSetSwizzle
 0x00000071025F79E8,pfnc_nvnTextureBuilderSetDepthStencilMode
 0x00000071025F79F0,pfnc_nvnTextureBuilderGetStorageSize
 0x00000071025F79F8,pfnc_nvnTextureBuilderGetStorageAlignment
 0x00000071025F7A00,pfnc_nvnTextureBuilderSetStorage
 0x00000071025F7A08,pfnc_nvnTextureBuilderSetPackagedTextureData
 0x00000071025F7A10,pfnc_nvnTextureBuilderSetPackagedTextureLayout
 0x00000071025F7A18,pfnc_nvnTextureBuilderSetStride
 0x00000071025F7A20,pfnc_nvnTextureBuilderSetGLTextureName
 0x00000071025F7A28,pfnc_nvnTextureBuilderGetStorageClass
 0x00000071025F7A30,pfnc_nvnTextureBuilderGetFlags
 0x00000071025F7A38,pfnc_nvnTextureBuilderGetTarget
 0x00000071025F7A40,pfnc_nvnTextureBuilderGetWidth
 0x00000071025F7A48,pfnc_nvnTextureBuilderGetHeight
 0x00000071025F7A50,pfnc_nvnTextureBuilderGetDepth
 0x00000071025F7A58,pfnc_nvnTextureBuilderGetLevels
 0x00000071025F7A60,pfnc_nvnTextureBuilderGetFormat
 0x00000071025F7A68,pfnc_nvnTextureBuilderGetSamples
 0x00000071025F7A70,pfnc_nvnTextureBuilderGetSwizzle
 0x00000071025F7A78,pfnc_nvnTextureBuilderGetDepthStencilMode
 0x00000071025F7A80,pfnc_nvnTextureBuilderGetPackagedTextureData
 0x00000071025F7A88,pfnc_nvnTextureBuilderGetStride
 0x00000071025F7A90,pfnc_nvnTextureBuilderGetSparseTileLayout
 0x00000071025F7A98,pfnc_nvnTextureBuilderGetGLTextureName
 0x00000071025F7AA0,pfnc_nvnTextureBuilderGetZCullStorageSize
 0x00000071025F7AA8,pfnc_nvnTextureBuilderGetMemoryPool
 0x00000071025F7AB0,pfnc_nvnTextureBuilderGetMemoryOffset
 0x00000071025F7AB8,pfnc_nvnTextureViewSetDefaults
 0x00000071025F7AC0,pfnc_nvnTextureViewSetLevels
 0x00000071025F7AC8,pfnc_nvnTextureViewSetLayers
 0x00000071025F7AD0,pfnc_nvnTextureViewSetFormat
 0x00000071025F7AD8,pfnc_nvnTextureViewSetSwizzle
 0x00000071025F7AE0,pfnc_nvnTextureViewSetDepthStencilMode
 0x00000071025F7AE8,pfnc_nvnTextureViewSetTarget
 0x00000071025F7AF0,pfnc_nvnTextureViewGetLevels
 0x00000071025F7AF8,pfnc_nvnTextureViewGetLayers
 0x00000071025F7B00,pfnc_nvnTextureViewGetFormat
 0x00000071025F7B08,pfnc_nvnTextureViewGetSwizzle
 0x00000071025F7B10,pfnc_nvnTextureViewGetDepthStencilMode
 0x00000071025F7B18,pfnc_nvnTextureViewGetTarget
 0x00000071025F7B20,pfnc_nvnTextureViewCompare
 0x00000071025F7B28,pfnc_nvnTextureInitialize
 0x00000071025F7B30,pfnc_nvnTextureGetZCullStorageSize
 0x00000071025F7B38,pfnc_nvnTextureFinalize
 0x00000071025F7B40,pfnc_nvnTextureSetDebugLabel
 0x00000071025F7B48,pfnc_nvnTextureGetStorageClass
 0x00000071025F7B50,pfnc_nvnTextureGetViewOffset
 0x00000071025F7B58,pfnc_nvnTextureGetFlags
 0x00000071025F7B60,pfnc_nvnTextureGetTarget
 0x00000071025F7B68,pfnc_nvnTextureGetWidth
 0x00000071025F7B70,pfnc_nvnTextureGetHeight
 0x00000071025F7B78,pfnc_nvnTextureGetDepth
 0x00000071025F7B80,pfnc_nvnTextureGetLevels
 0x00000071025F7B88,pfnc_nvnTextureGetFormat
 0x00000071025F7B90,pfnc_nvnTextureGetSamples
 0x00000071025F7B98,pfnc_nvnTextureGetSwizzle
 0x00000071025F7BA0,pfnc_nvnTextureGetDepthStencilMode
 0x00000071025F7BA8,pfnc_nvnTextureGetStride
 0x00000071025F7BB0,pfnc_nvnTextureGetTextureAddress
 0x00000071025F7BB8,pfnc_nvnTextureGetSparseTileLayout
 0x00000071025F7BC0,pfnc_nvnTextureWriteTexels
 0x00000071025F7BC8,pfnc_nvnTextureWriteTexelsStrided
 0x00000071025F7BD0,pfnc_nvnTextureReadTexels
 0x00000071025F7BD8,pfnc_nvnTextureReadTexelsStrided
 0x00000071025F7BE0,pfnc_nvnTextureFlushTexels
 0x00000071025F7BE8,pfnc_nvnTextureInvalidateTexels
 0x00000071025F7BF0,pfnc_nvnTextureGetMemoryPool
 0x00000071025F7BF8,pfnc_nvnTextureGetMemoryOffset
 0x00000071025F7C00,pfnc_nvnTextureGetStorageSize
 0x00000071025F7C08,pfnc_nvnTextureCompare
 0x00000071025F7C10,pfnc_nvnTextureGetDebugID
 0x00000071025F7C18,pfnc_nvnSamplerBuilderSetDevice
 0x00000071025F7C20,pfnc_nvnSamplerBuilderSetDefaults
 0x00000071025F7C28,pfnc_nvnSamplerBuilderSetMinMagFilter
 0x00000071025F7C30,pfnc_nvnSamplerBuilderSetWrapMode
 0x00000071025F7C38,pfnc_nvnSamplerBuilderSetLodClamp
 0x00000071025F7C40,pfnc_nvnSamplerBuilderSetLodBias
 0x00000071025F7C48,pfnc_nvnSamplerBuilderSetCompare
 0x00000071025F7C50,pfnc_nvnSamplerBuilderSetBorderColor
 0x00000071025F7C58,pfnc_nvnSamplerBuilderSetBorderColori
 0x00000071025F7C60,pfnc_nvnSamplerBuilderSetBorderColorui
 0x00000071025F7C68,pfnc_nvnSamplerBuilderSetMaxAnisotropy
 0x00000071025F7C70,pfnc_nvnSamplerBuilderSetReductionFilter
 0x00000071025F7C78,pfnc_nvnSamplerBuilderSetLodSnap
 0x00000071025F7C80,pfnc_nvnSamplerBuilderGetMinMagFilter
 0x00000071025F7C88,pfnc_nvnSamplerBuilderGetWrapMode
 0x00000071025F7C90,pfnc_nvnSamplerBuilderGetLodClamp
 0x00000071025F7C98,pfnc_nvnSamplerBuilderGetLodBias
 0x00000071025F7CA0,pfnc_nvnSamplerBuilderGetCompare
 0x00000071025F7CA8,pfnc_nvnSamplerBuilderGetBorderColor
 0x00000071025F7CB0,pfnc_nvnSamplerBuilderGetBorderColori
 0x00000071025F7CB8,pfnc_nvnSamplerBuilderGetBorderColorui
 0x00000071025F7CC0,pfnc_nvnSamplerBuilderGetMaxAnisotropy
 0x00000071025F7CC8,pfnc_nvnSamplerBuilderGetReductionFilter
 0x00000071025F7CD0,pfnc_nvnSamplerBuilderGetLodSnap
 0x00000071025F7CD8,pfnc_nvnSamplerInitialize
 0x00000071025F7CE0,pfnc_nvnSamplerFinalize
 0x00000071025F7CE8,pfnc_nvnSamplerSetDebugLabel
 0x00000071025F7CF0,pfnc_nvnSamplerGetMinMagFilter
 0x00000071025F7CF8,pfnc_nvnSamplerGetWrapMode
 0x00000071025F7D00,pfnc_nvnSamplerGetLodClamp
 0x00000071025F7D08,pfnc_nvnSamplerGetLodBias
 0x00000071025F7D10,pfnc_nvnSamplerGetCompare
 0x00000071025F7D18,pfnc_nvnSamplerGetBorderColor
 0x00000071025F7D20,pfnc_nvnSamplerGetBorderColori
 0x00000071025F7D28,pfnc_nvnSamplerGetBorderColorui
 0x00000071025F7D30,pfnc_nvnSamplerGetMaxAnisotropy
 0x00000071025F7D38,pfnc_nvnSamplerGetReductionFilter
 0x00000071025F7D40,pfnc_nvnSamplerCompare
 0x00000071025F7D48,pfnc_nvnSamplerGetDebugID
 0x00000071025F7D50,pfnc_nvnBlendStateSetDefaults
 0x00000071025F7D58,pfnc_nvnBlendStateSetBlendTarget
 0x00000071025F7D60,pfnc_nvnBlendStateSetBlendFunc
 0x00000071025F7D68,pfnc_nvnBlendStateSetBlendEquation
 0x00000071025F7D70,pfnc_nvnBlendStateSetAdvancedMode
 0x00000071025F7D78,pfnc_nvnBlendStateSetAdvancedOverlap
 0x00000071025F7D80,pfnc_nvnBlendStateSetAdvancedPremultipliedSrc
 0x00000071025F7D88,pfnc_nvnBlendStateSetAdvancedNormalizedDst
 0x00000071025F7D90,pfnc_nvnBlendStateGetBlendTarget
 0x00000071025F7D98,pfnc_nvnBlendStateGetBlendFunc
 0x00000071025F7DA0,pfnc_nvnBlendStateGetBlendEquation
 0x00000071025F7DA8,pfnc_nvnBlendStateGetAdvancedMode
 0x00000071025F7DB0,pfnc_nvnBlendStateGetAdvancedOverlap
 0x00000071025F7DB8,pfnc_nvnBlendStateGetAdvancedPremultipliedSrc
 0x00000071025F7DC0,pfnc_nvnBlendStateGetAdvancedNormalizedDst
 0x00000071025F7DC8,pfnc_nvnColorStateSetDefaults
 0x00000071025F7DD0,pfnc_nvnColorStateSetBlendEnable
 0x00000071025F7DD8,pfnc_nvnColorStateSetLogicOp
 0x00000071025F7DE0,pfnc_nvnColorStateSetAlphaTest
 0x00000071025F7DE8,pfnc_nvnColorStateGetBlendEnable
 0x00000071025F7DF0,pfnc_nvnColorStateGetLogicOp
 0x00000071025F7DF8,pfnc_nvnColorStateGetAlphaTest
 0x00000071025F7E00,pfnc_nvnChannelMaskStateSetDefaults
 0x00000071025F7E08,pfnc_nvnChannelMaskStateSetChannelMask
 0x00000071025F7E10,pfnc_nvnChannelMaskStateGetChannelMask
 0x00000071025F7E18,pfnc_nvnMultisampleStateSetDefaults
 0x00000071025F7E20,pfnc_nvnMultisampleStateSetMultisampleEnable
 0x00000071025F7E28,pfnc_nvnMultisampleStateSetSamples
 0x00000071025F7E30,pfnc_nvnMultisampleStateSetAlphaToCoverageEnable
 0x00000071025F7E38,pfnc_nvnMultisampleStateSetAlphaToCoverageDither
 0x00000071025F7E40,pfnc_nvnMultisampleStateGetMultisampleEnable
 0x00000071025F7E48,pfnc_nvnMultisampleStateGetSamples
 0x00000071025F7E50,pfnc_nvnMultisampleStateGetAlphaToCoverageEnable
 0x00000071025F7E58,pfnc_nvnMultisampleStateGetAlphaToCoverageDither
 0x00000071025F7E60,pfnc_nvnMultisampleStateSetRasterSamples
 0x00000071025F7E68,pfnc_nvnMultisampleStateGetRasterSamples
 0x00000071025F7E70,pfnc_nvnMultisampleStateSetCoverageModulationMode
 0x00000071025F7E78,pfnc_nvnMultisampleStateGetCoverageModulationMode
 0x00000071025F7E80,pfnc_nvnMultisampleStateSetCoverageToColorEnable
 0x00000071025F7E88,pfnc_nvnMultisampleStateGetCoverageToColorEnable
 0x00000071025F7E90,pfnc_nvnMultisampleStateSetCoverageToColorOutput
 0x00000071025F7E98,pfnc_nvnMultisampleStateGetCoverageToColorOutput
 0x00000071025F7EA0,pfnc_nvnMultisampleStateSetSampleLocationsEnable
 0x00000071025F7EA8,pfnc_nvnMultisampleStateGetSampleLocationsEnable
 0x00000071025F7EB0,pfnc_nvnMultisampleStateGetSampleLocationsGrid
 0x00000071025F7EB8,pfnc_nvnMultisampleStateSetSampleLocationsGridEnable
 0x00000071025F7EC0,pfnc_nvnMultisampleStateGetSampleLocationsGridEnable
 0x00000071025F7EC8,pfnc_nvnMultisampleStateSetSampleLocations
 0x00000071025F7ED0,pfnc_nvnPolygonStateSetDefaults
 0x00000071025F7ED8,pfnc_nvnPolygonStateSetCullFace
 0x00000071025F7EE0,pfnc_nvnPolygonStateSetFrontFace
 0x00000071025F7EE8,pfnc_nvnPolygonStateSetPolygonMode
 0x00000071025F7EF0,pfnc_nvnPolygonStateSetPolygonOffsetEnables
 0x00000071025F7EF8,pfnc_nvnPolygonStateGetCullFace
 0x00000071025F7F00,pfnc_nvnPolygonStateGetFrontFace
 0x00000071025F7F08,pfnc_nvnPolygonStateGetPolygonMode
 0x00000071025F7F10,pfnc_nvnPolygonStateGetPolygonOffsetEnables
 0x00000071025F7F18,pfnc_nvnDepthStencilStateSetDefaults
 0x00000071025F7F20,pfnc_nvnDepthStencilStateSetDepthTestEnable
 0x00000071025F7F28,pfnc_nvnDepthStencilStateSetDepthWriteEnable
 0x00000071025F7F30,pfnc_nvnDepthStencilStateSetDepthFunc
 0x00000071025F7F38,pfnc_nvnDepthStencilStateSetStencilTestEnable
 0x00000071025F7F40,pfnc_nvnDepthStencilStateSetStencilFunc
 0x00000071025F7F48,pfnc_nvnDepthStencilStateSetStencilOp
 0x00000071025F7F50,pfnc_nvnDepthStencilStateGetDepthTestEnable
 0x00000071025F7F58,pfnc_nvnDepthStencilStateGetDepthWriteEnable
 0x00000071025F7F60,pfnc_nvnDepthStencilStateGetDepthFunc
 0x00000071025F7F68,pfnc_nvnDepthStencilStateGetStencilTestEnable
 0x00000071025F7F70,pfnc_nvnDepthStencilStateGetStencilFunc
 0x00000071025F7F78,pfnc_nvnDepthStencilStateGetStencilOp
 0x00000071025F7F80,pfnc_nvnVertexAttribStateSetDefaults
 0x00000071025F7F88,pfnc_nvnVertexAttribStateSetFormat
 0x00000071025F7F90,pfnc_nvnVertexAttribStateSetStreamIndex
 0x00000071025F7F98,pfnc_nvnVertexAttribStateGetFormat
 0x00000071025F7FA0,pfnc_nvnVertexAttribStateGetStreamIndex
 0x00000071025F7FA8,pfnc_nvnVertexStreamStateSetDefaults
 0x00000071025F7FB0,pfnc_nvnVertexStreamStateSetStride
 0x00000071025F7FB8,pfnc_nvnVertexStreamStateSetDivisor
 0x00000071025F7FC0,pfnc_nvnVertexStreamStateGetStride
 0x00000071025F7FC8,pfnc_nvnVertexStreamStateGetDivisor
 0x00000071025F7FD0,pfnc_nvnCommandBufferInitialize
 0x00000071025F7FD8,pfnc_nvnCommandBufferFinalize
 0x00000071025F7FE0,pfnc_nvnCommandBufferSetDebugLabel
 0x00000071025F7FE8,pfnc_nvnCommandBufferSetMemoryCallback
 0x00000071025F7FF0,pfnc_nvnCommandBufferSetMemoryCallbackData
 0x00000071025F7FF8,pfnc_nvnCommandBufferAddCommandMemory
 0x00000071025F8000,pfnc_nvnCommandBufferAddControlMemory
 0x00000071025F8008,pfnc_nvnCommandBufferGetCommandMemorySize
 0x00000071025F8010,pfnc_nvnCommandBufferGetCommandMemoryUsed
 0x00000071025F8018,pfnc_nvnCommandBufferGetCommandMemoryFree
 0x00000071025F8020,pfnc_nvnCommandBufferGetControlMemorySize
 0x00000071025F8028,pfnc_nvnCommandBufferGetControlMemoryUsed
 0x00000071025F8030,pfnc_nvnCommandBufferGetControlMemoryFree
 0x00000071025F8038,pfnc_nvnCommandBufferBeginRecording
 0x00000071025F8040,pfnc_nvnCommandBufferEndRecording
 0x00000071025F8048,pfnc_nvnCommandBufferCallCommands
 0x00000071025F8050,pfnc_nvnCommandBufferCopyCommands
 0x00000071025F8058,pfnc_nvnCommandBufferBindBlendState
 0x00000071025F8060,pfnc_nvnCommandBufferBindChannelMaskState
 0x00000071025F8068,pfnc_nvnCommandBufferBindColorState
 0x00000071025F8070,pfnc_nvnCommandBufferBindMultisampleState
 0x00000071025F8078,pfnc_nvnCommandBufferBindPolygonState
 0x00000071025F8080,pfnc_nvnCommandBufferBindDepthStencilState
 0x00000071025F8088,pfnc_nvnCommandBufferBindVertexAttribState
 0x00000071025F8090,pfnc_nvnCommandBufferBindVertexStreamState
 0x00000071025F8098,pfnc_nvnCommandBufferBindProgram
 0x00000071025F80A0,pfnc_nvnCommandBufferBindVertexBuffer
 0x00000071025F80A8,pfnc_nvnCommandBufferBindVertexBuffers
 0x00000071025F80B0,pfnc_nvnCommandBufferBindUniformBuffer
 0x00000071025F80B8,pfnc_nvnCommandBufferBindUniformBuffers
 0x00000071025F80C0,pfnc_nvnCommandBufferBindTransformFeedbackBuffer
 0x00000071025F80C8,pfnc_nvnCommandBufferBindTransformFeedbackBuffers
 0x00000071025F80D0,pfnc_nvnCommandBufferBindStorageBuffer
 0x00000071025F80D8,pfnc_nvnCommandBufferBindStorageBuffers
 0x00000071025F80E0,pfnc_nvnCommandBufferBindTexture
 0x00000071025F80E8,pfnc_nvnCommandBufferBindTextures
 0x00000071025F80F0,pfnc_nvnCommandBufferBindImage
 0x00000071025F80F8,pfnc_nvnCommandBufferBindImages
 0x00000071025F8100,pfnc_nvnCommandBufferSetPatchSize
 0x00000071025F8108,pfnc_nvnCommandBufferSetInnerTessellationLevels
 0x00000071025F8110,pfnc_nvnCommandBufferSetOuterTessellationLevels
 0x00000071025F8118,pfnc_nvnCommandBufferSetPrimitiveRestart
 0x00000071025F8120,pfnc_nvnCommandBufferBeginTransformFeedback
 0x00000071025F8128,pfnc_nvnCommandBufferEndTransformFeedback
 0x00000071025F8130,pfnc_nvnCommandBufferPauseTransformFeedback
 0x00000071025F8138,pfnc_nvnCommandBufferResumeTransformFeedback
 0x00000071025F8140,pfnc_nvnCommandBufferDrawTransformFeedback
 0x00000071025F8148,pfnc_nvnCommandBufferDrawArrays
 0x00000071025F8150,pfnc_nvnCommandBufferDrawElements
 0x00000071025F8158,pfnc_nvnCommandBufferDrawElementsBaseVertex
 0x00000071025F8160,pfnc_nvnCommandBufferDrawArraysInstanced
 0x00000071025F8168,pfnc_nvnCommandBufferDrawElementsInstanced
 0x00000071025F8170,pfnc_nvnCommandBufferDrawArraysIndirect
 0x00000071025F8178,pfnc_nvnCommandBufferDrawElementsIndirect
 0x00000071025F8180,pfnc_nvnCommandBufferMultiDrawArraysIndirectCount
 0x00000071025F8188,pfnc_nvnCommandBufferMultiDrawElementsIndirectCount
 0x00000071025F8190,pfnc_nvnCommandBufferClearColor
 0x00000071025F8198,pfnc_nvnCommandBufferClearColori
 0x00000071025F81A0,pfnc_nvnCommandBufferClearColorui
 0x00000071025F81A8,pfnc_nvnCommandBufferClearDepthStencil
 0x00000071025F81B0,pfnc_nvnCommandBufferDispatchCompute
 0x00000071025F81B8,pfnc_nvnCommandBufferDispatchComputeIndirect
 0x00000071025F81C0,pfnc_nvnCommandBufferSetViewport
 0x00000071025F81C8,pfnc_nvnCommandBufferSetViewports
 0x00000071025F81D0,pfnc_nvnCommandBufferSetViewportSwizzles
 0x00000071025F81D8,pfnc_nvnCommandBufferSetScissor
 0x00000071025F81E0,pfnc_nvnCommandBufferSetScissors
 0x00000071025F81E8,pfnc_nvnCommandBufferSetDepthRange
 0x00000071025F81F0,pfnc_nvnCommandBufferSetDepthBounds
 0x00000071025F81F8,pfnc_nvnCommandBufferSetDepthRanges
 0x00000071025F8200,pfnc_nvnCommandBufferSetTiledCacheAction
 0x00000071025F8208,pfnc_nvnCommandBufferSetTiledCacheTileSize
 0x00000071025F8210,pfnc_nvnCommandBufferBindSeparateTexture
 0x00000071025F8218,pfnc_nvnCommandBufferBindSeparateSampler
 0x00000071025F8220,pfnc_nvnCommandBufferBindSeparateTextures
 0x00000071025F8228,pfnc_nvnCommandBufferBindSeparateSamplers
 0x00000071025F8230,pfnc_nvnCommandBufferSetStencilValueMask
 0x00000071025F8238,pfnc_nvnCommandBufferSetStencilMask
 0x00000071025F8240,pfnc_nvnCommandBufferSetStencilRef
 0x00000071025F8248,pfnc_nvnCommandBufferSetBlendColor
 0x00000071025F8250,pfnc_nvnCommandBufferSetPointSize
 0x00000071025F8258,pfnc_nvnCommandBufferSetLineWidth
 0x00000071025F8260,pfnc_nvnCommandBufferSetPolygonOffsetClamp
 0x00000071025F8268,pfnc_nvnCommandBufferSetAlphaRef
 0x00000071025F8270,pfnc_nvnCommandBufferSetSampleMask
 0x00000071025F8278,pfnc_nvnCommandBufferSetRasterizerDiscard
 0x00000071025F8280,pfnc_nvnCommandBufferSetDepthClamp
 0x00000071025F8288,pfnc_nvnCommandBufferSetConservativeRasterEnable
 0x00000071025F8290,pfnc_nvnCommandBufferSetConservativeRasterDilate
 0x00000071025F8298,pfnc_nvnCommandBufferSetSubpixelPrecisionBias
 0x00000071025F82A0,pfnc_nvnCommandBufferCopyBufferToTexture
 0x00000071025F82A8,pfnc_nvnCommandBufferCopyTextureToBuffer
 0x00000071025F82B0,pfnc_nvnCommandBufferCopyTextureToTexture
 0x00000071025F82B8,pfnc_nvnCommandBufferCopyBufferToBuffer
 0x00000071025F82C0,pfnc_nvnCommandBufferClearBuffer
 0x00000071025F82C8,pfnc_nvnCommandBufferClearTexture
 0x00000071025F82D0,pfnc_nvnCommandBufferClearTexturei
 0x00000071025F82D8,pfnc_nvnCommandBufferClearTextureui
 0x00000071025F82E0,pfnc_nvnCommandBufferUpdateUniformBuffer
 0x00000071025F82E8,pfnc_nvnCommandBufferReportCounter
 0x00000071025F82F0,pfnc_nvnCommandBufferResetCounter
 0x00000071025F82F8,pfnc_nvnCommandBufferReportValue
 0x00000071025F8300,pfnc_nvnCommandBufferSetRenderEnable
 0x00000071025F8308,pfnc_nvnCommandBufferSetRenderEnableConditional
 0x00000071025F8310,pfnc_nvnCommandBufferSetRenderTargets
 0x00000071025F8318,pfnc_nvnCommandBufferDiscardColor
 0x00000071025F8320,pfnc_nvnCommandBufferDiscardDepthStencil
 0x00000071025F8328,pfnc_nvnCommandBufferDownsample
 0x00000071025F8330,pfnc_nvnCommandBufferTiledDownsample
 0x00000071025F8338,pfnc_nvnCommandBufferDownsampleTextureView
 0x00000071025F8340,pfnc_nvnCommandBufferTiledDownsampleTextureView
 0x00000071025F8348,pfnc_nvnCommandBufferBarrier
 0x00000071025F8350,pfnc_nvnCommandBufferWaitSync
 0x00000071025F8358,pfnc_nvnCommandBufferFenceSync
 0x00000071025F8360,pfnc_nvnCommandBufferSetTexturePool
 0x00000071025F8368,pfnc_nvnCommandBufferSetSamplerPool
 0x00000071025F8370,pfnc_nvnCommandBufferSetShaderScratchMemory
 0x00000071025F8378,pfnc_nvnCommandBufferSaveZCullData
 0x00000071025F8380,pfnc_nvnCommandBufferRestoreZCullData
 0x00000071025F8388,pfnc_nvnCommandBufferSetCopyRowStride
 0x00000071025F8390,pfnc_nvnCommandBufferSetCopyImageStride
 0x00000071025F8398,pfnc_nvnCommandBufferGetCopyRowStride
 0x00000071025F83A0,pfnc_nvnCommandBufferGetCopyImageStride
 0x00000071025F83A8,pfnc_nvnCommandBufferDrawTexture
 0x00000071025F83B0,pfnc_nvnProgramSetSubroutineLinkage
 0x00000071025F83B8,pfnc_nvnCommandBufferSetProgramSubroutines
 0x00000071025F83C0,pfnc_nvnCommandBufferBindCoverageModulationTable
 0x00000071025F83C8,pfnc_nvnCommandBufferResolveDepthBuffer
 0x00000071025F83D0,pfnc_nvnCommandBufferPushDebugGroupStatic
 0x00000071025F83D8,pfnc_nvnCommandBufferPushDebugGroupDynamic
 0x00000071025F83E0,pfnc_nvnCommandBufferPushDebugGroup
 0x00000071025F83E8,pfnc_nvnCommandBufferPopDebugGroup
 0x00000071025F83F0,pfnc_nvnCommandBufferPopDebugGroupId
 0x00000071025F83F8,pfnc_nvnCommandBufferInsertDebugMarkerStatic
 0x00000071025F8400,pfnc_nvnCommandBufferInsertDebugMarkerDynamic
 0x00000071025F8408,pfnc_nvnCommandBufferInsertDebugMarker
 0x00000071025F8410,pfnc_nvnCommandBufferGetMemoryCallback
 0x00000071025F8418,pfnc_nvnCommandBufferGetMemoryCallbackData
 0x00000071025F8420,pfnc_nvnCommandBufferIsRecording
 0x00000071025F8428,pfnc_nvnSyncInitialize
 0x00000071025F8430,pfnc_nvnSyncFinalize
 0x00000071025F8438,pfnc_nvnSyncSetDebugLabel
 0x00000071025F8440,pfnc_nvnQueueFenceSync
 0x00000071025F8448,pfnc_nvnSyncWait
 0x00000071025F8450,pfnc_nvnQueueWaitSync
 0x00000071025F8458,pfnc_nvnEventBuilderSetDefaults
 0x00000071025F8460,pfnc_nvnEventBuilderSetStorage
 0x00000071025F8468,pfnc_nvnEventInitialize
 0x00000071025F8470,pfnc_nvnEventFinalize
 0x00000071025F8478,pfnc_nvnEventGetValue
 0x00000071025F8480,pfnc_nvnEventSignal
 0x00000071025F8488,pfnc_nvnCommandBufferWaitEvent
 0x00000071025F8490,pfnc_nvnCommandBufferSignalEvent
--- a/data/odyssey_functions.csv
+++ b/data/odyssey_functions.csv
--- a/data/uking_functions.csv
+++ b/data/uking_functions.csv
--- a/diff.py
+++ b/diff.py
@ -1 +0,0 @@
 tools/diff.py
--- a/diff_settings.py
+++ b/diff_settings.py
@ -1,23 +0,0 @@
 #!/usr/bin/env python3
 from pathlib import Path
 def apply(config, args):
    config['arch'] = 'aarch64'
    config['baseimg'] = 'data/main.elf'
    config['myimg'] = 'build/odyssey'
    config['source_directories'] = ['src', 'lib']
    config['objdump_executable'] = 'tools/aarch64-none-elf-objdump'
    for dir in ('build', 'build/nx64-release'):
        if (Path(dir) / 'build.ninja').is_file():
            config['make_command'] = ['ninja', '-C', dir]
 def map_build_target(make_target: str):
    if make_target == "build/odyssey":
        return "odyssey"
    # TODO: When support for directly diffing object files is added, this needs to strip
    # the build/ prefix from the object file targets.
    return make_target
--- a/include/NintendoSDK/.clang-format
+++ b/include/NintendoSDK/.clang-format
@ -1,74 +0,0 @@
 ---
 Language:        Cpp
 AccessModifierOffset: -4
 AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
 AlignOperands:   true
 AlignTrailingComments: true
 AllowAllParametersOfDeclarationOnNextLine: true
 AllowShortBlocksOnASingleLine: Never
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: Inline
 AllowShortIfStatementsOnASingleLine: Never
 AllowShortLoopsOnASingleLine: false
 AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
 AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: true
 BinPackParameters: true
 BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Attach
 BreakBeforeTernaryOperators: false
 BreakConstructorInitializersBeforeComma: false
 ColumnLimit:     100
 CommentPragmas:  '^ (IWYU pragma:|NOLINT)'
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
 ConstructorInitializerIndentWidth: 4
 ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
 DerivePointerAlignment: false
 DisableFormat:   false
 ForEachMacros:   []
 IncludeCategories:
  - Regex:           '^<[Ww]indows\.h>$'
    Priority:        1
  - Regex:           '^<'
    Priority:        2
  - Regex:           '^"'
    Priority:        3
 IndentCaseLabels: false
 IndentWidth:     4
 IndentWrappedFunctionNames: false
 KeepEmptyLinesAtTheStartOfBlocks: false
 MacroBlockBegin: ''
 MacroBlockEnd:   ''
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
 ObjCBlockIndentWidth: 4
 ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: true
 PenaltyBreakBeforeFirstCallParameter: 19
 PenaltyBreakComment: 300
 PenaltyBreakFirstLessLess: 120
 PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
 PointerAlignment: Left
 ReflowComments:  true
 SortIncludes:    true
 SpaceAfterCStyleCast: false
 SpaceBeforeAssignmentOperators: true
 SpaceBeforeParens: ControlStatements
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 2
 SpacesInAngles:  false
 SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
 Standard: c++17
 TabWidth:        4
 UseTab:          Never
 ...
--- a/include/NintendoSDK/CMakeLists.txt
+++ b/include/NintendoSDK/CMakeLists.txt
@ -1,128 +0,0 @@
 project(NintendoSDK CXX ASM)
 add_library(NintendoSDK OBJECT
  include/nvn/nvn_types.h
  include/nvn/nvn.h
  include/nvn/nvn_api.h
  include/nn/types.h
  include/nn/os.h
  include/nn/nifm.h
  include/nn/prepo.h
  include/nn/vfx/Config.h
  include/nn/vfx/System.h
  include/nn/vfx/Heap.h
  include/nn/socket.h
  include/nn/aoc.h
  include/nn/fs.h
  include/nn/ro.h
  include/nn/oe.h
  include/nn/util.h
  include/nn/image.h
  include/nn/util/Float2.h
  include/nn/ui2d/detail/TexCoordArray.h
  include/nn/ui2d/Layout.h
  include/nn/ui2d/Parts.h
  include/nn/ui2d/Pane.h
  include/nn/ui2d/Material.h
  include/nn/g3d/ResMaterialAnim.h
  include/nn/g3d/ResShapeAnim.h
  include/nn/g3d/ResLightAnim.h
  include/nn/g3d/ResSkeletalAnim.h
  include/nn/g3d/ResSceneAnim.h
  include/nn/g3d/BindFuncTable.h
  include/nn/g3d/ResFile.h
  include/nn/g3d/ResMaterial.h
  include/nn/g3d/ResFogAnim.h
  include/nn/g3d/ResModel.h
  include/nn/nn.h
  include/nn/settings.h
  include/nn/hid.h
  include/nn/atk/detail/StreamSoundRuntime.h
  include/nn/atk/detail/BasicSound.h
  include/nn/atk/detail/WaveSoundRuntime.h
  include/nn/atk/detail/SequenceSoundRuntime.h
  include/nn/atk/detail/SoundArchiveManager.h
  include/nn/atk/detail/AdvancedWaveSoundRuntime.h
  include/nn/atk/SoundArchivePlayer.h
  include/nn/atk/SoundPlayer.h
  include/nn/atk/SoundDataManager.h
  include/nn/nex/client.h
  include/nn/nex/RootObject.h
  include/nn/nex/socket.h
  include/nn/nex/key.h
  include/nn/nex/checksum.h
  include/nn/nex/reference.h
  include/nn/nex/pseudo.h
  include/nn/nex/string.h
  include/nn/nex/instance.h
  include/nn/nex/ddl.h
  include/nn/nex/encryption.h
  include/nn/nex/cache.h
  include/nn/nex/time.h
  include/nn/nex/plugin.h
  include/nn/nex/dynamic.h
  include/nn/nex/data.h
  include/nn/nex/auth.h
  include/nn/nex/buffer.h
  include/nn/nex/system.h
  include/nn/nex/hash.h
  include/nn/time.h
  include/nn/diag.h
  include/nn/init.h
  include/nn/crypto.h
  include/nn/ssl.h
  include/nn/gfx/detail/pool.h
  include/nn/gfx/detail/deviceimpl.h
  include/nn/gfx/detail/bufferimpl.h
  include/nn/gfx/device.h
  include/nn/gfx/memory.h
  include/nn/gfx/buffer.h
  include/nn/gfx/api.h
  include/nn/vi.h
  include/nn/account.h
  include/nn/audio.h
  include/nn/friends.h
  include/nn/mem.h
  include/vapours/results.hpp
  include/vapours/results/sf_results.hpp
  include/vapours/results/capsrv_results.hpp
  include/vapours/results/pgl_results.hpp
  include/vapours/results/lr_results.hpp
  include/vapours/results/spl_results.hpp
  include/vapours/results/pm_results.hpp
  include/vapours/results/settings_results.hpp
  include/vapours/results/debug_results.hpp
  include/vapours/results/cal_results.hpp
  include/vapours/results/i2c_results.hpp
  include/vapours/results/results_common.hpp
  include/vapours/results/time_results.hpp
  include/vapours/results/vi_results.hpp
  include/vapours/results/ns_results.hpp
  include/vapours/results/fs_results.hpp
  include/vapours/results/hipc_results.hpp
  include/vapours/results/os_results.hpp
  include/vapours/results/ro_results.hpp
  include/vapours/results/loader_results.hpp
  include/vapours/results/err_results.hpp
  include/vapours/results/ncm_results.hpp
  include/vapours/results/svc_results.hpp
  include/vapours/results/nim_results.hpp
  include/vapours/results/exosphere_results.hpp
  include/vapours/results/creport_results.hpp
  include/vapours/results/erpt_results.hpp
  include/vapours/results/kvdb_results.hpp
  include/vapours/results/dmnt_results.hpp
  include/vapours/results/updater_results.hpp
  include/vapours/results/fatal_results.hpp
  include/vapours/results/sm_results.hpp
  include/vapours/results/psc_results.hpp
  modules/nvn/nvnInit.cpp
 )
 target_include_directories(NintendoSDK PUBLIC include/)
 target_compile_options(NintendoSDK PRIVATE -fno-strict-aliasing)
 target_compile_options(NintendoSDK PRIVATE -Wall -Wextra)
 target_compile_options(NintendoSDK PRIVATE -Wno-invalid-offsetof)
 target_link_libraries(NintendoSDK PUBLIC)
--- a/include/NintendoSDK/README.md
+++ b/include/NintendoSDK/README.md
@ -1,10 +0,0 @@
 # nnheaders
 Repository of user created nnsdk headers.
 The header files contained herewithin are entirely user created via Reverse Engineering or publicly available sources (non stripped binaries containing symbols).
 Do not ask for or PR any copyrighted material to this repo. You will be ignored.
 # Credits
 - [Shadow](https://github.com/shadowninja108/) - For [Skyline](https://github.com/shadowninja108/Skyline), which was the primary inspiration and use case for this repo.
 - [Shibbo](https://github.com/shibbo) - For [OdysseyReversed](https://github.com/shibbo/OdysseyReversed/), which most of these headers came from.
--- a/include/NintendoSDK/include/nn/account.h
+++ b/include/NintendoSDK/include/nn/account.h
@ -1,57 +0,0 @@
 /**
 * @file account.h
 * @brief Account service implementation.
 */
 #pragma once
 #include <nn/os.h>
 #include <nn/types.h>
 namespace nn {
 namespace account {
 typedef char Nickname[0x21];
 typedef u64 NetworkServiceAccountId;
 class AsyncContext;
 class Uid {
 public:
    bool IsValid() const { return m_Storage[0] != 0 || m_Storage[1] != 0; }
    u64 m_Storage[2];
 };
 class UserHandle {
 public:
    Uid m_Uid;
    void* m_Handle;
 };
 void Initialize();
 Result ListAllUsers(s32*, Uid*, s32 numUsers);
 Result OpenUser(UserHandle*, Uid const&);
 Result IsNetworkServiceAccountAvailable(bool* out, UserHandle const&);
 void CloseUser(UserHandle const&);
 Result EnsureNetworkServiceAccountAvailable(UserHandle const& userHandle);
 Result EnsureNetworkServiceAccountIdTokenCacheAsync(AsyncContext*, UserHandle const&);
 Result LoadNetworkServiceAccountIdTokenCache(u64*, char*, u64, UserHandle const&);
 Result GetLastOpenedUser(Uid*);
 Result GetNickname(Nickname* nickname, Uid const& userID);
 Result GetUserId(Uid* uid, const UserHandle& handle);
 Result OpenPreselectedUser(UserHandle* handle);
 class AsyncContext {
 public:
    AsyncContext();
    Result HasDone(bool*);
    Result GetResult();
    Result Cancel();
    Result GetSystemEvent(nn::os::SystemEvent*);
 };
 };  // namespace account
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/aoc.h
+++ b/include/NintendoSDK/include/nn/aoc.h
@ -1,9 +0,0 @@
 #pragma once
 #include <nn/types.h>
 namespace nn::aoc {
 int ListAddOnContent(int*, int, int);
 }  // namespace nn::aoc
--- a/include/NintendoSDK/include/nn/atk/SoundArchivePlayer.h
+++ b/include/NintendoSDK/include/nn/atk/SoundArchivePlayer.h
@ -1,37 +0,0 @@
 /**
 * @file SoundArchivePlayer.h
 * @brief Basic sound player from a sound archive.
 */
 #pragma once
 #include <nn/atk/detail/AdvancedWaveSoundRuntime.h>
 #include <nn/atk/detail/SequenceSoundRuntime.h>
 #include <nn/atk/detail/SoundArchiveManager.h>
 #include <nn/atk/detail/StreamSoundRuntime.h>
 #include <nn/atk/detail/WaveSoundRuntime.h>
 namespace nn {
 namespace atk {
 class SoundArchivePlayer {
 public:
    SoundArchivePlayer();
    virtual ~SoundArchivePlayer();
    bool IsAvailable() const;
    void Finalize();
    void StopAllSound(s32, bool);
    void DisposeInstances();
    nn::atk::detail::SoundArchiveManager mArchiveManager;          // _8
    nn::atk::detail::SequenceSoundRuntime mSeqSoundRuntime;        // _50
    nn::atk::detail::WaveSoundRuntime mWaveSoundRuntime;           // _130
    nn::atk::detail::AdvancedWaveSoundRuntime mAdvancedWaveSound;  // _1B0
    nn::atk::detail::StreamSoundRuntime mStreamSoundRuntime;       // _1E0
    u64 _290;
    u32 _298;
    u8 _29C[0x2E8 - 0x29C];
 };
 };  // namespace atk
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/atk/SoundDataManager.h
+++ b/include/NintendoSDK/include/nn/atk/SoundDataManager.h
@ -1,25 +0,0 @@
 /**
 * @file SoundDataManager.h
 * @brief Sound data management implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace atk {
 class SoundDataManager {
 public:
    SoundDataManager();
    virtual ~SoundDataManager();
    virtual void InvalidateData(void const*, void const*);
    virtual void SetFileAddressToTable(u32, void const*);
    virtual u64 GetFileAddressFromTable(u32) const;
    virtual u32 GetFileAddressImpl(u32) const;
    u8 _0[0x240];
 };
 };  // namespace atk
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/atk/SoundPlayer.h
+++ b/include/NintendoSDK/include/nn/atk/SoundPlayer.h
@ -1,56 +0,0 @@
 /**
 * @file SoundPlayer.h
 * @brief Sound player.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace atk {
 enum PauseMode {
 };
 class SoundPlayer {
 public:
    SoundPlayer();
    ~SoundPlayer();
    void StopAllSound(s32);
    void Update();
    void DoFreePlayerHeap();
    void detail_SortPriorityList(bool);
    void PauseAllSound(s32, bool);
    void PauseAllSound(bool, s32, nn::atk::PauseMode);
    void SetVolume(f32 vol);
    void SetLowPassFilterFrequency(f32 filterFreq);
    void SetBiquadFilter(s32 filterType, f32 baseFreq);
    void SetDefaultOutputLine(u32 line);
    void detail_SetPlayableSoundLimit(s32 limit);
    bool CanPlaySound(s32);
    u64 _0;
    u64 _8;
    u64 _10;
    u64 _18;
    u64 _20;
    u64 _28;
    u64 _30;
    u64 _38;
    s32 _40;
    s32 mPlayableSoundCount;  // _44
    s32 _48;
    f32 mVolume;             // _4C
    f32 mLowPassFreq;        // _50
    s32 mFilterType;         // _54
    f32 mBaseFreq;           // _58
    u32 mDefaultOutputLine;  // _5C
    f32 mOutputVolume;       // _60
    u64 _64;
    u64 _6C;
 };
 };  // namespace atk
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/atk/detail/AdvancedWaveSoundRuntime.h
+++ b/include/NintendoSDK/include/nn/atk/detail/AdvancedWaveSoundRuntime.h
@ -1,28 +0,0 @@
 /**
 * @file AdvancedWaveSoundRuntime.h
 * @brief Runtime wave sound api.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace atk {
 namespace detail {
 class AdvancedWaveSoundRuntime {
 public:
    AdvancedWaveSoundRuntime();
    ~AdvancedWaveSoundRuntime();
    void Initialize(s32, void**, void const*);
    void Finalize();
    s32 GetActiveCount() const;
    void SetupUserParam(void**, u64);
    void Update();
    u8 _0[0x30];
 };
 };  // namespace detail
 };  // namespace atk
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/atk/detail/BasicSound.h
+++ b/include/NintendoSDK/include/nn/atk/detail/BasicSound.h
@ -1,137 +0,0 @@
 /**
 * @file BasicSound.h
 * @brief A basic sound.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace atk {
 class SoundActor;
 enum MixMode {
 };
 namespace detail {
 class PlayerHeap;
 class ExternalSoundPlayer;
 class BasicSound {
 public:
    BasicSound();
    virtual ~BasicSound();
    virtual void Initialize();
    virtual void Finalize();
    virtual bool IsPrepared() const = 0;
    virtual bool IsAttachedTempSpecialHandle() = 0;
    virtual void DetachTempSpecialHandle() = 0;
    virtual void OnUpdatePlayerPriority();
    virtual void UpdateMoveValue();
    virtual void OnUpdateParam();
    void SetPriority(s32, s32);
    void GetPriority(s32*, s32*) const;
    void ClearIsFinalizedForCannotAllocatedResourceFlag();
    void SetId(u32 newID);
    bool IsAttachedGeneralHandle();
    void DetachGeneralHandle();
    bool IsAttachedTempGeneralHandle();
    void DetachTempGeneralHandle();
    void StartPrepared();
    void Stop(s32);
    void SetPlayerPriority(s32);
    void ForceStop();
    void Pause(bool, s32);
    void Mute(bool, s32);
    void SetAutoStopCounter(s32);
    void FadeIn(s32);
    bool IsPause() const;
    bool IsMute() const;
    void Update();
    void UpdateParam();
    void UpdateMoveValue();
    void CalculateVolume() const;
    f32 CalculatePitch() const;
    f32 CalculateLpfFrequency() const;
    u32 CalculateOutLineFlag() const;
    void CalculateBiquadFilter(s32*, f32*) const;
    void AttachPlayerHeap(nn::atk::detail::PlayerHeap*);
    void DetachPlayerHeap(nn::atk::detail::PlayerHeap*);
    void AttachSoundPlayer(nn::atk::SoundPlayer*);
    void DetachSoundPlayer(nn::atk::SoundPlayer*);
    void AttachSoundActor(nn::atk::SoundActor*);
    void DetachSoundActor(nn::atk::SoundActor*);
    void AttachExternalSoundPlayer(nn::atk::detail::ExternalSoundPlayer*);
    void DetachExternalSoundPlayer(nn::atk::detail::ExternalSoundPlayer*);
    u32 GetRemainingFadeFrames() const;
    u32 GetRemainingPauseFadeFrames() const;
    u32 GetRemainingMuteFadeFrames() const;
    void SetInitialVolume(f32 vol);
    f32 GetInitialVolume() const;
    void SetVolume(f32, s32);
    s32 GetVolume() const;
    void SetPitch(f32);
    f32 GetPitch() const;
    void SetLpfFreq(f32);
    f32 GetLpfFreq() const;
    void SetBiquadFilter(s32, f32);
    void GetBiquadFilter(s32*, f32*) const;
    void SetOutputLine(u32);
    u32 GetOutputLine() const;
    void ResetOutputLine();
    void SetMixMode(nn::atk::MixMode);
    nn::atk::MixMode GetMixMode();
    void SetPan(f32);
    f32 GetPan() const;
    void SetSurroundPan(f32);
    f32 GetSurroundPan() const;
    void SetMainSend(f32);
    f32 GetMainSend() const;
    u64* _8;                             // nn::atk::detail::PlayerHeap*
    u64* _10;                            // nn::atk::SoundHandle*
    u64* _18;                            // nn::atk::SoundHandle*
    nn::atk::SoundPlayer* mSoundPlayer;  // _20
    u64* _28;                            // nn::atk::SoundActor*
    u64* _30;                            // nn::atk::detail::ExternalSoundPlayer*
    u64* _38;                            // nn::atk::SoundArchive*
    u8 _40[0xF0 - 0x40];
    s32 mPriority;  // _F0
    u32 _F4;
    u32 _F8;
    s32 mAutoStopCounter;  // _FC
    u64 _100;
    u32 mID;  // _108
    u32 _10C;
    u32 _110;
    u32 _114;
    f32 mInitialVolume;  // _118
    f32 mPitch;          // _11C
    f32 mLpfFreq;        // _120
    f32 _124;
    u32 mOutputLine;  // _128
    f32 _12C;
    f32 mVolume;  // _130
    u32 _134;
    u32 _138;
    nn::atk::MixMode mMixMode;  // _13C
    f32 mPan;                   // _140
    f32 mSurroundPan;           // _144
    f32 mMainSend;              // _148
    u8 _14C[0x158 - 0x14C];
    f32 mOutputVol;  // _158
    u8 _15C[0x190 - 0x15C];
    f32 mOutputPan;          // _190
    f32 mOutputSurroundPan;  // _194
    f32 mOutputMainSend;     // _198
    f32 mOutputFxSend;       // _19C
    static u64 g_LastInstanceId;
 };
 };  // namespace detail
 };  // namespace atk
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/atk/detail/SequenceSoundRuntime.h
+++ b/include/NintendoSDK/include/nn/atk/detail/SequenceSoundRuntime.h
@ -1,37 +0,0 @@
 /**
 * @file SequenceSoundRuntime.h
 * @brief Sequenced Sound Runtime Info
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace atk {
 namespace detail {
 class SoundArchiveManager;
 class SequenceSoundRuntime {
 public:
    SequenceSoundRuntime();
    ~SequenceSoundRuntime();
    void Initialize(s32, void**, void const*);
    void Finalize();
    void SetupSequenceTrack(s32, void**, void const*);
    void SetupUserParam(void**, u64);
    bool IsSoundArchiveAvailable() const;
    s32 GetActiveCount() const;
    s32 GetFreeCount() const;
    void SetSequenceSkipIntervalTick(s32 tick);
    s32 GetSequenceSkipIntervalTick();
    void Update();
    u8 _0[0xD0];
    nn::atk::detail::SoundArchiveManager* mArchiveManager;  // _D0
    u64 _D8;
 };
 };  // namespace detail
 };  // namespace atk
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/atk/detail/SoundArchiveManager.h
+++ b/include/NintendoSDK/include/nn/atk/detail/SoundArchiveManager.h
@ -1,42 +0,0 @@
 /**
 * @file SoundArchiveManager.h
 * @brief Sound archive manager implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace atk {
 class SoundHandle;
 class SoundArchive;
 class SoundDataManager;
 namespace detail {
 class AddonSoundArchiveContainer;
 class SoundArchiveManager {
 public:
    SoundArchiveManager();
    virtual ~SoundArchiveManager();
    void Initialize(nn::atk::SoundArchive const*, nn::atk::SoundDataManager const*);
    void ChangeTargetArchive(char const*);
    void Finalize();
    bool IsAvailable() const;
    nn::atk::detail::AddonSoundArchiveContainer* GetAddonSoundArchive(char const*) const;
    u64 _8;
    u64* _10;
    nn::atk::detail::AddonSoundArchiveContainer* _18;
    u64* _20;
    nn::atk::SoundArchive* mSoundArchive;  // _28
    u64 _30;
    u64 _38;
    u64 _40;
 };
 };  // namespace detail
 };  // namespace atk
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/atk/detail/StreamSoundRuntime.h
+++ b/include/NintendoSDK/include/nn/atk/detail/StreamSoundRuntime.h
@ -1,22 +0,0 @@
 /**
 * @file StreamSoundRuntime.h
 * @brief Stream sound runtime information.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace atk {
 namespace detail {
 class StreamSoundRuntime {
 public:
    StreamSoundRuntime();
    ~StreamSoundRuntime();
    u8 _0[0xB0];
 };
 };  // namespace detail
 };  // namespace atk
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/atk/detail/WaveSoundRuntime.h
+++ b/include/NintendoSDK/include/nn/atk/detail/WaveSoundRuntime.h
@ -1,29 +0,0 @@
 /**
 * @file WaveSoundRuntime.h
 * @brief Wave sound runtime info.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace atk {
 namespace detail {
 class WaveSoundRuntime {
 public:
    WaveSoundRuntime();
    ~WaveSoundRuntime();
    void Initialize(s32, void**, void const*);
    void Finalize();
    s32 GetActiveCount() const;
    s32 GetFreeWaveSoundCount() const;
    void SetupUserParam(void**, u64);
    void Update();
    u8 _0[0x80];
 };
 };  // namespace detail
 };  // namespace atk
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/audio.h
+++ b/include/NintendoSDK/include/nn/audio.h
@ -1,43 +0,0 @@
 /**
 * @file audio.h
 * @brief Audio implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace audio {
 struct AudioRendererConfig {
    u64* _0;
    u64* _8;
    u64* _10;
    u64* _18;
    u64* _20;
    u64* _28;
    u64* _30;
    u64* _38;
    u64* _40;
    u64* _48;
    u64* _50;
 };
 struct DelayType {
    u64* _0;
 };
 struct FinalMixType {
    u64* _0;
 };
 struct SubMixType {
    u64* _0;
 };
 void SetDelayInputOutput(nn::audio::DelayType*, s8 const*, s8 const*, s32);
 void* RemoveDelay(nn::audio::AudioRendererConfig*, nn::audio::DelayType*, nn::audio::FinalMixType*);
 void* RemoveDelay(nn::audio::AudioRendererConfig*, nn::audio::DelayType*, nn::audio::SubMixType*);
 bool IsDelayRemoveable(nn::audio::DelayType*);
 };  // namespace audio
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/bcat.h
+++ b/include/NintendoSDK/include/nn/bcat.h
@ -1,112 +0,0 @@
 /**
 * @file bcat.h
 * @brief BCAT service implementation.
 */
 #pragma once
 #include <nn/os.h>
 #include <nn/types.h>
 namespace nn {
 namespace bcat {
 struct DirectoryName {
    void isValid();
 };
 struct FileName {
    void isValid();
 };
 class DeliveryCacheDirectory {
 public:
    DeliveryCacheDirectory();
    ~DeliveryCacheDirectory();
    Result Open(nn::bcat::DirectoryName const&);
    Result GetCount();
    Result Close();
 };
 class DeliveryCacheFile {
 public:
    DeliveryCacheFile();
    ~DeliveryCacheFile();
    Result Open(nn::bcat::DirectoryName const&, nn::bcat::FileName const&);
    Result Read(size_t file1, s64, void*, size_t file2);
    Result GetSize();
    Result GetDigest();
    Result Close();
 };
 class DeliveryCacheProgress {
 public:
    DeliveryCacheProgress();
    ~DeliveryCacheProgress();
    Result Detach();
    Result Update();
    Result GetStatus();
    Result GetCurrentDirectoryName();
    Result GetCurrentFileName();
    Result GetCurrentDownloaded();
    Result GetCurrentTotale();
    Result GetWholeDownloaded();
    Result GetWholeTotal();
    Result GetResult();
    // void Attach(nn::bcat::detail::ipc::IDeliveryCacheProgressService*);
 };
 namespace detail {
 namespace DeliveryCacheProgressImpl {
 Result Clear();
 Result NotifyStartConnect();
 Result NotifyStartProcessList();
 Result SetWholeDownloadSize(s64);
 Result SetDownloadProgress(s64, nn::bcat::DirectoryName const&, nn::bcat::FileName const&, s64);
 Result NotifyStartDownloadFile(nn::bcat::DirectoryName const&, nn::bcat::FileName const&, s64);
 Result UpdateDownloadFileProgress(s64);
 Result NotifyStartCommitDirectory(nn::bcat::DirectoryName const&);
 Result NotifyDone(nn::Result);
 }  // namespace DeliveryCacheProgressImpl
 class ShimLibraryGlobal {
 public:
    ShimLibraryGlobal();
    ~ShimLibraryGlobal();
    Result Initialize();
    Result GetSession();
    Result MountDeliveryCacheStorage();
    Result IsDeliveryCacheStorageMounted();
    Result UnmountDeliveryCacheStorage();
    // void CreateFileService(nn::bcat::detail::ipc::IDeliveryCacheFileService**);
    // void CreateDirectoryService(nn::bcat::detail::ipc::IDeliveryCacheDirectoryService**)
    Result IncrementDeliveryCacheFileCount();
    Result DecrementDeliveryCacheFileCount();
    Result IncrementDeliveryCacheDirectoryCount();
    Result DecrementDeliveryCacheFileCount();
    Result EnumerateDeliveryCacheDirectory(int*, nn::bcat::DirectoryName*, int);
 };
 namespace ipc {
 Result Initialize();
 // void CreateBcatService(nn::bcat::detail::ipc::IBcatService**);
 Result Finalize();
 // void CreateBcatService(nn::bcat::detail::ipc::IBcatService**);
 // void CreateDeliveryCacheStorageService(nn::bcat::detail::ipc::IDeliveryCacheStorageService**);
 // void CreateDeliveryCacheStorageService(nn::bcat::detail::ipc::IDeliveryCacheStorageService**,
 // nn::ApplicationId);
 }  // namespace ipc
 }  // namespace detail
 Result Initialize();
 Result MountDeliveryCacheStorage();
 Result UnmountDeliveryCacheStorage();
 Result EnumerateDeliveryCacheDirectory(int*, nn::bcat::DirectoryName*, int);
 Result RequestSyncDeliveryCache(nn::bcat::DeliveryCacheProgress*);
 Result EnumerateDeliveryCacheDirectory(int*, nn::bcat::DirectoryName*, int);
 }  // namespace bcat
 }  // namespace nn
--- a/include/NintendoSDK/include/nn/crypto.h
+++ b/include/NintendoSDK/include/nn/crypto.h
@ -1,86 +0,0 @@
 /**
 * @file crypto.h
 * @brief Crypto service implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace crypto {
 void GenerateSha256Hash(void*, ulong, void const*, ulong);
 class Sha256Context;
 void DecryptAes128Cbc(void*, u64, void const*, u64, void const*, u64, void const*, u64);
 void EncryptAes128Cbc(void*, u64, void const*, u64, void const*, u64, void const*, u64);
 void DecryptAes128Ccm(void*, u64, void*, u64, void const*, u64, void const*, u64, void const*, u64,
                      void const*, u64, u64);
 namespace detail {
 class Md5Impl {
 public:
    void Initialize();
    void Update(void const*, u64 dataSize);
    void ProcessBlock();
    void GetHash(void*, u64 hashSize);
    void ProcessLastBlock();
    u32 _x0;
    u32 _x4;
    u32 _x8;
    u32 _xC;
    u8 _x10[0x50 - 0x10];
    u64 _x50;
    u32 _x58;
 };
 class Sha1Impl {
 public:
    void Initialize();
    void Update(void const*, u64);
    void ProcessBlock(void const*);
    void GetHash(void* destHash, u64);
    void ProcessLastBlock();
    u64 _x0;
    u64 _x8;
    u32 _x10;
    u128 _x14;
    u128 _x24;
    u128 _x34;
    u32 _x44;
    u64 _x48;
    u64 _x50;
    u64 _x58;
    u64 _x60;
 };
 class Sha256Impl {
 public:
    void Initialize();
    void Update(void const*, u64);
    void ProcessBlocks(u8 const*, u64);
    void GetHash(void* destHash, u64);
    void ProcessLastBlock();
    void InitializeWithContext(nn::crypto::Sha256Context const*);
    void GetContext(nn::crypto::Sha256Context*) const;
    u64 _x0;
    u64 _x8;
    u32 _x10;
    u128 _x14;
    u128 _x24;
    u128 _x34;
    u32 _x44;
    u64 _x48;
    u64 _x50;
    u64 _x58;
    u64 _x60;
    u64 _x68;
    u32 _x70;
 };
 };  // namespace detail
 };  // namespace crypto
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/diag.h
+++ b/include/NintendoSDK/include/nn/diag.h
@ -1,33 +0,0 @@
 /**
 * @file diag.h
 * @brief Module, logging, and symbol operations.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace diag {
 struct LogMetaData;
 struct ModuleInfo {
    char* mPath;
    u64 mBaseAddr;
    u64 mSize;
 };
 namespace detail {
 // LOG
 void LogImpl(nn::diag::LogMetaData const&, char const*, ...);
 void AbortImpl(char const*, char const*, char const*, s32);
 void AbortImpl(char const*, char const*, char const*, int, Result);
 };  // namespace detail
 // MODULE / SYMBOL
 u32* GetSymbolName(char* name, u64 nameSize, u64 addr);
 u64 GetRequiredBufferSizeForGetAllModuleInfo();
 s32 GetAllModuleInfo(nn::diag::ModuleInfo** out, void* buffer, u64 bufferSize);
 u64 GetSymbolSize(u64 addr);
 };  // namespace diag
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/friends.h
+++ b/include/NintendoSDK/include/nn/friends.h
@ -1,42 +0,0 @@
 /**
 * @file friends.h
 * @brief Friend implementation.
 */
 #pragma once
 #include <nn/account.h>
 #include <nn/os.h>
 namespace nn {
 namespace friends {
 typedef char Url[0xA0];
 class AsyncContext;
 class Profile;
 void Initialize();
 Result GetProfileList(nn::friends::AsyncContext* context, nn::friends::Profile* profiles,
                      nn::account::Uid const& userID,
                      nn::account::NetworkServiceAccountId const* accountIDs, s32 numAccounts);
 class Profile {
 public:
    Profile();
    nn::account::NetworkServiceAccountId GetAccountId() const;
    nn::account::Nickname& GetNickname() const;
    bool IsValid() const;
    Result GetProfileImageUrl(nn::friends::Url*, s32);
 };
 class AsyncContext {
 public:
    AsyncContext();
    ~AsyncContext();
    Result GetSystemEvent(nn::os::SystemEvent*);
    Result GetResult() const;
 };
 };  // namespace friends
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/fs.h
+++ b/include/NintendoSDK/include/nn/fs.h
@ -1,132 +0,0 @@
 /**
 * @file fs.h
 * @brief Filesystem implementation.
 */
 #pragma once
 #include <nn/account.h>
 #include <nn/types.h>
 namespace nn {
 typedef u64 ApplicationId;
 namespace fs {
 using namespace ams::fs;
 typedef u64 UserId;
 struct DirectoryEntry {
    char name[0x300 + 1];
    char _x302[3];
    u8 type;
    char _x304;
    s64 fileSize;
 };
 struct FileHandle {
    void* handle;
 };
 struct DirectoryHandle {
    void* handle;
 };
 enum DirectoryEntryType { DirectoryEntryType_Directory, DirectoryEntryType_File };
 enum OpenMode {
    OpenMode_Read = 1 << 0,
    OpenMode_Write = 1 << 1,
    OpenMode_Append = 1 << 2,
    OpenMode_ReadWrite = OpenMode_Read | OpenMode_Write
 };
 enum OpenDirectoryMode {
    OpenDirectoryMode_Directory = 1 << 0,
    OpenDirectoryMode_File = 1 << 1,
    OpenDirectoryMode_All = OpenDirectoryMode_Directory | OpenDirectoryMode_File,
 };
 struct ReadOption {
    u32 value;
    static const ReadOption None;
 };
 inline constexpr const ReadOption ReadOption::None = {0};
 enum WriteOptionFlag {
    WriteOptionFlag_Flush = 1 << 0,
 };
 struct WriteOption {
    int flags;
    static WriteOption CreateOption(int flags) {
        WriteOption op;
        op.flags = flags;
        return op;
    }
 };
 // ROM
 Result QueryMountRomCacheSize(size_t* size);
 Result QueryMountRomCacheSize(size_t* size, nn::ApplicationId);
 Result QueryMountAddOnContentCacheSize(size_t* size, int id);
 Result MountRom(char const* name, void* cache, size_t cache_size);
 Result MountAddOnContent(char const* name, int id, void* cache, size_t cache_size);
 bool CanMountRomForDebug();
 Result CanMountRom(nn::ApplicationId);
 Result QueryMountRomOnFileCacheSize(u64*, nn::fs::FileHandle);
 Result MountRomOnFile(char const*, nn::fs::FileHandle, void*, u64);
 // SAVE
 Result EnsureSaveData(nn::account::Uid const&);
 Result MountSaveData(char const*, nn::fs::UserId);
 Result MountSaveDataForDebug(char const*);
 Result CommitSaveData(const char* path);
 // FILE
 Result GetEntryType(nn::fs::DirectoryEntryType* type, char const* path);
 Result CreateFile(char const* filepath, s64 size);
 Result OpenFile(nn::fs::FileHandle*, char const* path, s32);
 Result SetFileSize(FileHandle fileHandle, s64 filesize);
 void CloseFile(FileHandle fileHandle);
 Result FlushFile(FileHandle fileHandle);
 Result DeleteFile(char const* filepath);
 Result ReadFile(u64* outSize, nn::fs::FileHandle handle, s64 offset, void* buffer, u64 bufferSize,
                const ReadOption& option);
 Result ReadFile(u64* outSize, nn::fs::FileHandle handle, s64 offset, void* buffer, u64 bufferSize);
 Result ReadFile(nn::fs::FileHandle handle, s64 offset, void* buffer, u64 bufferSize);
 Result WriteFile(FileHandle handle, s64 fileOffset, void const* buff, u64 size,
                 WriteOption const& option);
 Result GetFileSize(s64* size, FileHandle fileHandle);
 // DIRECTORY
 // there are three open modes; dir, file, all
 Result OpenDirectory(DirectoryHandle* handle, char const* path, s32 openMode);
 void CloseDirectory(DirectoryHandle directoryHandle);
 Result ReadDirectory(s64*, DirectoryEntry*, DirectoryHandle directoryHandle, s64);
 Result CreateDirectory(char const* directorypath);
 Result GetDirectoryEntryCount(s64*, DirectoryHandle);
 // SD
 Result MountSdCard(char const*);
 Result MountSdCardForDebug(char const*);
 bool IsSdCardInserted();
 Result FormatSdCard();
 Result FormatSdCardDryRun();
 bool IsExFatSupported();
 Result MountHost(char const* mount, char const* path);
 Result MountHostRoot();
 Result UnmountHostRoot();
 Result Unmount(char const* mount);
 // BCAT
 Result MountBcatSaveData(char const*, ApplicationId);
 Result CreateBcatSaveData(ApplicationId, s64);
 };  // namespace fs
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/g3d/BindFuncTable.h
+++ b/include/NintendoSDK/include/nn/g3d/BindFuncTable.h
@ -1,34 +0,0 @@
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace g3d {
 struct DDLDeclarations {
    u64 _0;
    u32 _8;
    u32 DDLDeclarations_xC;
    u64 _10;
    u64 _18;
 };
 struct nn::g3d::BindFuncTable::EntryPointer
 {
  _QWORD something_0;
  nn::g3d::BindFuncTable::StringLength *string;
 };
 struct nn::g3d::BindFuncTable::StringLength
 {
  size_t length;
  const char *content;
 };
 class BindFuncTable {
 private:
    int lengths[4];
    nn::g3d::BindFuncTable::EntryPointer strings[4];
 };
 };  // namespace g3d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/g3d/ResFile.h
+++ b/include/NintendoSDK/include/nn/g3d/ResFile.h
@ -1,75 +0,0 @@
 /**
 * @file ResFile.h
 * @brief Resource file for models.
 */
 #pragma once
 #include <nn/types.h>
 #include <nn/gfx/api.h>
 #include <nn/gfx/memory.h>
 #include <nn/util.h>
 namespace nn {
 namespace gfx {
 template <typename T>
 class TDevice;
 }
 namespace g3d {
 class ResModel;
 class ResMaterialAnim;
 class ResShapeAnim;
 class ResSceneAnim;
 typedef void* TextureRef;
 class ResFile : public nn::util::BinaryFileHeader {
 public:
    static bool IsValid(void const* modelSrc);
    void Relocate();
    void Unrelocate();
    static nn::g3d::ResFile* ResCast(void*);
    s32 BindTexture(nn::g3d::TextureRef (*ref)(char const*, void*), void*);
    void ReleaseTexture();
    void
    Setup(nn::gfx::TDevice<nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*);
    void
    Setup(nn::gfx::TDevice<nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*,
          nn::gfx::TMemoryPool<nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*,
          s64, u64);
    void
    Cleanup(nn::gfx::TDevice<nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*);
    void Reset();
    u64 mFileNameLength;                  // _20
    nn::g3d::ResModel* mModels;           // _28
    u64 mModelDictOffset;                 // _30
    u64 mSkeleAnimOffset;                 // _38
    u64 mSkeleAnimDictOffset;             // _40
    nn::g3d::ResMaterialAnim* mMatAnims;  // _48
    u64 mMatAnimsDictOffset;              // _50
    u64 mBoneVisiOffset;                  // _58
    u64 mBoneVisiDictOffset;              // _60
    nn::g3d::ResShapeAnim* mShapeAnims;   // _68
    u64 mShapeAnimDictOffset;             // _70
    nn::g3d::ResSceneAnim* mSceneAnims;   // _78
    u64 mSceneAnimDictOffset;             // _80
    u64 mMemoryPool;                      // _88
    u64 mBufferSection;                   // _90
    u64 mEmbeddedFilesOffset;             // _98
    u64 mEmbeddedFilesDictOffset;         // _A0
    u64 mPadding;                         // _A8
    u64 mStrTableOffset;                  // _B0
    u32 mStrTableSize;                    // _B8
    u16 mModelCount;                      // _BC
    u16 mSkeleAnimCount;                  // _BE
    u16 mMatAnimCount;                    // _C0
    u16 mBoneAnimCount;                   // _C2
    u16 mShapeAnimCount;                  // _C4
    u16 mSceneAnimCount;                  // _C6
    u16 mExternalFileCount;               // _C8
    u8 mPad[0x6];                         // _CA
 };
 };  // namespace g3d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/g3d/ResFogAnim.h
+++ b/include/NintendoSDK/include/nn/g3d/ResFogAnim.h
@ -1,21 +0,0 @@
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace g3d {
 class ResFogAnim {
 public:
    char mMagic[4];           // _0
    u16 mFlags;               // _4
    u16 mPad;                 // _6
    s32 mNumFrames;           // _8
    u8 mNumCurves;            // _C
    u8 mIdxDistanceAttnFunc;  // _D
    u16 mNumUserData;         // _E
    u32 mSizeBaked;           // _10
    u64 mNameOffset;          // _14
    u64 mFuncNameOffset;      // _1C
 };
 };  // namespace g3d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/g3d/ResLightAnim.h
+++ b/include/NintendoSDK/include/nn/g3d/ResLightAnim.h
@ -1,12 +0,0 @@
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace g3d {
 class ResLightAnim {
 public:
    s32 Bind(nn::g3d::BindFuncTable const&);
 };
 };  // namespace g3d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/g3d/ResMaterial.h
+++ b/include/NintendoSDK/include/nn/g3d/ResMaterial.h
@ -1,29 +0,0 @@
 /**
 * @file ResMaterial.h
 * @brief Resource material for models.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace g3d {
 typedef void* TextureRef;
 class ResMaterial {
 public:
    u64 BindTexture(nn::g3d::TextureRef (*)(char const*, void*), void*);
    void ForceBindTexture(nn::g3d::TextureRef const&, char const*);
    void ReleaseTexture();
    void
    Setup(nn::gfx::TDevice<nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<4>>>*);
    void
    Cleanup(nn::gfx::TDevice<nn::gfx::ApiVariation<nn::gfx::ApiType<8>, nn::gfx::ApiVersion<8>>>*);
    void Reset();
    void Reset(u32);
    u8 _0[0xB4];
 };
 };  // namespace g3d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/g3d/ResMaterialAnim.h
+++ b/include/NintendoSDK/include/nn/g3d/ResMaterialAnim.h
@ -1,19 +0,0 @@
 /**
 * @file ResMaterialAnim.h
 * @brief Resource file for material animations.
 */
 #pragma once
 namespace nn {
 namespace g3d {
 typedef void* TextureRef;
 class ResMaterialAnim {
 public:
    void ReleaseTexture();
    s32 BindTexture(nn::g3d::TextureRef (*)(char const*, void*), void*);
    void Reset();
 };
 };  // namespace g3d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/g3d/ResModel.h
+++ b/include/NintendoSDK/include/nn/g3d/ResModel.h
@ -1,32 +0,0 @@
 /**
 * @file ResModel.h
 * @brief Resource model.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace g3d {
 class ResMaterial;
 typedef void* TextureRef;
 class ResModel {
 public:
    u64 BindTexture(nn::g3d::TextureRef (*)(char const*, void*), void*);
    void ForceBindTexture(nn::g3d::TextureRef const&, char const*);
    void ReleaseTexture();
    void
    Setup(nn::gfx::TDevice<nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*);
    void
    Cleanup(nn::gfx::TDevice<nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*);
    void Reset();
    void Reset(u32);
    nn::g3d::ResMaterial* FindMaterial(char const* materialName) const;
    u8 _0[0x70];
 };
 };  // namespace g3d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/g3d/ResSceneAnim.h
+++ b/include/NintendoSDK/include/nn/g3d/ResSceneAnim.h
@ -1,41 +0,0 @@
 /**
 * @file ResSceneAnim.h
 * @brief Resource file for scene animations.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace g3d {
 class ResLightAnim;
 class ResFogAnim;
 struct BindFuncTable;
 class ResSceneAnim {
 public:
    s32 Bind(nn::g3d::BindFuncTable const&);
    void Release();
    void Reset();
    char mMagic[4];                      // _0
    s32 mBlockOffset;                    // _4
    u64 mBlockSize;                      // _8
    u64 mNameOffset;                     // _10
    u64 mPathOffset;                     // _18
    u64 mCameraAnimOffset;               // _20
    u64 mCameraAnimDictOffset;           // _28
    nn::g3d::ResLightAnim* mLightAnims;  // _30
    u64 mLightAnimDictOffset;            // _38
    nn::g3d::ResFogAnim* mFogAnims;      // _40
    u64 mFogAnimDictOffset;              // _48
    u64 mUserDataOffset;                 // _50
    u64 mUserDataDictOffset;             // _58
    u16 mUserDataCount;                  // _60
    u16 mCameraAnimCount;                // _62
    u16 mLightAnimCount;                 // _64
    u16 mFogAnimCount;                   // _66
 };
 };  // namespace g3d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/g3d/ResShapeAnim.h
+++ b/include/NintendoSDK/include/nn/g3d/ResShapeAnim.h
@ -1,15 +0,0 @@
 /**
 * @file ResShapeAnim.h
 * @brief Resource file for shape animations.
 */
 #pragma once
 namespace nn {
 namespace g3d {
 class ResShapeAnim {
 public:
    void Reset();
 };
 };  // namespace g3d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/g3d/ResSkeletalAnim.h
+++ b/include/NintendoSDK/include/nn/g3d/ResSkeletalAnim.h
@ -1,15 +0,0 @@
 /**
 * @file ResSkeletalAnim.h
 * @brief Resource file for skeletal animations.
 */
 #pragma once
 namespace nn {
 namespace g3d {
 class ResSkeletalAnim {
 public:
    void Reset();
 };
 };  // namespace g3d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/gfx/api.h
+++ b/include/NintendoSDK/include/nn/gfx/api.h
@ -1,22 +0,0 @@
 /**
 * @file api.h
 * @brief GFX API version and typing.
 */
 #pragma once
 namespace nn {
 namespace gfx {
 // passes both ApiType<4> and ApiVersion<8>
 template <typename T, typename T2>
 class ApiVariation {};
 // usually passed as just a 4
 template <int T>
 class ApiType {};
 // usually passed as just a 8
 template <int T>
 class ApiVersion {};
 };  // namespace gfx
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/gfx/buffer.h
+++ b/include/NintendoSDK/include/nn/gfx/buffer.h
@ -1,28 +0,0 @@
 /**
 * @file buffer.h
 * @brief GFX Buffers.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace gfx {
 class BufferInfo {
 public:
    void SetDefault();
    u64 mInfo;  // _0
 };
 class BufferTextureViewInfo {
 public:
    void SetDefault();
    u64 _0;
    u64 _8;
    u64 _10;
 };
 };  // namespace gfx
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/gfx/detail/bufferimpl.h
+++ b/include/NintendoSDK/include/nn/gfx/detail/bufferimpl.h
@ -1,55 +0,0 @@
 /**
 * @file bufferimpl.h
 * @brief Buffer implementation for GFX.
 */
 #pragma once
 namespace nn {
 namespace gfx {
 class GpuAddress;
 class BufferInfo;
 namespace detail {
 template <typename T>
 class MemoryPoolImpl;
 template <typename T>
 class DeviceImpl;
 template <typename T>
 class BufferImpl {
 public:
    BufferImpl();
    ~BufferImpl();
    void Initialize(nn::gfx::detail::DeviceImpl<
                        nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*,
                    nn::gfx::BufferInfo const&,
                    nn::gfx::detail::MemoryPoolImpl<
                        nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*,
                    s64, u64);
    void Finalize(nn::gfx::detail::DeviceImpl<
                  nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*);
    void* Map() const;
    void Unmap() const;
    void FlushMappedRange(s64, u64) const;
    void InvalidateMappedRange(s64, u64) const;
    void GetGpuAddress(nn::gfx::GpuAddress*) const;
    T* mBuff;  // _0
 };
 template <typename T>
 class CommandBufferImpl {
 public:
    CommandBufferImpl();
    ~CommandBufferImpl();
    void Reset();
    void Begin();
    void End();
    void Dispatch(s32, s32, s32);
 };
 };  // namespace detail
 };  // namespace gfx
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/gfx/detail/deviceimpl.h
+++ b/include/NintendoSDK/include/nn/gfx/detail/deviceimpl.h
@ -1,24 +0,0 @@
 /**
 * @file deviceimpl.h
 * @brief Device implementation for GFX.
 */
 #pragma once
 namespace nn {
 namespace gfx {
 class DeviceInfo;
 namespace detail {
 template <typename T>
 class DeviceImpl {
 public:
    DeviceImpl();
    ~DeviceImpl();
    void Initialize(nn::gfx::DeviceInfo const& deviceInfo);
    void Finalize();
 };
 };  // namespace detail
 };  // namespace gfx
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/gfx/detail/pool.h
+++ b/include/NintendoSDK/include/nn/gfx/detail/pool.h
@ -1,41 +0,0 @@
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace gfx {
 struct MemoryPoolInfo;
 template <typename T>
 struct DeviceImpl;
 namespace detail {
 class MemoryPoolData {
 public:
    void SetDefault();
    s32 _0;  // set to 0x88
    s32 _4;
    u64 _8;
 };
 template <typename T>
 class MemoryPoolImpl {
 public:
    MemoryPoolImpl();
    ~MemoryPoolImpl();
    void Initialize(nn::gfx::detail::DeviceImpl<
                        nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*,
                    nn::gfx::MemoryPoolInfo const&);
    void Finalize(nn::gfx::detail::DeviceImpl<
                  nn::gfx::ApiVariation<nn::gfx::ApiType<4>, nn::gfx::ApiVersion<8>>>*);
    void* Map() const;
    void Unmap() const;
    void FlushMappedRange(s64, u64) const;
    void InvalidateMappedRange(s64, u64) const;
    u8 _0[0x120];  // pool data
 };
 };  // namespace detail
 };  // namespace gfx
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/gfx/device.h
+++ b/include/NintendoSDK/include/nn/gfx/device.h
@ -1,20 +0,0 @@
 /**
 * @file device.h
 * @brief Device implementation for GFX.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace gfx {
 class DeviceInfo {
 public:
    u64 mInfo;  // _0
 };
 template <typename T>
 class TDevice {};
 };  // namespace gfx
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/gfx/memory.h
+++ b/include/NintendoSDK/include/nn/gfx/memory.h
@ -1,14 +0,0 @@
 /**
 * @file memory.h
 * @brief GFX Memory Pool.
 */
 #pragma once
 namespace nn {
 namespace gfx {
 // todo: finish me!
 template <typename T>
 class TMemoryPool {};
 };  // namespace gfx
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/hid.h
+++ b/include/NintendoSDK/include/nn/hid.h
@ -1,43 +0,0 @@
 /**
 * @file hid.h
 * @brief Functions that help process gamepad inputs.
 */
 #pragma once
 #include <nn/types.h>
 #include <nn/util.h>
 namespace nn {
 namespace hid {
 struct NpadHandheldState;
 struct NpadStyleTag;
 struct ControllerSupportArg {
    u8 mMinPlayerCount;
    u8 mMaxPlayerCount;
    u8 mTakeOverConnection;
    bool mLeftJustify;
    bool mPermitJoyconDual;
    bool mSingleMode;
    bool mUseColors;
    sead::Color4u8 mColors[4];
    u8 mUsingControllerNames;
    char mControllerNames[4][0x81];
 };
 struct ControllerSupportResultInfo {
    int mPlayerCount;
    int mSelectedId;
 };
 void InitializeNpad();
 void SetSupportedNpadIdType(u32 const*, u64);
 void SetSupportedNpadStyleSet(nn::util::BitFlagSet<32, nn::hid::NpadStyleTag>);
 void GetNpadStyleSet(u32 const&);
 void GetNpadStates(nn::hid::NpadHandheldState*, s32, u32 const&);
 static int ShowControllerSupport(nn::hid::ControllerSupportResultInfo*,
                                 ControllerSupportArg const&);
 };  // namespace hid
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/image.h
+++ b/include/NintendoSDK/include/nn/image.h
@ -1,50 +0,0 @@
 /**
 * @file image.h
 * @brief JPEG decoding library.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace image {
 // there's probably more
 enum JpegStatus {
    OK = 0,
    INVALID_FORMAT = -32,
    UNSUPPORTED_FORMAT = -33,
    OUT_OF_MEMORY = -64,
 };
 enum PixelFormat { RGBA32, RGB24 };
 enum ProcessStage { UNREGISTERED = 0, REGISTERED = 1, ANALYZED = 2 };
 struct Dimension {
    f32 width;
    f32 height;
 };
 class JpegDecoder {
 public:
    JpegDecoder();
    virtual ~JpegDecoder();
    void SetImageData(void const* source, u64 size);
    nn::image::JpegStatus Analyze();
    nn::image::Dimension GetAnalyzedDimension() const;
    s64 GetAnalyzedWorkBufferSize() const;
    JpegStatus Decode(void* out, s64, s32 alignment, void*, s64);
    nn::image::ProcessStage mProcessStage;  // _8
    void* mData;                            // _C
    s64 mSize;                              // _14
    s32 _18;
    nn::image::PixelFormat mFormat;  // _1C
    Dimension mImgDimensions;        // _20
    s64 _28;
    // rest is related to EXIF processing
 };
 };  // namespace image
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/init.h
+++ b/include/NintendoSDK/include/nn/init.h
@ -1,21 +0,0 @@
 /**
 * @file init.h
 * @brief Initialization functions for OS related functions.
 */
 #pragma once
 #include <nn/mem.h>
 #include <nn/types.h>
 namespace nn {
 namespace init {
 void InitializeAllocator(void* addr, u64 size);
 nn::mem::StandardAllocator* GetAllocator();
 namespace detail {
 void* DefaultAllocatorForThreadLocal(u64, u64);
 void* DefaultDeallocatorForThreadLocal(void*, u64);
 };  // namespace detail
 }  // namespace init
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/mem.h
+++ b/include/NintendoSDK/include/nn/mem.h
@ -1,30 +0,0 @@
 /**
 * @file mem.h
 * @brief Memory allocation functions.
 */
 #pragma once
 #include <nn/os.h>
 #include <nn/types.h>
 namespace nn {
 namespace mem {
 class StandardAllocator {
 public:
    StandardAllocator();
    void Initialize(void* address, u64 size);
    void Finalize();
    void* Reallocate(void* address, u64 newSize);
    void* Allocate(u64 size);
    void Free(void* address);
    void Dump();
    bool mIsInitialized;         // _0
    bool mIsEnabledThreadCache;  // _1
    u16 _2;
    u64* mAllocAddr;  // _4
 };
 };  // namespace mem
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/RootObject.h
+++ b/include/NintendoSDK/include/nn/nex/RootObject.h
@ -1,30 +0,0 @@
 /**
 * @file RootObject.h
 * @brief RootObject for NEX.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace nex {
 class RootObject {
 public:
    enum TargetPool {};
    virtual ~RootObject();
    void* operator new(u64);
    void operator delete(void*);
    void* operator new(u64, char const*, u32);
    void* operator new[](u64);
    void* operator new[](u64, char const*, u32);
    void operator delete[](void*);
    void operator delete(void*, char const*, u32);
    void operator delete[](void*, char const*, u32);
    void* operator new(u64, nn::nex::RootObject::TargetPool);
    void* operator new(u64, nn::nex::RootObject::TargetPool, char const*, u32);
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/auth.h
+++ b/include/NintendoSDK/include/nn/nex/auth.h
@ -1,20 +0,0 @@
 /**
 * @file auth.h
 * @brief Authorization for DDL.
 */
 #pragma once
 #include <nn/nex/ddl.h>
 namespace nn {
 namespace nex {
 class NintendoAuthenticationDDLDeclarations : public nn::nex::DDLDeclarations {
 public:
    virtual ~NintendoAuthenticationDDLDeclarations();
    virtual void Init();
    void Register();
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/buffer.h
+++ b/include/NintendoSDK/include/nn/nex/buffer.h
@ -1,25 +0,0 @@
 /**
 * @file buffer.h
 * @brief NEX buffer implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace nex {
 class String;
 // todo
 class Buffer {
 public:
    Buffer(nn::nex::Buffer const&);
    Buffer(nn::nex::Buffer&&);
    Buffer(nn::nex::String const&);
    void FreeDataBuffer(u8*, u64);
    virtual ~Buffer();
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/cache.h
+++ b/include/NintendoSDK/include/nn/nex/cache.h
@ -1,33 +0,0 @@
 /**
 * @file cache.h
 * @brief NEX Cache Mangement.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace nex {
 class String;
 class BasicCache;
 class CacheManager {
 public:
    CacheManager();
    ~CacheManager();
    nn::nex::BasicCache* GetCache(nn::nex::String const&);
 };
 class BasicCache {
 public:
    BasicCache(nn::nex::String const&);
    virtual ~BasicCache();
    u64 _8;
    u8 _10;
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/checksum.h
+++ b/include/NintendoSDK/include/nn/nex/checksum.h
@ -1,61 +0,0 @@
 /**
 * @file checksum.h
 * @brief NEX Checksum Implementation.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 namespace nn {
 namespace nex {
 class Buffer;
 class ChecksumAlgorithm : public nn::nex::RootObject {
 public:
    ChecksumAlgorithm();
    virtual ~ChecksumAlgorithm();
    virtual bool ComputeChecksum(nn::nex::Buffer const&, nn::nex::Buffer*) = 0;
    // virtual bool ComputeChecksum(u8 const **, u64 const *, u64, nn::nex::SignatureBytes &) = 0;
    virtual bool IsReady() const;
    virtual void ComputeChecksumForTransport(u8 const*, u64);
    virtual u32 ComputeChecksumForTransportArray(u8 const**, u64 const*, u64) = 0;
    virtual u32 GetChecksumLength() = 0;
    u64 _8;
    u8 _10;
 };
 class MD5Checksum : public nn::nex::ChecksumAlgorithm {
 public:
    MD5Checksum();
    virtual ~MD5Checksum();
    virtual bool ComputeChecksum(nn::nex::Buffer const&, nn::nex::Buffer*);
    virtual u32 ComputeChecksumForTransportArray(u8 const**, u64 const*, u64);
    virtual u32 GetChecksumLength();
 };
 class CRC16Checksum : public nn::nex::ChecksumAlgorithm {
 public:
    CRC16Checksum();
    virtual ~CRC16Checksum();
    virtual bool ComputeChecksum(nn::nex::Buffer const&, nn::nex::Buffer*);
    virtual u32 ComputeChecksumForTransportArray(u8 const**, u64 const*, u64);
    virtual u32 GetChecksumLength();
 };
 /*
 this actually inherits some sort of KeyedChecksum thing. whatever
 class HMACChecksum : public nn::nex::ChecksumAlgorithm
 {
 };
 */
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/client.h
+++ b/include/NintendoSDK/include/nn/nex/client.h
@ -1,111 +0,0 @@
 /**
 * @file client.h
 * @brief Client implementations for NEX.
 */
 #pragma once
 #include <nn/nex/system.h>
 namespace nn {
 namespace nex {
 class Credentials;
 class EndPoint;
 class Message;
 class ProtocolCallContext;
 class ProtocolRequestBrokerInterface;
 class Protocol : public nn::nex::SystemComponent {
 public:
    enum _Command { Response, Request };
    enum _Type {
        Client,  // implemented in nn::nex::ClientProtocol
        Server   // implemented in nn::nex::ServerProtocol
    };
    Protocol(u32);
    virtual ~Protocol();
    virtual char* GetType() const;
    virtual bool IsAKindOf(char const*) const;
    virtual void EnforceDeclareSysComponentMacro();
    virtual bool BeginInitialization();
    virtual bool BeginTermination();
    virtual nn::nex::Protocol::_Type GetProtocolType() const = 0;
    virtual void EndPointDisconnected(nn::nex::EndPoint*);
    virtual void FaultDetected(nn::nex::EndPoint*, u32);
    virtual nn::nex::Protocol* Clone() const;
    virtual bool Reload();
    nn::nex::EndPoint* GetOutgoingConnection() const;
    void SetIncomingConnection(nn::nex::EndPoint*);
    void SetProtocolID(u16);
    void AddMethodID(nn::nex::Message*, u32);
    void CopyMembers(nn::nex::Protocol const*);
    void AssociateProtocolRequestBroker(nn::nex::ProtocolRequestBrokerInterface*);
    void ClearFlag(u32 newFlag);
    static void ExtractProtocolKey(nn::nex::Message*, nn::nex::Protocol::_Command&, u16&);
    static bool IsOldRVDDLVersion(nn::nex::EndPoint*);
    u16 mProtocolID;  // _48
    u16 _4A;
    u32 _4C;
    nn::nex::EndPoint* mOutgoingConnection;                     // _50
    nn::nex::ProtocolRequestBrokerInterface* mBrokerInterface;  // _58
    u32 mFlags;                                                 // _60
    u32 _64;
    nn::nex::EndPoint* mIncomingConnection;  // _68
    u32 mUseLoopback;                        // _70 (boolean)
    u32 _74;
    u64 _78;
    u32 _80;
    u32 _84;
 };
 class ClientProtocol : public nn::nex::Protocol {
 public:
    ClientProtocol(u32);
    virtual ~ClientProtocol();
    virtual char* GetType() const;
    virtual bool IsAKindOf(char const*) const;
    virtual void EnforceDeclareSysComponentMacro();
    virtual nn::nex::Protocol::_Type GetProtocolType() const = 0;
    virtual void ExtractCallSpecificResults(nn::nex::Message*, nn::nex::ProtocolCallContext*) = 0;
    virtual nn::nex::ClientProtocol* CreateResponder() const = 0;
    virtual void SetDefaultCredentials(nn::nex::Credentials*);
    bool SendOverLocalLoopback(nn::nex::ProtocolCallContext*, nn::nex::Message*);
    bool SendRMCMessage(nn::nex::ProtocolCallContext*, nn::nex::Message*);
    void ProcessResponse(nn::nex::Message*, nn::nex::EndPoint*);
    nn::nex::Credentials* mCredentials;  // _88
 };
 class ServerProtocol : public nn::nex::Protocol {
 public:
    ServerProtocol(u32);
    virtual ~ServerProtocol();
    virtual char* GetType() const;
    virtual bool IsAKindOf(char const*) const;
    virtual void EnforceDeclareSysComponentMacro();
    virtual nn::nex::Protocol::_Type GetProtocolType() const = 0;
    virtual void DispatchProtocolMessage(nn::nex::Message*, nn::nex::Message*, bool*,
                                         nn::nex::EndPoint*) = 0;
    virtual void DispatchProtocolMessageWithAttemptCount(u64, nn::nex::Message*, nn::nex::Message*,
                                                         bool*, int*, nn::nex::EndPoint*);
    virtual bool UseAttemptCountMethod();
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/data.h
+++ b/include/NintendoSDK/include/nn/nex/data.h
@ -1,21 +0,0 @@
 /**
 * @file data.h
 * @brief NEX Data.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 namespace nn {
 namespace nex {
 class Data : public nn::nex::RootObject {
 public:
    Data();
    virtual ~Data();
    u8 _8;
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/ddl.h
+++ b/include/NintendoSDK/include/nn/nex/ddl.h
@ -1,40 +0,0 @@
 /**
 * @file ddl.h
 * @brief DDL Declaration Implementation.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 namespace nn {
 namespace nex {
 class DDLDeclarations : public nn::nex::RootObject {
 public:
    DDLDeclarations(bool);
    virtual ~DDLDeclarations();
    virtual void Init() = 0;
    void RegisterIfRequired();
    void Unregister();
    static void UnregisterAll();
    void LoadAll();
    void Load();
    void UnloadAll();
    void Unload();
    void ResetDOClassIDs();
    u32 mNumDecsLoaded;  // _8
    u8 DDLDeclarations_xC;
    u8 _D;  // padding
    u8 _E;  // ^^
    u8 _F;  // ^^
    u64 _10;
    bool _18;
    static nn::nex::DDLDeclarations* s_pFirstDDLDecl;
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/dynamic.h
+++ b/include/NintendoSDK/include/nn/nex/dynamic.h
@ -1,21 +0,0 @@
 /**
 * @file dynamic.h
 * @brief NEX Dyamnic Runtime.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 namespace nn {
 namespace nex {
 class DynamicRunTimeInterface : public nn::nex::RootObject {
 public:
    DynamicRunTimeInterface();
    virtual ~DynamicRunTimeInterface();
    u64* GetInstance();
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/encryption.h
+++ b/include/NintendoSDK/include/nn/nex/encryption.h
@ -1,61 +0,0 @@
 /**
 * @file encryption.h
 * @brief NEX Encryption Algorithm.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 namespace nn {
 namespace nex {
 class Buffer;
 class Key;
 class EncryptionAlgorithm : public nn::nex::RootObject {
 public:
    EncryptionAlgorithm(u32, u32);
    virtual ~EncryptionAlgorithm();
    virtual bool Encrypt(nn::nex::Buffer const&, nn::nex::Buffer*) = 0;
    virtual bool Encrypt(nn::nex::Buffer*);
    virtual bool Decrypt(nn::nex::Buffer const&, nn::nex::Buffer*) = 0;
    virtual bool Decrypt(nn::nex::Buffer*);
    virtual bool GetErrorString(u32, char* destStr, u64 errLen);
    virtual void KeyHasChanged();
    bool SetKey(nn::nex::Key const& key);
    u64 _8;
    u64 _10;
    u64 _18;
    u64 _20;
    u64 _28;
    u64 _30;
    u64 _38;
    u64 _40;
 };
 class RC4Encryption : public nn::nex::EncryptionAlgorithm {
 public:
    RC4Encryption();
    virtual ~RC4Encryption();
    virtual bool Encrypt(nn::nex::Buffer const&, nn::nex::Buffer*);
    virtual bool Encrypt(nn::nex::Buffer*);
    virtual bool Decrypt(nn::nex::Buffer const&, nn::nex::Buffer*);
    virtual bool Decrypt(nn::nex::Buffer*);
    virtual void KeyHasChanged();
    void GetDefaultKey();
    void PrepareEncryption();
    void ReinitStateArray();
    void SetReinitEverytime(bool);
    u8 _48[0x298 - 0x48];
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/hash.h
+++ b/include/NintendoSDK/include/nn/nex/hash.h
@ -1,35 +0,0 @@
 /**
 * @file hash.h
 * @brief NEX Hash Implementation.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 #include <nn/crypto.h>
 namespace nn {
 namespace nex {
 class MD5 : public nn::crypto::detail::Md5Impl, public nn::nex::RootObject {
 public:
    MD5();
    void init();
    void raw_digest(u8*);
    void hex_digest();
    u8 _5C[0x74 - 0x5C];
 };
 class Sha1 : public nn::crypto::detail::Sha1Impl, public nn::nex::RootObject {
 public:
    Sha1();
    void Update(void const*, u64);
    void GetHash(void*, u64);
    void GenerateHash(void*, u64, void const*, u64);
    u32 _68;
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/instance.h
+++ b/include/NintendoSDK/include/nn/nex/instance.h
@ -1,46 +0,0 @@
 /**
 * @file instance.h
 * @brief NEX Instance Controllers.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 namespace nn {
 namespace nex {
 class InstanceTable;
 class InstanceControl : public nn::nex::RootObject {
 public:
    InstanceControl(u32, u32);
    u32 mInstanceContext;     // _8
    u32 mInstanceType;        // _C
    void* mDelegateInstance;  // _10
    bool mIsValidControl;     // _18
    u8 _19;                   // probably padding
    u8 _1A;
    u8 _1B;
    static nn::nex::InstanceTable* s_oInstanceTable;
 };
 class InstanceTable : public nn::nex::RootObject {
 public:
    InstanceTable();
    virtual ~InstanceTable();
    bool AddInstance(nn::nex::InstanceControl*, u32, u32);
    void DelInstance(nn::nex::InstanceControl*, u32, u32);
    u32 CreateContext();
    bool DeleteContext(u32);
    void AllocateExtraContexts(u64 size);
    void FreeExtraContexts();
    u32 GetHighestID() const;
    u32 FindInstanceContext(nn::nex::InstanceControl*, u32);
    u8 _0[0x94];
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/key.h
+++ b/include/NintendoSDK/include/nn/nex/key.h
@ -1,39 +0,0 @@
 /**
 * @file key.h
 * @brief NEX Key Implementation.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 namespace nn {
 namespace nex {
 class String;
 class Key : public nn::nex::RootObject {
 public:
    Key();
    Key(u8 const* src, u64 size);
    Key(u64 size);
    Key(nn::nex::Key const&);
    Key(nn::nex::String const&);
    virtual ~Key();
    u64* GetContentPtr();
    u64 GetLength() const;
    nn::nex::Key& operator=(nn::nex::Key const&);
    bool operator==(nn::nex::Key const&);
    bool operator!=(nn::nex::Key const&);
    void PrepareContentPtr(u64);
    nn::nex::String* ToString();
    void ExtractToString(nn::nex::String*) const;
    void Trace(u64) const;
    void GenerateRandomKey(u64);
    u64* mContentPtrStart;  // _10
    u64* mContentPtrEnd;    // _18
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/plugin.h
+++ b/include/NintendoSDK/include/nn/nex/plugin.h
@ -1,33 +0,0 @@
 /**
 * @file plugin.h
 * @brief Plugin interface for NEX.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 namespace nn {
 namespace nex {
 class PluginObject : public nn::nex::RootObject {};
 class Plugin : public nn::nex::RootObject {
 public:
    Plugin();
    virtual ~Plugin();
    // there's a bunch of pure virtual methods but nothing ever inherits this class...
    virtual bool Initalize();
    virtual void ThreadAttach();
    virtual void ThreadDetach();
    virtual void Destroy();
    void SetLibrary(void*);
    void* mLibrary;  // _8s
    static nn::nex::Plugin* s_pInstance;
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/pseudo.h
+++ b/include/NintendoSDK/include/nn/nex/pseudo.h
@ -1,80 +0,0 @@
 /**
 * @file psuedo.h
 * @brief Psuedo variable implementation for NEX.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 #include <nn/nex/instance.h>
 namespace nn {
 namespace nex {
 class PseudoGlobalVariableList;
 class PseudoGlobalVariableRoot : public nn::nex::RootObject {
 public:
    PseudoGlobalVariableRoot();
    virtual ~PseudoGlobalVariableRoot();
    virtual void AllocateExtraContexts() = 0;
    virtual void FreeExtraContexts() = 0;
    virtual void ResetContext(u32) = 0;
    virtual PseudoGlobalVariableRoot* GetNext() = 0;
    virtual void SetNext(PseudoGlobalVariableRoot* pNextVariable) = 0;
    static void ResetContextForAllVariables(u32);
    static void AllocateExtraContextsForAllVariables(u64);
    static void FreeExtraContextsForAllVariables();
    static s64 GetNbOfExtraContexts();
    nn::nex::PseudoGlobalVariableRoot* mNextRoot;  // _8
    static s64 s_uiNbOfExtraContexts;
    static PseudoGlobalVariableList s_oList;
 };
 class PseudoGlobalVariableList : public nn::nex::RootObject {
 public:
    PseudoGlobalVariableList();
    virtual ~PseudoGlobalVariableList();
    void AddVariable(nn::nex::PseudoGlobalVariableRoot*);
    void RemoveVariable(nn::nex::PseudoGlobalVariableRoot*);
    static nn::nex::PseudoGlobalVariableRoot* GetVariable(u32 idx);
    static u32 FindVariableIndex(nn::nex::PseudoGlobalVariableRoot*);
    void AllocateExtraContextsForAllVariables();
    void FreeExtraContextsForAllVariables();
    void ResetContextForAllVariables(u32);
    static u32 GetNbOfVariables();
    static PseudoGlobalVariableRoot* s_pVariableListHead;
    static u32 m_uiNbOfVariables;
 };
 template <typename T>
 class PseudoGlobalVariable : public nn::nex::PseudoGlobalVariableRoot {
 public:
    PseudoGlobalVariable();
    virtual ~PseudoGlobalVariable();
    virtual void AllocateExtraContexts();
    virtual void FreeExtraContexts();
    virtual void ResetContext(u32);
    virtual PseudoGlobalVariableRoot* GetNext();
    virtual void SetNext(PseudoGlobalVariableRoot* pNextVariable);
 };
 class PseudoSingleton : public nn::nex::InstanceControl {
 public:
    PseudoSingleton(u32);
    virtual ~PseudoSingleton();
    static bool s_bUseInstantiationContext;
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/reference.h
+++ b/include/NintendoSDK/include/nn/nex/reference.h
@ -1,18 +0,0 @@
 /**
 * @file reference.h
 * @brief Reference implementations for NEX.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 namespace nn {
 namespace nex {
 class RefCountedObject : public nn::nex::RootObject {
 public:
    virtual ~RefCountedObject();
    u32 _8;
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/socket.h
+++ b/include/NintendoSDK/include/nn/nex/socket.h
@ -1,73 +0,0 @@
 #pragma once
 #include <arpa/inet.h> //FIXME requires proper musl-setup
 #include <sys/socket.h>
 #include "RootObject.h"
 namespace nn {
 namespace nex {
 class TransportProtocol {
 public:
    enum Type {
        Sock_Default = 0,
        Sock_Stream = SOCK_STREAM,
        Sock_DGram = SOCK_DGRAM,
        Sock_Raw = SOCK_RAW,
        Sock_SeqPacket = SOCK_SEQPACKET,
        Sock_NonBlock = SOCK_NONBLOCK
    };
 };
 class SocketDriver : nn::nex::RootObject {
 public:
    typedef in_addr_t InetAddress;
    enum _SocketFlag : int32_t {
        Msg_None = 0,
        Msg_Oob = MSG_OOB,
        Msg_Peek = MSG_PEEK,
        Msg_DontRoute = MSG_DONTROUTE,
        Msg_Eor = MSG_EOR,
        Msg_Trunc = MSG_TRUNC,
        Msg_CTrunc = MSG_CTRUNC,
        Msg_WaitAll = MSG_WAITALL,
        Msg_DontWait = MSG_DONTWAIT,
        Msg_Eof = MSG_EOF,
        Msg_Notification = MSG_NOTIFICATION,
        Msg_Nbio = MSG_NBIO,
        Msg_Compat = MSG_COMPAT,
        //    Msg_SoCallbck = MSG_SOCALLBCK,
        //    Msg_NoSignal = MSG_NOSIGNAL,
        Msg_CMsg_CloExec = MSG_CMSG_CLOEXEC
    };
    class Socket {
        virtual void Open(nn::nex::TransportProtocol::Type);
        virtual void Close();
        virtual void Bind(ushort&);
        virtual void RecvFrom(uchar*, ulong, InetAddress*, ulong*,
                              nn::nex::SocketDriver::_SocketFlag);
        virtual void SendTo(uchar const*, ulong, nn::nex::SocketDriver::InetAddress const&, ulong*);
    };
    class PollInfo {};
    virtual Socket* Create();
    virtual void Delete(Socket*);
    virtual int Poll(PollInfo*, uint, uint);
    virtual bool CanUseGetAllReceivableSockets();
    virtual void GetAllReceivableSockets(Socket**, ulong, uint);
 };
 class BerkelySocket : public SocketDriver::Socket {};
 class BerkeleySocketDriver
    : SocketDriver {  // inherits SocketDriver and RootObject but not documented
    virtual ~BerkeleySocketDriver();
 };
 class ClientWebSocketDriver : SocketDriver {
    class ClientWebSocket : Socket {};
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/string.h
+++ b/include/NintendoSDK/include/nn/nex/string.h
@ -1,47 +0,0 @@
 /**
 * @file string.h
 * @brief NEX String Implementation.
 */
 #pragma once
 #include <nn/nex/RootObject.h>
 namespace nn {
 namespace nex {
 class String : public nn::nex::RootObject {
 public:
    String();
    String(const char*);
    String(const wchar_t*);
    String(const char16_t*);
    String(const String&);
    String(String&&);
    String& operator=(String&&);
    String& operator=(const char*);
    String& operator=(const wchar_t*);
    String& operator=(const String&);
    String& operator=(const char16_t*);
    String& operator+=(const String&);
    String operator==(const String&);
    bool operator<(nn::nex::String const&);
    void Truncate(u64) const;
    u64 GetLength() const;
    void Reserve(u64);
    void SetBufferChar(char*);
    void SetStringToPreReservedBuffer(char const*);
    s32 GetWideCharLength() const;
    void CopyString(char*, u64) const;
    void CreateCopy(wchar_t**) const;
    void ReleaseCopy(wchar_t*);
    void ToUpper();
    void ToLower();
    void DeleteContent();
    template <typename T>
    void Assign(T const*);
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/system.h
+++ b/include/NintendoSDK/include/nn/nex/system.h
@ -1,66 +0,0 @@
 /**
 * @file system.h
 * @brief System state / component interface for NEX.
 */
 #pragma once
 #include <nn/nex/reference.h>
 namespace nn {
 namespace nex {
 class String;
 class SystemComponent : public nn::nex::RefCountedObject {
 public:
    enum _State {
        State_Uninitialized = 1 << 0,
        State_Initializing = 1 << 1,
        State_Ready = 1 << 2,
        State_ReadyInUse = 1 << 3,
        State_Terminating = 1 << 4,
        State_TerminatingWhileInUse = 1 << 5,
        State_Terminated = 1 << 6,
        State_Faulty = 1 << 7,
        State_Unknown = 1 << 8,
        State_HighestState = 1 << 8
    };
    SystemComponent(nn::nex::String const&);
    virtual ~SystemComponent();
    virtual char* GetType() const;
    virtual bool IsAKindOf(char const*) const;
    virtual void EnforceDeclareSysComponentMacro() = 0;
    virtual void StateTransition(nn::nex::SystemComponent::_State);
    virtual void OnInitialize();
    virtual void OnTerminate();
    virtual bool BeginInitialization();
    virtual bool EndInitialization();
    virtual bool BeginTermination();
    virtual bool EndTermination();
    virtual bool ValidTransition(nn::nex::SystemComponent::_State);
    virtual bool UseIsAllowed();
    virtual nn::nex::SystemComponent::_State TestState();
    virtual void DoWork();
    nn::nex::SystemComponent::_State Initialize();
    nn::nex::SystemComponent::_State Terminate();
    u8 SystemComponent_xC;
    u8 _D;
    u8 _E;
    u8 _F;
    u64 _10;
    u64 _18;
    u64 _20;
    u32 _28;
    u32 _2C;
    u64 _30;
    nn::nex::SystemComponent::_State mState;  // _38
    u32 _3C;
    u64 _40;
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nex/time.h
+++ b/include/NintendoSDK/include/nn/nex/time.h
@ -1,49 +0,0 @@
 /**
 * @file time.h
 * @brief NEX Time Library.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace nex {
 class TimeProvider;
 class Time {
 public:
    static void Reset();
    static void RegisterTimeProvider(TimeProvider* provider);
    Time Multiply(f32) const;
    Time Divide(f32) const;
    Time Scale(f32) const;
    static Time ConvertTimeoutToDeadline(u32 timeout);
    static u32 ConvertDeadlineToTimeout(Time deadline);
    u64 mCurTime;  // _0
    static u64* s_pfGetSessionTime;  // some sort of callback?
 };
 class SystemClock {
 public:
    SystemClock();
    virtual ~SystemClock();
    static void RegisterTimeProvider(nn::nex::TimeProvider*, bool);
    static void ApplyCorrection(Time curTime, Time newTime);
    static Time ProtectedGetTime();
    static Time GetTimeImpl(bool);
    static Time GetTimeImplCorrectless();
    static void Reset();
    static nn::nex::TimeProvider* s_pTimeProvider;
    static bool s_needCorrection;
    static bool s_tiCorrection;
 };
 };  // namespace nex
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nifm.h
+++ b/include/NintendoSDK/include/nn/nifm.h
@ -1,21 +0,0 @@
 /**
 * @file nifm.h
 * @brief Network inferface module.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace nifm {
 Result Initialize();
 void SetLocalNetworkMode(bool);
 void SubmitNetworkRequestAndWait();
 bool IsNetworkAvailable();
 Result HandleNetworkRequestResult();
 void SubmitNetworkRequest();
 bool IsNetworkRequestOnHold();
 Result GetCurrentPrimaryIpAddress(u64* inAddr);
 };  // namespace nifm
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/nn.h
+++ b/include/NintendoSDK/include/nn/nn.h
@ -1,33 +0,0 @@
 /**
 * @file nn.h
 * @brief Barebones NN functions, such as init and nnMain.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 typedef u64 ApplicationId;
 };
 #ifdef __cplusplus
 extern "C" {
 #endif
 int main(int argc, char** argv);
 void nninitStartup();
 void _init();
 void _fini();
 void __nnDetailNintendoSdkRuntimeObjectFileRefer();
 void __nnDetailNintendoSdkRuntimeObjectFile();
 void __nnDetailNintendoSdkNsoFileRefer();
 void __nnmusl_init_dso_0();
 void __nnmusl_fini_dso_0();
 void __nnDetailNintendoSdkNsoFile_0();
 #ifdef __cplusplus
 }
 #endif
--- a/include/NintendoSDK/include/nn/oe.h
+++ b/include/NintendoSDK/include/nn/oe.h
@ -1,37 +0,0 @@
 /**
 * @file oe.h
 * @brief Extenstions to OS functions.
 */
 #pragma once
 #include <nn/settings.h>
 #include <nn/types.h>
 namespace nn {
 namespace oe {
 typedef s32 FocusHandlingMode;
 typedef s32 PerformanceMode;
 struct DisplayVersion {
    char name[16];
 };
 void Initialize();
 void SetPerformanceConfiguration(nn::oe::PerformanceMode, s32);
 s32 GetOperationMode();
 s32 GetPerformanceMode();
 void SetResumeNotificationEnabled(bool);
 void SetOperationModeChangedNotificationEnabled(bool);
 void SetPerformanceModeChangedNotificationEnabled(bool);
 void SetFocusHandlingMode(nn::oe::FocusHandlingMode);
 bool TryPopNotificationMessage(u32*);
 s32 GetCurrentFocusState();
 void EnableGamePlayRecording(void*, u64);
 bool IsUserInactivityDetectionTimeExtended();
 void SetUserInactivityDetectionTimeExtended(bool);
 void FinishStartupLogo();
 nn::settings::LanguageCode GetDesiredLanguage();
 void GetDisplayVersion(DisplayVersion*);
 };  // namespace oe
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/os.h
+++ b/include/NintendoSDK/include/nn/os.h
@ -1,265 +0,0 @@
 /**
 * @file os.h
 * @brief Operating System implementations.
 */
 #pragma once
 #include <type_traits>
 #include <nn/time.h>
 #include <nn/types.h>
 namespace nn {
 namespace os {
 namespace detail {
 struct InternalCriticalSection {
    u32 Image;
 };
 struct InternalConditionVariable {
    u32 Image;
 };
 }  // namespace detail
 typedef u64 Tick;
 struct LightEventType {
    std::aligned_storage_t<0xc, 4> storage;
 };
 // https://github.com/misson20000/nn-types/blob/master/nn_os.h
 struct EventType {
    nn::os::EventType* _x0;
    nn::os::EventType* _x8;
    bool isSignaled;
    bool initiallySignaled;
    bool shouldAutoClear;
    bool isInit;
    u32 signalCounter;
    u32 signalCounter2;
    nn::os::detail::InternalCriticalSection crit;
    nn::os::detail::InternalConditionVariable condvar;
 };
 typedef EventType Event;
 // https://github.com/misson20000/nn-types/blob/master/nn_os.h
 struct ThreadType {
    u64 field_8;
    u64 field_10;
    u64 field_18;
    char field_20[32];
    uint32_t thread_status;
    char field_41;
    u16 field_42;
    uint32_t thread_prio_shift;
    uint64_t thread_stack_base_addr;
    uint64_t thread_stack_base_addr_mirror;
    uint64_t thread_stack_size;
    uint64_t thread_param;
    uint64_t thread_func;
    u64 field_70;
    u64 field_78;
    u64 field_80;
    char field_88[0x100];
    char thread_name[0x20];
    const char* thread_name_addr;
    nn::os::detail::InternalCriticalSection crit;
    nn::os::detail::InternalConditionVariable condvar;
    u32 thread_handle;
 };
 #ifdef SWITCH
 static_assert(sizeof(ThreadType) == 0x1C0, "Wrong size");
 #endif
 struct MessageQueueType {
    u64 _x0;
    u64 _x8;
    u64 _x10;
    u64 _x18;
    void* Buffer;
    u32 MaxCount;
    u32 Count;
    u32 Offset;
    bool Initialized;
    detail::InternalCriticalSection _x38;
    detail::InternalConditionVariable _x3C;
    detail::InternalConditionVariable _x40;
 };
 struct ConditionVariableType {};
 struct SemaphoreType {
    std::aligned_storage_t<0x28, 8> storage;
 };
 struct SystemEvent;
 struct SystemEventType;
 // ARG
 void SetHostArgc(s32);
 s32 GetHostArgc();
 void SetHostArgv(char**);
 char** GetHostArgv();
 // MEMORY
 void InitializeVirtualAddressMemory();
 Result AllocateAddressRegion(u64*, u64);
 Result AllocateMemory(u64*, u64);
 Result AllocateMemoryPages(u64, u64);
 void AllocateMemoryBlock(u64*, u64);
 void FreeMemoryBlock(u64, u64);
 void SetMemoryHeapSize(u64);
 // MUTEX
 struct MutexType {
    u8 curState;            // _0
    bool isRecursiveMutex;  // _1
    s32 lockLevel;          // _2
    u8 _6[0x20 - 0xE];
 };
 void InitializeMutex(nn::os::MutexType*, bool, s32);
 void FinalizeMutex(nn::os::MutexType*);
 void LockMutex(nn::os::MutexType*);
 bool TryLockMutex(nn::os::MutexType*);
 void UnlockMutex(nn::os::MutexType*);
 bool IsMutexLockedByCurrentThread(nn::os::MutexType const*);
 // QUEUE
 void InitializeMessageQueue(nn::os::MessageQueueType*, u64* buf, u64 queueCount);
 void FinalizeMessageQueue(nn::os::MessageQueueType*);
 bool TrySendMessageQueue(MessageQueueType*, u64);
 void SendMessageQueue(MessageQueueType*, u64);
 bool TimedSendMessageQueue(MessageQueueType*, u64, nn::TimeSpan);
 bool TryReceiveMessageQueue(u64* out, MessageQueueType*);
 void ReceiveMessageQueue(u64* out, MessageQueueType*);
 bool TimedReceiveMessageQueue(u64* out, MessageQueueType*, nn::TimeSpan);
 bool TryPeekMessageQueue(u64*, MessageQueueType const*);
 void PeekMessageQueue(u64*, MessageQueueType const*);
 bool TimedPeekMessageQueue(u64*, MessageQueueType const*);
 bool TryJamMessageQueue(nn::os::MessageQueueType*, u64);
 void JamMessageQueue(nn::os::MessageQueueType*, u64);
 bool TimedJamMessageQueue(nn::os::MessageQueueType*, u64, nn::TimeSpan);
 // CONDITION VARIABLE
 void InitializeConditionVariable(ConditionVariableType*);
 void FinalizeConditionVariable(ConditionVariableType*);
 void SignalConditionVariable(ConditionVariableType*);
 void BroadcastConditionVariable(ConditionVariableType*);
 void WaitConditionVariable(ConditionVariableType*);
 u8 TimedWaitConditionVariable(ConditionVariableType*, MutexType*, nn::TimeSpan);
 // THREAD
 Result CreateThread(nn::os::ThreadType*, void (*)(void*), void* arg, void* srcStack, u64 stackSize,
                    s32 priority, s32 coreNum);
 Result CreateThread(nn::os::ThreadType*, void (*)(void*), void* arg, void* srcStack, u64 stackSize,
                    s32 priority);
 void DestroyThread(nn::os::ThreadType*);
 void StartThread(nn::os::ThreadType*);
 void SetThreadName(nn::os::ThreadType*, char const* threadName);
 void SetThreadNamePointer(nn::os::ThreadType*, char const*);
 char* GetThreadNamePointer(nn::os::ThreadType const*);
 nn::os::ThreadType* GetCurrentThread();
 void GetCurrentStackInfo(uintptr_t* stack_addr, size_t* stack_size);
 s32 ChangeThreadPriority(nn::os::ThreadType* thread, s32 priority);
 s32 GetThreadPriority(nn::os::ThreadType const* thread);
 u64 GetThreadId(const nn::os::ThreadType* thread);
 void YieldThread();
 void SuspendThread(nn::os::ThreadType*);
 void ResumeThread(nn::os::ThreadType*);
 void SleepThread(nn::TimeSpan);
 void WaitThread(nn::os::ThreadType*);
 void SetThreadCoreMask(nn::os::ThreadType*, int, u64 mask);
 // EVENTS
 void InitializeEvent(EventType*, bool initiallySignaled, bool autoclear);
 void FinalizeEvent(EventType*);
 void SignalEvent(EventType*);
 void WaitEvent(EventType*);
 bool TryWaitEvent(EventType*);
 bool TimedWaitEvent(EventType*, nn::TimeSpan);
 void ClearEvent(EventType*);
 // LIGHT EVENTS
 void InitializeLightEvent(LightEventType*, bool initiallySignaled, bool autoclear);
 void FinalizeLightEvent(LightEventType*);
 void SignalLightEvent(LightEventType*);
 void WaitLightEvent(LightEventType*);
 bool TimedWaitLightEvent(LightEventType*, nn::TimeSpan);
 void ClearLightEvent(LightEventType*);
 TimeSpan ConvertToTimeSpan(Tick ticks);
 // SEMAPHORES
 void InitializeSemaphore(SemaphoreType* semaphore, s32 initial_count, s32 max_count);
 void FinalizeSemaphore(SemaphoreType* semaphore);
 void AcquireSemaphore(SemaphoreType* semaphore);
 bool TryAcquireSemaphore(SemaphoreType* semaphore);
 void ReleaseSemaphore(SemaphoreType* semaphore);
 // EXCEPTION HANDLING
 typedef union {
    u64 x;  ///< 64-bit AArch64 register view.
    u32 w;  ///< 32-bit AArch64 register view.
    u32 r;  ///< AArch32 register view.
 } CpuRegister;
 /// Armv8 NEON register.
 typedef union {
    u128 v;    ///< 128-bit vector view.
    double d;  ///< 64-bit double-precision view.
    float s;   ///< 32-bit single-precision view.
 } FpuRegister;
 struct UserExceptionInfo {
    u32 ErrorDescription;  ///< See \ref ThreadExceptionDesc.
    u32 pad[3];
    CpuRegister CpuRegisters[29];  ///< GPRs 0..28. Note: also contains AArch32 registers.
    CpuRegister FP;                ///< Frame pointer.
    CpuRegister LR;                ///< Link register.
    CpuRegister SP;                ///< Stack pointer.
    CpuRegister PC;                ///< Program counter (elr_el1).
    u64 padding;
    FpuRegister FpuRegisters[32];  ///< 32 general-purpose NEON registers.
    u32 PState;  ///< pstate & 0xFF0FFE20
    u32 AFSR0;
    u32 AFSR1;
    u32 ESR;
    CpuRegister FAR;  ///< Fault Address Register.
 };
 void SetUserExceptionHandler(void (*)(UserExceptionInfo*), void*, ulong, UserExceptionInfo*);
 // OTHER
 void GenerateRandomBytes(void*, u64);
 nn::os::Tick GetSystemTick();
 nn::os::Tick GetSystemTickFrequency();
 u64 GetThreadAvailableCoreMask();
 void SetMemoryHeapSize(u64 size);
 // Thread-local storage
 struct TlsSlot {
    u32 slot;
 };
 Result AllocateTlsSlot(TlsSlot* slot_out, void (*)(u64));
 void FreeTlsSlot(TlsSlot slot);
 u64 GetTlsValue(TlsSlot slot);
 void SetTlsValue(TlsSlot slot, u64 value);
 u32 GetCurrentCoreNumber();
 namespace detail {
 extern s32 g_CommandLineParameter;
 extern char** g_CommandLineParameterArgv;
 };  // namespace detail
 };  // namespace os
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/prepo.h
+++ b/include/NintendoSDK/include/nn/prepo.h
@ -1,62 +0,0 @@
 #pragma once
 #include <nn/types.h>
 namespace nn::account {
 class Uid;
 }
 namespace nn::prepo {
 namespace detail {
 class PlayReportGenerator {
 public:
    PlayReportGenerator() = default;
    void Initialize();
 private:
    void* m_Data = nullptr;
 };
 }  // namespace detail
 enum class TransmissionStatus {};
 class PlayReport {
 public:
    PlayReport();
    explicit PlayReport(const char* event_id);
    Result SetEventId(const char* event_id);
    void SetBuffer(void* buffer, size_t size);
    void Clear();
    Result Add(const char* key, s64 value);
    Result Add(const char* key, f64 value);
    Result Add(const char* key, const char* value);
    Result Save();
    Result Save(const account::Uid& uid);
    s32 GetCount() const;
    static u32 CalcBufferSize(s32 num_entries) { return size_t(0x82) * num_entries + 3; }
 private:
    char m_EventId[32];
    void* m_Buffer;
    size_t m_BufferSize;
    detail::PlayReportGenerator m_Generator;
 };
 void Initialize();
 Result RequestImmediateTransmission();
 Result GetTransmissionStatus(TransmissionStatus* status);
 Result ClearStorage();
 Result SetOperationMode(s64 mode);
 Result IsUserAgreementCheckEnabled(bool* enabled);
 Result SetUserAgreementCheckEnabled(bool enabled);
 Result GetStorageUsage(s64*, s64*);
 }  // namespace nn::prepo
--- a/include/NintendoSDK/include/nn/ro.h
+++ b/include/NintendoSDK/include/nn/ro.h
@ -1,114 +0,0 @@
 /**
 * @file ro.h
 * @brief Dynamic module API.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace ro {
 namespace rtld {
 struct ModuleObject; //TODO find this object and implement it. Original `#include` name: ModuleObject.hpp, full path name: nn::ro::rtld::ModuleObject
 }
 class Module {
 public:
    rtld::ModuleObject* ModuleObject;
    u32 State;
    void* NroPtr;
    void* BssPtr;
    void* _x20;
    void* SourceBuffer;
    char Name[256]; /* Created by retype action */
    u8 _x130;
    u8 _x131;
    bool isLoaded;  // bool
 };
 struct ModuleId {
    u8 build_id[0x20];
 };
 struct NroHeader {
    u32 entrypoint_insn;
    u32 mod_offset;
    u8 _x8[0x8];
    u32 magic;
    u8 _x14[0x4];
    u32 size;
    u8 reserved_1C[0x4];
    u32 text_offset;
    u32 text_size;
    u32 ro_offset;
    u32 ro_size;
    u32 rw_offset;
    u32 rw_size;
    u32 bss_size;
    u8 _x3C[0x4];
    ModuleId module_id;
    u8 _x60[0x20];
 };
 static_assert(sizeof(NroHeader) == 0x80, "NroHeader definition!");
 struct ProgramId {
    u64 value;
    inline explicit operator u64() const { return this->value; }
 };
 struct NrrHeader {
    u32 magic;
    u8 _x4[0xC];
    u64 program_id_mask;
    u64 program_id_pattern;
    u8 _x20[0x10];
    u8 modulus[0x100];
    u8 fixed_key_signature[0x100];
    u8 nrr_signature[0x100];
    ProgramId program_id;
    u32 size;
    u8 type; /* 7.0.0+ */
    u8 _x33D[3];
    u32 hashes_offset;
    u32 num_hashes;
    u8 _x348[8];
 };
 static_assert(sizeof(NrrHeader) == 0x350, "NrrHeader definition!");
 struct RegistrationInfo {
    enum State {
        State_Unregistered,
        State_Registered,
    };
    State state;
    NrrHeader* nrrPtr;
    u64 _x10;
    u64 _x18;
 };
 enum BindFlag {
    BindFlag_Now = BIT(0),
    BindFlag_Lazy = BIT(1),
 };
 Result Initialize();
 Result LookupSymbol(uintptr_t* pOutAddress, const char* name);
 Result LookupModuleSymbol(uintptr_t* pOutAddress, const Module* pModule, const char* name);
 Result LoadModule(Module* pOutModule, const void* pImage, void* buffer, size_t bufferSize,
                  int flag);
 // Result LoadModule(Module *pOutModule, const void *pImage, void *buffer, size_t bufferSize,int
 // flag, bool isNotReferenced);
 Result UnloadModule(Module*);
 Result GetBufferSize(size_t*, const void*);
 Result RegisterModuleInfo(RegistrationInfo*, void const*);
 Result RegisterModuleInfo(RegistrationInfo*, void const*, u32);
 Result UnregisterModuleInfo(RegistrationInfo*, void const*);
 };  // namespace ro
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/settings.h
+++ b/include/NintendoSDK/include/nn/settings.h
@ -1,31 +0,0 @@
 #pragma once
 namespace nn {
 namespace settings {
 enum Language {
    Language_Japanese,
    Language_English,
    Language_French,
    Language_German,
    Language_Italian,
    Language_Spanish,
    Language_Chinese,
    Language_Korean,
    Language_Dutch,
    Language_Portuguese,
    Language_Russian,
    Language_Taiwanese,
    Language_BritishEnglish,
    Language_CanadianFrench,
    Language_LatinAmericanSpanish
 };
 struct LanguageCode {
    char code[0x8];
    static LanguageCode Make(nn::settings::Language);
 };
 bool operator==(nn::settings::LanguageCode const&, nn::settings::LanguageCode const&);
 };  // namespace settings
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/socket.h
+++ b/include/NintendoSDK/include/nn/socket.h
@ -1,26 +0,0 @@
 /**
 * @file socket.h
 * @brief Functions for opening sockets for wireless communication.
 */
 #pragma once
 #include <sys/socket.h>
 #include <nn/types.h>
 namespace nn {
 namespace socket {
 struct InAddr {
    u32 addr;
 };
 Result Initialize(void* pool, ulong poolSize, ulong allocPoolSize, int concurLimit);
 Result Finalize();
 s32 SetSockOpt(s32 socket, s32 socketLevel, s32 option, void const*, u64 len);
 u64 Send(s32 socket, void const* buffer, u64 bufferLength, s32 flags);
 s32 Socket(s32 domain, s32 type, s32 proto);
 u16 InetHtons(u16);
 u32 InetAton(const char* str, InAddr*);
 u32 Connect(s32 socket, const sockaddr* addr, u32 addrLen);
 };  // namespace socket
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/ssl.h
+++ b/include/NintendoSDK/include/nn/ssl.h
@ -1,26 +0,0 @@
 /**
 * @file ssl.h
 * @brief SSL implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace ssl {
 enum CertificateFormat { PEM = 0x01, DER = 0x02 };
 class Context {
 public:
    enum SslVersion { Auto = 0x01, v10 = 0x08, v11 = 0x10, v12 = 0x20 };
    Result Create(nn::ssl::Context::SslVersion version);
    Result ImportServerPki(u64*, char const* certData, u32 certSize,
                           nn::ssl::CertificateFormat certFormat);
 };
 Result Initialize();
 Result Finalize();
 };  // namespace ssl
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/time.h
+++ b/include/NintendoSDK/include/nn/time.h
@ -1,82 +0,0 @@
 /**
 * @file time.h
 * @brief Time implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 class TimeSpan {
 public:
    u64 nanoseconds;
    static TimeSpan FromNanoSeconds(u64 nanoSeconds) {
        TimeSpan ret;
        ret.nanoseconds = nanoSeconds;
        return ret;
    }
    static TimeSpan FromSeconds(u64 seconds) {
        return FromNanoSeconds(seconds * 1000 * 1000 * 1000);
    }
    static TimeSpan FromMinutes(u64 minutes) {
        return FromNanoSeconds(minutes * 1000 * 1000 * 1000 * 60);
    }
    static TimeSpan FromHours(u64 hours) {
        return FromNanoSeconds(hours * 1000 * 1000 * 1000 * 60 * 60);
    }
    static TimeSpan FromDays(u64 days) {
        return FromNanoSeconds(days * 1000 * 1000 * 1000 * 60 * 60 * 24);
    }
 };
 namespace time {
 Result Initialize();
 bool IsInitialized();
 struct CalendarTime {
    s16 year;
    s8 month;
    s8 day;
    s8 hour;
    s8 minute;
    s8 second;
 };
 enum DayOfTheWeek { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };
 struct TimeZone {
    char standardTimeName[0x8];
    bool _9;        // daylight savings or something?
    s32 utcOffset;  // in seconds
 };
 struct CalendarAdditionalInfo {
    nn::time::DayOfTheWeek dayOfTheWeek;
    s32 dayofYear;
    nn::time::TimeZone timeZone;
 };
 struct PosixTime {
    u64 time;
 };
 class StandardUserSystemClock {
 public:
    static Result GetCurrentTime(nn::time::PosixTime*);
 };
 struct TimeZoneRule;  // shrug
 Result ToCalendarTime(nn::time::CalendarTime*, nn::time::CalendarAdditionalInfo*,
                      nn::time::PosixTime const&);
 Result ToCalendarTime(nn::time::CalendarTime*, nn::time::CalendarAdditionalInfo*,
                      nn::time::PosixTime const&, nn::time::TimeZoneRule const&);
 Result ToPosixTime(int*, PosixTime*, int, const CalendarTime&);
 CalendarTime ToCalendarTimeInUtc(const PosixTime&);
 PosixTime ToPosixTimeFromUtc(const CalendarTime&);
 };  // namespace time
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/types.h
+++ b/include/NintendoSDK/include/nn/types.h
@ -1,23 +0,0 @@
 #pragma once
 #include <cstddef>
 #include <cstdint>
 #include <vapours/results.hpp>
 using u8 = std::uint8_t;
 using u16 = std::uint16_t;
 using u32 = std::uint32_t;
 using u64 = std::uint64_t;
 using u128 = __uint128_t;
 using s8 = std::int8_t;
 using s16 = std::int16_t;
 using s32 = std::int32_t;
 using s64 = std::int64_t;
 using f32 = float;
 using f64 = double;
 using char16 = char16_t;
 using size_t = std::size_t;
 using ulong = u64;
--- a/include/NintendoSDK/include/nn/ui2d/Layout.h
+++ b/include/NintendoSDK/include/nn/ui2d/Layout.h
@ -1,49 +0,0 @@
 /**
 * @file Layout.h
 * @brief UI Layout implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace ui2d {
 class AnimTransform;
 class Pane;
 class Layout {
 public:
    Layout();
    virtual ~Layout();
    virtual void DeleteAnimTransform(nn::ui2d::AnimTransform*);
    virtual void BindAnimation(nn::ui2d::AnimTransform*);
    virtual void UnbindAnimation(nn::ui2d::AnimTransform*);
    virtual void UnbindAnimation(nn::ui2d::Pane*);
    virtual void UnbindAllAnimation();
    virtual void Animate();
    virtual void UpdateAnimFrame(f32 frame);
    virtual void AnimateAndUpdateAnimFrame(f32 frame);
    void SetAllocator(void* (*)(u64, u64, void*), void (*)(void*, void*), void*);
    void AllocateMemory(u64, u64);
    void AllocateMemory(u64);
    void FreeMemory(void* src);
    u64 _10;
    u64 _18;
    u64 _20;
    u64 _28;
    u64 _30;
    u64 _40;
    u64 _48;
    u64 _50;
    u64 _58;
    u64 _60;
 };
 };  // namespace ui2d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/ui2d/Material.h
+++ b/include/NintendoSDK/include/nn/ui2d/Material.h
@ -1,29 +0,0 @@
 /**
 * @file Material.h
 * @brief UI Material implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace ui2d {
 class AnimTransform;
 class BuildResultInformation;
 struct UserShaderInformation;
 class Material {
 public:
    Material();
    void Initialize();
    void ReserveMem(s32, s32, s32, s32, bool, s32, bool, s32, bool, bool);
    void SetupUserShaderConstantBufferInformation(nn::ui2d::UserShaderInformation const&);
    virtual ~Material();
    virtual void BindAnimation(nn::ui2d::AnimTransform*);
    virtual void UnbindAnimation(nn::ui2d::AnimTransform*);
 };
 };  // namespace ui2d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/ui2d/Pane.h
+++ b/include/NintendoSDK/include/nn/ui2d/Pane.h
@ -1,75 +0,0 @@
 /**
 * @file Pane.h
 * @brief Base UI panel.
 */
 #pragma once
 #include "sead/runtime.h" //FIXME this definitely is wrong
 #include "types.h"
 namespace nn {
 namespace ui2d {
 class AnimTransform;
 class Layout;
 class Pane {
 public:
    Pane();
    Pane(nn::ui2d::Pane const&);
    virtual ~Pane();
    virtual sead::RuntimeTypeInfo::Interface* GetRuntimeTypeInfo() const;
    virtual s32 GetVertexColor(s32);
    virtual u8 GetColorElement(s32);
    virtual void SetColorElement(u32, u8);
    virtual u8 GetVertexColorElement(s32);
    virtual void SetVertexColorElement(u32, u8);
    virtual u32 GetMaterialCount() const;
    virtual u64* GetMaterial(s32) const;
    virtual void BindAnimation(nn::ui2d::AnimTransform*, bool, bool);
    virtual void UnbindAnimation(nn::ui2d::AnimTransform*, bool);
    void Initialize();
    void SetName(char const*);
    void SetUserData(char const*);
    void AppendChild(nn::ui2d::Pane*);
    void PrependChild(nn::ui2d::Pane*);
    void InsertChild(nn::ui2d::Pane*, nn::ui2d::Pane*);
    void RemoveChild(nn::ui2d::Pane*);
    void GetVertexPos() const;
    u64 _8;
    u64 _10;
    u64 _18;
    u64 _20;
    u64 _28;
    u64 _30;
    u64 _38;
    u64 _40;
    u32 _48;
    u32 _4C;
    u64 _50;
    u16 _58;
    u16 _5A;
    u32 _5C;
    u64 _60;
    nn::ui2d::Layout* mLayout;  // _68
    u128 _70;
    u128 _80;
    u128 _90;
    u64 _A0;
    u64 _A8;
    u64 _B0;
    u64 _B8;
    u64 _C0;
    u64 _C8;
    u64 _D0;
    u16 _D8;
    u16 _DA;
    u32 _DC;
 };
 };  // namespace ui2d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/ui2d/Parts.h
+++ b/include/NintendoSDK/include/nn/ui2d/Parts.h
@ -1,29 +0,0 @@
 /**
 * @file Parts.h
 * @brief Layout parts.
 */
 #pragma once
 #include <nn/ui2d/Pane.h>
 namespace nn {
 namespace ui2d {
 struct BuildArgSet;
 struct ResParts;
 class Parts : nn::ui2d::Pane {
 public:
    Parts();
    Parts(nn::ui2d::ResParts const*, nn::ui2d::ResParts const*, nn::ui2d::BuildArgSet const&);
    Parts(nn::ui2d::Parts const&);
    virtual ~Parts();
    virtual sead::RuntimeTypeInfo::Interface* GetRuntimeTypeInfo() const;
    u64 _E0;
    u64 _E8;
    u32 _F0;
 };
 };  // namespace ui2d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/ui2d/detail/TexCoordArray.h
+++ b/include/NintendoSDK/include/nn/ui2d/detail/TexCoordArray.h
@ -1,38 +0,0 @@
 /**
 * @file TexCoordArray.h
 * @brief Texture coordinate array implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace util {
 struct Float2;
 }
 namespace ui2d {
 class Layout;
 namespace detail {
 class TexCoordArray {
 public:
    void Initialize();
    void Free();
    void Reserve(s32);
    void SetSize(s32 size);
    void GetCoord(nn::util::Float2*, s32) const;
    void SetCoord(s32, nn::util::Float2 const*);
    void Copy(void const*, s32);
    bool CompareCopiedInstanceTest(nn::ui2d::detail::TexCoordArray const&) const;
    u16 _0;
    u16 _2;
    u32 _4;                     // padding?
    nn::ui2d::Layout* mLayout;  // _8
 };
 };  // namespace detail
 };  // namespace ui2d
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/util.h
+++ b/include/NintendoSDK/include/nn/util.h
@ -1,60 +0,0 @@
 /**
 * @file util.h
 * @brief Helper functions for OS functionality.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace util {
 struct Unorm8x4 {
    u8 elements[0x4];
 };
 enum CharacterEncodingResult { Success, BadLength, InvalidFormat };
 CharacterEncodingResult PickOutCharacterFromUtf8String(char*, char const** str);
 CharacterEncodingResult ConvertCharacterUtf8ToUtf32(u32* dest, char const* src);
 CharacterEncodingResult ConvertStringUtf16NativeToUtf8(char*, s32, u16 const*, s32);
 CharacterEncodingResult ConvertStringUtf8ToUtf16Native(u16*, s32, char const*, s32);
 class RelocationTable {
 public:
    void Relocate();
    void Unrelocate();
    s32 mMagic;         // _0
    u32 mPosition;      // _4
    s32 mSectionCount;  // _8
 };
 class BinaryFileHeader {
 public:
    bool IsValid(s64 packedSig, s32 majorVer, s32 minorVer, s32 microVer) const;
    bool IsRelocated() const;
    bool IsEndianReverse() const;
    nn::util::RelocationTable* GetRelocationTable();
    s32 mMagic;                // _0
    u32 mSig;                  // _4
    u8 mVerMicro;              // _8
    u8 mVerMinor;              // _9
    u16 mVerMajor;             // _A
    u16 mBOM;                  // _C
    u8 mAlignment;             // _E
    u8 mTargetAddrSize;        // _F
    u32 mFileNameOffset;       // _10
    u16 mFlag;                 // _14
    u16 mFirstBlockOffs;       // _16
    u32 mRelocationTableOffs;  // _18
    u32 mSize;                 // _1C
 };
 template <s32 size, typename T>
 struct BitFlagSet {};
 };  // namespace util
 void ReferSymbol(void const*);
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/util/Float2.h
+++ b/include/NintendoSDK/include/nn/util/Float2.h
@ -1,19 +0,0 @@
 /**
 * @file Float2.h
 * @brief Some odd float implementation that I don't understand yet...
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace util {
 struct Float2 {
    u64 _0;
    u64 _8;
    u64 _10;
    u64 _18;
 };
 };  // namespace util
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/vfx/Config.h
+++ b/include/NintendoSDK/include/nn/vfx/Config.h
@ -1,15 +0,0 @@
 /**
 * @file Config.h
 * @brief VFX configuration.
 */
 #pragma once
 namespace nn {
 namespace vfx {
 class Config {
 public:
    virtual ~Config();
 };
 };  // namespace vfx
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/vfx/Heap.h
+++ b/include/NintendoSDK/include/nn/vfx/Heap.h
@ -1,17 +0,0 @@
 /**
 * @file Heap.h
 * @brief VFX heap implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace vfx {
 class Heap {
 public:
    virtual ~Heap();
 };
 };  // namespace vfx
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/vfx/System.h
+++ b/include/NintendoSDK/include/nn/vfx/System.h
@ -1,27 +0,0 @@
 /**
 * @file System.h
 * @brief VFX system implementation.
 */
 #pragma once
 #include <nn/types.h>
 #include <nn/vfx/Config.h>
 // this class is massive
 namespace nn {
 namespace vfx {
 struct Heap;
 class System {
 public:
    System(nn::vfx::Config const&);
    virtual ~System();
    virtual void Initialize(nn::vfx::Heap*, nn::vfx::Heap*, nn::vfx::Config const&);
    u8 _0[0x1700];
 };
 };  // namespace vfx
 };  // namespace nn
--- a/include/NintendoSDK/include/nn/vi.h
+++ b/include/NintendoSDK/include/nn/vi.h
@ -1,40 +0,0 @@
 /**
 * @file vi.h
 * @brief Visual interface implementation.
 */
 #pragma once
 #include <nn/types.h>
 namespace nn {
 namespace os {
 struct SystemEventType;
 }
 namespace vi {
 class Display;
 class Layer;
 class NativWindow;
 struct DisplayInfo {
    static const int maxNameLen = 64;
    char name[maxNameLen];
    bool hasLayerLimit;
    int64_t maxLayers;
    int64_t maxWidth;
    int64_t maxHeight;
 };
 enum ScalingMode { None, Exact, FitLayer, ScaleAndCrop, PreserveAspectRatio };
 void Initialize();
 Result OpenDefaultDisplay(nn::vi::Display** outDisp);
 Result CreateLayer(nn::vi::Layer** outLayer, nn::vi::Display* disp);
 Result SetLayerScalingMode(nn::vi::Layer* layer, nn::vi::ScalingMode scalingMode);
 Result GetDisplayVsyncEvent(nn::os::SystemEventType*, nn::vi::Display*);
 Result GetNativeWindow(void** window, nn::vi::Layer*);
 Result GetLatestFrameNumber(u64* pOutFrameNumber, const Layer* pLayer);
 int ListDisplays(DisplayInfo* outDisplays, int count);
 };  // namespace vi
 };  // namespace nn
--- a/include/NintendoSDK/include/nvn/nvn.h
+++ b/include/NintendoSDK/include/nvn/nvn.h
@ -1,6 +0,0 @@
 #pragma once
 #include <nvn/nvn_types.h>
 #include <nvn/nvn_api.h>
 NVNdummyProc nvnBootstrapLoader(const char *name);
--- a/include/NintendoSDK/include/nvn/nvn_api.h
+++ b/include/NintendoSDK/include/nvn/nvn_api.h
--- a/include/NintendoSDK/include/nvn/nvn_types.h
+++ b/include/NintendoSDK/include/nvn/nvn_types.h
--- a/include/NintendoSDK/include/vapours/results.hpp
+++ b/include/NintendoSDK/include/vapours/results.hpp
@ -1,55 +0,0 @@
 /*
 * Copyright (c) 2018-2020 Atmosphère-NX
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 /* Utilities. */
 #include <vapours/results/results_common.hpp>
 /* Official. */
 #include <vapours/results/cal_results.hpp>
 #include <vapours/results/capsrv_results.hpp>
 #include <vapours/results/creport_results.hpp>
 #include <vapours/results/debug_results.hpp>
 #include <vapours/results/dmnt_results.hpp>
 #include <vapours/results/erpt_results.hpp>
 #include <vapours/results/err_results.hpp>
 #include <vapours/results/fatal_results.hpp>
 #include <vapours/results/fs_results.hpp>
 #include <vapours/results/hipc_results.hpp>
 #include <vapours/results/i2c_results.hpp>
 #include <vapours/results/kvdb_results.hpp>
 #include <vapours/results/loader_results.hpp>
 #include <vapours/results/lr_results.hpp>
 #include <vapours/results/ncm_results.hpp>
 #include <vapours/results/nim_results.hpp>
 #include <vapours/results/ns_results.hpp>
 #include <vapours/results/os_results.hpp>
 #include <vapours/results/pgl_results.hpp>
 #include <vapours/results/pm_results.hpp>
 #include <vapours/results/psc_results.hpp>
 #include <vapours/results/ro_results.hpp>
 #include <vapours/results/settings_results.hpp>
 #include <vapours/results/sf_results.hpp>
 #include <vapours/results/sm_results.hpp>
 #include <vapours/results/spl_results.hpp>
 #include <vapours/results/svc_results.hpp>
 #include <vapours/results/time_results.hpp>
 #include <vapours/results/updater_results.hpp>
 #include <vapours/results/vi_results.hpp>
 /* Unofficial. */
 #include <vapours/results/exosphere_results.hpp>
--- a/include/NintendoSDK/include/vapours/results/cal_results.hpp
+++ b/include/NintendoSDK/include/vapours/results/cal_results.hpp
@ -1,26 +0,0 @@
 /*
 * Copyright (c) 2018-2020 Atmosphère-NX
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include <vapours/results/results_common.hpp>
 namespace ams::cal {
    R_DEFINE_NAMESPACE_RESULT_MODULE(198);
    R_DEFINE_ERROR_RESULT(CalibrationDataCrcError, 101);
 }
--- a/include/NintendoSDK/include/vapours/results/capsrv_results.hpp
+++ b/include/NintendoSDK/include/vapours/results/capsrv_results.hpp
@ -1,92 +0,0 @@
 /*
 * Copyright (c) 2018-2019 Atmosphère-NX
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include <vapours/results/results_common.hpp>
 namespace ams::capsrv {
    R_DEFINE_NAMESPACE_RESULT_MODULE(206);
    R_DEFINE_ERROR_RANGE(AlbumError, 2, 99);
        R_DEFINE_ERROR_RESULT(AlbumWorkMemoryError,                     3);
        R_DEFINE_ERROR_RESULT(AlbumAlreadyOpened,                       7);
        R_DEFINE_ERROR_RESULT(AlbumOutOfRange,                          8);
        R_DEFINE_ERROR_RANGE(AlbumInvalidFileId, 10, 19);
            R_DEFINE_ERROR_RESULT(AlbumInvalidApplicationId,            11);
            R_DEFINE_ERROR_RESULT(AlbumInvalidTimestamp,                12);
            R_DEFINE_ERROR_RESULT(AlbumInvalidStorage,                  13);
            R_DEFINE_ERROR_RESULT(AlbumInvalidFileContents,             14);
        R_DEFINE_ERROR_RESULT(AlbumIsNotMounted,                        21);
        R_DEFINE_ERROR_RESULT(AlbumIsFull,                              22);
        R_DEFINE_ERROR_RESULT(AlbumFileNotFound,                        23);
        R_DEFINE_ERROR_RESULT(AlbumInvalidFileData,                     24);
        R_DEFINE_ERROR_RESULT(AlbumFileCountLimit,                      25);
        R_DEFINE_ERROR_RESULT(AlbumFileNoThumbnail,                     26);
        R_DEFINE_ERROR_RESULT(AlbumReadBufferShortage,                  30);
        R_DEFINE_ERROR_RANGE(AlbumFileSystemError, 90, 99);
            R_DEFINE_ERROR_RANGE(AlbumAccessCorrupted, 94, 96);
                R_DEFINE_ERROR_RESULT(AlbumDestinationAccessCorrupted,  96);
    R_DEFINE_ERROR_RANGE(ControlError, 800, 899);
    R_DEFINE_ERROR_RESULT(ControlResourceLimit, 820);
    R_DEFINE_ERROR_RESULT(ControlNotOpened,     822);
    R_DEFINE_ERROR_RESULT(NotSupported, 1023);
    R_DEFINE_ERROR_RANGE(InternalError, 1024, 2047);
        R_DEFINE_ERROR_RESULT(InternalJpegEncoderError,         1210);
        R_DEFINE_ERROR_RESULT(InternalJpegWorkMemoryShortage,   1212);
        R_DEFINE_ERROR_RANGE(InternalFileDataVerificationError, 1300, 1399);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationEmptyFileData,                1301);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationExifExtractionFailed,         1302);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationExifAnalyzationFailed,        1303);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationDateTimeExtractionFailed,     1304);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInvalidDateTimeLength,        1305);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInconsistentDateTime,         1306);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationMakerNoteExtractionFailed,    1307);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInconsistentApplicationId,    1308);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInconsistentSignature,        1309);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationUnsupportedOrientation,       1310);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInvalidDataDimension,         1311);
            R_DEFINE_ERROR_RESULT(InternalFileDataVerificationInconsistentOrientation,      1312);
        R_DEFINE_ERROR_RANGE(InternalAlbumLimitationError, 1400, 1499);
            R_DEFINE_ERROR_RESULT(InternalAlbumLimitationFileCountLimit,    1401);
        R_DEFINE_ERROR_RANGE(InternalSignatureError, 1500, 1599);
        R_DEFINE_ERROR_RESULT(InternalSignatureExifExtractionFailed,        1501);
        R_DEFINE_ERROR_RESULT(InternalSignatureMakerNoteExtractionFailed,   1502);
        R_DEFINE_ERROR_RANGE(InternalAlbumSessionError, 1700, 1799);
            R_DEFINE_ERROR_RESULT(InternalAlbumLimitationSessionCountLimit, 1701);
        R_DEFINE_ERROR_RANGE(InternalAlbumTemporaryFileError, 1900, 1999);
            R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileCountLimit,             1901);
            R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileCreateError,            1902);
            R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileCreateRetryCountLimit,  1903);
            R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileOpenError,              1904);
            R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileGetFileSizeError,       1905);
            R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileSetFileSizeError,       1906);
            R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileReadFileError,          1907);
            R_DEFINE_ERROR_RESULT(InternalAlbumTemporaryFileWriteFileError,         1908);
 }
--- a/include/NintendoSDK/include/vapours/results/creport_results.hpp
+++ b/include/NintendoSDK/include/vapours/results/creport_results.hpp
@ -1,37 +0,0 @@
 /*
 * Copyright (c) 2018-2020 Atmosphère-NX
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include <vapours/results/results_common.hpp>
 namespace ams::creport {
    R_DEFINE_NAMESPACE_RESULT_MODULE(168);
    R_DEFINE_ERROR_RESULT(UndefinedInstruction, 0);
    R_DEFINE_ERROR_RESULT(InstructionAbort,     1);
    R_DEFINE_ERROR_RESULT(DataAbort,            2);
    R_DEFINE_ERROR_RESULT(AlignmentFault,       3);
    R_DEFINE_ERROR_RESULT(DebuggerAttached,     4);
    R_DEFINE_ERROR_RESULT(BreakPoint,           5);
    R_DEFINE_ERROR_RESULT(UserBreak,            6);
    R_DEFINE_ERROR_RESULT(DebuggerBreak,        7);
    R_DEFINE_ERROR_RESULT(UndefinedSystemCall,  8);
    R_DEFINE_ERROR_RESULT(MemorySystemError,    9);
    R_DEFINE_ERROR_RESULT(IncompleteReport,     99);
 }
--- a/include/NintendoSDK/include/vapours/results/debug_results.hpp
+++ b/include/NintendoSDK/include/vapours/results/debug_results.hpp
@ -1,28 +0,0 @@
 /*
 * Copyright (c) 2018-2020 Atmosphère-NX
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include <vapours/results/results_common.hpp>
 namespace ams::dbg {
    R_DEFINE_NAMESPACE_RESULT_MODULE(183);
    R_DEFINE_ERROR_RESULT(CannotDebug,     1);
    R_DEFINE_ERROR_RESULT(AlreadyAttached, 2);
    R_DEFINE_ERROR_RESULT(Cancelled,       3);
 }
--- a/include/NintendoSDK/include/vapours/results/dmnt_results.hpp
+++ b/include/NintendoSDK/include/vapours/results/dmnt_results.hpp
@ -1,50 +0,0 @@
 /*
 * Copyright (c) 2018-2020 Atmosphère-NX
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include <vapours/results/results_common.hpp>
 namespace ams::dmnt {
    R_DEFINE_NAMESPACE_RESULT_MODULE(13);
    R_DEFINE_ERROR_RESULT(Unknown,           1);
    R_DEFINE_ERROR_RESULT(DebuggingDisabled, 2);
    /* Atmosphere extension. */
    namespace cheat {
        R_DEFINE_ABSTRACT_ERROR_RANGE(CheatError, 6500, 6599);
            R_DEFINE_ERROR_RESULT(CheatNotAttached,     6500);
            R_DEFINE_ERROR_RESULT(CheatNullBuffer,      6501);
            R_DEFINE_ERROR_RESULT(CheatInvalidBuffer,   6502);
            R_DEFINE_ERROR_RESULT(CheatUnknownId,       6503);
            R_DEFINE_ERROR_RESULT(CheatOutOfResource,   6504);
            R_DEFINE_ERROR_RESULT(CheatInvalid,         6505);
            R_DEFINE_ERROR_RESULT(CheatCannotDisable,   6506);
        R_DEFINE_ABSTRACT_ERROR_RANGE(FrozenAddressError, 6600, 6699);
            R_DEFINE_ERROR_RESULT(FrozenAddressInvalidWidth,  6600);
            R_DEFINE_ERROR_RESULT(FrozenAddressAlreadyExists, 6601);
            R_DEFINE_ERROR_RESULT(FrozenAddressNotFound,      6602);
            R_DEFINE_ERROR_RESULT(FrozenAddressOutOfResource, 6603);
        R_DEFINE_ABSTRACT_ERROR_RANGE(VirtualMachineError, 6700, 6799);
            R_DEFINE_ERROR_RESULT(VirtualMachineInvalidConditionDepth, 6700);
    }
 }
--- a/Show More
+++ b/Show More