Initial commit

source/emulator/src/Libs/LibC.cpp

@@ -0,0 +1,219 @@
+#include "Kyty/Core/Common.h"
+#include "Kyty/Core/DbgAssert.h"
+#include "Kyty/Core/LinkList.h"
+#include "Kyty/Core/Singleton.h"
+#include "Kyty/Core/String.h"
+
+#include "Emulator/Common.h"
+#include "Emulator/Libs/Libs.h"
+#include "Emulator/Libs/Printf.h"
+#include "Emulator/Libs/VaContext.h"
+#include "Emulator/SymbolDatabase.h"
+
+#include <cstdlib>
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+namespace LibC {
+
+LIB_VERSION("libc", 1, "libc", 1, 1);
+
+static uint32_t g_need_flag = 1;
+
+using cxa_destructor_func_t = void (*)(void*);
+
+struct CxaDestructor
+{
+	cxa_destructor_func_t destructor_func;
+	void*                 destructor_object;
+	void*                 module_id;
+};
+
+struct CContext
+{
+	Core::List<CxaDestructor> cxa;
+};
+
+static KYTY_SYSV_ABI void exit(int code)
+{
+	PRINT_NAME();
+
+	::exit(code);
+}
+
+static KYTY_SYSV_ABI void init_env()
+{
+	PRINT_NAME();
+}
+
+static KYTY_SYSV_ABI int atexit(void (*func)())
+{
+	PRINT_NAME();
+
+	::printf("func = %" PRIx64 "\n", reinterpret_cast<uint64_t>(func));
+
+	::atexit(func);
+
+	return 0;
+}
+
+static KYTY_SYSV_ABI int printf(VA_ARGS)
+{
+	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
+	VA_CONTEXT(ctx);
+
+	PRINT_NAME();
+
+	return GetPrintFuncV()(&ctx);
+}
+
+static KYTY_SYSV_ABI int puts(const char* s)
+{
+	PRINT_NAME();
+
+	return GetPrintFunc()("%s\n", s);
+}
+
+static KYTY_SYSV_ABI void catchReturnFromMain(int status)
+{
+	PRINT_NAME();
+
+	::printf("return from main = %d\n", status);
+}
+
+static KYTY_SYSV_ABI int cxa_atexit(void (*func)(void*), void* arg, void* d)
+{
+	PRINT_NAME();
+
+	auto* cc = Core::Singleton<CContext>::Instance();
+
+	CxaDestructor c {};
+	c.destructor_func   = func;
+	c.destructor_object = arg;
+	c.module_id         = d;
+
+	cc->cxa.Add(c);
+
+	return 0;
+}
+
+void KYTY_SYSV_ABI cxa_finalize(void* d)
+{
+	PRINT_NAME();
+
+	auto* cc = Core::Singleton<CContext>::Instance();
+
+	FOR_LIST_R(i, cc->cxa)
+	{
+		auto& c = cc->cxa[i];
+		if (c.module_id == d && c.destructor_func != nullptr)
+		{
+			c.destructor_func(c.destructor_object);
+			c.destructor_func = nullptr;
+		}
+	}
+}
+
+} // namespace LibC
+
+namespace LibcInternalExt {
+
+LIB_VERSION("LibcInternalExt", 1, "LibcInternal", 1, 1);
+
+static uint64_t g_mspace_atomic_id_mask = 0;
+static uint64_t g_mstate_table[64]      = {0};
+
+struct Info
+{
+	uint64_t  size;
+	uint32_t  unknown1;
+	uint32_t  unknown2;
+	uint64_t* mspace_atomic_id_mask;
+	uint64_t* mstate_table;
+};
+
+void KYTY_SYSV_ABI LibcHeapGetTraceInfo(Info* info)
+{
+	PRINT_NAME();
+
+	EXIT_NOT_IMPLEMENTED(info->size != 32);
+
+	info->mspace_atomic_id_mask = &g_mspace_atomic_id_mask;
+	info->mstate_table          = g_mstate_table;
+}
+
+LIB_DEFINE(InitLibcInternalExt_1)
+{
+	LIB_FUNC("NWtTN10cJzE", LibcInternalExt::LibcHeapGetTraceInfo);
+}
+
+} // namespace LibcInternalExt
+
+namespace LibcInternal {
+
+LIB_VERSION("LibcInternal", 1, "LibcInternal", 1, 1);
+
+static uint32_t g_need_flag = 1;
+
+int KYTY_SYSV_ABI vprintf(const char* str, VaList* c)
+{
+	PRINT_NAME();
+
+	return GetVPrintFunc()(str, c);
+}
+
+int KYTY_SYSV_ABI fflush(FILE* stream)
+{
+	PRINT_NAME();
+
+	EXIT_NOT_IMPLEMENTED(stream != stdout);
+
+	return ::fflush(stream);
+}
+
+void* KYTY_SYSV_ABI memset(void* s, int c, size_t n)
+{
+	PRINT_NAME();
+
+	return ::memset(s, c, n);
+}
+
+LIB_DEFINE(InitLibcInternal_1)
+{
+	LibcInternalExt::InitLibcInternalExt_1(s);
+
+	LIB_OBJECT("ZT4ODD2Ts9o", &LibcInternal::g_need_flag);
+	LIB_OBJECT("2sWzhYqFH4E", stdout);
+
+	LIB_FUNC("GMpvxPFW924", LibcInternal::vprintf);
+	LIB_FUNC("MUjC4lbHrK4", LibcInternal::fflush);
+	LIB_FUNC("8zTFvBIAIN8", LibcInternal::memset);
+
+	LIB_FUNC("H2e8t5ScQGc", LibC::cxa_finalize);
+}
+
+} // namespace LibcInternal
+
+LIB_USING(LibC);
+
+LIB_DEFINE(InitLibC_1)
+{
+	LibcInternal::InitLibcInternal_1(s);
+
+	LIB_OBJECT("P330P3dFF68", &LibC::g_need_flag);
+
+	LIB_FUNC("uMei1W9uyNo", LibC::exit);
+	LIB_FUNC("bzQExy189ZI", LibC::init_env);
+	LIB_FUNC("8G2LB+A3rzg", LibC::atexit);
+	LIB_FUNC("hcuQgD53UxM", LibC::printf);
+	LIB_FUNC("YQ0navp+YIc", LibC::puts);
+	LIB_FUNC("XKRegsFpEpk", LibC::catchReturnFromMain);
+	LIB_FUNC("tsvEmnenz48", LibC::cxa_atexit);
+	LIB_FUNC("H2e8t5ScQGc", LibC::cxa_finalize);
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED

source/emulator/src/Libs/LibDebug.cpp

@@ -0,0 +1,37 @@
+#include "Kyty/Core/Common.h"
+#include "Kyty/Core/String.h"
+
+#include "Emulator/Common.h"
+#include "Emulator/Libs/Libs.h"
+#include "Emulator/SymbolDatabase.h"
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+namespace LibRazorCpu {
+
+LIB_VERSION("RazorCpu", 1, "RazorCpu", 1, 1);
+
+static KYTY_SYSV_ABI uint32_t RazorCpuIsCapturing()
+{
+	PRINT_NAME();
+
+	return 0;
+}
+
+LIB_DEFINE(InitLibRazorCpu_1)
+{
+	LIB_FUNC("EboejOQvLL4", LibRazorCpu::RazorCpuIsCapturing);
+}
+
+} // namespace LibRazorCpu
+
+LIB_DEFINE(InitDebug_1)
+{
+	LibRazorCpu::InitLibRazorCpu_1(s);
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED

source/emulator/src/Libs/LibDiscMap.cpp

@@ -0,0 +1,52 @@
+#include "Kyty/Core/Common.h"
+#include "Kyty/Core/String.h"
+
+#include "Emulator/Common.h"
+#include "Emulator/Libs/Libs.h"
+#include "Emulator/SymbolDatabase.h"
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+LIB_VERSION("DiscMap", 1, "DiscMap", 1, 1);
+
+namespace DiscMap {
+
+static KYTY_SYSV_ABI int DiscMapIsRequestOnHDD(const char* file, uint64_t a2, uint64_t a3, const int* a4)
+{
+	PRINT_NAME();
+
+	printf("\tfile = %s\n", file);
+	printf("\ta2 = %016" PRIx64 "\n", a2);
+	printf("\ta3 = %016" PRIx64 "\n", a3);
+	printf("\t*a4 = %08" PRIx32 "\n", *a4);
+
+	return 0;
+}
+
+static KYTY_SYSV_ABI int Unknown(const char* file, uint64_t a2, uint64_t a3, const uint64_t* a4, const uint64_t* a5, const uint64_t* a6)
+{
+	PRINT_NAME();
+
+	printf("\tfile = %s\n", file);
+	printf("\ta2 = %016" PRIx64 "\n", a2);
+	printf("\ta3 = %016" PRIx64 "\n", a3);
+	printf("\t*a4 = %016" PRIx64 "\n", *a4);
+	printf("\t*a5 = %016" PRIx64 "\n", *a5);
+	printf("\t*a6 = %016" PRIx64 "\n", *a6);
+
+	return 0;
+}
+
+} // namespace DiscMap
+
+LIB_DEFINE(InitDiscMap_1)
+{
+	LIB_FUNC("lbQKqsERhtE", DiscMap::DiscMapIsRequestOnHDD);
+	LIB_FUNC("fJgP+wqifno", DiscMap::Unknown);
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED

source/emulator/src/Libs/LibGraphicsDriver.cpp

@@ -0,0 +1,45 @@
+#include "Emulator/Common.h"
+#include "Emulator/Graphics/Graphics.h"
+#include "Emulator/Libs/Libs.h"
+#include "Emulator/SymbolDatabase.h"
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+LIB_VERSION("GraphicsDriver", 1, "GraphicsDriver", 1, 1);
+
+LIB_DEFINE(InitGraphicsDriver_1)
+{
+	PRINT_NAME_ENABLE(true);
+
+	LIB_FUNC("gAhCn6UiU4Y", Graphics::GraphicsSetVsShader);
+	LIB_FUNC("5uFKckiJYRM", Graphics::GraphicsSetPsShader350);
+	LIB_FUNC("Kx-h-nWQJ8A", Graphics::GraphicsSetCsShaderWithModifier);
+	LIB_FUNC("HlTPoZ-oY7Y", Graphics::GraphicsDrawIndex);
+	LIB_FUNC("GGsn7jMTxw4", Graphics::GraphicsDrawIndexAuto);
+	LIB_FUNC("zwY0YV91TTI", Graphics::GraphicsSubmitCommandBuffers);
+	LIB_FUNC("xbxNatawohc", Graphics::GraphicsSubmitAndFlipCommandBuffers);
+	LIB_FUNC("yvZ73uQUqrk", Graphics::GraphicsSubmitDone);
+	LIB_FUNC("iBt3Oe00Kvc", Graphics::GraphicsFlushMemory);
+	LIB_FUNC("b0xyllnVY-I", Graphics::GraphicsAddEqEvent);
+	LIB_FUNC("PVT+fuoS9gU", Graphics::GraphicsDeleteEqEvent);
+	LIB_FUNC("yb2cRhagD1I", Graphics::GraphicsDrawInitDefaultHardwareState350);
+	LIB_FUNC("nF6bFRUBRAU", Graphics::GraphicsDispatchInitDefaultHardwareState);
+	LIB_FUNC("1qXLHIpROPE", Graphics::GraphicsInsertWaitFlipDone);
+	LIB_FUNC("0BzLGljcwBo", Graphics::GraphicsDispatchDirect);
+	LIB_FUNC("29oKvKXzEZo", Graphics::GraphicsMapComputeQueue);
+	LIB_FUNC("ArSg-TGinhk", Graphics::GraphicsUnmapComputeQueue);
+	LIB_FUNC("ffrNQOshows", Graphics::GraphicsComputeWaitOnAddress);
+	LIB_FUNC("bX5IbRvECXk", Graphics::GraphicsDingDong);
+	LIB_FUNC("W1Etj-jlW7Y", Graphics::GraphicsInsertPushMarker);
+	LIB_FUNC("7qZVNgEu+SY", Graphics::GraphicsInsertPopMarker);
+	LIB_FUNC("+AFvOEXrKJk", Graphics::GraphicsSetEmbeddedVsShader);
+	LIB_FUNC("ZFqKFl23aMc", Graphics::GraphicsRegisterOwner);
+	LIB_FUNC("nvEwfYAImTs", Graphics::GraphicsRegisterResource);
+	LIB_FUNC("Fwvh++m9IQI", Graphics::GraphicsGetGpuCoreClockFrequency);
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED

source/emulator/src/Libs/LibKernel.cpp

@@ -0,0 +1,560 @@
+#include "Kyty/Core/Common.h"
+#include "Kyty/Core/DbgAssert.h"
+#include "Kyty/Core/Singleton.h"
+#include "Kyty/Core/String.h"
+#include "Kyty/Math/Rand.h"
+
+#include "Emulator/Common.h"
+#include "Emulator/Config.h"
+#include "Emulator/Kernel/EventFlag.h"
+#include "Emulator/Kernel/EventQueue.h"
+#include "Emulator/Kernel/FileSystem.h"
+#include "Emulator/Kernel/Memory.h"
+#include "Emulator/Kernel/Pthread.h"
+#include "Emulator/Libs/Errno.h"
+#include "Emulator/Libs/Libs.h"
+#include "Emulator/RuntimeLinker.h"
+#include "Emulator/SymbolDatabase.h"
+
+#include <cstdlib>
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+LIB_VERSION("libkernel", 1, "libkernel", 1, 1);
+
+namespace LibKernel {
+
+using KernelModule                   = int32_t;
+using get_thread_atexit_count_func_t = KYTY_SYSV_ABI int (*)(KernelModule);
+using thread_atexit_report_func_t    = KYTY_SYSV_ABI void (*)(KernelModule);
+
+#pragma pack(1)
+
+struct KernelLoadModuleOpt
+{
+	size_t size;
+};
+
+struct KernelUnloadModuleOpt
+{
+	size_t size;
+};
+
+struct TlsInfo
+{
+	Loader::Program* program;
+	uint64_t         offset;
+};
+
+struct MallocReplace
+{
+	uint64_t size               = sizeof(MallocReplace);
+	void*    malloc_initialize  = nullptr;
+	void*    malloc_finalize    = nullptr;
+	void*    malloc             = nullptr;
+	void*    free               = nullptr;
+	void*    calloc             = nullptr;
+	void*    realloc            = nullptr;
+	void*    memalign           = nullptr;
+	void*    reallocalign       = nullptr;
+	void*    posix_memalign     = nullptr;
+	void*    malloc_stats       = nullptr;
+	void*    malloc_stats_fast  = nullptr;
+	void*    malloc_usable_size = nullptr;
+	void*    aligned_alloc      = nullptr;
+};
+
+struct NewReplace
+{
+	uint64_t size                           = sizeof(NewReplace);
+	void*    new_p                          = nullptr;
+	void*    new_nothrow                    = nullptr;
+	void*    new_array                      = nullptr;
+	void*    new_array_nothrow              = nullptr;
+	void*    delete_p                       = nullptr;
+	void*    delete_nothrow                 = nullptr;
+	void*    delete_array                   = nullptr;
+	void*    delete_array_nothrow           = nullptr;
+	void*    delete_with_size               = nullptr;
+	void*    delete_with_size_nothrow       = nullptr;
+	void*    delete_array_with_size         = nullptr;
+	void*    delete_array_with_size_nothrow = nullptr;
+};
+
+struct ModuleInfo
+{
+	uint64_t     size;
+	uint64_t     info[32];
+	KernelModule handle;
+	uint8_t      pad[156];
+};
+
+#pragma pack()
+
+constexpr size_t PROGNAME_MAX_SIZE = 511;
+
+static uint64_t    g_stack_chk_guard                     = 0xDeadBeef5533CCAA;
+static char        g_progname_buf[PROGNAME_MAX_SIZE + 1] = {0};
+static const char* g_progname                            = g_progname_buf;
+
+static get_thread_atexit_count_func_t g_get_thread_atexit_count_func = nullptr;
+static thread_atexit_report_func_t    g_thread_atexit_report_func    = nullptr;
+
+static thread_local int g_errno = 0;
+
+void SetProgName(const String& name)
+{
+	strncpy(g_progname_buf, name.C_Str(), PROGNAME_MAX_SIZE);
+}
+
+// struct KernelContext
+//{
+//	Vector<Loader::Program*> programs;
+//};
+
+static KYTY_SYSV_ABI int* get_error_addr()
+{
+	PRINT_NAME();
+
+	return &g_errno;
+}
+
+static KYTY_SYSV_ABI void stack_chk_fail()
+{
+	PRINT_NAME();
+
+	EXIT("stack fail!!!");
+}
+
+static KYTY_SYSV_ABI KernelModule KernelLoadStartModule(const char* module_file_name, size_t args, const void* argp, uint32_t flags,
+                                                        const KernelLoadModuleOpt* opt, int* res)
+{
+	PRINT_NAME();
+
+	// EXIT_NOT_IMPLEMENTED(!Core::Thread::IsMainThread());
+
+	printf("\tmodule_file_name = %s\n", module_file_name);
+
+	EXIT_NOT_IMPLEMENTED(flags != 0);
+	EXIT_NOT_IMPLEMENTED(opt != nullptr);
+
+	auto* rt = Core::Singleton<Loader::RuntimeLinker>::Instance();
+
+	auto* program = rt->LoadProgram(FileSystem::GetRealFilename(String::FromUtf8(module_file_name)));
+
+	auto handle = program->unique_id;
+
+	program->dbg_print_reloc = true;
+
+	rt->RelocateAll();
+
+	int result = rt->StartModule(program, args, argp, nullptr);
+
+	printf("\tmodule_start() result = %d\n", result);
+
+	EXIT_NOT_IMPLEMENTED(result < 0);
+
+	if (res != nullptr)
+	{
+		*res = result;
+	}
+
+	return static_cast<KernelModule>(handle);
+}
+
+static int KYTY_SYSV_ABI KernelStopUnloadModule(KernelModule handle, size_t args, const void* argp, uint32_t flags,
+                                                const KernelUnloadModuleOpt* opt, int* res)
+{
+	PRINT_NAME();
+
+	// EXIT_NOT_IMPLEMENTED(!Core::Thread::IsMainThread());
+
+	auto* rt = Core::Singleton<Loader::RuntimeLinker>::Instance();
+
+	EXIT_NOT_IMPLEMENTED(flags != 0);
+	EXIT_NOT_IMPLEMENTED(opt != nullptr);
+
+	auto* program = rt->FindProgramById(handle);
+
+	EXIT_NOT_IMPLEMENTED(program == nullptr);
+
+	if (g_get_thread_atexit_count_func != nullptr && g_get_thread_atexit_count_func(program->unique_id) > 0)
+	{
+		printf("KernelStopUnloadModule: cannot unload %s\n", program->file_name.C_Str());
+		if (g_thread_atexit_report_func != nullptr)
+		{
+			g_thread_atexit_report_func(program->unique_id);
+		}
+		return KERNEL_ERROR_EBUSY;
+	}
+
+	int result = rt->StopModule(program, args, argp, nullptr);
+
+	printf("\tmodule_stop() result = %d\n", result);
+
+	EXIT_NOT_IMPLEMENTED(result < 0);
+
+	if (res != nullptr)
+	{
+		*res = result;
+	}
+
+	rt->UnloadProgram(program);
+
+	return OK;
+}
+
+static void* KYTY_SYSV_ABI tls_get_addr(TlsInfo* info)
+{
+	PRINT_NAME();
+
+	// EXIT_NOT_IMPLEMENTED(!Core::Thread::IsMainThread());
+
+	return Loader::RuntimeLinker::TlsGetAddr(info->program) + info->offset;
+}
+
+static void* KYTY_SYSV_ABI KernelGetProcParam()
+{
+	PRINT_NAME();
+
+	auto* rt = Core::Singleton<Loader::RuntimeLinker>::Instance();
+
+	return reinterpret_cast<void*>(rt->GetProcParam());
+}
+
+static void KYTY_SYSV_ABI KernelRtldSetApplicationHeapAPI(void* api[])
+{
+	PRINT_NAME();
+
+	for (int i = 0; i < 10; i++)
+	{
+		printf("\tapi[%d] = 0x%016" PRIx64 "\n", i, reinterpret_cast<uint64_t>(api[i]));
+	}
+
+	[[maybe_unused]] auto* heap_malloc         = api[0];
+	[[maybe_unused]] auto* heap_free           = api[1];
+	[[maybe_unused]] auto* heap_posix_memalign = api[6];
+}
+
+static int KYTY_SYSV_ABI write(int d, const char* str, int64_t size)
+{
+	// PRINT_NAME();
+
+	EXIT_NOT_IMPLEMENTED(d < 0 || d > 2);
+
+	int size_int = static_cast<int>(size);
+
+	printf(FG_BRIGHT_MAGENTA "%.*s" DEFAULT, size_int, str);
+
+	return size_int;
+}
+
+static int KYTY_SYSV_ABI KernelGetModuleInfoFromAddr(uint64_t addr, int n, ModuleInfo* r)
+{
+	PRINT_NAME();
+
+	printf("\taddr = %016" PRIx64 "\n", addr);
+	printf("\tn = %d\n", n);
+
+	EXIT_NOT_IMPLEMENTED(n != 2);
+	EXIT_NOT_IMPLEMENTED(r == nullptr);
+
+	auto* rt = Core::Singleton<Loader::RuntimeLinker>::Instance();
+
+	auto* p = rt->FindProgramByAddr(addr);
+
+	if (p == nullptr)
+	{
+		printf("\thandle: not found\n");
+		r->handle = 0;
+		return -1;
+	}
+
+	r->handle = p->unique_id;
+
+	printf("\thandle: %d\n", r->handle);
+
+	return 0;
+}
+
+static void KYTY_SYSV_ABI KernelDebugRaiseExceptionOnReleaseMode(int /*c1*/, int /*c2*/)
+{
+	PRINT_NAME();
+}
+
+static void KYTY_SYSV_ABI KernelDebugRaiseException(int /*c1*/, int /*c2*/)
+{
+	PRINT_NAME();
+}
+
+static void KYTY_SYSV_ABI exit(int code)
+{
+	PRINT_NAME();
+
+	::exit(code);
+}
+
+static KYTY_SYSV_ABI MallocReplace* KernelGetSanitizerMallocReplaceExternal()
+{
+	PRINT_NAME();
+
+	static MallocReplace ret;
+
+	return &ret;
+}
+
+static KYTY_SYSV_ABI NewReplace* KernelGetSanitizerNewReplaceExternal()
+{
+	PRINT_NAME();
+
+	static NewReplace ret;
+
+	return &ret;
+}
+
+static KYTY_SYSV_ABI int elf_phdr_match_addr(ModuleInfo* m, uint64_t dtor_vaddr)
+{
+	PRINT_NAME();
+
+	EXIT_NOT_IMPLEMENTED(m == nullptr);
+
+	auto* rt     = Core::Singleton<Loader::RuntimeLinker>::Instance();
+	auto* p      = rt->FindProgramByAddr(dtor_vaddr);
+	int   result = (p != nullptr && p->unique_id == m->handle) ? 1 : 0;
+
+	printf("\thandle     = %" PRId32 "\n", m->handle);
+	printf("\tdtor_vaddr = %016" PRIx64 "\n", dtor_vaddr);
+	printf("\tmatch      = %s\n", result == 1 ? "true" : "false");
+
+	return result;
+}
+
+int KYTY_SYSV_ABI KernelUuidCreate(uint32_t* uuid)
+{
+	PRINT_NAME();
+
+	if (uuid == nullptr)
+	{
+		return KERNEL_ERROR_EINVAL;
+	}
+
+	uuid[0] = Kyty::Math::Rand::Uint();
+	uuid[1] = Kyty::Math::Rand::Uint();
+	uuid[2] = Kyty::Math::Rand::Uint();
+	uuid[3] = Kyty::Math::Rand::Uint();
+
+	return OK;
+}
+
+static KYTY_SYSV_ABI void pthread_cxa_finalize(void* /*p*/)
+{
+	PRINT_NAME();
+}
+
+void KYTY_SYSV_ABI KernelSetThreadAtexitCount(get_thread_atexit_count_func_t func)
+{
+	PRINT_NAME();
+
+	EXIT_NOT_IMPLEMENTED(g_get_thread_atexit_count_func != nullptr);
+
+	g_get_thread_atexit_count_func = func;
+}
+
+void KYTY_SYSV_ABI KernelSetThreadAtexitReport(thread_atexit_report_func_t func)
+{
+	PRINT_NAME();
+
+	EXIT_NOT_IMPLEMENTED(g_thread_atexit_report_func != nullptr);
+
+	g_thread_atexit_report_func = func;
+}
+
+int KYTY_SYSV_ABI KernelRtldThreadAtexitIncrement(uint64_t* /*c*/)
+{
+	PRINT_NAME();
+
+	//__sync_fetch_and_add(c, 1);
+
+	return 0;
+}
+
+int KYTY_SYSV_ABI KernelRtldThreadAtexitDecrement(uint64_t* /*c*/)
+{
+	PRINT_NAME();
+
+	//__sync_fetch_and_sub(c, 1);
+
+	return 0;
+}
+
+int KYTY_SYSV_ABI KernelIsNeoMode()
+{
+	PRINT_NAME();
+
+	return (Config::IsNeo() ? 1 : 0);
+}
+
+} // namespace LibKernel
+
+namespace Posix {
+
+LIB_VERSION("Posix", 1, "libkernel", 1, 1);
+
+int KYTY_SYSV_ABI clock_gettime(int clock_id, LibKernel::KernelTimespec* time)
+{
+	PRINT_NAME();
+
+	if (LibKernel::KernelClockGettime(clock_id, time) < 0)
+	{
+		return -1;
+	}
+
+	return 0;
+}
+
+LIB_DEFINE(InitLibKernel_1_Posix)
+{
+	LIB_FUNC("lLMT9vJAck0", clock_gettime);
+}
+
+} // namespace Posix
+
+namespace FileSystem = LibKernel::FileSystem;
+namespace Memory     = LibKernel::Memory;
+namespace EventQueue = LibKernel::EventQueue;
+namespace EventFlag  = LibKernel::EventFlag;
+
+LIB_DEFINE(InitLibKernel_1_FS)
+{
+	LIB_FUNC("1G3lF1Gg1k8", FileSystem::KernelOpen);
+	LIB_FUNC("UK2Tl2DWUns", FileSystem::KernelClose);
+	LIB_FUNC("Cg4srZ6TKbU", FileSystem::KernelRead);
+	LIB_FUNC("4wSze92BhLI", FileSystem::KernelWrite);
+	LIB_FUNC("+r3rMFwItV4", FileSystem::KernelPread);
+	LIB_FUNC("nKWi-N2HBV4", FileSystem::KernelPwrite);
+	LIB_FUNC("eV9wAD2riIA", FileSystem::KernelStat);
+	LIB_FUNC("kBwCPsYX-m4", FileSystem::KernelFstat);
+	LIB_FUNC("AUXVxWeJU-A", FileSystem::KernelUnlink);
+	LIB_FUNC("taRWhTJFTgE", FileSystem::KernelGetdirentries);
+	LIB_FUNC("oib76F-12fk", FileSystem::KernelLseek);
+}
+
+LIB_DEFINE(InitLibKernel_1_Mem)
+{
+	LIB_FUNC("mL8NDH86iQI", Memory::KernelMapNamedFlexibleMemory);
+	LIB_FUNC("cQke9UuBQOk", Memory::KernelMunmap);
+	LIB_FUNC("pO96TwzOm5E", Memory::KernelGetDirectMemorySize);
+	LIB_FUNC("rTXw65xmLIA", Memory::KernelAllocateDirectMemory);
+	LIB_FUNC("L-Q3LEjIbgA", Memory::KernelMapDirectMemory);
+	LIB_FUNC("MBuItvba6z8", Memory::KernelReleaseDirectMemory);
+	LIB_FUNC("WFcfL2lzido", Memory::KernelQueryMemoryProtection);
+}
+
+LIB_DEFINE(InitLibKernel_1_Equeue)
+{
+	LIB_FUNC("D0OdFMjp46I", EventQueue::KernelCreateEqueue);
+	LIB_FUNC("jpFjmgAC5AE", EventQueue::KernelDeleteEqueue);
+	LIB_FUNC("fzyMKs9kim0", EventQueue::KernelWaitEqueue);
+}
+
+LIB_DEFINE(InitLibKernel_1_EventFlag)
+{
+	LIB_FUNC("BpFoboUJoZU", EventFlag::KernelCreateEventFlag);
+	LIB_FUNC("JTvBflhYazQ", EventFlag::KernelWaitEventFlag);
+}
+
+LIB_DEFINE(InitLibKernel_1_Pthread)
+{
+	LIB_FUNC("9UK1vLZQft4", LibKernel::PthreadMutexLock);
+	LIB_FUNC("tn3VlD0hG60", LibKernel::PthreadMutexUnlock);
+	LIB_FUNC("2Of0f+3mhhE", LibKernel::PthreadMutexDestroy);
+	LIB_FUNC("cmo1RIYva9o", LibKernel::PthreadMutexInit);
+	LIB_FUNC("upoVrzMHFeE", LibKernel::PthreadMutexTrylock);
+	LIB_FUNC("smWEktiyyG0", LibKernel::PthreadMutexattrDestroy);
+	LIB_FUNC("F8bUHwAG284", LibKernel::PthreadMutexattrInit);
+	LIB_FUNC("iMp8QpE+XO4", LibKernel::PthreadMutexattrSettype);
+	LIB_FUNC("1FGvU0i9saQ", LibKernel::PthreadMutexattrSetprotocol);
+
+	LIB_FUNC("aI+OeCz8xrQ", LibKernel::PthreadSelf);
+	LIB_FUNC("6UgtwV+0zb4", LibKernel::PthreadCreate);
+	LIB_FUNC("3PtV6p3QNX4", LibKernel::PthreadEqual);
+	LIB_FUNC("onNY9Byn-W8", LibKernel::PthreadJoin);
+	LIB_FUNC("How7B8Oet6k", LibKernel::PthreadGetname);
+
+	LIB_FUNC("62KCwEMmzcM", LibKernel::PthreadAttrDestroy);
+	LIB_FUNC("x1X76arYMxU", LibKernel::PthreadAttrGet);
+	LIB_FUNC("8+s5BzZjxSg", LibKernel::PthreadAttrGetaffinity);
+	LIB_FUNC("nsYoNRywwNg", LibKernel::PthreadAttrInit);
+	LIB_FUNC("JaRMy+QcpeU", LibKernel::PthreadAttrGetdetachstate);
+	LIB_FUNC("UTXzJbWhhTE", LibKernel::PthreadAttrSetstacksize);
+	LIB_FUNC("-Wreprtu0Qs", LibKernel::PthreadAttrSetdetachstate);
+	LIB_FUNC("eXbUSpEaTsA", LibKernel::PthreadAttrSetinheritsched);
+	LIB_FUNC("DzES9hQF4f4", LibKernel::PthreadAttrSetschedparam);
+	LIB_FUNC("4+h9EzwKF4I", LibKernel::PthreadAttrSetschedpolicy);
+
+	LIB_FUNC("6ULAa0fq4jA", LibKernel::PthreadRwlockInit);
+	LIB_FUNC("BB+kb08Tl9A", LibKernel::PthreadRwlockDestroy);
+	LIB_FUNC("Ox9i0c7L5w0", LibKernel::PthreadRwlockRdlock);
+	LIB_FUNC("+L98PIbGttk", LibKernel::PthreadRwlockUnlock);
+	LIB_FUNC("mqdNorrB+gI", LibKernel::PthreadRwlockWrlock);
+
+	LIB_FUNC("2Tb92quprl0", LibKernel::PthreadCondInit);
+	LIB_FUNC("g+PZd2hiacg", LibKernel::PthreadCondDestroy);
+	LIB_FUNC("WKAXJ4XBPQ4", LibKernel::PthreadCondWait);
+	LIB_FUNC("JGgj7Uvrl+A", LibKernel::PthreadCondBroadcast);
+	LIB_FUNC("BmMjYxmew1w", LibKernel::PthreadCondTimedwait);
+
+	LIB_FUNC("QBi7HCK03hw", LibKernel::KernelClockGettime);
+	LIB_FUNC("ejekcaNQNq0", LibKernel::KernelGettimeofday);
+	LIB_FUNC("1j3S3n-tTW4", LibKernel::KernelGetTscFrequency);
+
+	LIB_FUNC("7H0iTOciTLo", LibKernel::pthread_mutex_lock_s);
+	LIB_FUNC("2Z+PpY6CaJg", LibKernel::pthread_mutex_unlock_s);
+	LIB_FUNC("mkx2fVhNMsg", LibKernel::pthread_cond_broadcast_s);
+	LIB_FUNC("Op8TBGY5KHg", LibKernel::pthread_cond_wait_s);
+}
+
+LIB_DEFINE(InitLibKernel_1)
+{
+	InitLibKernel_1_FS(s);
+	InitLibKernel_1_Mem(s);
+	InitLibKernel_1_Equeue(s);
+	InitLibKernel_1_EventFlag(s);
+	InitLibKernel_1_Pthread(s);
+	Posix::InitLibKernel_1_Posix(s);
+
+	LIB_OBJECT("f7uOxY9mM1U", &LibKernel::g_stack_chk_guard);
+	LIB_OBJECT("djxxOmW6-aw", &LibKernel::g_progname);
+
+	LIB_FUNC("Ou3iL1abvng", LibKernel::stack_chk_fail);
+	LIB_FUNC("wzvqT4UqKX8", LibKernel::KernelLoadStartModule);
+	LIB_FUNC("QKd0qM58Qes", LibKernel::KernelStopUnloadModule);
+	LIB_FUNC("vNe1w4diLCs", LibKernel::tls_get_addr);
+	LIB_FUNC("959qrazPIrg", LibKernel::KernelGetProcParam);
+	LIB_FUNC("p5EcQeEeJAE", LibKernel::KernelRtldSetApplicationHeapAPI);
+	LIB_FUNC("FxVZqBAA7ks", LibKernel::write);
+	LIB_FUNC("f7KBOafysXo", LibKernel::KernelGetModuleInfoFromAddr);
+	LIB_FUNC("zE-wXIZjLoM", LibKernel::KernelDebugRaiseExceptionOnReleaseMode);
+	LIB_FUNC("OMDRKKAZ8I4", LibKernel::KernelDebugRaiseException);
+	LIB_FUNC("6Z83sYWFlA8", LibKernel::exit);
+	LIB_FUNC("py6L8jiVAN8", LibKernel::KernelGetSanitizerMallocReplaceExternal);
+	LIB_FUNC("bnZxYgAFeA0", LibKernel::KernelGetSanitizerNewReplaceExternal);
+	LIB_FUNC("Fjc4-n1+y2g", LibKernel::elf_phdr_match_addr);
+	LIB_FUNC("kbw4UHHSYy0", LibKernel::pthread_cxa_finalize);
+	LIB_FUNC("Xjoosiw+XPI", LibKernel::KernelUuidCreate);
+	LIB_FUNC("WslcK1FQcGI", LibKernel::KernelIsNeoMode);
+	LIB_FUNC("9BcDykPmo1I", LibKernel::get_error_addr);
+
+	LIB_FUNC("1jfXLRVzisc", LibKernel::KernelUsleep);
+	LIB_FUNC("rNhWz+lvOMU", LibKernel::KernelSetThreadDtors);
+	LIB_FUNC("WhCc1w3EhSI", LibKernel::KernelSetThreadAtexitReport);
+	LIB_FUNC("pB-yGZ2nQ9o", LibKernel::KernelSetThreadAtexitCount);
+	LIB_FUNC("Tz4RNUCBbGI", LibKernel::KernelRtldThreadAtexitIncrement);
+	LIB_FUNC("8OnWXlgQlvo", LibKernel::KernelRtldThreadAtexitDecrement);
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED

source/emulator/src/Libs/LibPad.cpp

@@ -0,0 +1,25 @@
+#include "Emulator/Common.h"
+#include "Emulator/Controller.h"
+#include "Emulator/Libs/Libs.h"
+#include "Emulator/SymbolDatabase.h"
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+LIB_VERSION("Pad", 1, "Pad", 1, 1);
+
+LIB_DEFINE(InitPad_1)
+{
+	PRINT_NAME_ENABLE(true);
+
+	LIB_FUNC("hv1luiJrqQM", Controller::PadInit);
+	LIB_FUNC("xk0AcarP3V4", Controller::PadOpen);
+	LIB_FUNC("clVvL4ZDntw", Controller::PadSetMotionSensorState);
+	LIB_FUNC("gjP9-KQzoUk", Controller::PadGetControllerInformation);
+	LIB_FUNC("YndgXqQVV7c", Controller::PadReadState);
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED

source/emulator/src/Libs/LibSysmodule.cpp

@@ -0,0 +1,62 @@
+#include "Kyty/Core/Common.h"
+#include "Kyty/Core/DbgAssert.h"
+#include "Kyty/Core/String.h"
+
+#include "Emulator/Common.h"
+#include "Emulator/Libs/Libs.h"
+#include "Emulator/SymbolDatabase.h"
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+LIB_VERSION("Sysmodule", 1, "Sysmodule", 1, 1);
+
+namespace Sysmodule {
+
+static KYTY_SYSV_ABI int SysmoduleLoadModule(uint16_t id)
+{
+	PRINT_NAME();
+
+	printf("\tid = %d\n", static_cast<int>(id));
+
+	return 0;
+}
+
+static KYTY_SYSV_ABI int SysmoduleUnloadModule(uint16_t id)
+{
+	PRINT_NAME();
+
+	printf("\tid = %d\n", static_cast<int>(id));
+
+	return 0;
+}
+
+static KYTY_SYSV_ABI int SysmoduleLoadModuleInternalWithArg(uint16_t id, int arg1, int arg2, int arg3, int* ret)
+{
+	PRINT_NAME();
+
+	printf("\tid = %d\n", static_cast<int>(id));
+
+	EXIT_IF(arg1 != 0);
+	EXIT_IF(arg2 != 0);
+	EXIT_IF(arg3 != 0);
+	EXIT_IF(ret == nullptr);
+
+	*ret = 0;
+
+	return 0;
+}
+
+} // namespace Sysmodule
+
+LIB_DEFINE(InitSysmodule_1)
+{
+	LIB_FUNC("eR2bZFAAU0Q", Sysmodule::SysmoduleUnloadModule);
+	LIB_FUNC("hHrGoGoNf+s", Sysmodule::SysmoduleLoadModuleInternalWithArg);
+	LIB_FUNC("g8cM39EUZ6o", Sysmodule::SysmoduleLoadModule);
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED

source/emulator/src/Libs/LibUserService.cpp

@@ -0,0 +1,44 @@
+#include "Kyty/Core/DbgAssert.h"
+#include "Kyty/Core/String.h"
+
+#include "Emulator/Common.h"
+#include "Emulator/Libs/Libs.h"
+#include "Emulator/SymbolDatabase.h"
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+LIB_VERSION("UserService", 1, "UserService", 1, 1);
+
+namespace UserService {
+
+static KYTY_SYSV_ABI int UserServiceInitialize(const void* /*params*/)
+{
+	PRINT_NAME();
+
+	return 0;
+}
+
+static KYTY_SYSV_ABI int UserServiceGetInitialUser(int* user_id)
+{
+	PRINT_NAME();
+
+	EXIT_NOT_IMPLEMENTED(user_id == nullptr);
+
+	*user_id = 1;
+
+	return 0;
+}
+
+} // namespace UserService
+
+LIB_DEFINE(InitUserService_1)
+{
+	LIB_FUNC("j3YMu1MVNNo", UserService::UserServiceInitialize);
+	LIB_FUNC("CdWp0oHWGr0", UserService::UserServiceGetInitialUser);
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED

source/emulator/src/Libs/LibVideoOut.cpp

@@ -0,0 +1,29 @@
+#include "Emulator/Common.h"
+#include "Emulator/Graphics/VideoOut.h"
+#include "Emulator/Libs/Libs.h"
+#include "Emulator/SymbolDatabase.h"
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+LIB_VERSION("VideoOut", 1, "VideoOut", 0, 0);
+
+LIB_DEFINE(InitVideoOut_1)
+{
+	PRINT_NAME_ENABLE(true);
+
+	LIB_FUNC("Up36PTk687E", VideoOut::VideoOutOpen);
+	LIB_FUNC("uquVH4-Du78", VideoOut::VideoOutClose);
+	LIB_FUNC("6kPnj51T62Y", VideoOut::VideoOutGetResolutionStatus);
+	LIB_FUNC("i6-sR91Wt-4", VideoOut::VideoOutSetBufferAttribute);
+	LIB_FUNC("CBiu4mCE1DA", VideoOut::VideoOutSetFlipRate);
+	LIB_FUNC("HXzjK9yI30k", VideoOut::VideoOutAddFlipEvent);
+	LIB_FUNC("w3BY+tAEiQY", VideoOut::VideoOutRegisterBuffers);
+	LIB_FUNC("U46NwOiJpys", VideoOut::VideoOutSubmitFlip);
+	LIB_FUNC("SbU3dwp80lQ", VideoOut::VideoOutGetFlipStatus);
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED

source/emulator/src/Libs/Libs.cpp

@@ -0,0 +1,39 @@
+#include "Emulator/Libs/Libs.h"
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+namespace LibcInternal {
+LIB_DEFINE(InitLibcInternal_1);
+} // namespace LibcInternal
+
+LIB_DEFINE(InitLibC_1);
+LIB_DEFINE(InitLibKernel_1);
+LIB_DEFINE(InitVideoOut_1);
+LIB_DEFINE(InitSysmodule_1);
+LIB_DEFINE(InitDiscMap_1);
+LIB_DEFINE(InitDebug_1);
+LIB_DEFINE(InitGraphicsDriver_1);
+LIB_DEFINE(InitUserService_1);
+LIB_DEFINE(InitPad_1);
+
+bool Init(const String& id, Loader::SymbolDatabase* s)
+{
+	LIB_CHECK(U"libc_1", InitLibC_1);
+	LIB_CHECK(U"libc_internal_1", LibcInternal::InitLibcInternal_1);
+	LIB_CHECK(U"libkernel_1", InitLibKernel_1);
+	LIB_CHECK(U"libVideoOut_1", InitVideoOut_1);
+	LIB_CHECK(U"libSysmodule_1", InitSysmodule_1);
+	LIB_CHECK(U"libDiscMap_1", InitDiscMap_1);
+	LIB_CHECK(U"libDebug_1", InitDebug_1);
+	LIB_CHECK(U"libGraphicsDriver_1", InitGraphicsDriver_1);
+	LIB_CHECK(U"libUserService_1", InitUserService_1);
+	LIB_CHECK(U"libPad_1", InitPad_1);
+
+	return false;
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED

source/emulator/src/Libs/Printf.cpp

@@ -0,0 +1,895 @@
+//
+// Original algorithm is from:
+// 	https://github.com/mpaland/printf
+// 	Marco Paland (info@paland.com)
+// 	2014-2019, PALANDesign Hannover, Germany
+//  licensed under The MIT License (MIT)
+
+#include "Emulator/Libs/Printf.h"
+
+#include "Kyty/Core/Common.h"
+#include "Kyty/Core/Vector.h"
+
+#include "Emulator/Common.h"
+#include "Emulator/Libs/VaContext.h"
+
+#include <cfloat>
+#include <cmath>
+#include <cstddef>
+
+#ifdef KYTY_EMU_ENABLED
+
+namespace Kyty::Libs {
+
+constexpr uint32_t FLAGS_ZEROPAD   = (1U << 0U);
+constexpr uint32_t FLAGS_LEFT      = (1U << 1U);
+constexpr uint32_t FLAGS_PLUS      = (1U << 2U);
+constexpr uint32_t FLAGS_SPACE     = (1U << 3U);
+constexpr uint32_t FLAGS_HASH      = (1U << 4U);
+constexpr uint32_t FLAGS_UPPERCASE = (1U << 5U);
+constexpr uint32_t FLAGS_CHAR      = (1U << 6U);
+constexpr uint32_t FLAGS_SHORT     = (1U << 7U);
+constexpr uint32_t FLAGS_LONG      = (1U << 8U);
+constexpr uint32_t FLAGS_LONG_LONG = (1U << 9U);
+constexpr uint32_t FLAGS_PRECISION = (1U << 10U);
+constexpr uint32_t FLAGS_ADAPT_EXP = (1U << 11U);
+
+constexpr size_t   PRINTF_NTOA_BUFFER_SIZE        = 32U;
+constexpr size_t   PRINTF_FTOA_BUFFER_SIZE        = 32U;
+constexpr double   PRINTF_MAX_FLOAT               = 1e9;
+constexpr uint32_t PRINTF_DEFAULT_FLOAT_PRECISION = 6U;
+
+using out_fct_type = void (*)(char character, Vector<char>* buffer, size_t idx, size_t /*maxlen*/);
+
+// internal null output
+static inline void _out_null(char character, Vector<char>* buffer, size_t /*idx*/, size_t /*maxlen*/)
+{
+	buffer->Add(character);
+}
+
+static inline bool _is_digit(char ch)
+{
+	return (ch >= '0') && (ch <= '9');
+}
+
+static unsigned int _atoi(const char** str)
+{
+	unsigned int i = 0U;
+	while (_is_digit(**str))
+	{
+		i = i * 10U + static_cast<unsigned int>(*((*str)++) - '0');
+	}
+	return i;
+}
+
+static size_t _out_rev(out_fct_type out, Vector<char>* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width,
+                       unsigned int flags)
+{
+	const size_t start_idx = idx;
+
+	// pad spaces up to given width
+	if ((flags & FLAGS_LEFT) == 0 && (flags & FLAGS_ZEROPAD) == 0)
+	{
+		for (size_t i = len; i < width; i++)
+		{
+			out(' ', buffer, idx++, maxlen);
+		}
+	}
+
+	// reverse string
+	while (len != 0u)
+	{
+		out(buf[--len], buffer, idx++, maxlen);
+	}
+
+	// append pad spaces up to given width
+	if ((flags & FLAGS_LEFT) != 0u)
+	{
+		while (idx - start_idx < width)
+		{
+			out(' ', buffer, idx++, maxlen);
+		}
+	}
+
+	return idx;
+}
+
+// internal itoa format
+static size_t _ntoa_format(out_fct_type out, Vector<char>* buffer, size_t idx, size_t maxlen, char* buf, size_t len, bool negative,
+                           unsigned int base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+	// pad leading zeros
+	if ((flags & FLAGS_LEFT) == 0u)
+	{
+		if ((width != 0u) && ((flags & FLAGS_ZEROPAD) != 0u) && (negative || ((flags & (FLAGS_PLUS | FLAGS_SPACE)) != 0u)))
+		{
+			width--;
+		}
+		while ((len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE))
+		{
+			buf[len++] = '0';
+		}
+		while (((flags & FLAGS_ZEROPAD) != 0u) && (len < width) && (len < PRINTF_NTOA_BUFFER_SIZE))
+		{
+			buf[len++] = '0';
+		}
+	}
+
+	// handle hash
+	if ((flags & FLAGS_HASH) != 0u)
+	{
+		if (((flags & FLAGS_PRECISION) == 0u) && (len != 0u) && ((len == prec) || (len == width)))
+		{
+			len--;
+			if ((len != 0u) && (base == 16U))
+			{
+				len--;
+			}
+		}
+		if ((base == 16U) && ((flags & FLAGS_UPPERCASE) == 0u) && (len < PRINTF_NTOA_BUFFER_SIZE))
+		{
+			buf[len++] = 'x';
+		} else if ((base == 16U) && ((flags & FLAGS_UPPERCASE) != 0u) && (len < PRINTF_NTOA_BUFFER_SIZE))
+		{
+			buf[len++] = 'X';
+		} else if ((base == 2U) && (len < PRINTF_NTOA_BUFFER_SIZE))
+		{
+			buf[len++] = 'b';
+		}
+		if (len < PRINTF_NTOA_BUFFER_SIZE)
+		{
+			buf[len++] = '0';
+		}
+	}
+
+	if (len < PRINTF_NTOA_BUFFER_SIZE)
+	{
+		if (negative)
+		{
+			buf[len++] = '-';
+		} else if ((flags & FLAGS_PLUS) != 0u)
+		{
+			buf[len++] = '+'; // ignore the space if the '+' exists
+		} else if ((flags & FLAGS_SPACE) != 0u)
+		{
+			buf[len++] = ' ';
+		}
+	}
+
+	return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+static size_t _ntoa_long_long(out_fct_type out, Vector<char>* buffer, size_t idx, size_t maxlen, uint64_t value, bool negative,
+                              uint64_t base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+	char   buf[PRINTF_NTOA_BUFFER_SIZE];
+	size_t len = 0U;
+
+	// no hash for 0 values
+	if (value == 0u)
+	{
+		flags &= ~FLAGS_HASH;
+	}
+
+	// write if precision != 0 and value is != 0
+	if (((flags & FLAGS_PRECISION) == 0u) || (value != 0u))
+	{
+		do
+		{
+			const char digit = static_cast<char>(value % base);
+			// NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
+			buf[len++] = digit < 10 ? '0' + digit : ((flags & FLAGS_UPPERCASE) != 0u ? 'A' : 'a') + digit - 10;
+			value /= base;
+		} while ((value != 0u) && (len < PRINTF_NTOA_BUFFER_SIZE));
+	}
+
+	return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, static_cast<unsigned int>(base), prec, width, flags);
+}
+
+// internal itoa for 'long' type
+static size_t _ntoa_long(out_fct_type out, Vector<char>* buffer, size_t idx, size_t maxlen, uint32_t value, bool negative, uint32_t base,
+                         unsigned int prec, unsigned int width, unsigned int flags)
+{
+	char   buf[PRINTF_NTOA_BUFFER_SIZE];
+	size_t len = 0U;
+
+	// no hash for 0 values
+	if (value == 0u)
+	{
+		flags &= ~FLAGS_HASH;
+	}
+
+	// write if precision != 0 and value is != 0
+	if (((flags & FLAGS_PRECISION) == 0u) || (value != 0u))
+	{
+		do
+		{
+			char digit = static_cast<char>(value % base);
+			// NOLINTNEXTLINE(bugprone-narrowing-conversions,cppcoreguidelines-narrowing-conversions)
+			buf[len++] = digit < 10 ? '0' + digit : ((flags & FLAGS_UPPERCASE) != 0u ? 'A' : 'a') + digit - 10;
+			value /= base;
+		} while ((value != 0u) && (len < PRINTF_NTOA_BUFFER_SIZE));
+	}
+
+	return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, static_cast<unsigned int>(base), prec, width, flags);
+}
+
+static size_t _etoa(out_fct_type out, Vector<char>* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width,
+                    unsigned int flags);
+
+// internal ftoa for fixed decimal floating point
+// NOLINTNEXTLINE(readability-function-cognitive-complexity)
+static size_t _ftoa(out_fct_type out, Vector<char>* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width,
+                    unsigned int flags)
+{
+	char   buf[PRINTF_FTOA_BUFFER_SIZE];
+	size_t len  = 0U;
+	double diff = 0.0;
+
+	// powers of 10
+	static const double pow10[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
+
+	// test for special values
+	if (value != value)
+	{
+		return _out_rev(out, buffer, idx, maxlen, "nan", 3, width, flags);
+	}
+	if (value < -DBL_MAX)
+	{
+		return _out_rev(out, buffer, idx, maxlen, "fni-", 4, width, flags);
+	}
+	if (value > DBL_MAX)
+	{
+		return _out_rev(out, buffer, idx, maxlen, (flags & FLAGS_PLUS) != 0u ? "fni+" : "fni", (flags & FLAGS_PLUS) != 0u ? 4U : 3U, width,
+		                flags);
+	}
+
+	// test for very large values
+	// standard printf behavior is to print EVERY whole number digit -- which could be 100s of characters overflowing your buffers == bad
+	if ((value > PRINTF_MAX_FLOAT) || (value < -PRINTF_MAX_FLOAT))
+	{
+		return _etoa(out, buffer, idx, maxlen, value, prec, width, flags);
+	}
+
+	// test for negative
+	bool negative = false;
+	if (value < 0)
+	{
+		negative = true;
+		value    = 0 - value;
+	}
+
+	// set default precision, if not set explicitly
+	if ((flags & FLAGS_PRECISION) == 0u)
+	{
+		prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+	}
+	// limit precision to 9, cause a prec >= 10 can lead to overflow errors
+	while ((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U))
+	{
+		buf[len++] = '0';
+		prec--;
+	}
+
+	int    whole = static_cast<int>(value);
+	double tmp   = (value - whole) * pow10[prec];
+	auto   frac  = static_cast<uint32_t>(tmp);
+	diff         = tmp - frac;
+
+	if (diff > 0.5)
+	{
+		++frac;
+		// handle rollover, e.g. case 0.99 with prec 1 is 1.0
+		if (frac >= pow10[prec])
+		{
+			frac = 0;
+			++whole;
+		}
+	} else if (diff < 0.5)
+	{
+	} else if ((frac == 0U) || ((frac & 1U) != 0u))
+	{
+		// if halfway, round up if odd OR if last digit is 0
+		++frac;
+	}
+
+	if (prec == 0U)
+	{
+		diff = value - static_cast<double>(whole);
+		if ((!(diff < 0.5) || (diff > 0.5)) && ((static_cast<uint32_t>(whole) & 1u) != 0))
+		{
+			// exactly 0.5 and ODD, then round up
+			// 1.5 -> 2, but 2.5 -> 2
+			++whole;
+		}
+	} else
+	{
+		unsigned int count = prec;
+		// now do fractional part, as an unsigned number
+		while (len < PRINTF_FTOA_BUFFER_SIZE)
+		{
+			--count;
+			buf[len++] = static_cast<char>(48U + (frac % 10U));
+			if ((frac /= 10U) == 0u)
+			{
+				break;
+			}
+		}
+		// add extra 0s
+		while ((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U))
+		{
+			buf[len++] = '0';
+		}
+		if (len < PRINTF_FTOA_BUFFER_SIZE)
+		{
+			// add decimal
+			buf[len++] = '.';
+		}
+	}
+
+	// do whole part, number is reversed
+	while (len < PRINTF_FTOA_BUFFER_SIZE)
+	{
+		buf[len++] = static_cast<char>(48 + (whole % 10));
+		if ((whole /= 10) == 0)
+		{
+			break;
+		}
+	}
+
+	// pad leading zeros
+	if (((flags & FLAGS_LEFT) == 0u) && ((flags & FLAGS_ZEROPAD) != 0u))
+	{
+		if ((width != 0u) && (negative || ((flags & (FLAGS_PLUS | FLAGS_SPACE)) != 0u)))
+		{
+			width--;
+		}
+		while ((len < width) && (len < PRINTF_FTOA_BUFFER_SIZE))
+		{
+			buf[len++] = '0';
+		}
+	}
+
+	if (len < PRINTF_FTOA_BUFFER_SIZE)
+	{
+		if (negative)
+		{
+			buf[len++] = '-';
+		} else if ((flags & FLAGS_PLUS) != 0u)
+		{
+			buf[len++] = '+'; // ignore the space if the '+' exists
+		} else if ((flags & FLAGS_SPACE) != 0u)
+		{
+			buf[len++] = ' ';
+		}
+	}
+
+	return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+// internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse <m.jasperse@gmail.com>
+static size_t _etoa(out_fct_type out, Vector<char>* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width,
+                    unsigned int flags)
+{
+	// check for NaN and special values
+	if ((value != value) || (value > DBL_MAX) || (value < -DBL_MAX))
+	{
+		return _ftoa(out, buffer, idx, maxlen, value, prec, width, flags);
+	}
+
+	// determine the sign
+	const bool negative = value < 0;
+	if (negative)
+	{
+		value = -value;
+	}
+
+	// default precision
+	if ((flags & FLAGS_PRECISION) == 0u)
+	{
+		prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+	}
+
+	// determine the decimal exponent
+	// based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c)
+	union
+	{
+		uint64_t U;
+		double   F;
+	} conv {};
+
+	conv.F   = value;
+	int exp2 = static_cast<int>((conv.U >> 52U) & 0x07FFU) - 1023; // effectively log2
+	conv.U   = (conv.U & ((1ULL << 52U) - 1U)) | (1023ULL << 52U); // drop the exponent so conv.F is now in [1,2)
+	// now approximate log10 from the log2 integer part and an expansion of ln around 1.5
+	int expval = static_cast<int>(0.1760912590558 + exp2 * 0.301029995663981 + (conv.F - 1.5) * 0.289529654602168);
+	// now we want to compute 10^expval but we want to be sure it won't overflow
+	// exp2            = static_cast<int>(expval * 3.321928094887362 + 0.5);
+	exp2            = lround(expval * 3.321928094887362);
+	const double z  = expval * 2.302585092994046 - exp2 * 0.6931471805599453;
+	const double z2 = z * z;
+	conv.U          = static_cast<uint64_t>(exp2 + 1023) << 52U;
+	// compute exp(z) using continued fractions, see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex
+	conv.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14)))));
+	// correct for rounding errors
+	if (value < conv.F)
+	{
+		expval--;
+		conv.F /= 10;
+	}
+
+	// the exponent format is "%+03d" and largest value is "307", so set aside 4-5 characters
+	unsigned int minwidth = ((expval < 100) && (expval > -100)) ? 4U : 5U;
+
+	// in "%g" mode, "prec" is the number of *significant figures* not decimals
+	if ((flags & FLAGS_ADAPT_EXP) != 0u)
+	{
+		// do we want to fall-back to "%f" mode?
+		if ((value >= 1e-4) && (value < 1e6))
+		{
+			if (static_cast<int>(prec) > expval)
+			{
+				prec = static_cast<unsigned>(static_cast<int>(prec) - expval - 1);
+			} else
+			{
+				prec = 0;
+			}
+			flags |= FLAGS_PRECISION; // make sure _ftoa respects precision
+			// no characters in exponent
+			minwidth = 0U;
+			expval   = 0;
+		} else
+		{
+			// we use one sigfig for the whole part
+			if ((prec > 0) && ((flags & FLAGS_PRECISION) != 0u))
+			{
+				--prec;
+			}
+		}
+	}
+
+	// will everything fit?
+	unsigned int fwidth = width;
+	if (width > minwidth)
+	{
+		// we didn't fall-back so subtract the characters required for the exponent
+		fwidth -= minwidth;
+	} else
+	{
+		// not enough characters, so go back to default sizing
+		fwidth = 0U;
+	}
+	if (((flags & FLAGS_LEFT) != 0u) && (minwidth != 0u))
+	{
+		// if we're padding on the right, DON'T pad the floating part
+		fwidth = 0U;
+	}
+
+	// rescale the float value
+	if (expval != 0)
+	{
+		value /= conv.F;
+	}
+
+	// output the floating part
+	const size_t start_idx = idx;
+	idx                    = _ftoa(out, buffer, idx, maxlen, negative ? -value : value, prec, fwidth, flags & ~FLAGS_ADAPT_EXP);
+
+	// output the exponent part
+	if (minwidth != 0u)
+	{
+		// output the exponential symbol
+		out((flags & FLAGS_UPPERCASE) != 0u ? 'E' : 'e', buffer, idx++, maxlen);
+		// output the exponent value
+		idx = _ntoa_long(out, buffer, idx, maxlen, (expval < 0) ? -expval : expval, expval < 0, 10, 0, minwidth - 1,
+		                 FLAGS_ZEROPAD | FLAGS_PLUS);
+		// might need to right-pad spaces
+		if ((flags & FLAGS_LEFT) != 0u)
+		{
+			while (idx - start_idx < width)
+			{
+				out(' ', buffer, idx++, maxlen);
+			}
+		}
+	}
+	return idx;
+}
+
+static inline unsigned int _strnlen_s(const char* str, size_t maxsize)
+{
+	const char* s = nullptr;
+	for (s = str; (*s != 0) && ((maxsize--) != 0u); ++s)
+	{
+		;
+	}
+	return static_cast<unsigned int>(s - str);
+}
+
+// NOLINTNEXTLINE(readability-function-cognitive-complexity)
+int my_vprint(const char* format, VaList* va_list)
+{
+	Vector<char> buffer;
+
+	uint32_t flags     = 0;
+	uint32_t width     = 0;
+	uint32_t precision = 0;
+	uint32_t n         = 0;
+	size_t   idx       = 0U;
+	auto     maxlen    = static_cast<size_t>(-1);
+
+	// use null output function
+	auto out = _out_null;
+
+	while (*format != 0)
+	{
+		// format specifier?  %[flags][width][.precision][length]
+		if (*format != '%')
+		{
+			// no
+			out(*format, &buffer, idx++, maxlen);
+			format++;
+			continue;
+		}
+
+		// yes, evaluate it
+		format++;
+
+		// evaluate flags
+		flags = 0U;
+		do
+		{
+			switch (*format)
+			{
+				case '0':
+					flags |= FLAGS_ZEROPAD;
+					format++;
+					n = 1U;
+					break;
+				case '-':
+					flags |= FLAGS_LEFT;
+					format++;
+					n = 1U;
+					break;
+				case '+':
+					flags |= FLAGS_PLUS;
+					format++;
+					n = 1U;
+					break;
+				case ' ':
+					flags |= FLAGS_SPACE;
+					format++;
+					n = 1U;
+					break;
+				case '#':
+					flags |= FLAGS_HASH;
+					format++;
+					n = 1U;
+					break;
+				default: n = 0U; break;
+			}
+		} while (n != 0u);
+
+		// evaluate width field
+		width = 0U;
+		if (_is_digit(*format))
+		{
+			width = _atoi(&format);
+		} else if (*format == '*')
+		{
+			// const int w = va_arg(va, int);
+			const int w = VaArg_int(va_list);
+			if (w < 0)
+			{
+				flags |= FLAGS_LEFT; // reverse padding
+				width = static_cast<unsigned int>(-w);
+			} else
+			{
+				width = static_cast<unsigned int>(w);
+			}
+			format++;
+		}
+
+		// evaluate precision field
+		precision = 0U;
+		if (*format == '.')
+		{
+			flags |= FLAGS_PRECISION;
+			format++;
+			if (_is_digit(*format))
+			{
+				precision = _atoi(&format);
+			} else if (*format == '*')
+			{
+				// const int prec = (int)va_arg(va, int);
+				const int prec = VaArg_int(va_list);
+				precision      = prec > 0 ? static_cast<unsigned int>(prec) : 0U;
+				format++;
+			}
+		}
+
+		// evaluate length field
+		switch (*format)
+		{
+			case 'l':
+				flags |= FLAGS_LONG;
+				format++;
+				if (*format == 'l')
+				{
+					flags |= FLAGS_LONG_LONG;
+					format++;
+				}
+				break;
+			case 'h':
+				flags |= FLAGS_SHORT;
+				format++;
+				if (*format == 'h')
+				{
+					flags |= FLAGS_CHAR;
+					format++;
+				}
+				break;
+			case 't':
+				flags |= (sizeof(ptrdiff_t) == sizeof(int32_t) ? FLAGS_LONG : FLAGS_LONG_LONG);
+				format++;
+				break;
+			case 'j':
+				flags |= (sizeof(intmax_t) == sizeof(int32_t) ? FLAGS_LONG : FLAGS_LONG_LONG);
+				format++;
+				break;
+			case 'z':
+				flags |= (sizeof(size_t) == sizeof(int32_t) ? FLAGS_LONG : FLAGS_LONG_LONG);
+				format++;
+				break;
+			default: break;
+		}
+
+		// evaluate specifier
+		switch (*format)
+		{
+			case 'd':
+			case 'i':
+			case 'u':
+			case 'x':
+			case 'X':
+			case 'o':
+			case 'b':
+			{
+				// set the base
+				unsigned int base = 0;
+				if (*format == 'x' || *format == 'X')
+				{
+					base = 16U;
+				} else if (*format == 'o')
+				{
+					base = 8U;
+				} else if (*format == 'b')
+				{
+					base = 2U;
+				} else
+				{
+					base = 10U;
+					flags &= ~FLAGS_HASH; // no hash for dec format
+				}
+				// uppercase
+				if (*format == 'X')
+				{
+					flags |= FLAGS_UPPERCASE;
+				}
+
+				// no plus or space flag for u, x, X, o, b
+				if ((*format != 'i') && (*format != 'd'))
+				{
+					flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
+				}
+
+				// ignore '0' flag when precision is given
+				if ((flags & FLAGS_PRECISION) != 0u)
+				{
+					flags &= ~FLAGS_ZEROPAD;
+				}
+
+				// convert the integer
+				if ((*format == 'i') || (*format == 'd'))
+				{
+					// signed
+					if ((flags & FLAGS_LONG_LONG) != 0u || (flags & FLAGS_LONG) != 0u)
+					{
+						// const long long value = va_arg(va, long long);
+						auto value = VaArg_long_long(va_list);
+						idx = _ntoa_long_long(out, &buffer, idx, maxlen, static_cast<uint64_t>(value > 0 ? value : 0 - value), value < 0,
+						                      base, precision, width, flags);
+					} else if ((flags & FLAGS_LONG) != 0u)
+					{
+						// const long value = va_arg(va, long);
+						auto value = VaArg_long(va_list);
+						idx = _ntoa_long(out, &buffer, idx, maxlen, static_cast<uint32_t>(value > 0 ? value : 0 - value), value < 0, base,
+						                 precision, width, flags);
+					} else
+					{
+						// const int value = (flags & FLAGS_CHAR)    ? (char)va_arg(va, int)
+						//                 : (flags & FLAGS_SHORT) ? (short int)va_arg(va, int)
+						//                                       : va_arg(va, int);
+						int value = (flags & FLAGS_CHAR) != 0u    ? static_cast<char>(VaArg_int(va_list))
+						            : (flags & FLAGS_SHORT) != 0u ? static_cast<int16_t>(VaArg_int(va_list))
+						                                          : VaArg_int(va_list);
+						idx = _ntoa_long(out, &buffer, idx, maxlen, static_cast<unsigned int>(value > 0 ? value : 0 - value), value < 0,
+						                 base, precision, width, flags);
+					}
+				} else
+				{
+					// unsigned
+					if ((flags & FLAGS_LONG_LONG) != 0u || (flags & FLAGS_LONG) != 0u)
+					{
+						idx = _ntoa_long_long(out, &buffer, idx, maxlen, static_cast<uint64_t>(VaArg_long_long(va_list)), false, base,
+						                      precision, width, flags);
+					} else if ((flags & FLAGS_LONG) != 0u)
+					{
+						idx = _ntoa_long(out, &buffer, idx, maxlen, static_cast<uint32_t>(VaArg_long(va_list)), false, base, precision,
+						                 width, flags);
+					} else
+					{
+						const unsigned int value = (flags & FLAGS_CHAR) != 0u    ? static_cast<unsigned char>(VaArg_int(va_list))
+						                           : (flags & FLAGS_SHORT) != 0u ? static_cast<uint16_t>(VaArg_int(va_list))
+						                                                         : static_cast<unsigned int>(VaArg_int(va_list));
+						idx                      = _ntoa_long(out, &buffer, idx, maxlen, value, false, base, precision, width, flags);
+					}
+				}
+				format++;
+				break;
+			}
+			case 'f':
+			case 'F':
+				if (*format == 'F')
+				{
+					flags |= FLAGS_UPPERCASE;
+				}
+				idx = _ftoa(out, &buffer, idx, maxlen, VaArg_double(va_list), precision, width, flags);
+				format++;
+				break;
+			case 'e':
+			case 'E':
+			case 'g':
+			case 'G':
+				if ((*format == 'g') || (*format == 'G'))
+				{
+					flags |= FLAGS_ADAPT_EXP;
+				}
+				if ((*format == 'E') || (*format == 'G'))
+				{
+					flags |= FLAGS_UPPERCASE;
+				}
+				idx = _etoa(out, &buffer, idx, maxlen, VaArg_double(va_list), precision, width, flags);
+				format++;
+				break;
+			case 'c':
+			{
+				unsigned int l = 1U;
+				// pre padding
+				if ((flags & FLAGS_LEFT) == 0u)
+				{
+					while (l++ < width)
+					{
+						out(' ', &buffer, idx++, maxlen);
+					}
+				}
+				// char output
+				out(static_cast<char>(VaArg_int(va_list)), &buffer, idx++, maxlen);
+				// post padding
+				if ((flags & FLAGS_LEFT) != 0u)
+				{
+					while (l++ < width)
+					{
+						out(' ', &buffer, idx++, maxlen);
+					}
+				}
+				format++;
+				break;
+			}
+
+			case 's':
+			{
+				// const char*  p = va_arg(va, char*);
+				const char*  p = VaArg_ptr<const char>(va_list);
+				unsigned int l = _strnlen_s(p, precision != 0u ? precision : static_cast<size_t>(-1));
+				// pre padding
+				if ((flags & FLAGS_PRECISION) != 0u)
+				{
+					l = (l < precision ? l : precision);
+				}
+				if ((flags & FLAGS_LEFT) == 0u)
+				{
+					while (l++ < width)
+					{
+						out(' ', &buffer, idx++, maxlen);
+					}
+				}
+				// string output
+				while ((*p != 0) && (((flags & FLAGS_PRECISION) == 0u) || ((precision--) != 0u)))
+				{
+					out(*(p++), &buffer, idx++, maxlen);
+				}
+				// post padding
+				if ((flags & FLAGS_LEFT) != 0u)
+				{
+					while (l++ < width)
+					{
+						out(' ', &buffer, idx++, maxlen);
+					}
+				}
+				format++;
+				break;
+			}
+
+			case 'p':
+			{
+				width = sizeof(void*) * 2U;
+				flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE;
+				const bool is_ll = sizeof(uintptr_t) == sizeof(int64_t);
+				if (is_ll)
+				{
+					idx = _ntoa_long_long(out, &buffer, idx, maxlen, reinterpret_cast<uintptr_t>(VaArg_ptr<void>(va_list)), false, 16U,
+					                      precision, width, flags);
+				} else
+				{
+					idx =
+					    _ntoa_long(out, &buffer, idx, maxlen, static_cast<uint32_t>(reinterpret_cast<uintptr_t>(VaArg_ptr<void>(va_list))),
+					               false, 16U, precision, width, flags);
+				}
+				format++;
+				break;
+			}
+
+			case '%':
+				out('%', &buffer, idx++, maxlen);
+				format++;
+				break;
+
+			default:
+				out(*format, &buffer, idx++, maxlen);
+				format++;
+				break;
+		}
+	}
+
+	// termination
+	out(static_cast<char>(0), &buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
+
+	printf(FG_BRIGHT_MAGENTA "%s" DEFAULT, buffer.GetDataConst());
+
+	// return written chars without terminating \0
+	return static_cast<int>(idx);
+}
+
+int my_print_v(VaContext* ctx)
+{
+	const char* format = VaArg_ptr<const char>(&ctx->va_list);
+
+	return my_vprint(format, &ctx->va_list);
+}
+
+int KYTY_SYSV_ABI my_print2(VA_ARGS)
+{
+	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
+	VA_CONTEXT(ctx);
+
+	return my_print_v(&ctx);
+}
+
+libc_print_func_t GetPrintFunc()
+{
+	return reinterpret_cast<libc_print_func_t>(my_print2);
+}
+
+libc_print_v_func_t GetPrintFuncV()
+{
+	return my_print_v;
+}
+
+libc_vprint_func_t GetVPrintFunc()
+{
+	return my_vprint;
+}
+
+} // namespace Kyty::Libs
+
+#endif // KYTY_EMU_ENABLED