diff --git a/core/libs/prx/libSceHmd2/Export.cpp b/core/libs/prx/libSceHmd2/Export.cpp
index dad10e73f21d..f237350a2e00 100644
--- a/core/libs/prx/libSceHmd2/Export.cpp
+++ b/core/libs/prx/libSceHmd2/Export.cpp
@@ -1,4 +1,5 @@
 #include "Hmd2.hpp"
+#include "prx/libc/include/general/ExportMacros.hpp"
 #include "prx/libc/include/ApplicationHeap.hpp"
 #include "prx/libc/include/General.hpp"
 #include "prx/libSceHmd/Hmd.hpp"
@@ -18,6 +19,12 @@ std::mutex stateMutex;
 bool initialized = false;
 std::int32_t openHandle = 0;
 
+std::int32_t BeforeInitialize(std::int32_t answer, const char* name) {
+    std::lock_guard lock(stateMutex);
+    if (initialized) NotImplemented_nid_no_patch(name);
+    return answer;
+}
+
 std::uint32_t CompiledSdkVersion() {
     static const auto* processParameters = static_cast<const std::byte*>(ApplicationProcessParameters_nid_no_patch());
     std::uint32_t version;
@@ -221,4 +228,347 @@ std::int32_t APS5_VABI sceHmd2SetVibration(std::int32_t handle, std::uint32_t le
     return 0;
 }
 
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeZero() {
+    return BeforeInitialize(0, __func__);
+}
+APS5_EXPORT("vDgpdS2N9Rw", Hmd2BeforeInitializeZero);
+APS5_EXPORT("Ri35gKTZpvE", Hmd2BeforeInitializeZero);
+APS5_EXPORT("9oyW8puiKeI", Hmd2BeforeInitializeZero);
+APS5_EXPORT("1HZNE6jhBnQ", Hmd2BeforeInitializeZero);
+APS5_EXPORT("cdwAKBZLXjs", Hmd2BeforeInitializeZero);
+APS5_EXPORT("Yub1MF58jfY", Hmd2BeforeInitializeZero);
+APS5_EXPORT("JYXAuQFnPyw", Hmd2BeforeInitializeZero);
+APS5_EXPORT("VuPKqCu3wzw", Hmd2BeforeInitializeZero);
+APS5_EXPORT("GSThagVyW5U", Hmd2BeforeInitializeZero);
+APS5_EXPORT("J4qE5N937MY", Hmd2BeforeInitializeZero);
+APS5_EXPORT("9KnNj-dyASg", Hmd2BeforeInitializeZero);
+APS5_EXPORT("Qta2bkstbFk", Hmd2BeforeInitializeZero);
+APS5_EXPORT("5ZcObnDRBXE", Hmd2BeforeInitializeZero);
+APS5_EXPORT("AvPNn0qx4WQ", Hmd2BeforeInitializeZero);
+APS5_EXPORT("jp0apqNGgi8", Hmd2BeforeInitializeZero);
+APS5_EXPORT("-kZT7X7OMg0", Hmd2BeforeInitializeZero);
+APS5_EXPORT("1ewLtng-SVk", Hmd2BeforeInitializeZero);
+APS5_EXPORT("B0b8DeIUGes", Hmd2BeforeInitializeZero);
+APS5_EXPORT("HclLg4Oj5yw", Hmd2BeforeInitializeZero);
+APS5_EXPORT("VbEvrQXsZyY", Hmd2BeforeInitializeZero);
+APS5_EXPORT("bB6MKZi5UCQ", Hmd2BeforeInitializeZero);
+APS5_EXPORT("OXQ1EDf02XU", Hmd2BeforeInitializeZero);
+APS5_EXPORT("IAxfMTvFm0M", Hmd2BeforeInitializeZero);
+APS5_EXPORT("qTJtAtaLeno", Hmd2BeforeInitializeZero);
+APS5_EXPORT("j7Q16UX6l34", Hmd2BeforeInitializeZero);
+APS5_EXPORT("pmmNM06rLqU", Hmd2BeforeInitializeZero);
+APS5_EXPORT("zdQfyDK9Ods", Hmd2BeforeInitializeZero);
+APS5_EXPORT("aPRwp9GnljM", Hmd2BeforeInitializeZero);
+APS5_EXPORT("MjY1gBSaed0", Hmd2BeforeInitializeZero);
+APS5_EXPORT("evAMjJYHqW4", Hmd2BeforeInitializeZero);
+APS5_EXPORT("r93FLEZ3BBk", Hmd2BeforeInitializeZero);
+APS5_EXPORT("IdYURdEdNFo", Hmd2BeforeInitializeZero);
+APS5_EXPORT("CVcL2Cu2AEI", Hmd2BeforeInitializeZero);
+APS5_EXPORT("NmKIfVxr2s0", Hmd2BeforeInitializeZero);
+APS5_EXPORT("KeDLkkp62Gg", Hmd2BeforeInitializeZero);
+APS5_EXPORT("+aadu6-ra+A", Hmd2BeforeInitializeZero);
+APS5_EXPORT("FgnTiwwGSzk", Hmd2BeforeInitializeZero);
+APS5_EXPORT("PWAUwOTHbbo", Hmd2BeforeInitializeZero);
+APS5_EXPORT("WzaEApHnsP8", Hmd2BeforeInitializeZero);
+APS5_EXPORT("dXzQI8QVY7Y", Hmd2BeforeInitializeZero);
+APS5_EXPORT("cCvFKGqRh1k", Hmd2BeforeInitializeZero);
+APS5_EXPORT("uj4-2VEAFPU", Hmd2BeforeInitializeZero);
+APS5_EXPORT("sIaGStI-iLM", Hmd2BeforeInitializeZero);
+APS5_EXPORT("JzwpZOemDO8", Hmd2BeforeInitializeZero);
+APS5_EXPORT("IsC4R4bZFVU", Hmd2BeforeInitializeZero);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeNotInitialized() {
+    return BeforeInitialize(Hmd2::NotInitialized, __func__);
+}
+APS5_EXPORT("sXaPEPY-fLA", Hmd2BeforeInitializeNotInitialized);
+APS5_EXPORT("3F5inHhKzXg", Hmd2BeforeInitializeNotInitialized);
+APS5_EXPORT("sJAiB-6p55U", Hmd2BeforeInitializeNotInitialized);
+APS5_EXPORT("E8hDydLjsSs", Hmd2BeforeInitializeNotInitialized);
+APS5_EXPORT("xEQkSb2WJ7Y", Hmd2BeforeInitializeNotInitialized);
+APS5_EXPORT("aaP4dnR4q-0", Hmd2BeforeInitializeNotInitialized);
+APS5_EXPORT("lEU0TeUoGwI", Hmd2BeforeInitializeNotInitialized);
+APS5_EXPORT("cFVyjHBpUUU", Hmd2BeforeInitializeNotInitialized);
+APS5_EXPORT("zROtb46jTj4", Hmd2BeforeInitializeNotInitialized);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeError0004() {
+    return BeforeInitialize(Hmd2::Error0004, __func__);
+}
+APS5_EXPORT("kAMsjYHBbNQ", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("5m73zmLpsQ0", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("EPeH4xuQ2XQ", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("TJ8lyRsjFY4", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("-XQVcLnyX68", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("giQwQoHhYYA", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("zNc9IkgawMI", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("-tnG5UJPvAc", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("FPhFmG+jXuQ", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("CKlkvNngofQ", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("yL1CZaciFWE", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("qlzgyG3s0RY", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("kTIDrDLzMv0", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("9Gee0ef8a+U", Hmd2BeforeInitializeError0004);
+APS5_EXPORT("ecZVjQdwmBI", Hmd2BeforeInitializeError0004);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeParameterNull() {
+    return BeforeInitialize(Hmd2::ParameterNull, __func__);
+}
+APS5_EXPORT("MNtiJTDOPAU", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("RRy9WmqZfgU", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("uobR4m9lgwc", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("-XPk5KWBYdo", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("J44idh9izZM", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("Ps0wAvYaa1E", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("kLnMR8oQ1MY", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("kMz4rbBxvjo", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("DIU1sFRRaiE", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("ZQvU4vDzZGQ", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("TJpyGGP9YEY", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("Dih+Odk+RC0", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("oaqdSJw+HVY", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("m35gtHuanXU", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("CTM7QPLJF9Q", Hmd2BeforeInitializeParameterNull);
+APS5_EXPORT("+rExHeC9lP0", Hmd2BeforeInitializeParameterNull);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeParameterInvalid() {
+    return BeforeInitialize(Hmd2::ParameterInvalid, __func__);
+}
+APS5_EXPORT("bBh5bCp9coo", Hmd2BeforeInitializeParameterInvalid);
+APS5_EXPORT("G3PNDE2VjfY", Hmd2BeforeInitializeParameterInvalid);
+APS5_EXPORT("nScCT0OPU0o", Hmd2BeforeInitializeParameterInvalid);
+APS5_EXPORT("6Q0Ng7OTN9o", Hmd2BeforeInitializeParameterInvalid);
+APS5_EXPORT("-fJKh4SnFR0", Hmd2BeforeInitializeParameterInvalid);
+APS5_EXPORT("jUA2s-l0npY", Hmd2BeforeInitializeParameterInvalid);
+APS5_EXPORT("+9XhyAIJVj4", Hmd2BeforeInitializeParameterInvalid);
+APS5_EXPORT("eBGK-o6E4RQ", Hmd2BeforeInitializeParameterInvalid);
+APS5_EXPORT("MTuFeL9184E", Hmd2BeforeInitializeParameterInvalid);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeReprojectionNotInitialized() {
+    return BeforeInitialize(Hmd2::ReprojectionNotInitialized, __func__);
+}
+APS5_EXPORT("d3SEIYTP6wc", Hmd2BeforeInitializeReprojectionNotInitialized);
+APS5_EXPORT("EVECbTvBezo", Hmd2BeforeInitializeReprojectionNotInitialized);
+APS5_EXPORT("ciusPdJKjSU", Hmd2BeforeInitializeReprojectionNotInitialized);
+APS5_EXPORT("DIwqTkcZiJo", Hmd2BeforeInitializeReprojectionNotInitialized);
+APS5_EXPORT("64ERZWVFBTE", Hmd2BeforeInitializeReprojectionNotInitialized);
+APS5_EXPORT("z0+0gXUJWs8", Hmd2BeforeInitializeReprojectionNotInitialized);
+APS5_EXPORT("rjAd4nCY4DM", Hmd2BeforeInitializeReprojectionNotInitialized);
+APS5_EXPORT("Acyg4vTdGm0", Hmd2BeforeInitializeReprojectionNotInitialized);
+APS5_EXPORT("aGOWaEeg04I", Hmd2BeforeInitializeReprojectionNotInitialized);
+APS5_EXPORT("9up+EPhw1No", Hmd2BeforeInitializeReprojectionNotInitialized);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeError002C() {
+    return BeforeInitialize(Hmd2::Error002C, __func__);
+}
+APS5_EXPORT("V1kLQmP-17U", Hmd2BeforeInitializeError002C);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeError1002() {
+    return BeforeInitialize(Hmd2::Error1002, __func__);
+}
+APS5_EXPORT("2LVD1EC5SYE", Hmd2BeforeInitializeError1002);
+APS5_EXPORT("Bf87AL6zWxU", Hmd2BeforeInitializeError1002);
+APS5_EXPORT("XKt7w1MODFY", Hmd2BeforeInitializeError1002);
+APS5_EXPORT("Y5s22M-qUDA", Hmd2BeforeInitializeError1002);
+APS5_EXPORT("JJKY-BtQJLg", Hmd2BeforeInitializeError1002);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeError1003() {
+    return BeforeInitialize(Hmd2::Error1003, __func__);
+}
+APS5_EXPORT("9kj9vw8UShQ", Hmd2BeforeInitializeError1003);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeMinusOne() {
+    return BeforeInitialize(-1, __func__);
+}
+APS5_EXPORT("EAkv8Mqt33E", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("Rv7bkmKvmz0", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("1oPZizn0SNA", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("TwCpE-nNrlo", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("jkqAeQfdtxw", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("+l0RQph81Z8", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("qsmAtGw1Ncc", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("uKhwYoMsIsA", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("WNdaigr94dI", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("P6S5ZVWf-H0", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("sun6NWE1sdg", Hmd2BeforeInitializeMinusOne);
+APS5_EXPORT("--TFsJYXo04", Hmd2BeforeInitializeMinusOne);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeValue0400() {
+    return BeforeInitialize(0x400, __func__);
+}
+APS5_EXPORT("BWqcwjCozzI", Hmd2BeforeInitializeValue0400);
+
+std::int32_t APS5_VABI Hmd2BeforeInitializeValue20000() {
+    return BeforeInitialize(0x20000, __func__);
+}
+APS5_EXPORT("PRz7TdBGUI0", Hmd2BeforeInitializeValue20000);
+
+
+std::int32_t APS5_VABI Hmd2CheckFirstThenError0004(const void* a0) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::Error0004, __func__);
+}
+APS5_EXPORT("9WeZr4kYfzk", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("N+5h1hCOFAg", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("w2vEs2y5ZmE", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("L5gat1pe0y0", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("4GnLHR9NJ1w", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("AHk7nGSzef0", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("ncjX9d3mc0M", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("l63QYAUuogc", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("mrcBySCdXSo", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("ieBra+td8sU", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("s+rzBnewgGs", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("Nfcm0GBdzZI", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("Tc9rasWfrm4", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("ckTbKTX4KZg", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("D7576PUbUjk", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("tTJ04SrBT8U", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("sDP7hZ-P6OI", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("J+eVNbN9ndY", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("kozvHBNyxf0", Hmd2CheckFirstThenError0004);
+APS5_EXPORT("638Tmg5y6U4", Hmd2CheckFirstThenError0004);
+
+std::int32_t APS5_VABI Hmd2CheckFirstThenZero(const void* a0) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(0, __func__);
+}
+APS5_EXPORT("8ETtFtp5zqY", Hmd2CheckFirstThenZero);
+APS5_EXPORT("CWPkBm3EXQA", Hmd2CheckFirstThenZero);
+APS5_EXPORT("R62liQQIAaA", Hmd2CheckFirstThenZero);
+APS5_EXPORT("-bcWLHsdzo0", Hmd2CheckFirstThenZero);
+APS5_EXPORT("JngJzgNbu8U", Hmd2CheckFirstThenZero);
+APS5_EXPORT("xNBSz8xrGdk", Hmd2CheckFirstThenZero);
+APS5_EXPORT("yUVPfN-jRIU", Hmd2CheckFirstThenZero);
+APS5_EXPORT("BKPR3RZ5aO4", Hmd2CheckFirstThenZero);
+
+std::int32_t APS5_VABI Hmd2CheckFirstThenError1002(const void* a0) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::Error1002, __func__);
+}
+APS5_EXPORT("IG4y+drWAWw", Hmd2CheckFirstThenError1002);
+APS5_EXPORT("rhYUml9vppE", Hmd2CheckFirstThenError1002);
+APS5_EXPORT("6574xHS+jZk", Hmd2CheckFirstThenError1002);
+APS5_EXPORT("mXzaY6xVoxg", Hmd2CheckFirstThenError1002);
+APS5_EXPORT("6af-HIZQQn4", Hmd2CheckFirstThenError1002);
+APS5_EXPORT("6qWtdTHQsTk", Hmd2CheckFirstThenError1002);
+APS5_EXPORT("pUm8t8xWhFg", Hmd2CheckFirstThenError1002);
+APS5_EXPORT("A0XKI-WjxK8", Hmd2CheckFirstThenError1002);
+
+std::int32_t APS5_VABI Hmd2CheckFirstThenMinusOne(const void* a0) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(-1, __func__);
+}
+APS5_EXPORT("A9s2j8OioPQ", Hmd2CheckFirstThenMinusOne);
+APS5_EXPORT("YIgtmrL+HLY", Hmd2CheckFirstThenMinusOne);
+APS5_EXPORT("Ng8zEkGxDNs", Hmd2CheckFirstThenMinusOne);
+APS5_EXPORT("EtslTnqO1xU", Hmd2CheckFirstThenMinusOne);
+APS5_EXPORT("hfrnRTryKQQ", Hmd2CheckFirstThenMinusOne);
+
+std::int32_t APS5_VABI Hmd2CheckFirstTwoThenParameterInvalid(const void* a0, const void* a1) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    if (a1 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::ParameterInvalid, __func__);
+}
+APS5_EXPORT("PPX68fNToFM", Hmd2CheckFirstTwoThenParameterInvalid);
+APS5_EXPORT("LxPIfjHaY4c", Hmd2CheckFirstTwoThenParameterInvalid);
+APS5_EXPORT("w8gBTTdg+po", Hmd2CheckFirstTwoThenParameterInvalid);
+
+std::int32_t APS5_VABI Hmd2CheckSecondThenError002C(const void* a0, const void* a1) {
+    (void)a0;
+    if (a1 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::Error002C, __func__);
+}
+APS5_EXPORT("tWJPX2ycRMM", Hmd2CheckSecondThenError002C);
+APS5_EXPORT("5UMB9PJA70o", Hmd2CheckSecondThenError002C);
+APS5_EXPORT("xQs62qCk1EI", Hmd2CheckSecondThenError002C);
+
+std::int32_t APS5_VABI Hmd2CheckFirstThenParameterInvalid(const void* a0) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::ParameterInvalid, __func__);
+}
+APS5_EXPORT("MMc+bSlqkzk", Hmd2CheckFirstThenParameterInvalid);
+APS5_EXPORT("NpZHgvSYgEA", Hmd2CheckFirstThenParameterInvalid);
+
+std::int32_t APS5_VABI Hmd2CheckAllSixThenZero(const void* a0, const void* a1, const void* a2, const void* a3, const void* a4, const void* a5) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    if (a1 == nullptr) return Hmd2::ParameterNull;
+    if (a2 == nullptr) return Hmd2::ParameterNull;
+    if (a3 == nullptr) return Hmd2::ParameterNull;
+    if (a4 == nullptr) return Hmd2::ParameterNull;
+    if (a5 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(0, __func__);
+}
+APS5_EXPORT("z-serf9vsb0", Hmd2CheckAllSixThenZero);
+APS5_EXPORT("IRMUFu+uG5s", Hmd2CheckAllSixThenZero);
+
+std::int32_t APS5_VABI Hmd2CheckSecondThenParameterInvalid(const void* a0, const void* a1) {
+    (void)a0;
+    if (a1 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::ParameterInvalid, __func__);
+}
+APS5_EXPORT("72U64E+0z6U", Hmd2CheckSecondThenParameterInvalid);
+APS5_EXPORT("LCQzi5ILGrY", Hmd2CheckSecondThenParameterInvalid);
+
+std::int32_t APS5_VABI Hmd2CheckFirstThenError800d0203(const void* a0) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::Error800d0203, __func__);
+}
+APS5_EXPORT("Im0qL0j9Ubg", Hmd2CheckFirstThenError800d0203);
+
+std::int32_t APS5_VABI Hmd2CheckFirstThenError1003(const void* a0) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::Error1003, __func__);
+}
+APS5_EXPORT("ng6eI8uA0h4", Hmd2CheckFirstThenError1003);
+
+std::int32_t APS5_VABI Hmd2CheckFirstThenError1010(const void* a0) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::Error1010, __func__);
+}
+APS5_EXPORT("mPPGgjyJrCI", Hmd2CheckFirstThenError1010);
+
+std::int32_t APS5_VABI Hmd2CheckFirstTwoThenError1002(const void* a0, const void* a1) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    if (a1 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::Error1002, __func__);
+}
+APS5_EXPORT("ZupCJmV5BDI", Hmd2CheckFirstTwoThenError1002);
+
+std::int32_t APS5_VABI Hmd2CheckFirstTwoThenError1003(const void* a0, const void* a1) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    if (a1 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::Error1003, __func__);
+}
+APS5_EXPORT("mAQZwOX1IHU", Hmd2CheckFirstTwoThenError1003);
+
+std::int32_t APS5_VABI Hmd2CheckFirstAndThirdThenZero(const void* a0, const void* a1, const void* a2) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    (void)a1;
+    if (a2 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(0, __func__);
+}
+APS5_EXPORT("oacDkQkinLo", Hmd2CheckFirstAndThirdThenZero);
+
+std::int32_t APS5_VABI Hmd2CheckFirstAndThirdThenError1003(const void* a0, const void* a1, const void* a2) {
+    if (a0 == nullptr) return Hmd2::ParameterNull;
+    (void)a1;
+    if (a2 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::Error1003, __func__);
+}
+APS5_EXPORT("zn7PHGzzEyI", Hmd2CheckFirstAndThirdThenError1003);
+
+std::int32_t APS5_VABI Hmd2CheckSecondThenInvalidHandle(const void* a0, const void* a1) {
+    (void)a0;
+    if (a1 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::InvalidHandle, __func__);
+}
+APS5_EXPORT("wEHILc7TP04", Hmd2CheckSecondThenInvalidHandle);
+
+std::int32_t APS5_VABI Hmd2CheckSecondThenError1002(const void* a0, const void* a1) {
+    (void)a0;
+    if (a1 == nullptr) return Hmd2::ParameterNull;
+    return BeforeInitialize(Hmd2::Error1002, __func__);
+}
+APS5_EXPORT("W-ZIlUXcrNA", Hmd2CheckSecondThenError1002);
+
 }
diff --git a/core/libs/prx/libSceHmd2/Hmd2.hpp b/core/libs/prx/libSceHmd2/Hmd2.hpp
index 3594b32bd1ac..ff5600f4a684 100644
--- a/core/libs/prx/libSceHmd2/Hmd2.hpp
+++ b/core/libs/prx/libSceHmd2/Hmd2.hpp
@@ -14,6 +14,13 @@ inline constexpr std::int32_t InvalidHandle = static_cast<std::int32_t>(0x8a7200
 inline constexpr std::int32_t AlreadyOpened = static_cast<std::int32_t>(0x8a720006);
 inline constexpr std::int32_t ParameterNull = static_cast<std::int32_t>(0x8a720008);
 inline constexpr std::int32_t ParameterInvalid = static_cast<std::int32_t>(0x8a720009);
+inline constexpr std::int32_t Error0004 = static_cast<std::int32_t>(0x8a720004);
+inline constexpr std::int32_t ReprojectionNotInitialized = static_cast<std::int32_t>(0x8a72000b);
+inline constexpr std::int32_t Error002C = static_cast<std::int32_t>(0x8a72002c);
+inline constexpr std::int32_t Error1002 = static_cast<std::int32_t>(0x8a721002);
+inline constexpr std::int32_t Error1003 = static_cast<std::int32_t>(0x8a721003);
+inline constexpr std::int32_t Error1010 = static_cast<std::int32_t>(0x8a721010);
+inline constexpr std::int32_t Error800d0203 = static_cast<std::int32_t>(0x800d0203);
 
 inline constexpr std::uint32_t UserIdSdkVersion = 0x07000000;
 
diff --git a/core/libs/tests/GuestHmd2.cpp b/core/libs/tests/GuestHmd2.cpp
index 98cd831bdf20..456d17b5a865 100644
--- a/core/libs/tests/GuestHmd2.cpp
+++ b/core/libs/tests/GuestHmd2.cpp
@@ -9,6 +9,39 @@
 #include <cstdlib>
 #include <cstring>
 
+extern "C" {
+std::int32_t APS5_VABI Hmd2CheckFirstThenError0004(const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstThenZero(const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstThenError1002(const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstThenMinusOne(const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstTwoThenParameterInvalid(const void*, const void*);
+std::int32_t APS5_VABI Hmd2CheckSecondThenError002C(const void*, const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstThenParameterInvalid(const void*);
+std::int32_t APS5_VABI Hmd2CheckAllSixThenZero(const void*, const void*, const void*, const void*, const void*, const void*);
+std::int32_t APS5_VABI Hmd2CheckSecondThenParameterInvalid(const void*, const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstThenError800d0203(const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstThenError1003(const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstThenError1010(const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstTwoThenError1002(const void*, const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstTwoThenError1003(const void*, const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstAndThirdThenZero(const void*, const void*, const void*);
+std::int32_t APS5_VABI Hmd2CheckFirstAndThirdThenError1003(const void*, const void*, const void*);
+std::int32_t APS5_VABI Hmd2CheckSecondThenInvalidHandle(const void*, const void*);
+std::int32_t APS5_VABI Hmd2CheckSecondThenError1002(const void*, const void*);
+std::int32_t APS5_VABI Hmd2BeforeInitializeZero();
+std::int32_t APS5_VABI Hmd2BeforeInitializeNotInitialized();
+std::int32_t APS5_VABI Hmd2BeforeInitializeError0004();
+std::int32_t APS5_VABI Hmd2BeforeInitializeParameterNull();
+std::int32_t APS5_VABI Hmd2BeforeInitializeParameterInvalid();
+std::int32_t APS5_VABI Hmd2BeforeInitializeReprojectionNotInitialized();
+std::int32_t APS5_VABI Hmd2BeforeInitializeError002C();
+std::int32_t APS5_VABI Hmd2BeforeInitializeError1002();
+std::int32_t APS5_VABI Hmd2BeforeInitializeError1003();
+std::int32_t APS5_VABI Hmd2BeforeInitializeMinusOne();
+std::int32_t APS5_VABI Hmd2BeforeInitializeValue0400();
+std::int32_t APS5_VABI Hmd2BeforeInitializeValue20000();
+}
+
 namespace {
 
 alignas(16) std::array<std::byte, 0x40> process{};
@@ -42,6 +75,66 @@ void TestBeforeInitialize() {
     Require(sceHmd2Open(USER_SERVICE_INITIAL_USER_ID, 0, 0, nullptr) == Hmd2::NotInitialized, "open before initialization");
     Require(sceHmd2Close(0) == Hmd2::NotInitialized, "close before initialization");
     Require(sceHmd2Terminate() == Hmd2::NotInitialized, "terminate before initialization");
+    const std::uint8_t dummyBytes[16]{};
+    const void* dummy = dummyBytes;
+    Require(Hmd2CheckFirstThenError0004(dummy) == Hmd2::Error0004, "Hmd2CheckFirstThenError0004 with every pointer present before initialization");
+    Require(Hmd2CheckFirstThenError0004(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenError0004 with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstThenZero(dummy) == 0, "Hmd2CheckFirstThenZero with every pointer present before initialization");
+    Require(Hmd2CheckFirstThenZero(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenZero with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstThenError1002(dummy) == Hmd2::Error1002, "Hmd2CheckFirstThenError1002 with every pointer present before initialization");
+    Require(Hmd2CheckFirstThenError1002(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenError1002 with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstThenMinusOne(dummy) == -1, "Hmd2CheckFirstThenMinusOne with every pointer present before initialization");
+    Require(Hmd2CheckFirstThenMinusOne(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenMinusOne with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstTwoThenParameterInvalid(dummy, dummy) == Hmd2::ParameterInvalid, "Hmd2CheckFirstTwoThenParameterInvalid with every pointer present before initialization");
+    Require(Hmd2CheckFirstTwoThenParameterInvalid(nullptr, dummy) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenParameterInvalid with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstTwoThenParameterInvalid(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenParameterInvalid with pointer 1 null before initialization");
+    Require(Hmd2CheckSecondThenError002C(dummy, dummy) == Hmd2::Error002C, "Hmd2CheckSecondThenError002C with every pointer present before initialization");
+    Require(Hmd2CheckSecondThenError002C(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckSecondThenError002C with pointer 1 null before initialization");
+    Require(Hmd2CheckFirstThenParameterInvalid(dummy) == Hmd2::ParameterInvalid, "Hmd2CheckFirstThenParameterInvalid with every pointer present before initialization");
+    Require(Hmd2CheckFirstThenParameterInvalid(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenParameterInvalid with pointer 0 null before initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, dummy, dummy, dummy, dummy, dummy) == 0, "Hmd2CheckAllSixThenZero with every pointer present before initialization");
+    Require(Hmd2CheckAllSixThenZero(nullptr, dummy, dummy, dummy, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 0 null before initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, nullptr, dummy, dummy, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 1 null before initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, dummy, nullptr, dummy, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 2 null before initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, dummy, dummy, nullptr, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 3 null before initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, dummy, dummy, dummy, nullptr, dummy) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 4 null before initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, dummy, dummy, dummy, dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 5 null before initialization");
+    Require(Hmd2CheckSecondThenParameterInvalid(dummy, dummy) == Hmd2::ParameterInvalid, "Hmd2CheckSecondThenParameterInvalid with every pointer present before initialization");
+    Require(Hmd2CheckSecondThenParameterInvalid(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckSecondThenParameterInvalid with pointer 1 null before initialization");
+    Require(Hmd2CheckFirstThenError800d0203(dummy) == Hmd2::Error800d0203, "Hmd2CheckFirstThenError800d0203 with every pointer present before initialization");
+    Require(Hmd2CheckFirstThenError800d0203(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenError800d0203 with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstThenError1003(dummy) == Hmd2::Error1003, "Hmd2CheckFirstThenError1003 with every pointer present before initialization");
+    Require(Hmd2CheckFirstThenError1003(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenError1003 with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstThenError1010(dummy) == Hmd2::Error1010, "Hmd2CheckFirstThenError1010 with every pointer present before initialization");
+    Require(Hmd2CheckFirstThenError1010(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenError1010 with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstTwoThenError1002(dummy, dummy) == Hmd2::Error1002, "Hmd2CheckFirstTwoThenError1002 with every pointer present before initialization");
+    Require(Hmd2CheckFirstTwoThenError1002(nullptr, dummy) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenError1002 with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstTwoThenError1002(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenError1002 with pointer 1 null before initialization");
+    Require(Hmd2CheckFirstTwoThenError1003(dummy, dummy) == Hmd2::Error1003, "Hmd2CheckFirstTwoThenError1003 with every pointer present before initialization");
+    Require(Hmd2CheckFirstTwoThenError1003(nullptr, dummy) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenError1003 with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstTwoThenError1003(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenError1003 with pointer 1 null before initialization");
+    Require(Hmd2CheckFirstAndThirdThenZero(dummy, dummy, dummy) == 0, "Hmd2CheckFirstAndThirdThenZero with every pointer present before initialization");
+    Require(Hmd2CheckFirstAndThirdThenZero(nullptr, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckFirstAndThirdThenZero with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstAndThirdThenZero(dummy, dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstAndThirdThenZero with pointer 2 null before initialization");
+    Require(Hmd2CheckFirstAndThirdThenError1003(dummy, dummy, dummy) == Hmd2::Error1003, "Hmd2CheckFirstAndThirdThenError1003 with every pointer present before initialization");
+    Require(Hmd2CheckFirstAndThirdThenError1003(nullptr, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckFirstAndThirdThenError1003 with pointer 0 null before initialization");
+    Require(Hmd2CheckFirstAndThirdThenError1003(dummy, dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstAndThirdThenError1003 with pointer 2 null before initialization");
+    Require(Hmd2CheckSecondThenInvalidHandle(dummy, dummy) == Hmd2::InvalidHandle, "Hmd2CheckSecondThenInvalidHandle with every pointer present before initialization");
+    Require(Hmd2CheckSecondThenInvalidHandle(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckSecondThenInvalidHandle with pointer 1 null before initialization");
+    Require(Hmd2CheckSecondThenError1002(dummy, dummy) == Hmd2::Error1002, "Hmd2CheckSecondThenError1002 with every pointer present before initialization");
+    Require(Hmd2CheckSecondThenError1002(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckSecondThenError1002 with pointer 1 null before initialization");
+    Require(Hmd2BeforeInitializeZero() == 0, "Hmd2BeforeInitializeZero before initialization");
+    Require(Hmd2BeforeInitializeNotInitialized() == Hmd2::NotInitialized, "Hmd2BeforeInitializeNotInitialized before initialization");
+    Require(Hmd2BeforeInitializeError0004() == Hmd2::Error0004, "Hmd2BeforeInitializeError0004 before initialization");
+    Require(Hmd2BeforeInitializeParameterNull() == Hmd2::ParameterNull, "Hmd2BeforeInitializeParameterNull before initialization");
+    Require(Hmd2BeforeInitializeParameterInvalid() == Hmd2::ParameterInvalid, "Hmd2BeforeInitializeParameterInvalid before initialization");
+    Require(Hmd2BeforeInitializeReprojectionNotInitialized() == Hmd2::ReprojectionNotInitialized, "Hmd2BeforeInitializeReprojectionNotInitialized before initialization");
+    Require(Hmd2BeforeInitializeError002C() == Hmd2::Error002C, "Hmd2BeforeInitializeError002C before initialization");
+    Require(Hmd2BeforeInitializeError1002() == Hmd2::Error1002, "Hmd2BeforeInitializeError1002 before initialization");
+    Require(Hmd2BeforeInitializeError1003() == Hmd2::Error1003, "Hmd2BeforeInitializeError1003 before initialization");
+    Require(Hmd2BeforeInitializeMinusOne() == -1, "Hmd2BeforeInitializeMinusOne before initialization");
+    Require(Hmd2BeforeInitializeValue0400() == 0x400, "Hmd2BeforeInitializeValue0400 before initialization");
+    Require(Hmd2BeforeInitializeValue20000() == 0x20000, "Hmd2BeforeInitializeValue20000 before initialization");
     Require(sceHmd2SetVibration(0, 0) == 0, "vibration of the unopened handle 0 failed");
 }
 
@@ -53,6 +146,66 @@ void TestWithoutHeadset() {
     Hmd2::DeviceInformation info;
     Require(sceHmd2GetDeviceInformation(&info) == Hmd2::NotInitialized, "device information without a headset");
     Require(sceHmd2Terminate() == Hmd2::NotInitialized, "terminate after the failed initialization");
+    const std::uint8_t dummyBytes[16]{};
+    const void* dummy = dummyBytes;
+    Require(Hmd2CheckFirstThenError0004(dummy) == Hmd2::Error0004, "Hmd2CheckFirstThenError0004 with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstThenError0004(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenError0004 with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstThenZero(dummy) == 0, "Hmd2CheckFirstThenZero with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstThenZero(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenZero with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstThenError1002(dummy) == Hmd2::Error1002, "Hmd2CheckFirstThenError1002 with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstThenError1002(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenError1002 with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstThenMinusOne(dummy) == -1, "Hmd2CheckFirstThenMinusOne with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstThenMinusOne(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenMinusOne with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstTwoThenParameterInvalid(dummy, dummy) == Hmd2::ParameterInvalid, "Hmd2CheckFirstTwoThenParameterInvalid with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstTwoThenParameterInvalid(nullptr, dummy) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenParameterInvalid with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstTwoThenParameterInvalid(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenParameterInvalid with pointer 1 null after the failed initialization");
+    Require(Hmd2CheckSecondThenError002C(dummy, dummy) == Hmd2::Error002C, "Hmd2CheckSecondThenError002C with every pointer present after the failed initialization");
+    Require(Hmd2CheckSecondThenError002C(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckSecondThenError002C with pointer 1 null after the failed initialization");
+    Require(Hmd2CheckFirstThenParameterInvalid(dummy) == Hmd2::ParameterInvalid, "Hmd2CheckFirstThenParameterInvalid with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstThenParameterInvalid(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenParameterInvalid with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, dummy, dummy, dummy, dummy, dummy) == 0, "Hmd2CheckAllSixThenZero with every pointer present after the failed initialization");
+    Require(Hmd2CheckAllSixThenZero(nullptr, dummy, dummy, dummy, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, nullptr, dummy, dummy, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 1 null after the failed initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, dummy, nullptr, dummy, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 2 null after the failed initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, dummy, dummy, nullptr, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 3 null after the failed initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, dummy, dummy, dummy, nullptr, dummy) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 4 null after the failed initialization");
+    Require(Hmd2CheckAllSixThenZero(dummy, dummy, dummy, dummy, dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckAllSixThenZero with pointer 5 null after the failed initialization");
+    Require(Hmd2CheckSecondThenParameterInvalid(dummy, dummy) == Hmd2::ParameterInvalid, "Hmd2CheckSecondThenParameterInvalid with every pointer present after the failed initialization");
+    Require(Hmd2CheckSecondThenParameterInvalid(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckSecondThenParameterInvalid with pointer 1 null after the failed initialization");
+    Require(Hmd2CheckFirstThenError800d0203(dummy) == Hmd2::Error800d0203, "Hmd2CheckFirstThenError800d0203 with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstThenError800d0203(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenError800d0203 with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstThenError1003(dummy) == Hmd2::Error1003, "Hmd2CheckFirstThenError1003 with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstThenError1003(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenError1003 with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstThenError1010(dummy) == Hmd2::Error1010, "Hmd2CheckFirstThenError1010 with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstThenError1010(nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstThenError1010 with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstTwoThenError1002(dummy, dummy) == Hmd2::Error1002, "Hmd2CheckFirstTwoThenError1002 with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstTwoThenError1002(nullptr, dummy) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenError1002 with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstTwoThenError1002(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenError1002 with pointer 1 null after the failed initialization");
+    Require(Hmd2CheckFirstTwoThenError1003(dummy, dummy) == Hmd2::Error1003, "Hmd2CheckFirstTwoThenError1003 with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstTwoThenError1003(nullptr, dummy) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenError1003 with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstTwoThenError1003(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstTwoThenError1003 with pointer 1 null after the failed initialization");
+    Require(Hmd2CheckFirstAndThirdThenZero(dummy, dummy, dummy) == 0, "Hmd2CheckFirstAndThirdThenZero with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstAndThirdThenZero(nullptr, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckFirstAndThirdThenZero with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstAndThirdThenZero(dummy, dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstAndThirdThenZero with pointer 2 null after the failed initialization");
+    Require(Hmd2CheckFirstAndThirdThenError1003(dummy, dummy, dummy) == Hmd2::Error1003, "Hmd2CheckFirstAndThirdThenError1003 with every pointer present after the failed initialization");
+    Require(Hmd2CheckFirstAndThirdThenError1003(nullptr, dummy, dummy) == Hmd2::ParameterNull, "Hmd2CheckFirstAndThirdThenError1003 with pointer 0 null after the failed initialization");
+    Require(Hmd2CheckFirstAndThirdThenError1003(dummy, dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckFirstAndThirdThenError1003 with pointer 2 null after the failed initialization");
+    Require(Hmd2CheckSecondThenInvalidHandle(dummy, dummy) == Hmd2::InvalidHandle, "Hmd2CheckSecondThenInvalidHandle with every pointer present after the failed initialization");
+    Require(Hmd2CheckSecondThenInvalidHandle(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckSecondThenInvalidHandle with pointer 1 null after the failed initialization");
+    Require(Hmd2CheckSecondThenError1002(dummy, dummy) == Hmd2::Error1002, "Hmd2CheckSecondThenError1002 with every pointer present after the failed initialization");
+    Require(Hmd2CheckSecondThenError1002(dummy, nullptr) == Hmd2::ParameterNull, "Hmd2CheckSecondThenError1002 with pointer 1 null after the failed initialization");
+    Require(Hmd2BeforeInitializeZero() == 0, "Hmd2BeforeInitializeZero after the failed initialization");
+    Require(Hmd2BeforeInitializeNotInitialized() == Hmd2::NotInitialized, "Hmd2BeforeInitializeNotInitialized after the failed initialization");
+    Require(Hmd2BeforeInitializeError0004() == Hmd2::Error0004, "Hmd2BeforeInitializeError0004 after the failed initialization");
+    Require(Hmd2BeforeInitializeParameterNull() == Hmd2::ParameterNull, "Hmd2BeforeInitializeParameterNull after the failed initialization");
+    Require(Hmd2BeforeInitializeParameterInvalid() == Hmd2::ParameterInvalid, "Hmd2BeforeInitializeParameterInvalid after the failed initialization");
+    Require(Hmd2BeforeInitializeReprojectionNotInitialized() == Hmd2::ReprojectionNotInitialized, "Hmd2BeforeInitializeReprojectionNotInitialized after the failed initialization");
+    Require(Hmd2BeforeInitializeError002C() == Hmd2::Error002C, "Hmd2BeforeInitializeError002C after the failed initialization");
+    Require(Hmd2BeforeInitializeError1002() == Hmd2::Error1002, "Hmd2BeforeInitializeError1002 after the failed initialization");
+    Require(Hmd2BeforeInitializeError1003() == Hmd2::Error1003, "Hmd2BeforeInitializeError1003 after the failed initialization");
+    Require(Hmd2BeforeInitializeMinusOne() == -1, "Hmd2BeforeInitializeMinusOne after the failed initialization");
+    Require(Hmd2BeforeInitializeValue0400() == 0x400, "Hmd2BeforeInitializeValue0400 after the failed initialization");
+    Require(Hmd2BeforeInitializeValue20000() == 0x20000, "Hmd2BeforeInitializeValue20000 after the failed initialization");
 }
 
 }
diff --git a/docs/dev/debt/libSceHmd2.md b/docs/dev/debt/libSceHmd2.md
index 6cadc9f83b8e..72c1860ea6a2 100644
--- a/docs/dev/debt/libSceHmd2.md
+++ b/docs/dev/debt/libSceHmd2.md
@@ -16,3 +16,35 @@
 ### Functional
 
 - [sceHmd2Initialize](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - the firmware also fails with 0x8a72001f when `sceKernelGetAppInfo` fails and with 0x8a72000a for some applications, depending on app info fields at 0x2c, 0x4b and 0x4d whose meaning is unknown, and then calls `sceMbusInit`; none of this is modelled
+- [Hmd2BeforeInitializeZero](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers 0 to these 45 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `vDgpdS2N9Rw` (sceHmd2InternalRegisterVibrationCallback), `Ri35gKTZpvE` (sceHmd2InternalUnregisterVibrationCallback), `9oyW8puiKeI`, `1HZNE6jhBnQ` (sceHmd2InternalPowerEventInitialize), `cdwAKBZLXjs`, `Yub1MF58jfY`, `JYXAuQFnPyw` (sceHmd2InternalDfuOpen), `VuPKqCu3wzw` (sceHmd2InternalDfuClose), `GSThagVyW5U` (sceHmd2InternalCrashReportOpen), `J4qE5N937MY` (sceHmd2InternalCrashReportClose), `9KnNj-dyASg`, `Qta2bkstbFk`, `5ZcObnDRBXE`, `AvPNn0qx4WQ`, `jp0apqNGgi8` (sceHmd2SetIpdOffset), `-kZT7X7OMg0` (sceHmd2InternalRelocalizerOpen), `1ewLtng-SVk` (sceHmd2InternalRelocalizerClose), `B0b8DeIUGes` (sceHmd2InternalTrackingOpen), `HclLg4Oj5yw` (sceHmd2InternalTrackingClose), `VbEvrQXsZyY` (sceHmd2InternalLedDetectorOpen), `bB6MKZi5UCQ` (sceHmd2InternalLedDetectorClose), `OXQ1EDf02XU` (sceHmd2InternalImageOpen), `IAxfMTvFm0M` (sceHmd2InternalImageClose), `qTJtAtaLeno` (sceHmd2InternalGenDataOpen), `j7Q16UX6l34` (sceHmd2InternalGenDataClose), `pmmNM06rLqU`, `zdQfyDK9Ods` (sceHmd2InternalSlamTraceOpen), `aPRwp9GnljM` (sceHmd2InternalSlamTraceClose), `MjY1gBSaed0` (sceHmd2InternalGazeOpen), `evAMjJYHqW4` (sceHmd2InternalGazeClose), `r93FLEZ3BBk` (sceHmd2InternalGazeStart), `IdYURdEdNFo` (sceHmd2InternalGazeStop), `CVcL2Cu2AEI` (sceHmd2GazeActivateGazeTracking), `NmKIfVxr2s0`, `KeDLkkp62Gg`, `+aadu6-ra+A`, `FgnTiwwGSzk`, `PWAUwOTHbbo` (sceHmd2InternalCreateSharedMemory), `WzaEApHnsP8` (sceHmd2InternalIsGameVr2d), `dXzQI8QVY7Y` (sceHmd2InternalIsMiniAppVr2d), `cCvFKGqRh1k` (sceHmd2InternalIsCommonDlgVr2d), `uj4-2VEAFPU` (sceHmd2InternalIsCommonDlgMiniAppVr2d), `sIaGStI-iLM` (sceHmd2InternalMapSharedMemory), `JzwpZOemDO8`, `IsC4R4bZFVU`. Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeNotInitialized](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720002` to these 9 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `sXaPEPY-fLA` (sceHmd2InternalOpen), `3F5inHhKzXg` (sceHmd2InternalGetDeviceInformation), `sJAiB-6p55U`, `E8hDydLjsSs`, `xEQkSb2WJ7Y`, `aaP4dnR4q-0`, `lEU0TeUoGwI`, `cFVyjHBpUUU`, `zROtb46jTj4`. Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeError0004](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720004` to these 15 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `kAMsjYHBbNQ` (sceHmd2InternalSetVolume), `5m73zmLpsQ0` (sceHmd2InternalResetViewPosition), `EPeH4xuQ2XQ` (sceHmd2InternalGetStatus), `TJ8lyRsjFY4` (sceHmd2InternalClearTrackerFts), `-XQVcLnyX68` (sceHmd2InternalSetSlamCommand), `giQwQoHhYYA` (sceHmd2InternalDfuStart), `zNc9IkgawMI`, `-tnG5UJPvAc` (sceHmd2GazeStartUserCalibration), `FPhFmG+jXuQ` (sceHmd2GazeStopUserCalibration), `CKlkvNngofQ`, `yL1CZaciFWE` (sceHmd2GazeSetUserCalibrationPoint), `qlzgyG3s0RY`, `kTIDrDLzMv0`, `9Gee0ef8a+U`, `ecZVjQdwmBI` (sceHmd2GazeSetEnabledEye). Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeParameterNull](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` to these 16 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `MNtiJTDOPAU`, `RRy9WmqZfgU` (sceHmd2InternalDecryptData), `uobR4m9lgwc` (sceHmd2InternalGetMirroringMode), `-XPk5KWBYdo` (sceHmd2InternalRelocalizerSetResultData), `J44idh9izZM`, `Ps0wAvYaa1E`, `kLnMR8oQ1MY`, `kMz4rbBxvjo`, `DIU1sFRRaiE` (sceHmd2GazeGetCalibrationData), `ZQvU4vDzZGQ` (sceHmd2GazeSetUserCalibrationData), `TJpyGGP9YEY`, `Dih+Odk+RC0`, `oaqdSJw+HVY`, `m35gtHuanXU`, `CTM7QPLJF9Q` (sceHmd2InternalGetFlipInfo), `+rExHeC9lP0` (sceHmd2GazeObjectSelectionInitialize). Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeParameterInvalid](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720009` to these 9 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `bBh5bCp9coo` (sceHmd2InternalSetPositionResetIcon), `G3PNDE2VjfY` (sceHmd2InternalSetPowerOff), `nScCT0OPU0o`, `6Q0Ng7OTN9o`, `-fJKh4SnFR0` (sceHmd2InternalSetBudgetMode), `jUA2s-l0npY` (sceHmd2InternalSetForceIcon), `+9XhyAIJVj4`, `eBGK-o6E4RQ` (sceHmd2InternalBindDeviceWithUserId), `MTuFeL9184E`. Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeReprojectionNotInitialized](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a72000b` to these 10 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `d3SEIYTP6wc`, `EVECbTvBezo`, `ciusPdJKjSU`, `DIwqTkcZiJo` (sceHmd2ReprojectionSetUserEventStart), `64ERZWVFBTE` (sceHmd2ReprojectionSetUserEventEnd), `z0+0gXUJWs8` (sceHmd2ReprojectionClearUserEventStart), `rjAd4nCY4DM` (sceHmd2ReprojectionClearUserEventEnd), `Acyg4vTdGm0` (sceHmd2ReprojectionGetCurrentOutput), `aGOWaEeg04I`, `9up+EPhw1No`. Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeError002C](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a72002c` to these 1 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `V1kLQmP-17U` (sceHmd2GazeObjectSelectionTerminate). Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeError1002](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a721002` to these 5 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `2LVD1EC5SYE`, `Bf87AL6zWxU`, `XKt7w1MODFY`, `Y5s22M-qUDA`, `JJKY-BtQJLg`. Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeError1003](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a721003` to these 1 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `9kj9vw8UShQ`. Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeMinusOne](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers -1 to these 12 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `EAkv8Mqt33E` (sceHmd2InternalRelocalizerStart), `Rv7bkmKvmz0` (sceHmd2InternalRelocalizerStop), `1oPZizn0SNA` (sceHmd2InternalTrackingStart), `TwCpE-nNrlo` (sceHmd2InternalTrackingStop), `jkqAeQfdtxw` (sceHmd2InternalLedDetectorStart), `+l0RQph81Z8` (sceHmd2InternalLedDetectorStop), `qsmAtGw1Ncc` (sceHmd2InternalImageStart), `uKhwYoMsIsA` (sceHmd2InternalImageStop), `WNdaigr94dI` (sceHmd2InternalGenDataStart), `P6S5ZVWf-H0` (sceHmd2InternalGenDataStop), `sun6NWE1sdg` (sceHmd2InternalSlamTraceStart), `--TFsJYXo04` (sceHmd2InternalSlamTraceStop). Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeValue0400](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x400` to these 1 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `BWqcwjCozzI`. Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2BeforeInitializeValue20000](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x20000` to these 1 exports both with every argument null and with every argument pointing at a zeroed 16 KiB buffer, writing nothing: `PRz7TdBGUI0`. Measured from a payload process on firmware 13.60, so a game process before initialization is assumed to answer the same; the arguments and the behaviour after initialization are not measured, and the handler throws once `sceHmd2Initialize` has succeeded
+- [libSceHmd2 pre-initialization sweep](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - the names in the entries above are the aerolib names of the NIDs where one exists; the error names `Error0004`, `Error002C`, `Error1002` and `Error1003` are placeholders for codes whose meaning is unknown, and `ReprojectionNotInitialized` is ours because every export answering `0x8a72000b` is a reprojection one. Exports that answered differently to null and to zeroed arguments, wrote output, returned a pointer-like value, answered `0x8a72000a` (which `sceHmd2Initialize` also returns for some applications) or crashed the probe are left as they were
+- [Hmd2CheckFirstThenError0004](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 is null and `0x8a720004` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 20 exports: `9WeZr4kYfzk` (sceHmd2InternalGetFwVersion), `N+5h1hCOFAg` (sceHmd2InternalGetRequiredPUPVersion), `w2vEs2y5ZmE` (sceHmd2InternalGetOpticalParam), `L5gat1pe0y0` (sceHmd2InternalSetCameraSeeThroughParam), `4GnLHR9NJ1w`, `AHk7nGSzef0` (sceHmd2InternalGetTrackerFtsData), `ncjX9d3mc0M`, `l63QYAUuogc` (sceHmd2InternalGetSlamCommand), `mrcBySCdXSo` (sceHmd2InternalDfuGetStatus), `ieBra+td8sU` (sceHmd2InternalDfuGetUpdateStatus), `s+rzBnewgGs` (sceHmd2InternalDfuCheckAfterPvt), `Nfcm0GBdzZI` (sceHmd2InternalRelocalizerGetVersion), `Tc9rasWfrm4` (sceHmd2InternalSetHomeCalibration), `ckTbKTX4KZg`, `D7576PUbUjk` (sceHmd2InternalGazeReadStatus), `tTJ04SrBT8U`, `sDP7hZ-P6OI` (sceHmd2GazeGetDeviceStatus), `J+eVNbN9ndY` (sceHmd2GazeGetUserCalibrationStatus), `kozvHBNyxf0`, `638Tmg5y6U4`. Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstThenZero](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 is null and 0 when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 8 exports: `8ETtFtp5zqY` (sceHmd2InternalGetVrMode), `CWPkBm3EXQA`, `R62liQQIAaA` (sceHmd2InternalGetFakeLensSeparationDistance), `-bcWLHsdzo0`, `JngJzgNbu8U` (sceHmd2SetFieldOfView), `xNBSz8xrGdk`, `yUVPfN-jRIU`, `BKPR3RZ5aO4`. Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstThenError1002](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 is null and `0x8a721002` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 8 exports: `IG4y+drWAWw` (sceHmd2InternalRelocalizerReadData), `rhYUml9vppE` (sceHmd2InternalRelocalizerReadDataAsync), `6574xHS+jZk` (sceHmd2InternalRelocalizerReadData2), `mXzaY6xVoxg` (sceHmd2InternalTrackingReadData), `6af-HIZQQn4` (sceHmd2InternalTrackingReadData2), `6qWtdTHQsTk`, `pUm8t8xWhFg`, `A0XKI-WjxK8` (sceHmd2InternalImageReadData). Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstThenMinusOne](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 is null and -1 when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 5 exports: `A9s2j8OioPQ`, `YIgtmrL+HLY`, `Ng8zEkGxDNs`, `EtslTnqO1xU` (sceHmd2InternalImageStart2), `hfrnRTryKQQ` (sceHmd2InternalImageSetConfig). Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstTwoThenParameterInvalid](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 and argument 1 is null and `0x8a720009` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 3 exports: `PPX68fNToFM`, `LxPIfjHaY4c` (sceHmd2GazeObjectSelectionQueryMemory), `w8gBTTdg+po` (sceHmd2GazeObjectSelectionGetSelectedObject). Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckSecondThenError002C](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 1 is null and `0x8a72002c` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 3 exports: `tWJPX2ycRMM`, `5UMB9PJA70o`, `xQs62qCk1EI`. Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstThenParameterInvalid](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 is null and `0x8a720009` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 2 exports: `MMc+bSlqkzk` (sceHmd2InternalSetVirtualDisplaySize), `NpZHgvSYgEA`. Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckAllSixThenZero](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 and argument 1 and argument 2 and argument 3 and argument 4 and argument 5 is null and 0 when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 2 exports: `z-serf9vsb0` (sceHmd2InternalPushVr2dData), `IRMUFu+uG5s`. Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckSecondThenParameterInvalid](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 1 is null and `0x8a720009` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 2 exports: `72U64E+0z6U`, `LCQzi5ILGrY` (sceHmd2GazeGetCalibrationDataMaxSize). Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstThenError800d0203](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 is null and `0x800d0203` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 1 exports: `Im0qL0j9Ubg`. Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstThenError1003](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 is null and `0x8a721003` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 1 exports: `ng6eI8uA0h4` (sceHmd2InternalImageGetMemoryLayout). Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstThenError1010](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 is null and `0x8a721010` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 1 exports: `mPPGgjyJrCI`. Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstTwoThenError1002](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 and argument 1 is null and `0x8a721002` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 1 exports: `ZupCJmV5BDI` (sceHmd2InternalImageGetFrameData). Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstTwoThenError1003](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 and argument 1 is null and `0x8a721003` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 1 exports: `mAQZwOX1IHU` (sceHmd2InternalImageGetAverageLuminance). Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstAndThirdThenZero](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 and argument 2 is null and 0 when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 1 exports: `oacDkQkinLo`. Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckFirstAndThirdThenError1003](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 0 and argument 2 is null and `0x8a721003` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 1 exports: `zn7PHGzzEyI`. Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckSecondThenInvalidHandle](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 1 is null and `0x8a720003` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 1 exports: `wEHILc7TP04` (sceHmd2GazeInsertRawDataWithHandle). Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [Hmd2CheckSecondThenError1002](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - before `sceHmd2Initialize` the console answers `0x8a720008` when argument 1 is null and `0x8a721002` when every argument points at a zeroed 16 KiB buffer, writing nothing, for these 1 exports: `W-ZIlUXcrNA`. Each argument was nulled on its own with the others present (probe `hmd2n`, payload process, firmware 13.60); what the present arguments mean, and the behaviour after initialization, are not measured, so the handler throws once `sceHmd2Initialize` has succeeded
+- [libSceHmd2 null-argument sweep](../../../core/libs/prx/libSceHmd2/Export.cpp) (libSceHmd2) - `Error1010` and `Error800d0203` are placeholder names. Left as they were: the exports that write output (`omimgG5itSs`, `FBUEhH9tQ1A`, `6PeHcAaKYg8`, `yur+xPdWPAg`, `RnieDDp5ge4`, `jM3NEJA11yw`, `b0H-n-tUk0U`) and those whose answer with a single null argument is neither `0x8a720008` nor their all-present answer, which take a handle or slot number rather than a pointer first (`MXhloJ6Iw3w`, `19wrIIiqFgM`, `Z389vAm47Ys`, `cDcrvEG8j8k`, `tuqJO6O6cb4`, `fd4fu1cziaI`, `UxMg7iL4nRs`, `K1GELwlaaGc`, `RFn39VCHjGY`, `FRoSjceDv10`, `wiv8+7ogrq0`, `wQ44gBwBw44`)