new build system

CMakeLists.txt

@@ -0,0 +1,39 @@
+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)

ToolchainNX64.cmake

@@ -0,0 +1,46 @@
+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)

data/data_symbols.csv

@@ -0,0 +1,499 @@
+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

diff.py

@@ -0,0 +1 @@
+tools/diff.py

diff_settings.py

@@ -0,0 +1,23 @@
+#!/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

include/NintendoSDK/.clang-format

@@ -0,0 +1,74 @@
+---
+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
+...

include/NintendoSDK/CMakeLists.txt

@@ -0,0 +1,128 @@
+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)

include/NintendoSDK/README.md

@@ -0,0 +1,10 @@
+# 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.

include/NintendoSDK/include/nn/account.h

@@ -0,0 +1,57 @@
+/**
+ * @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

include/NintendoSDK/include/nn/aoc.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <nn/types.h>
+
+namespace nn::aoc {
+
+int ListAddOnContent(int*, int, int);
+
+}  // namespace nn::aoc

include/NintendoSDK/include/nn/atk/SoundArchivePlayer.h

@@ -0,0 +1,37 @@
+/**
+ * @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

include/NintendoSDK/include/nn/atk/SoundDataManager.h

@@ -0,0 +1,25 @@
+/**
+ * @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

include/NintendoSDK/include/nn/atk/SoundPlayer.h

@@ -0,0 +1,56 @@
+/**
+ * @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

include/NintendoSDK/include/nn/atk/detail/AdvancedWaveSoundRuntime.h

@@ -0,0 +1,28 @@
+/**
+ * @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

include/NintendoSDK/include/nn/atk/detail/BasicSound.h

@@ -0,0 +1,137 @@
+/**
+ * @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

include/NintendoSDK/include/nn/atk/detail/SequenceSoundRuntime.h

@@ -0,0 +1,37 @@
+/**
+ * @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

include/NintendoSDK/include/nn/atk/detail/SoundArchiveManager.h

@@ -0,0 +1,42 @@
+/**
+ * @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

include/NintendoSDK/include/nn/atk/detail/StreamSoundRuntime.h

@@ -0,0 +1,22 @@
+/**
+ * @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

include/NintendoSDK/include/nn/atk/detail/WaveSoundRuntime.h

@@ -0,0 +1,29 @@
+/**
+ * @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

include/NintendoSDK/include/nn/audio.h

@@ -0,0 +1,43 @@
+/**
+ * @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

include/NintendoSDK/include/nn/bcat.h

@@ -0,0 +1,112 @@
+/**
+ * @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

include/NintendoSDK/include/nn/crypto.h

@@ -0,0 +1,86 @@
+/**
+ * @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

include/NintendoSDK/include/nn/diag.h

@@ -0,0 +1,33 @@
+/**
+ * @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

include/NintendoSDK/include/nn/friends.h

@@ -0,0 +1,42 @@
+/**
+ * @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

include/NintendoSDK/include/nn/fs.h

@@ -0,0 +1,132 @@
+/**
+ * @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

include/NintendoSDK/include/nn/g3d/BindFuncTable.h

@@ -0,0 +1,34 @@
+#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

include/NintendoSDK/include/nn/g3d/ResFile.h

@@ -0,0 +1,75 @@
+/**
+ * @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

include/NintendoSDK/include/nn/g3d/ResFogAnim.h

@@ -0,0 +1,21 @@
+#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

include/NintendoSDK/include/nn/g3d/ResLightAnim.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <nn/types.h>
+
+namespace nn {
+namespace g3d {
+class ResLightAnim {
+public:
+    s32 Bind(nn::g3d::BindFuncTable const&);
+};
+};  // namespace g3d
+};  // namespace nn

include/NintendoSDK/include/nn/g3d/ResMaterial.h

@@ -0,0 +1,29 @@
+/**
+ * @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

include/NintendoSDK/include/nn/g3d/ResMaterialAnim.h

@@ -0,0 +1,19 @@
+/**
+ * @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

include/NintendoSDK/include/nn/g3d/ResModel.h

@@ -0,0 +1,32 @@
+/**
+ * @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

include/NintendoSDK/include/nn/g3d/ResSceneAnim.h

@@ -0,0 +1,41 @@
+/**
+ * @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

include/NintendoSDK/include/nn/g3d/ResShapeAnim.h

@@ -0,0 +1,15 @@
+/**
+ * @file ResShapeAnim.h
+ * @brief Resource file for shape animations.
+ */
+
+#pragma once
+
+namespace nn {
+namespace g3d {
+class ResShapeAnim {
+public:
+    void Reset();
+};
+};  // namespace g3d
+};  // namespace nn

include/NintendoSDK/include/nn/g3d/ResSkeletalAnim.h

@@ -0,0 +1,15 @@
+/**
+ * @file ResSkeletalAnim.h
+ * @brief Resource file for skeletal animations.
+ */
+
+#pragma once
+
+namespace nn {
+namespace g3d {
+class ResSkeletalAnim {
+public:
+    void Reset();
+};
+};  // namespace g3d
+};  // namespace nn

include/NintendoSDK/include/nn/gfx/api.h

@@ -0,0 +1,22 @@
+/**
+ * @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

include/NintendoSDK/include/nn/gfx/buffer.h

@@ -0,0 +1,28 @@
+/**
+ * @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

include/NintendoSDK/include/nn/gfx/detail/bufferimpl.h

@@ -0,0 +1,55 @@
+/**
+ * @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

include/NintendoSDK/include/nn/gfx/detail/deviceimpl.h

@@ -0,0 +1,24 @@
+/**
+ * @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

include/NintendoSDK/include/nn/gfx/detail/pool.h

@@ -0,0 +1,41 @@
+#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

include/NintendoSDK/include/nn/gfx/device.h

@@ -0,0 +1,20 @@
+/**
+ * @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

include/NintendoSDK/include/nn/gfx/memory.h

@@ -0,0 +1,14 @@
+/**
+ * @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

include/NintendoSDK/include/nn/hid.h

@@ -0,0 +1,43 @@
+/**
+ * @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

include/NintendoSDK/include/nn/image.h

@@ -0,0 +1,50 @@
+/**
+ * @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

include/NintendoSDK/include/nn/init.h

@@ -0,0 +1,21 @@
+/**
+ * @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

include/NintendoSDK/include/nn/mem.h

@@ -0,0 +1,30 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/RootObject.h

@@ -0,0 +1,30 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/auth.h

@@ -0,0 +1,20 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/buffer.h

@@ -0,0 +1,25 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/cache.h

@@ -0,0 +1,33 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/checksum.h

@@ -0,0 +1,61 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/client.h

@@ -0,0 +1,111 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/data.h

@@ -0,0 +1,21 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/ddl.h

@@ -0,0 +1,40 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/dynamic.h

@@ -0,0 +1,21 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/encryption.h

@@ -0,0 +1,61 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/hash.h

@@ -0,0 +1,35 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/instance.h

@@ -0,0 +1,46 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/key.h

@@ -0,0 +1,39 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/plugin.h

@@ -0,0 +1,33 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/pseudo.h

@@ -0,0 +1,80 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/reference.h

@@ -0,0 +1,18 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/socket.h

@@ -0,0 +1,73 @@
+#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

include/NintendoSDK/include/nn/nex/string.h

@@ -0,0 +1,47 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/system.h

@@ -0,0 +1,66 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nex/time.h

@@ -0,0 +1,49 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nifm.h

@@ -0,0 +1,21 @@
+/**
+ * @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

include/NintendoSDK/include/nn/nn.h

@@ -0,0 +1,33 @@
+/**
+ * @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

include/NintendoSDK/include/nn/oe.h

@@ -0,0 +1,37 @@
+/**
+ * @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

include/NintendoSDK/include/nn/os.h

@@ -0,0 +1,265 @@
+/**
+ * @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

include/NintendoSDK/include/nn/prepo.h

@@ -0,0 +1,62 @@
+#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

include/NintendoSDK/include/nn/ro.h

@@ -0,0 +1,114 @@
+/**
+ * @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

include/NintendoSDK/include/nn/settings.h

@@ -0,0 +1,31 @@
+#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

include/NintendoSDK/include/nn/socket.h

@@ -0,0 +1,26 @@
+/**
+ * @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

include/NintendoSDK/include/nn/ssl.h

@@ -0,0 +1,26 @@
+/**
+ * @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

include/NintendoSDK/include/nn/time.h

@@ -0,0 +1,82 @@
+/**
+ * @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

include/NintendoSDK/include/nn/types.h

@@ -0,0 +1,23 @@
+#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;

include/NintendoSDK/include/nn/ui2d/Layout.h

@@ -0,0 +1,49 @@
+/**
+ * @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

include/NintendoSDK/include/nn/ui2d/Material.h

@@ -0,0 +1,29 @@
+/**
+ * @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

include/NintendoSDK/include/nn/ui2d/Pane.h

@@ -0,0 +1,75 @@
+/**
+ * @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

include/NintendoSDK/include/nn/ui2d/Parts.h

@@ -0,0 +1,29 @@
+/**
+ * @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

include/NintendoSDK/include/nn/ui2d/detail/TexCoordArray.h

@@ -0,0 +1,38 @@
+/**
+ * @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

include/NintendoSDK/include/nn/util.h

@@ -0,0 +1,60 @@
+/**
+ * @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

include/NintendoSDK/include/nn/util/Float2.h

@@ -0,0 +1,19 @@
+/**
+ * @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

include/NintendoSDK/include/nn/vfx/Config.h

@@ -0,0 +1,15 @@
+/**
+ * @file Config.h
+ * @brief VFX configuration.
+ */
+
+#pragma once
+
+namespace nn {
+namespace vfx {
+class Config {
+public:
+    virtual ~Config();
+};
+};  // namespace vfx
+};  // namespace nn

include/NintendoSDK/include/nn/vfx/Heap.h

@@ -0,0 +1,17 @@
+/**
+ * @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

include/NintendoSDK/include/nn/vfx/System.h

@@ -0,0 +1,27 @@
+/**
+ * @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

include/NintendoSDK/include/nn/vi.h

@@ -0,0 +1,40 @@
+/**
+ * @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

include/NintendoSDK/include/nvn/nvn.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <nvn/nvn_types.h>
+#include <nvn/nvn_api.h>
+
+NVNdummyProc nvnBootstrapLoader(const char *name);

include/NintendoSDK/include/vapours/results.hpp

@@ -0,0 +1,55 @@
+/*
+ * 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>

include/NintendoSDK/include/vapours/results/cal_results.hpp

@@ -0,0 +1,26 @@
+/*
+ * 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);
+
+}

include/NintendoSDK/include/vapours/results/capsrv_results.hpp

@@ -0,0 +1,92 @@
+/*
+ * 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);
+
+}

include/NintendoSDK/include/vapours/results/creport_results.hpp

@@ -0,0 +1,37 @@
+/*
+ * 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);
+
+}

include/NintendoSDK/include/vapours/results/debug_results.hpp

@@ -0,0 +1,28 @@
+/*
+ * 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);
+
+}

include/NintendoSDK/include/vapours/results/dmnt_results.hpp

@@ -0,0 +1,50 @@
+/*
+ * 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);
+
+    }
+
+}

include/NintendoSDK/include/vapours/results/erpt_results.hpp

@@ -0,0 +1,43 @@
+/*
+ * 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::erpt {
+
+    R_DEFINE_NAMESPACE_RESULT_MODULE(147);
+
+    R_DEFINE_ERROR_RESULT(NotInitialized,            1);
+    R_DEFINE_ERROR_RESULT(AlreadyInitialized,        2);
+    R_DEFINE_ERROR_RESULT(OutOfArraySpace,           3);
+    R_DEFINE_ERROR_RESULT(OutOfFieldSpace,           4);
+    R_DEFINE_ERROR_RESULT(OutOfMemory,               5);
+    R_DEFINE_ERROR_RESULT(InvalidArgument,           7);
+    R_DEFINE_ERROR_RESULT(NotFound,                  8);
+    R_DEFINE_ERROR_RESULT(FieldCategoryMismatch,     9);
+    R_DEFINE_ERROR_RESULT(FieldTypeMismatch,        10);
+    R_DEFINE_ERROR_RESULT(AlreadyExists,            11);
+    R_DEFINE_ERROR_RESULT(CorruptJournal,           12);
+    R_DEFINE_ERROR_RESULT(CategoryNotFound,         13);
+    R_DEFINE_ERROR_RESULT(RequiredContextMissing,   14);
+    R_DEFINE_ERROR_RESULT(RequiredFieldMissing,     15);
+    R_DEFINE_ERROR_RESULT(FormatterError,           16);
+    R_DEFINE_ERROR_RESULT(InvalidPowerState,        17);
+    R_DEFINE_ERROR_RESULT(ArrayFieldTooLarge,       18);
+    R_DEFINE_ERROR_RESULT(AlreadyOwned,             19);
+
+}