#include "psprecomp/runtime.hpp"
#include <cstdint>

namespace psprecomp {
void register_generated_unit_0(Runtime &runtime);
void register_generated_unit_1(Runtime &runtime);
void register_generated_unit_2(Runtime &runtime);
void register_generated_unit_3(Runtime &runtime);
void register_generated_unit_4(Runtime &runtime);
void register_generated_unit_5(Runtime &runtime);
void register_generated_unit_6(Runtime &runtime);
void register_generated_unit_7(Runtime &runtime);
void register_generated_unit_8(Runtime &runtime);
void register_generated_unit_9(Runtime &runtime);
void register_generated_unit_10(Runtime &runtime);
void register_generated_unit_11(Runtime &runtime);
void register_generated_unit_12(Runtime &runtime);
void register_generated_unit_13(Runtime &runtime);
void register_generated_unit_14(Runtime &runtime);
void register_generated_unit_15(Runtime &runtime);
void register_generated_unit_16(Runtime &runtime);
void register_generated_unit_17(Runtime &runtime);
void register_generated_unit_18(Runtime &runtime);
void register_generated_unit_19(Runtime &runtime);
void register_generated_unit_20(Runtime &runtime);
void register_generated_unit_21(Runtime &runtime);
void register_generated_unit_22(Runtime &runtime);
void register_generated_unit_23(Runtime &runtime);
void register_generated_unit_24(Runtime &runtime);
void register_generated_unit_25(Runtime &runtime);
void register_generated_unit_26(Runtime &runtime);
void register_generated_unit_27(Runtime &runtime);
void register_generated_unit_28(Runtime &runtime);
void register_generated_unit_29(Runtime &runtime);
void register_generated_unit_30(Runtime &runtime);
void register_generated_unit_31(Runtime &runtime);
void register_generated_unit_32(Runtime &runtime);
void register_generated_unit_33(Runtime &runtime);
void register_generated_unit_34(Runtime &runtime);
void register_generated_unit_35(Runtime &runtime);
void register_generated_unit_36(Runtime &runtime);
void register_generated_unit_37(Runtime &runtime);
void register_generated_unit_38(Runtime &runtime);
void register_generated_unit_39(Runtime &runtime);
void register_generated_unit_40(Runtime &runtime);
void register_generated_unit_41(Runtime &runtime);
void register_generated_unit_42(Runtime &runtime);
void register_generated_unit_43(Runtime &runtime);
void register_generated_unit_44(Runtime &runtime);
void register_generated_unit_45(Runtime &runtime);
void register_generated_unit_46(Runtime &runtime);
void register_generated_unit_47(Runtime &runtime);
void register_generated_unit_48(Runtime &runtime);
void register_generated_unit_49(Runtime &runtime);
void register_generated_unit_50(Runtime &runtime);
void register_generated_unit_51(Runtime &runtime);
void register_generated_unit_52(Runtime &runtime);
void register_generated_unit_53(Runtime &runtime);
void register_generated_unit_54(Runtime &runtime);
void register_generated_unit_55(Runtime &runtime);
void register_generated_unit_56(Runtime &runtime);
void register_generated_unit_57(Runtime &runtime);
void register_generated_unit_58(Runtime &runtime);
void register_generated_unit_59(Runtime &runtime);
void register_generated_unit_60(Runtime &runtime);
void register_generated_unit_61(Runtime &runtime);
void register_generated_unit_62(Runtime &runtime);
void register_generated_unit_63(Runtime &runtime);
void register_generated_unit_64(Runtime &runtime);
void register_generated_unit_65(Runtime &runtime);
void register_generated_unit_66(Runtime &runtime);
void register_generated_unit_67(Runtime &runtime);
void register_generated_unit_68(Runtime &runtime);
void register_generated_unit_69(Runtime &runtime);
void register_generated_unit_70(Runtime &runtime);
void register_generated_unit_71(Runtime &runtime);
void register_generated_unit_72(Runtime &runtime);
void register_generated_unit_73(Runtime &runtime);
void register_generated_unit_74(Runtime &runtime);
void register_generated_unit_75(Runtime &runtime);
void register_generated_unit_76(Runtime &runtime);
void register_generated_unit_77(Runtime &runtime);
void register_generated_unit_78(Runtime &runtime);
void register_generated_unit_79(Runtime &runtime);
void register_generated_unit_80(Runtime &runtime);
void register_generated_unit_81(Runtime &runtime);
void register_generated_unit_82(Runtime &runtime);
void register_generated_unit_83(Runtime &runtime);
void register_generated_unit_84(Runtime &runtime);
void register_generated_unit_85(Runtime &runtime);
void register_generated_unit_86(Runtime &runtime);
void register_generated_unit_87(Runtime &runtime);
void register_generated_unit_88(Runtime &runtime);
void register_generated_unit_89(Runtime &runtime);
void register_generated_unit_90(Runtime &runtime);
void register_generated_unit_91(Runtime &runtime);
void register_generated_unit_92(Runtime &runtime);
void register_generated_unit_93(Runtime &runtime);
void register_generated_unit_94(Runtime &runtime);
void register_generated_unit_95(Runtime &runtime);
void register_generated_unit_96(Runtime &runtime);
void register_generated_unit_97(Runtime &runtime);
void register_generated_unit_98(Runtime &runtime);
void register_generated_unit_99(Runtime &runtime);
void register_generated_unit_100(Runtime &runtime);
void register_generated_unit_101(Runtime &runtime);
void register_generated_unit_102(Runtime &runtime);
void register_generated_unit_103(Runtime &runtime);
void register_generated_unit_104(Runtime &runtime);
void register_generated_unit_105(Runtime &runtime);
void register_generated_unit_106(Runtime &runtime);
void register_generated_unit_107(Runtime &runtime);
void register_generated_unit_108(Runtime &runtime);
void register_generated_unit_109(Runtime &runtime);
void register_generated_unit_110(Runtime &runtime);
void register_generated_unit_111(Runtime &runtime);
void register_generated_unit_112(Runtime &runtime);
void register_generated_unit_113(Runtime &runtime);
void register_generated_unit_114(Runtime &runtime);
void register_generated_unit_115(Runtime &runtime);
void register_generated_unit_116(Runtime &runtime);
void register_generated_unit_117(Runtime &runtime);
void register_generated_unit_118(Runtime &runtime);
void register_generated_unit_119(Runtime &runtime);
void register_generated_unit_120(Runtime &runtime);
void register_generated_unit_121(Runtime &runtime);
void register_generated_unit_122(Runtime &runtime);
void register_generated_unit_123(Runtime &runtime);
void register_generated_unit_124(Runtime &runtime);
void register_generated_unit_125(Runtime &runtime);
void register_generated_unit_126(Runtime &runtime);
void register_generated_unit_127(Runtime &runtime);
void register_generated_unit_128(Runtime &runtime);
void register_generated_unit_129(Runtime &runtime);
void register_generated_unit_130(Runtime &runtime);
void register_generated_unit_131(Runtime &runtime);
void register_generated_unit_132(Runtime &runtime);
void register_generated_unit_133(Runtime &runtime);
void register_generated_unit_134(Runtime &runtime);
void register_generated_unit_135(Runtime &runtime);
void register_generated_unit_136(Runtime &runtime);
void register_generated_unit_137(Runtime &runtime);
void register_generated_unit_138(Runtime &runtime);
void register_generated_unit_139(Runtime &runtime);
void register_generated_unit_140(Runtime &runtime);
void register_generated_unit_141(Runtime &runtime);
void register_generated_unit_142(Runtime &runtime);
void register_generated_unit_143(Runtime &runtime);
void register_generated_unit_144(Runtime &runtime);
void register_generated_unit_145(Runtime &runtime);
void register_generated_unit_146(Runtime &runtime);
void register_generated_unit_147(Runtime &runtime);
void register_generated_unit_148(Runtime &runtime);
void register_generated_unit_149(Runtime &runtime);
void register_generated_unit_150(Runtime &runtime);
void register_generated_unit_151(Runtime &runtime);
void register_generated_unit_152(Runtime &runtime);
void register_generated_unit_153(Runtime &runtime);
void register_generated_unit_154(Runtime &runtime);
void register_generated_unit_155(Runtime &runtime);
void register_generated_unit_156(Runtime &runtime);
void register_generated_unit_157(Runtime &runtime);
void register_generated_unit_158(Runtime &runtime);
void register_generated_unit_159(Runtime &runtime);
void register_generated_unit_160(Runtime &runtime);
void register_generated_unit_161(Runtime &runtime);
void register_generated_unit_162(Runtime &runtime);
void register_generated_unit_163(Runtime &runtime);
void register_generated_unit_164(Runtime &runtime);
void register_generated_unit_165(Runtime &runtime);
void register_generated_unit_166(Runtime &runtime);
void register_generated_unit_167(Runtime &runtime);
void register_generated_unit_168(Runtime &runtime);
void register_generated_unit_169(Runtime &runtime);
void register_generated_unit_170(Runtime &runtime);
void register_generated_unit_171(Runtime &runtime);
void register_generated_unit_172(Runtime &runtime);
void register_generated_unit_173(Runtime &runtime);
void register_generated_unit_174(Runtime &runtime);
void register_generated_unit_175(Runtime &runtime);
void register_generated_unit_176(Runtime &runtime);
void register_generated_unit_177(Runtime &runtime);
void register_generated_unit_178(Runtime &runtime);
void register_generated_unit_179(Runtime &runtime);
void register_generated_unit_180(Runtime &runtime);
void register_generated_unit_181(Runtime &runtime);
void register_generated_unit_182(Runtime &runtime);
void register_generated_unit_183(Runtime &runtime);
void register_generated_unit_184(Runtime &runtime);
void register_generated_unit_185(Runtime &runtime);
void register_generated_unit_186(Runtime &runtime);
void register_generated_unit_187(Runtime &runtime);
void register_generated_unit_188(Runtime &runtime);
void register_generated_unit_189(Runtime &runtime);
void register_generated_unit_190(Runtime &runtime);
void register_generated_unit_191(Runtime &runtime);
void register_generated_unit_192(Runtime &runtime);
void register_generated_unit_193(Runtime &runtime);
void register_generated_unit_194(Runtime &runtime);
void register_generated_unit_195(Runtime &runtime);
void register_generated_unit_196(Runtime &runtime);
void register_generated_unit_197(Runtime &runtime);
void register_generated_unit_198(Runtime &runtime);
void register_generated_unit_199(Runtime &runtime);
void register_generated_unit_200(Runtime &runtime);
void register_generated_unit_201(Runtime &runtime);
void register_generated_unit_202(Runtime &runtime);
void register_generated_unit_203(Runtime &runtime);
void register_generated_unit_204(Runtime &runtime);
void register_generated_unit_205(Runtime &runtime);
void register_generated_unit_206(Runtime &runtime);
void register_generated_unit_207(Runtime &runtime);
void register_generated_unit_208(Runtime &runtime);
void register_generated_unit_209(Runtime &runtime);
void register_generated_unit_210(Runtime &runtime);
void register_generated_unit_211(Runtime &runtime);
void register_generated_unit_212(Runtime &runtime);
void register_generated_unit_213(Runtime &runtime);
void register_generated_unit_214(Runtime &runtime);

static void import_0(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(0u, "IoFileMgrForUser", 0x3251EA56u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_1(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(1u, "IoFileMgrForUser", 0x6A638D83u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_2(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(2u, "IoFileMgrForUser", 0xA0B5A7C2u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_3(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(3u, "IoFileMgrForUser", 0x42EC03ACu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_4(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(4u, "IoFileMgrForUser", 0x27EB27B8u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_5(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(5u, "IoFileMgrForUser", 0x71B19E77u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_6(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(6u, "IoFileMgrForUser", 0xE23EEC33u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_7(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(7u, "IoFileMgrForUser", 0xB29DDF9Cu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_8(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(8u, "IoFileMgrForUser", 0xE3EB004Cu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_9(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(9u, "IoFileMgrForUser", 0xEB092469u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_10(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(10u, "IoFileMgrForUser", 0x06A70004u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_11(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(11u, "IoFileMgrForUser", 0xACE946E8u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_12(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(12u, "IoFileMgrForUser", 0x779103A0u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_13(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(13u, "IoFileMgrForUser", 0x54F5FB11u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_14(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(14u, "IoFileMgrForUser", 0xE8BC6571u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_15(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(15u, "IoFileMgrForUser", 0xB293727Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_16(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(16u, "IoFileMgrForUser", 0x810C4BC3u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_17(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(17u, "IoFileMgrForUser", 0xFF5940B6u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_18(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(18u, "IoFileMgrForUser", 0x109F50BCu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_19(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(19u, "IoFileMgrForUser", 0x89AA9906u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_20(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(20u, "LoadExecForUser", 0x05572A5Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_21(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(21u, "LoadExecForUser", 0x4AC57943u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_22(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(22u, "ModuleMgrForUser", 0xF0A26395u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_23(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(23u, "ModuleMgrForUser", 0xD8B73127u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_24(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(24u, "ModuleMgrForUser", 0xB7F46618u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_25(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(25u, "ModuleMgrForUser", 0x50F0C1ECu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_26(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(26u, "ModuleMgrForUser", 0xD1FF982Au, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_27(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(27u, "ModuleMgrForUser", 0x2E0911AAu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_28(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(28u, "ModuleMgrForUser", 0xD675EBB8u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_29(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(29u, "StdioForUser", 0x172D316Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_30(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(30u, "StdioForUser", 0xA6BAB2E9u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_31(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(31u, "StdioForUser", 0xF78BA90Au, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_32(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(32u, "SysMemUserForUser", 0xA291F107u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_33(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(33u, "SysMemUserForUser", 0x237DBD4Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_34(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(34u, "SysMemUserForUser", 0xB6D61D02u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_35(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(35u, "SysMemUserForUser", 0x9D9A5BA1u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_36(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(36u, "SysMemUserForUser", 0x7591C7DBu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_37(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(37u, "SysMemUserForUser", 0xF77D77CBu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_38(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(38u, "SysMemUserForUser", 0x13A5ABEFu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_39(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(39u, "ThreadManForUser", 0x349D6D6Cu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_40(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(40u, "ThreadManForUser", 0x446D8DE6u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_41(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(41u, "ThreadManForUser", 0xF475845Du, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_42(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(42u, "ThreadManForUser", 0xAA73C935u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_43(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(43u, "ThreadManForUser", 0x809CE29Bu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_44(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(44u, "ThreadManForUser", 0x383F7BCCu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_45(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(45u, "ThreadManForUser", 0xEA748E31u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_46(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(46u, "ThreadManForUser", 0x71BC9871u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_47(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(47u, "ThreadManForUser", 0x293B45B8u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_48(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(48u, "ThreadManForUser", 0x64D4540Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_49(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(49u, "ThreadManForUser", 0x8218B4DDu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_50(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(50u, "ThreadManForUser", 0x82826F70u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_51(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(51u, "ThreadManForUser", 0xD59EAD2Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_52(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(52u, "ThreadManForUser", 0x9944F31Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_53(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(53u, "ThreadManForUser", 0x278C0DF5u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_54(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(54u, "ThreadManForUser", 0xCEADEB47u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_55(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(55u, "ThreadManForUser", 0x68DA9E36u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_56(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(56u, "ThreadManForUser", 0xD6DA4BA1u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_57(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(57u, "ThreadManForUser", 0x28B6489Cu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_58(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(58u, "ThreadManForUser", 0x3F53E640u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_59(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(59u, "ThreadManForUser", 0x4E3A1105u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_60(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(60u, "ThreadManForUser", 0x6D212BACu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_61(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(61u, "ThreadManForUser", 0x58B1F937u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_62(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(62u, "ThreadManForUser", 0x55C20A00u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_63(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(63u, "ThreadManForUser", 0x1FB15A32u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_64(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(64u, "ThreadManForUser", 0x812346E4u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_65(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(65u, "ThreadManForUser", 0x402FCF22u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_66(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(66u, "ThreadManForUser", 0x30FD48F0u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_67(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(67u, "ThreadManForUser", 0xE81CAF8Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_68(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(68u, "ThreadManForUser", 0xEDBA5844u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_69(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(69u, "ThreadManForUser", 0xC07BB470u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_70(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(70u, "ThreadManForUser", 0xED1410E0u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_71(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(71u, "ThreadManForUser", 0xD979E9BFu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_72(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(72u, "ThreadManForUser", 0xBA6B92E2u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_73(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(73u, "ThreadManForUser", 0xE1619D7Cu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_74(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(74u, "ThreadManForUser", 0xDB738F35u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_75(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(75u, "ThreadManForUser", 0x82BC5777u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_76(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(76u, "ThreadManForUser", 0x369ED59Du, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_77(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(77u, "ThreadManForUser", 0x9FA03CD3u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_78(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(78u, "UtilsForUser", 0x91E4F6A7u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_79(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(79u, "UtilsForUser", 0x27CC57F0u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_80(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(80u, "UtilsForUser", 0x71EC4271u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_81(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(81u, "UtilsForUser", 0x79D1C3FAu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_82(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(82u, "UtilsForUser", 0xB435DEC5u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_83(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(83u, "UtilsForUser", 0x6AD345D7u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_84(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(84u, "sceSuspendForUser", 0xEADB1BD7u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_85(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(85u, "sceSuspendForUser", 0x3AEE7261u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_86(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(86u, "sceSuspendForUser", 0x090CCB3Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_87(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(87u, "sceSuspendForUser", 0xA14F40B2u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_88(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(88u, "sceSuspendForUser", 0xA569E425u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_89(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(89u, "sceAudio", 0x136CAF51u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_90(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(90u, "sceAudio", 0xE2D56B2Du, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_91(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(91u, "sceAudio", 0x13F592BCu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_92(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(92u, "sceAudio", 0x5EC81C55u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_93(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(93u, "sceAudio", 0x6FC46853u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_94(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(94u, "sceAudio", 0xB011922Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_95(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(95u, "sceAudio", 0xCB2E439Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_96(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(96u, "sceAudio", 0x95FD0C2Du, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_97(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(97u, "sceAudio", 0xB7E1D8E7u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_98(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(98u, "sceSasCore", 0xA3589D81u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_99(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(99u, "sceSasCore", 0x50A14DFCu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_100(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(100u, "sceSasCore", 0x68A46B95u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_101(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(101u, "sceSasCore", 0x440CA7D8u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_102(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(102u, "sceSasCore", 0xAD84D37Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_103(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(103u, "sceSasCore", 0x99944089u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_104(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(104u, "sceSasCore", 0xB7660A23u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_105(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(105u, "sceSasCore", 0x019B25EBu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_106(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(106u, "sceSasCore", 0x9EC3676Au, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_107(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(107u, "sceSasCore", 0x5F9529F6u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_108(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(108u, "sceSasCore", 0x74AE582Au, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_109(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(109u, "sceSasCore", 0xCBCD4F79u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_110(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(110u, "sceSasCore", 0x42778A9Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_111(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(111u, "sceSasCore", 0xA0CF2FA4u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_112(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(112u, "sceSasCore", 0x76F01ACAu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_113(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(113u, "sceSasCore", 0xF983B186u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_114(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(114u, "sceSasCore", 0xD5A229C9u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_115(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(115u, "sceSasCore", 0x33D4AB37u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_116(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(116u, "sceSasCore", 0x267A6DD2u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_117(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(117u, "sceAtrac3plus", 0x61EB33F5u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_118(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(118u, "sceAtrac3plus", 0x0FAE370Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_119(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(119u, "sceAtrac3plus", 0x6A8C3CD5u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_120(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(120u, "sceAtrac3plus", 0x9AE849A7u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_121(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(121u, "sceAtrac3plus", 0x5D268707u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_122(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(122u, "sceAtrac3plus", 0x7DB31251u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_123(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(123u, "sceAtrac3plus", 0xA2BBA8BEu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_124(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(124u, "sceAtrac3plus", 0xA554A158u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_125(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(125u, "sceAtrac3plus", 0xFAA4F89Bu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_126(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(126u, "sceAtrac3plus", 0x868120B5u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_127(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(127u, "sceAtrac3plus", 0xCA3CA3D2u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_128(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(128u, "sceAtrac3plus", 0x644E5607u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_129(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(129u, "sceAtrac3plus", 0xE88F759Bu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_130(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(130u, "sceGe_user", 0x1F6752ADu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_131(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(131u, "sceGe_user", 0xE47E40E4u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_132(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(132u, "sceGe_user", 0xAB49E76Au, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_133(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(133u, "sceGe_user", 0xB287BD61u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_134(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(134u, "sceGe_user", 0xA4FC06A4u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_135(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(135u, "sceGe_user", 0x05DB22CEu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_136(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(136u, "sceCtrl", 0x6A2774F3u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_137(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(137u, "sceCtrl", 0x1F4011E6u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_138(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(138u, "sceCtrl", 0x1F803938u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_139(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(139u, "sceDisplay", 0x0E20F177u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_140(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(140u, "sceDisplay", 0x289D82FEu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_141(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(141u, "sceDisplay", 0x4D4E10ECu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_142(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(142u, "sceDisplay", 0x36CDFADEu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_143(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(143u, "sceDisplay", 0x984C27E7u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_144(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(144u, "sceDisplay", 0x773DD3A3u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_145(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(145u, "sceMpeg", 0x21FF80E4u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_146(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(146u, "sceMpeg", 0x611E9E11u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_147(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(147u, "sceMpeg", 0x682A619Bu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_148(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(148u, "sceMpeg", 0x874624D6u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_149(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(149u, "sceMpeg", 0xC132E22Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_150(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(150u, "sceMpeg", 0xD8C5F121u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_151(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(151u, "sceMpeg", 0x606A4649u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_152(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(152u, "sceMpeg", 0x42560F23u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_153(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(153u, "sceMpeg", 0x591A4AA2u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_154(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(154u, "sceMpeg", 0xA780CF7Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_155(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(155u, "sceMpeg", 0xCEB870B1u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_156(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(156u, "sceMpeg", 0xF8DCB679u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_157(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(157u, "sceMpeg", 0x167AFD9Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_158(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(158u, "sceMpeg", 0xFE246728u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_159(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(159u, "sceMpeg", 0xE1CE83A7u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_160(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(160u, "sceMpeg", 0x707B7629u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_161(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(161u, "sceMpeg", 0x0E3C2E9Du, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_162(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(162u, "sceMpeg", 0x740FCCD1u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_163(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(163u, "sceMpeg", 0x800C44DFu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_164(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(164u, "sceMpeg", 0xD7A29F46u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_165(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(165u, "sceMpeg", 0x37295ED8u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_166(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(166u, "sceMpeg", 0x13407F13u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_167(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(167u, "sceMpeg", 0xB240A59Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_168(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(168u, "sceMpeg", 0xB5F6DC87u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_169(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(169u, "sceUmdUser", 0x46EBB729u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_170(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(170u, "sceUmdUser", 0xC6183D47u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_171(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(171u, "sceUmdUser", 0x8EF08FCEu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_172(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(172u, "sceUmdUser", 0x56202973u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_173(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(173u, "sceUmdUser", 0x6B4A146Cu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_174(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(174u, "sceUmdUser", 0x20628E6Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_175(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(175u, "sceUmdUser", 0xAEE7404Du, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_176(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(176u, "sceUmdUser", 0xBD2BDE07u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_177(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(177u, "sceUtility", 0x50C4CD57u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_178(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(178u, "sceUtility", 0x9790B33Cu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_179(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(179u, "sceUtility", 0xD4B95FFBu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_180(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(180u, "sceUtility", 0x8874DBE0u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_181(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(181u, "sceUtility", 0x2AD8E239u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_182(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(182u, "sceUtility", 0x67AF3428u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_183(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(183u, "sceUtility", 0x95FC253Bu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_184(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(184u, "sceUtility", 0x9A1C91D7u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_185(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(185u, "sceUtility", 0xA5DA2406u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_186(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(186u, "sceUtility", 0x34B78343u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_187(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(187u, "sceUtility", 0x1579A159u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_188(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(188u, "sceUtility", 0x64D50C56u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_189(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(189u, "scePower", 0x04B7766Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_190(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(190u, "scePower", 0xDFA8BAF8u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_191(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(191u, "scePower", 0xEA382A27u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_192(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(192u, "sceNet", 0x39AF39A6u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_193(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(193u, "sceNet", 0x281928A9u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_194(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(194u, "sceNet", 0x89360950u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_195(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(195u, "sceNet", 0x0BF0A3AEu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_196(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(196u, "sceNetAdhoc", 0xE1D621D7u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_197(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(197u, "sceNetAdhoc", 0xA62C6F57u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_198(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(198u, "sceNetAdhoc", 0x6F92741Bu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_199(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(199u, "sceNetAdhoc", 0xABED3790u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_200(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(200u, "sceNetAdhoc", 0xDFE53E03u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_201(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(201u, "sceNetAdhoc", 0x7F27BB5Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_202(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(202u, "sceNetAdhoc", 0x877F6D66u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_203(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(203u, "sceNetAdhoc", 0xFC6FC07Bu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_204(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(204u, "sceNetAdhoc", 0xE08BDAC1u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_205(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(205u, "sceNetAdhoc", 0x9DF81198u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_206(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(206u, "sceNetAdhoc", 0x4DA4C788u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_207(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(207u, "sceNetAdhoc", 0x8BEA2B3Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_208(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(208u, "sceNetAdhoc", 0x9AC2EEACu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_209(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(209u, "sceNetAdhoc", 0x157E6225u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_210(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(210u, "sceNetAdhocctl", 0xE26F226Eu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_211(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(211u, "sceNetAdhocctl", 0x9D689E13u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_212(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(212u, "sceNetAdhocctl", 0x0AD043EDu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_213(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(213u, "sceNetAdhocctl", 0xEC0635C1u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_214(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(214u, "sceNetAdhocctl", 0x5E7F79C9u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_215(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(215u, "sceNetAdhocctl", 0x08FFF7A0u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_216(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(216u, "sceNetAdhocctl", 0x34401D65u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_217(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(217u, "sceNetAdhocctl", 0x20B317A0u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_218(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(218u, "sceNetAdhocctl", 0x8916C003u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_219(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(219u, "sceNetAdhocctl", 0x81AEE1BEu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_220(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(220u, "sceNetAdhocMatching", 0x2A2A1E07u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_221(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(221u, "sceNetAdhocMatching", 0x7945ECDAu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_222(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(222u, "sceNetAdhocMatching", 0xCA5EDA6Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_223(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(223u, "sceNetAdhocMatching", 0x93EF3843u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_224(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(224u, "sceNetAdhocMatching", 0x32B156B3u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_225(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(225u, "sceNetAdhocMatching", 0xF16EAF4Fu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_226(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(226u, "sceNetAdhocMatching", 0x5E3D4B79u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_227(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(227u, "sceNetAdhocMatching", 0xEA3C6108u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_228(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(228u, "sceNetAdhocMatching", 0xB58E61B7u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_229(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(229u, "sceRtc", 0x6FF40ACCu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_230(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(230u, "sceRtc", 0x9ED0AE87u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_231(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(231u, "sceWlanDrv", 0xD7763699u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_232(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(232u, "InterruptManager", 0xCA04A2B9u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_233(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(233u, "InterruptManager", 0xD61E6961u, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

static void import_234(Runtime &rt, AllegrexContext &ctx) {
    const RuntimeExecutionContextToken caller_context = capture_runtime_execution_context();
    const std::uint32_t import_pc = ctx.pc;
    const std::uint32_t return_address = ctx.gpr[31];
    rt.invoke_import_cached(234u, "InterruptManager", 0xFB8E22ECu, ctx);
    if (!rt.stopped() && runtime_execution_context_matches(caller_context) &&
        ctx.pc == import_pc) ctx.pc = return_address;
}

void register_generated_functions(Runtime &runtime) {
    register_generated_unit_0(runtime);
    register_generated_unit_1(runtime);
    register_generated_unit_2(runtime);
    register_generated_unit_3(runtime);
    register_generated_unit_4(runtime);
    register_generated_unit_5(runtime);
    register_generated_unit_6(runtime);
    register_generated_unit_7(runtime);
    register_generated_unit_8(runtime);
    register_generated_unit_9(runtime);
    register_generated_unit_10(runtime);
    register_generated_unit_11(runtime);
    register_generated_unit_12(runtime);
    register_generated_unit_13(runtime);
    register_generated_unit_14(runtime);
    register_generated_unit_15(runtime);
    register_generated_unit_16(runtime);
    register_generated_unit_17(runtime);
    register_generated_unit_18(runtime);
    register_generated_unit_19(runtime);
    register_generated_unit_20(runtime);
    register_generated_unit_21(runtime);
    register_generated_unit_22(runtime);
    register_generated_unit_23(runtime);
    register_generated_unit_24(runtime);
    register_generated_unit_25(runtime);
    register_generated_unit_26(runtime);
    register_generated_unit_27(runtime);
    register_generated_unit_28(runtime);
    register_generated_unit_29(runtime);
    register_generated_unit_30(runtime);
    register_generated_unit_31(runtime);
    register_generated_unit_32(runtime);
    register_generated_unit_33(runtime);
    register_generated_unit_34(runtime);
    register_generated_unit_35(runtime);
    register_generated_unit_36(runtime);
    register_generated_unit_37(runtime);
    register_generated_unit_38(runtime);
    register_generated_unit_39(runtime);
    register_generated_unit_40(runtime);
    register_generated_unit_41(runtime);
    register_generated_unit_42(runtime);
    register_generated_unit_43(runtime);
    register_generated_unit_44(runtime);
    register_generated_unit_45(runtime);
    register_generated_unit_46(runtime);
    register_generated_unit_47(runtime);
    register_generated_unit_48(runtime);
    register_generated_unit_49(runtime);
    register_generated_unit_50(runtime);
    register_generated_unit_51(runtime);
    register_generated_unit_52(runtime);
    register_generated_unit_53(runtime);
    register_generated_unit_54(runtime);
    register_generated_unit_55(runtime);
    register_generated_unit_56(runtime);
    register_generated_unit_57(runtime);
    register_generated_unit_58(runtime);
    register_generated_unit_59(runtime);
    register_generated_unit_60(runtime);
    register_generated_unit_61(runtime);
    register_generated_unit_62(runtime);
    register_generated_unit_63(runtime);
    register_generated_unit_64(runtime);
    register_generated_unit_65(runtime);
    register_generated_unit_66(runtime);
    register_generated_unit_67(runtime);
    register_generated_unit_68(runtime);
    register_generated_unit_69(runtime);
    register_generated_unit_70(runtime);
    register_generated_unit_71(runtime);
    register_generated_unit_72(runtime);
    register_generated_unit_73(runtime);
    register_generated_unit_74(runtime);
    register_generated_unit_75(runtime);
    register_generated_unit_76(runtime);
    register_generated_unit_77(runtime);
    register_generated_unit_78(runtime);
    register_generated_unit_79(runtime);
    register_generated_unit_80(runtime);
    register_generated_unit_81(runtime);
    register_generated_unit_82(runtime);
    register_generated_unit_83(runtime);
    register_generated_unit_84(runtime);
    register_generated_unit_85(runtime);
    register_generated_unit_86(runtime);
    register_generated_unit_87(runtime);
    register_generated_unit_88(runtime);
    register_generated_unit_89(runtime);
    register_generated_unit_90(runtime);
    register_generated_unit_91(runtime);
    register_generated_unit_92(runtime);
    register_generated_unit_93(runtime);
    register_generated_unit_94(runtime);
    register_generated_unit_95(runtime);
    register_generated_unit_96(runtime);
    register_generated_unit_97(runtime);
    register_generated_unit_98(runtime);
    register_generated_unit_99(runtime);
    register_generated_unit_100(runtime);
    register_generated_unit_101(runtime);
    register_generated_unit_102(runtime);
    register_generated_unit_103(runtime);
    register_generated_unit_104(runtime);
    register_generated_unit_105(runtime);
    register_generated_unit_106(runtime);
    register_generated_unit_107(runtime);
    register_generated_unit_108(runtime);
    register_generated_unit_109(runtime);
    register_generated_unit_110(runtime);
    register_generated_unit_111(runtime);
    register_generated_unit_112(runtime);
    register_generated_unit_113(runtime);
    register_generated_unit_114(runtime);
    register_generated_unit_115(runtime);
    register_generated_unit_116(runtime);
    register_generated_unit_117(runtime);
    register_generated_unit_118(runtime);
    register_generated_unit_119(runtime);
    register_generated_unit_120(runtime);
    register_generated_unit_121(runtime);
    register_generated_unit_122(runtime);
    register_generated_unit_123(runtime);
    register_generated_unit_124(runtime);
    register_generated_unit_125(runtime);
    register_generated_unit_126(runtime);
    register_generated_unit_127(runtime);
    register_generated_unit_128(runtime);
    register_generated_unit_129(runtime);
    register_generated_unit_130(runtime);
    register_generated_unit_131(runtime);
    register_generated_unit_132(runtime);
    register_generated_unit_133(runtime);
    register_generated_unit_134(runtime);
    register_generated_unit_135(runtime);
    register_generated_unit_136(runtime);
    register_generated_unit_137(runtime);
    register_generated_unit_138(runtime);
    register_generated_unit_139(runtime);
    register_generated_unit_140(runtime);
    register_generated_unit_141(runtime);
    register_generated_unit_142(runtime);
    register_generated_unit_143(runtime);
    register_generated_unit_144(runtime);
    register_generated_unit_145(runtime);
    register_generated_unit_146(runtime);
    register_generated_unit_147(runtime);
    register_generated_unit_148(runtime);
    register_generated_unit_149(runtime);
    register_generated_unit_150(runtime);
    register_generated_unit_151(runtime);
    register_generated_unit_152(runtime);
    register_generated_unit_153(runtime);
    register_generated_unit_154(runtime);
    register_generated_unit_155(runtime);
    register_generated_unit_156(runtime);
    register_generated_unit_157(runtime);
    register_generated_unit_158(runtime);
    register_generated_unit_159(runtime);
    register_generated_unit_160(runtime);
    register_generated_unit_161(runtime);
    register_generated_unit_162(runtime);
    register_generated_unit_163(runtime);
    register_generated_unit_164(runtime);
    register_generated_unit_165(runtime);
    register_generated_unit_166(runtime);
    register_generated_unit_167(runtime);
    register_generated_unit_168(runtime);
    register_generated_unit_169(runtime);
    register_generated_unit_170(runtime);
    register_generated_unit_171(runtime);
    register_generated_unit_172(runtime);
    register_generated_unit_173(runtime);
    register_generated_unit_174(runtime);
    register_generated_unit_175(runtime);
    register_generated_unit_176(runtime);
    register_generated_unit_177(runtime);
    register_generated_unit_178(runtime);
    register_generated_unit_179(runtime);
    register_generated_unit_180(runtime);
    register_generated_unit_181(runtime);
    register_generated_unit_182(runtime);
    register_generated_unit_183(runtime);
    register_generated_unit_184(runtime);
    register_generated_unit_185(runtime);
    register_generated_unit_186(runtime);
    register_generated_unit_187(runtime);
    register_generated_unit_188(runtime);
    register_generated_unit_189(runtime);
    register_generated_unit_190(runtime);
    register_generated_unit_191(runtime);
    register_generated_unit_192(runtime);
    register_generated_unit_193(runtime);
    register_generated_unit_194(runtime);
    register_generated_unit_195(runtime);
    register_generated_unit_196(runtime);
    register_generated_unit_197(runtime);
    register_generated_unit_198(runtime);
    register_generated_unit_199(runtime);
    register_generated_unit_200(runtime);
    register_generated_unit_201(runtime);
    register_generated_unit_202(runtime);
    register_generated_unit_203(runtime);
    register_generated_unit_204(runtime);
    register_generated_unit_205(runtime);
    register_generated_unit_206(runtime);
    register_generated_unit_207(runtime);
    register_generated_unit_208(runtime);
    register_generated_unit_209(runtime);
    register_generated_unit_210(runtime);
    register_generated_unit_211(runtime);
    register_generated_unit_212(runtime);
    register_generated_unit_213(runtime);
    register_generated_unit_214(runtime);
    runtime.register_function(0x08B0BD6Cu, &import_0, "IoFileMgrForUser::0x3251EA56");
    runtime.register_function(0x08B0BD74u, &import_1, "IoFileMgrForUser::0x6A638D83");
    runtime.register_function(0x08B0BD7Cu, &import_2, "IoFileMgrForUser::0xA0B5A7C2");
    runtime.register_function(0x08B0BD84u, &import_3, "IoFileMgrForUser::0x42EC03AC");
    runtime.register_function(0x08B0BD8Cu, &import_4, "IoFileMgrForUser::0x27EB27B8");
    runtime.register_function(0x08B0BD94u, &import_5, "IoFileMgrForUser::0x71B19E77");
    runtime.register_function(0x08B0BD9Cu, &import_6, "IoFileMgrForUser::0xE23EEC33");
    runtime.register_function(0x08B0BDA4u, &import_7, "IoFileMgrForUser::0xB29DDF9C");
    runtime.register_function(0x08B0BDACu, &import_8, "IoFileMgrForUser::0xE3EB004C");
    runtime.register_function(0x08B0BDB4u, &import_9, "IoFileMgrForUser::0xEB092469");
    runtime.register_function(0x08B0BDBCu, &import_10, "IoFileMgrForUser::0x06A70004");
    runtime.register_function(0x08B0BDC4u, &import_11, "IoFileMgrForUser::0xACE946E8");
    runtime.register_function(0x08B0BDCCu, &import_12, "IoFileMgrForUser::0x779103A0");
    runtime.register_function(0x08B0BDD4u, &import_13, "IoFileMgrForUser::0x54F5FB11");
    runtime.register_function(0x08B0BDDCu, &import_14, "IoFileMgrForUser::0xE8BC6571");
    runtime.register_function(0x08B0BDE4u, &import_15, "IoFileMgrForUser::0xB293727F");
    runtime.register_function(0x08B0BDECu, &import_16, "IoFileMgrForUser::0x810C4BC3");
    runtime.register_function(0x08B0BDF4u, &import_17, "IoFileMgrForUser::0xFF5940B6");
    runtime.register_function(0x08B0BDFCu, &import_18, "IoFileMgrForUser::0x109F50BC");
    runtime.register_function(0x08B0BE04u, &import_19, "IoFileMgrForUser::0x89AA9906");
    runtime.register_function(0x08B0BD5Cu, &import_20, "LoadExecForUser::0x05572A5F");
    runtime.register_function(0x08B0BD64u, &import_21, "LoadExecForUser::0x4AC57943");
    runtime.register_function(0x08B0BD24u, &import_22, "ModuleMgrForUser::0xF0A26395");
    runtime.register_function(0x08B0BD2Cu, &import_23, "ModuleMgrForUser::0xD8B73127");
    runtime.register_function(0x08B0BD34u, &import_24, "ModuleMgrForUser::0xB7F46618");
    runtime.register_function(0x08B0BD3Cu, &import_25, "ModuleMgrForUser::0x50F0C1EC");
    runtime.register_function(0x08B0BD44u, &import_26, "ModuleMgrForUser::0xD1FF982A");
    runtime.register_function(0x08B0BD4Cu, &import_27, "ModuleMgrForUser::0x2E0911AA");
    runtime.register_function(0x08B0BD54u, &import_28, "ModuleMgrForUser::0xD675EBB8");
    runtime.register_function(0x08B0BD0Cu, &import_29, "StdioForUser::0x172D316E");
    runtime.register_function(0x08B0BD14u, &import_30, "StdioForUser::0xA6BAB2E9");
    runtime.register_function(0x08B0BD1Cu, &import_31, "StdioForUser::0xF78BA90A");
    runtime.register_function(0x08B0BCD4u, &import_32, "SysMemUserForUser::0xA291F107");
    runtime.register_function(0x08B0BCDCu, &import_33, "SysMemUserForUser::0x237DBD4F");
    runtime.register_function(0x08B0BCE4u, &import_34, "SysMemUserForUser::0xB6D61D02");
    runtime.register_function(0x08B0BCECu, &import_35, "SysMemUserForUser::0x9D9A5BA1");
    runtime.register_function(0x08B0BCF4u, &import_36, "SysMemUserForUser::0x7591C7DB");
    runtime.register_function(0x08B0BCFCu, &import_37, "SysMemUserForUser::0xF77D77CB");
    runtime.register_function(0x08B0BD04u, &import_38, "SysMemUserForUser::0x13A5ABEF");
    runtime.register_function(0x08B0BB9Cu, &import_39, "ThreadManForUser::0x349D6D6C");
    runtime.register_function(0x08B0BBA4u, &import_40, "ThreadManForUser::0x446D8DE6");
    runtime.register_function(0x08B0BBACu, &import_41, "ThreadManForUser::0xF475845D");
    runtime.register_function(0x08B0BBB4u, &import_42, "ThreadManForUser::0xAA73C935");
    runtime.register_function(0x08B0BBBCu, &import_43, "ThreadManForUser::0x809CE29B");
    runtime.register_function(0x08B0BBC4u, &import_44, "ThreadManForUser::0x383F7BCC");
    runtime.register_function(0x08B0BBCCu, &import_45, "ThreadManForUser::0xEA748E31");
    runtime.register_function(0x08B0BBD4u, &import_46, "ThreadManForUser::0x71BC9871");
    runtime.register_function(0x08B0BBDCu, &import_47, "ThreadManForUser::0x293B45B8");
    runtime.register_function(0x08B0BBE4u, &import_48, "ThreadManForUser::0x64D4540E");
    runtime.register_function(0x08B0BBECu, &import_49, "ThreadManForUser::0x8218B4DD");
    runtime.register_function(0x08B0BBF4u, &import_50, "ThreadManForUser::0x82826F70");
    runtime.register_function(0x08B0BBFCu, &import_51, "ThreadManForUser::0xD59EAD2F");
    runtime.register_function(0x08B0BC04u, &import_52, "ThreadManForUser::0x9944F31F");
    runtime.register_function(0x08B0BC0Cu, &import_53, "ThreadManForUser::0x278C0DF5");
    runtime.register_function(0x08B0BC14u, &import_54, "ThreadManForUser::0xCEADEB47");
    runtime.register_function(0x08B0BC1Cu, &import_55, "ThreadManForUser::0x68DA9E36");
    runtime.register_function(0x08B0BC24u, &import_56, "ThreadManForUser::0xD6DA4BA1");
    runtime.register_function(0x08B0BC2Cu, &import_57, "ThreadManForUser::0x28B6489C");
    runtime.register_function(0x08B0BC34u, &import_58, "ThreadManForUser::0x3F53E640");
    runtime.register_function(0x08B0BC3Cu, &import_59, "ThreadManForUser::0x4E3A1105");
    runtime.register_function(0x08B0BC44u, &import_60, "ThreadManForUser::0x6D212BAC");
    runtime.register_function(0x08B0BC4Cu, &import_61, "ThreadManForUser::0x58B1F937");
    runtime.register_function(0x08B0BC54u, &import_62, "ThreadManForUser::0x55C20A00");
    runtime.register_function(0x08B0BC5Cu, &import_63, "ThreadManForUser::0x1FB15A32");
    runtime.register_function(0x08B0BC64u, &import_64, "ThreadManForUser::0x812346E4");
    runtime.register_function(0x08B0BC6Cu, &import_65, "ThreadManForUser::0x402FCF22");
    runtime.register_function(0x08B0BC74u, &import_66, "ThreadManForUser::0x30FD48F0");
    runtime.register_function(0x08B0BC7Cu, &import_67, "ThreadManForUser::0xE81CAF8F");
    runtime.register_function(0x08B0BC84u, &import_68, "ThreadManForUser::0xEDBA5844");
    runtime.register_function(0x08B0BC8Cu, &import_69, "ThreadManForUser::0xC07BB470");
    runtime.register_function(0x08B0BC94u, &import_70, "ThreadManForUser::0xED1410E0");
    runtime.register_function(0x08B0BC9Cu, &import_71, "ThreadManForUser::0xD979E9BF");
    runtime.register_function(0x08B0BCA4u, &import_72, "ThreadManForUser::0xBA6B92E2");
    runtime.register_function(0x08B0BCACu, &import_73, "ThreadManForUser::0xE1619D7C");
    runtime.register_function(0x08B0BCB4u, &import_74, "ThreadManForUser::0xDB738F35");
    runtime.register_function(0x08B0BCBCu, &import_75, "ThreadManForUser::0x82BC5777");
    runtime.register_function(0x08B0BCC4u, &import_76, "ThreadManForUser::0x369ED59D");
    runtime.register_function(0x08B0BCCCu, &import_77, "ThreadManForUser::0x9FA03CD3");
    runtime.register_function(0x08B0BB6Cu, &import_78, "UtilsForUser::0x91E4F6A7");
    runtime.register_function(0x08B0BB74u, &import_79, "UtilsForUser::0x27CC57F0");
    runtime.register_function(0x08B0BB7Cu, &import_80, "UtilsForUser::0x71EC4271");
    runtime.register_function(0x08B0BB84u, &import_81, "UtilsForUser::0x79D1C3FA");
    runtime.register_function(0x08B0BB8Cu, &import_82, "UtilsForUser::0xB435DEC5");
    runtime.register_function(0x08B0BB94u, &import_83, "UtilsForUser::0x6AD345D7");
    runtime.register_function(0x08B0BB44u, &import_84, "sceSuspendForUser::0xEADB1BD7");
    runtime.register_function(0x08B0BB4Cu, &import_85, "sceSuspendForUser::0x3AEE7261");
    runtime.register_function(0x08B0BB54u, &import_86, "sceSuspendForUser::0x090CCB3F");
    runtime.register_function(0x08B0BB5Cu, &import_87, "sceSuspendForUser::0xA14F40B2");
    runtime.register_function(0x08B0BB64u, &import_88, "sceSuspendForUser::0xA569E425");
    runtime.register_function(0x08B0BAFCu, &import_89, "sceAudio::0x136CAF51");
    runtime.register_function(0x08B0BB04u, &import_90, "sceAudio::0xE2D56B2D");
    runtime.register_function(0x08B0BB0Cu, &import_91, "sceAudio::0x13F592BC");
    runtime.register_function(0x08B0BB14u, &import_92, "sceAudio::0x5EC81C55");
    runtime.register_function(0x08B0BB1Cu, &import_93, "sceAudio::0x6FC46853");
    runtime.register_function(0x08B0BB24u, &import_94, "sceAudio::0xB011922F");
    runtime.register_function(0x08B0BB2Cu, &import_95, "sceAudio::0xCB2E439E");
    runtime.register_function(0x08B0BB34u, &import_96, "sceAudio::0x95FD0C2D");
    runtime.register_function(0x08B0BB3Cu, &import_97, "sceAudio::0xB7E1D8E7");
    runtime.register_function(0x08B0BA64u, &import_98, "sceSasCore::0xA3589D81");
    runtime.register_function(0x08B0BA6Cu, &import_99, "sceSasCore::0x50A14DFC");
    runtime.register_function(0x08B0BA74u, &import_100, "sceSasCore::0x68A46B95");
    runtime.register_function(0x08B0BA7Cu, &import_101, "sceSasCore::0x440CA7D8");
    runtime.register_function(0x08B0BA84u, &import_102, "sceSasCore::0xAD84D37F");
    runtime.register_function(0x08B0BA8Cu, &import_103, "sceSasCore::0x99944089");
    runtime.register_function(0x08B0BA94u, &import_104, "sceSasCore::0xB7660A23");
    runtime.register_function(0x08B0BA9Cu, &import_105, "sceSasCore::0x019B25EB");
    runtime.register_function(0x08B0BAA4u, &import_106, "sceSasCore::0x9EC3676A");
    runtime.register_function(0x08B0BAACu, &import_107, "sceSasCore::0x5F9529F6");
    runtime.register_function(0x08B0BAB4u, &import_108, "sceSasCore::0x74AE582A");
    runtime.register_function(0x08B0BABCu, &import_109, "sceSasCore::0xCBCD4F79");
    runtime.register_function(0x08B0BAC4u, &import_110, "sceSasCore::0x42778A9F");
    runtime.register_function(0x08B0BACCu, &import_111, "sceSasCore::0xA0CF2FA4");
    runtime.register_function(0x08B0BAD4u, &import_112, "sceSasCore::0x76F01ACA");
    runtime.register_function(0x08B0BADCu, &import_113, "sceSasCore::0xF983B186");
    runtime.register_function(0x08B0BAE4u, &import_114, "sceSasCore::0xD5A229C9");
    runtime.register_function(0x08B0BAECu, &import_115, "sceSasCore::0x33D4AB37");
    runtime.register_function(0x08B0BAF4u, &import_116, "sceSasCore::0x267A6DD2");
    runtime.register_function(0x08B0B9FCu, &import_117, "sceAtrac3plus::0x61EB33F5");
    runtime.register_function(0x08B0BA04u, &import_118, "sceAtrac3plus::0x0FAE370E");
    runtime.register_function(0x08B0BA0Cu, &import_119, "sceAtrac3plus::0x6A8C3CD5");
    runtime.register_function(0x08B0BA14u, &import_120, "sceAtrac3plus::0x9AE849A7");
    runtime.register_function(0x08B0BA1Cu, &import_121, "sceAtrac3plus::0x5D268707");
    runtime.register_function(0x08B0BA24u, &import_122, "sceAtrac3plus::0x7DB31251");
    runtime.register_function(0x08B0BA2Cu, &import_123, "sceAtrac3plus::0xA2BBA8BE");
    runtime.register_function(0x08B0BA34u, &import_124, "sceAtrac3plus::0xA554A158");
    runtime.register_function(0x08B0BA3Cu, &import_125, "sceAtrac3plus::0xFAA4F89B");
    runtime.register_function(0x08B0BA44u, &import_126, "sceAtrac3plus::0x868120B5");
    runtime.register_function(0x08B0BA4Cu, &import_127, "sceAtrac3plus::0xCA3CA3D2");
    runtime.register_function(0x08B0BA54u, &import_128, "sceAtrac3plus::0x644E5607");
    runtime.register_function(0x08B0BA5Cu, &import_129, "sceAtrac3plus::0xE88F759B");
    runtime.register_function(0x08B0B9CCu, &import_130, "sceGe_user::0x1F6752AD");
    runtime.register_function(0x08B0B9D4u, &import_131, "sceGe_user::0xE47E40E4");
    runtime.register_function(0x08B0B9DCu, &import_132, "sceGe_user::0xAB49E76A");
    runtime.register_function(0x08B0B9E4u, &import_133, "sceGe_user::0xB287BD61");
    runtime.register_function(0x08B0B9ECu, &import_134, "sceGe_user::0xA4FC06A4");
    runtime.register_function(0x08B0B9F4u, &import_135, "sceGe_user::0x05DB22CE");
    runtime.register_function(0x08B0B9B4u, &import_136, "sceCtrl::0x6A2774F3");
    runtime.register_function(0x08B0B9BCu, &import_137, "sceCtrl::0x1F4011E6");
    runtime.register_function(0x08B0B9C4u, &import_138, "sceCtrl::0x1F803938");
    runtime.register_function(0x08B0B984u, &import_139, "sceDisplay::0x0E20F177");
    runtime.register_function(0x08B0B98Cu, &import_140, "sceDisplay::0x289D82FE");
    runtime.register_function(0x08B0B994u, &import_141, "sceDisplay::0x4D4E10EC");
    runtime.register_function(0x08B0B99Cu, &import_142, "sceDisplay::0x36CDFADE");
    runtime.register_function(0x08B0B9A4u, &import_143, "sceDisplay::0x984C27E7");
    runtime.register_function(0x08B0B9ACu, &import_144, "sceDisplay::0x773DD3A3");
    runtime.register_function(0x08B0B8C4u, &import_145, "sceMpeg::0x21FF80E4");
    runtime.register_function(0x08B0B8CCu, &import_146, "sceMpeg::0x611E9E11");
    runtime.register_function(0x08B0B8D4u, &import_147, "sceMpeg::0x682A619B");
    runtime.register_function(0x08B0B8DCu, &import_148, "sceMpeg::0x874624D6");
    runtime.register_function(0x08B0B8E4u, &import_149, "sceMpeg::0xC132E22F");
    runtime.register_function(0x08B0B8ECu, &import_150, "sceMpeg::0xD8C5F121");
    runtime.register_function(0x08B0B8F4u, &import_151, "sceMpeg::0x606A4649");
    runtime.register_function(0x08B0B8FCu, &import_152, "sceMpeg::0x42560F23");
    runtime.register_function(0x08B0B904u, &import_153, "sceMpeg::0x591A4AA2");
    runtime.register_function(0x08B0B90Cu, &import_154, "sceMpeg::0xA780CF7E");
    runtime.register_function(0x08B0B914u, &import_155, "sceMpeg::0xCEB870B1");
    runtime.register_function(0x08B0B91Cu, &import_156, "sceMpeg::0xF8DCB679");
    runtime.register_function(0x08B0B924u, &import_157, "sceMpeg::0x167AFD9E");
    runtime.register_function(0x08B0B92Cu, &import_158, "sceMpeg::0xFE246728");
    runtime.register_function(0x08B0B934u, &import_159, "sceMpeg::0xE1CE83A7");
    runtime.register_function(0x08B0B93Cu, &import_160, "sceMpeg::0x707B7629");
    runtime.register_function(0x08B0B944u, &import_161, "sceMpeg::0x0E3C2E9D");
    runtime.register_function(0x08B0B94Cu, &import_162, "sceMpeg::0x740FCCD1");
    runtime.register_function(0x08B0B954u, &import_163, "sceMpeg::0x800C44DF");
    runtime.register_function(0x08B0B95Cu, &import_164, "sceMpeg::0xD7A29F46");
    runtime.register_function(0x08B0B964u, &import_165, "sceMpeg::0x37295ED8");
    runtime.register_function(0x08B0B96Cu, &import_166, "sceMpeg::0x13407F13");
    runtime.register_function(0x08B0B974u, &import_167, "sceMpeg::0xB240A59E");
    runtime.register_function(0x08B0B97Cu, &import_168, "sceMpeg::0xB5F6DC87");
    runtime.register_function(0x08B0B884u, &import_169, "sceUmdUser::0x46EBB729");
    runtime.register_function(0x08B0B88Cu, &import_170, "sceUmdUser::0xC6183D47");
    runtime.register_function(0x08B0B894u, &import_171, "sceUmdUser::0x8EF08FCE");
    runtime.register_function(0x08B0B89Cu, &import_172, "sceUmdUser::0x56202973");
    runtime.register_function(0x08B0B8A4u, &import_173, "sceUmdUser::0x6B4A146C");
    runtime.register_function(0x08B0B8ACu, &import_174, "sceUmdUser::0x20628E6F");
    runtime.register_function(0x08B0B8B4u, &import_175, "sceUmdUser::0xAEE7404D");
    runtime.register_function(0x08B0B8BCu, &import_176, "sceUmdUser::0xBD2BDE07");
    runtime.register_function(0x08B0B824u, &import_177, "sceUtility::0x50C4CD57");
    runtime.register_function(0x08B0B82Cu, &import_178, "sceUtility::0x9790B33C");
    runtime.register_function(0x08B0B834u, &import_179, "sceUtility::0xD4B95FFB");
    runtime.register_function(0x08B0B83Cu, &import_180, "sceUtility::0x8874DBE0");
    runtime.register_function(0x08B0B844u, &import_181, "sceUtility::0x2AD8E239");
    runtime.register_function(0x08B0B84Cu, &import_182, "sceUtility::0x67AF3428");
    runtime.register_function(0x08B0B854u, &import_183, "sceUtility::0x95FC253B");
    runtime.register_function(0x08B0B85Cu, &import_184, "sceUtility::0x9A1C91D7");
    runtime.register_function(0x08B0B864u, &import_185, "sceUtility::0xA5DA2406");
    runtime.register_function(0x08B0B86Cu, &import_186, "sceUtility::0x34B78343");
    runtime.register_function(0x08B0B874u, &import_187, "sceUtility::0x1579A159");
    runtime.register_function(0x08B0B87Cu, &import_188, "sceUtility::0x64D50C56");
    runtime.register_function(0x08B0B80Cu, &import_189, "scePower::0x04B7766E");
    runtime.register_function(0x08B0B814u, &import_190, "scePower::0xDFA8BAF8");
    runtime.register_function(0x08B0B81Cu, &import_191, "scePower::0xEA382A27");
    runtime.register_function(0x08B0B7ECu, &import_192, "sceNet::0x39AF39A6");
    runtime.register_function(0x08B0B7F4u, &import_193, "sceNet::0x281928A9");
    runtime.register_function(0x08B0B7FCu, &import_194, "sceNet::0x89360950");
    runtime.register_function(0x08B0B804u, &import_195, "sceNet::0x0BF0A3AE");
    runtime.register_function(0x08B0B77Cu, &import_196, "sceNetAdhoc::0xE1D621D7");
    runtime.register_function(0x08B0B784u, &import_197, "sceNetAdhoc::0xA62C6F57");
    runtime.register_function(0x08B0B78Cu, &import_198, "sceNetAdhoc::0x6F92741B");
    runtime.register_function(0x08B0B794u, &import_199, "sceNetAdhoc::0xABED3790");
    runtime.register_function(0x08B0B79Cu, &import_200, "sceNetAdhoc::0xDFE53E03");
    runtime.register_function(0x08B0B7A4u, &import_201, "sceNetAdhoc::0x7F27BB5E");
    runtime.register_function(0x08B0B7ACu, &import_202, "sceNetAdhoc::0x877F6D66");
    runtime.register_function(0x08B0B7B4u, &import_203, "sceNetAdhoc::0xFC6FC07B");
    runtime.register_function(0x08B0B7BCu, &import_204, "sceNetAdhoc::0xE08BDAC1");
    runtime.register_function(0x08B0B7C4u, &import_205, "sceNetAdhoc::0x9DF81198");
    runtime.register_function(0x08B0B7CCu, &import_206, "sceNetAdhoc::0x4DA4C788");
    runtime.register_function(0x08B0B7D4u, &import_207, "sceNetAdhoc::0x8BEA2B3E");
    runtime.register_function(0x08B0B7DCu, &import_208, "sceNetAdhoc::0x9AC2EEAC");
    runtime.register_function(0x08B0B7E4u, &import_209, "sceNetAdhoc::0x157E6225");
    runtime.register_function(0x08B0B72Cu, &import_210, "sceNetAdhocctl::0xE26F226E");
    runtime.register_function(0x08B0B734u, &import_211, "sceNetAdhocctl::0x9D689E13");
    runtime.register_function(0x08B0B73Cu, &import_212, "sceNetAdhocctl::0x0AD043ED");
    runtime.register_function(0x08B0B744u, &import_213, "sceNetAdhocctl::0xEC0635C1");
    runtime.register_function(0x08B0B74Cu, &import_214, "sceNetAdhocctl::0x5E7F79C9");
    runtime.register_function(0x08B0B754u, &import_215, "sceNetAdhocctl::0x08FFF7A0");
    runtime.register_function(0x08B0B75Cu, &import_216, "sceNetAdhocctl::0x34401D65");
    runtime.register_function(0x08B0B764u, &import_217, "sceNetAdhocctl::0x20B317A0");
    runtime.register_function(0x08B0B76Cu, &import_218, "sceNetAdhocctl::0x8916C003");
    runtime.register_function(0x08B0B774u, &import_219, "sceNetAdhocctl::0x81AEE1BE");
    runtime.register_function(0x08B0B6E4u, &import_220, "sceNetAdhocMatching::0x2A2A1E07");
    runtime.register_function(0x08B0B6ECu, &import_221, "sceNetAdhocMatching::0x7945ECDA");
    runtime.register_function(0x08B0B6F4u, &import_222, "sceNetAdhocMatching::0xCA5EDA6F");
    runtime.register_function(0x08B0B6FCu, &import_223, "sceNetAdhocMatching::0x93EF3843");
    runtime.register_function(0x08B0B704u, &import_224, "sceNetAdhocMatching::0x32B156B3");
    runtime.register_function(0x08B0B70Cu, &import_225, "sceNetAdhocMatching::0xF16EAF4F");
    runtime.register_function(0x08B0B714u, &import_226, "sceNetAdhocMatching::0x5E3D4B79");
    runtime.register_function(0x08B0B71Cu, &import_227, "sceNetAdhocMatching::0xEA3C6108");
    runtime.register_function(0x08B0B724u, &import_228, "sceNetAdhocMatching::0xB58E61B7");
    runtime.register_function(0x08B0B6D4u, &import_229, "sceRtc::0x6FF40ACC");
    runtime.register_function(0x08B0B6DCu, &import_230, "sceRtc::0x9ED0AE87");
    runtime.register_function(0x08B0B6CCu, &import_231, "sceWlanDrv::0xD7763699");
    runtime.register_function(0x08B0B6B4u, &import_232, "InterruptManager::0xCA04A2B9");
    runtime.register_function(0x08B0B6BCu, &import_233, "InterruptManager::0xD61E6961");
    runtime.register_function(0x08B0B6C4u, &import_234, "InterruptManager::0xFB8E22EC");
}
} // namespace psprecomp