From 9268cbd42e7c93dc64a4ed66dce294547e0998ee Mon Sep 17 00:00:00 2001
From: Philippe Symons <philippe.symons@zappware.com>
Date: Wed, 9 Apr 2025 20:04:08 +0200
Subject: [PATCH] Reduce binary size by eliminating libstdc++

This commit removes all references to things in the libstdc++ library to remove a decent chunk of bloat.

This means every std::to_string() call, std::string and std::vector. (as well as iostream related stuff).

I replaced those with my own versions ptgb::to_string() and ptgb::vector. Especially the latter is not exactly the same,
but close enough.

I also replaced operator new and delete with my own implementation to avoid pulling in everything related to exceptions
from libstdc++

Another problem was the fact that libtonc uses siscanf, which pulls in everything related to the scanf family of functions
and locale support. The worst part of that was that it included a 13KB "categories" symbol from libc_a-categories.o,
which was pulled in because of the locale support integrated into newlibc's siscanf() function. To fix that, I created a
custom, extremely restricted implementation of siscanf. libtonc only used this function to parse at most 2 integers from a
string anyway.
---
 Makefile                                     |    6 +-
 include/button_menu.h                        |    6 +-
 include/gameboy_colour.h                     |    1 -
 include/gb_link.h                            |    3 +-
 include/libraries/nanoprintf/CONTRIBUTORS.md |   10 +
 include/libraries/nanoprintf/LICENSE         |   53 +
 include/libraries/nanoprintf/nanoprintf.h    | 1140 ++++++++++++++++++
 include/libstd_replacements.h                |  187 +++
 include/pokemon_data.h                       |    1 -
 include/script_var.h                         |   14 +-
 include/select_menu.h                        |    7 +-
 include/z80_asm.h                            |   24 +-
 loader/data/multiboot_rom.bin                |  Bin 201716 -> 0 bytes
 source/button_menu.cpp                       |    4 +-
 source/flash_mem.cpp                         |   14 +-
 source/gameboy_colour.cpp                    |   60 +-
 source/global_frame_controller.cpp           |    4 +-
 source/libstd_replacements.cpp               |  117 ++
 source/main.cpp                              |   36 +-
 source/mystery_gift_builder.cpp              |   49 +-
 source/payload_builder.cpp                   |   76 +-
 source/pokemon.cpp                           |   13 +-
 source/rom_data.cpp                          |   26 +-
 source/script_var.cpp                        |    9 +-
 source/z80_asm.cpp                           |  102 +-
 25 files changed, 1763 insertions(+), 199 deletions(-)
 create mode 100644 include/libraries/nanoprintf/CONTRIBUTORS.md
 create mode 100644 include/libraries/nanoprintf/LICENSE
 create mode 100644 include/libraries/nanoprintf/nanoprintf.h
 create mode 100644 include/libstd_replacements.h
 delete mode 100644 loader/data/multiboot_rom.bin
 create mode 100644 source/libstd_replacements.cpp

diff --git a/Makefile b/Makefile
index 80e7e29..7239e05 100644
--- a/Makefile
+++ b/Makefile
@@ -46,7 +46,7 @@ CFLAGS	:=	-g -Wall -O2\
 		$(ARCH) 
 
 CFLAGS	+=	$(INCLUDE) -ffunction-sections -fdata-sections -Os -Wall -mthumb -mcpu=arm7tdmi -mtune=arm7tdmi
-CXXFLAGS	:=	$(CFLAGS) -g0 -fno-rtti -fno-exceptions -std=c++20 -Wno-volatile -D_GLIBCXX_USE_CXX20_ABI=0
+CXXFLAGS	:=	$(CFLAGS) -g0 -fno-rtti -fno-exceptions -fdata-sections -ffunction-sections -std=c++20 -Wno-volatile -D_GLIBCXX_USE_CXX20_ABI=0
 
 ifeq ($(BUILD_TYPE), debug)
 	CFLAGS += -g -DDEBUG
@@ -57,7 +57,7 @@ else ifeq ($(BUILD_TYPE), release)
 endif
 
 ASFLAGS	:=	-g $(ARCH)
-LDFLAGS	=	-Os -g $(ARCH) -Wl,-Map,$(notdir $*.map) -Wl,--gc-sections -mthumb -mcpu=arm7tdmi -mtune=arm7tdmi
+LDFLAGS	=	-Os -g $(ARCH) -Wl,-Map,$(notdir $*.map) -Wl,--gc-sections -mthumb -mcpu=arm7tdmi -mtune=arm7tdmi -Wl,-Map,output.map,--cref -nodefaultlibs
 
 CFLAGS += -flto
 LDFLAGS += -flto
@@ -65,7 +65,7 @@ LDFLAGS += -flto
 #---------------------------------------------------------------------------------
 # any extra libraries we wish to link with the project
 #---------------------------------------------------------------------------------
-LIBS	:= -lmm -ltonc -lgba -lc -lgcc
+LIBS	:= -lmm -ltonc -lgba -lc -lgcc -lsysbase
 
 
 #---------------------------------------------------------------------------------
diff --git a/include/button_menu.h b/include/button_menu.h
index fe5597d..f01c755 100644
--- a/include/button_menu.h
+++ b/include/button_menu.h
@@ -2,7 +2,7 @@
 #define MAIN_MENU_H
 
 #include <tonc.h>
-#include <vector>
+#include "libstd_replacements.h"
 
 #include "button_handler.h"
 
@@ -33,8 +33,8 @@ public:
     void clear_vector();
 
 private:
-    std::vector<Button> button_vector;
-    std::vector<int> return_values;
+    ptgb::vector<Button> button_vector;
+    ptgb::vector<int> return_values;
     int columns;
     int rows;
     int button_height;
diff --git a/include/gameboy_colour.h b/include/gameboy_colour.h
index 0fbfccd..5017a60 100644
--- a/include/gameboy_colour.h
+++ b/include/gameboy_colour.h
@@ -4,7 +4,6 @@
 #define GAMEBOY_COLOUR_H_
 
 #include <tonc.h>
-#include <string>
 #include "libraries/gba-link-connection/LinkSPI.hpp"
 #include "pokemon_party.h"
 
diff --git a/include/gb_link.h b/include/gb_link.h
index faa0e9d..cf49b95 100644
--- a/include/gb_link.h
+++ b/include/gb_link.h
@@ -73,8 +73,9 @@ typedef enum
 
 #define GB_LINK_H
 #include <tonc.h>
+//#include <string>
 
-void log(std::string text);
+//void log(std::string text);
 void wait(u32 verticalLines);
 inline void VBLANK() {}
 void init();
diff --git a/include/libraries/nanoprintf/CONTRIBUTORS.md b/include/libraries/nanoprintf/CONTRIBUTORS.md
new file mode 100644
index 0000000..bffbd43
--- /dev/null
+++ b/include/libraries/nanoprintf/CONTRIBUTORS.md
@@ -0,0 +1,10 @@
+# Contributors
+
+## Special thanks for all the people who had helped this project so far:
+
+* [Dino Dai Zovi](https://github.com/ddz)
+* [Shang Yuanchun](https://github.com/ideal)
+* [Shreyas Balakrishna](https://github.com/shreyasbharath)
+* [Jim Keener](https://github.com/jimktrains)
+* [Dean T](https://github.com/deanoburrito)
+* [Oskars Rubenis](https://github.com/Okarss)
diff --git a/include/libraries/nanoprintf/LICENSE b/include/libraries/nanoprintf/LICENSE
new file mode 100644
index 0000000..039373b
--- /dev/null
+++ b/include/libraries/nanoprintf/LICENSE
@@ -0,0 +1,53 @@
+Nanoprintf is dual-licensed under both the "Unlicense" and the
+"Zero-Clause BSD" (0BSD) licenses. The intent of this dual-licensing
+structure is to make nanoprintf as consumable as possible in as many
+environments / countries / companies as possible without encumbering
+users.
+
+This license applies to all of the nanoprintf source code, build code,
+and tests, with the explicit exception of doctest.h, which exists under
+its own license and is included in this repository.
+
+The text of the two licenses follows below:
+
+============================== UNLICENSE ==============================
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>
+
+================================ 0BSD =================================
+
+Copyright (C) 2019 by Charles Nicholson <charles.nicholson+nanoprintf@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for
+any purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/include/libraries/nanoprintf/nanoprintf.h b/include/libraries/nanoprintf/nanoprintf.h
new file mode 100644
index 0000000..6a89479
--- /dev/null
+++ b/include/libraries/nanoprintf/nanoprintf.h
@@ -0,0 +1,1140 @@
+/* nanoprintf v0.5.4: a tiny embeddable printf replacement written in C.
+   https://github.com/charlesnicholson/nanoprintf
+   charles.nicholson+nanoprintf@gmail.com
+   dual-licensed under 0bsd and unlicense, take your pick. see eof for details. */
+
+#ifndef NANOPRINTF_H_INCLUDED
+#define NANOPRINTF_H_INCLUDED
+
+#include <stdarg.h>
+#include <stddef.h>
+
+// Define this to fully sandbox nanoprintf inside of a translation unit.
+#ifdef NANOPRINTF_VISIBILITY_STATIC
+  #define NPF_VISIBILITY static
+#else
+  #define NPF_VISIBILITY extern
+#endif
+
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+  #define NPF_PRINTF_ATTR(FORMAT_INDEX, VARGS_INDEX) \
+    __attribute__((format(printf, FORMAT_INDEX, VARGS_INDEX)))
+#else
+  #define NPF_PRINTF_ATTR(FORMAT_INDEX, VARGS_INDEX)
+#endif
+
+// Public API
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// The npf_ functions all return the number of bytes required to express the
+// fully-formatted string, not including the null terminator character.
+// The npf_ functions do not return negative values, since the lack of 'l' length
+// modifier support makes encoding errors impossible.
+
+NPF_VISIBILITY int npf_snprintf(
+  char *buffer, size_t bufsz, const char *format, ...) NPF_PRINTF_ATTR(3, 4);
+
+NPF_VISIBILITY int npf_vsnprintf(
+  char *buffer, size_t bufsz, char const *format, va_list vlist) NPF_PRINTF_ATTR(3, 0);
+
+typedef void (*npf_putc)(int c, void *ctx);
+NPF_VISIBILITY int npf_pprintf(
+  npf_putc pc, void *pc_ctx, char const *format, ...) NPF_PRINTF_ATTR(3, 4);
+
+NPF_VISIBILITY int npf_vpprintf(
+  npf_putc pc, void *pc_ctx, char const *format, va_list vlist) NPF_PRINTF_ATTR(3, 0);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NANOPRINTF_H_INCLUDED
+
+/* The implementation of nanoprintf begins here, to be compiled only if
+   NANOPRINTF_IMPLEMENTATION is defined. In a multi-file library what follows would
+   be nanoprintf.c. */
+
+#ifdef NANOPRINTF_IMPLEMENTATION
+
+#ifndef NANOPRINTF_IMPLEMENTATION_INCLUDED
+#define NANOPRINTF_IMPLEMENTATION_INCLUDED
+
+#include <limits.h>
+#include <stdint.h>
+
+// The conversion buffer must fit at least UINT64_MAX in octal format with the leading '0'.
+#ifndef NANOPRINTF_CONVERSION_BUFFER_SIZE
+  #define NANOPRINTF_CONVERSION_BUFFER_SIZE    23
+#endif
+#if NANOPRINTF_CONVERSION_BUFFER_SIZE < 23
+  #error The size of the conversion buffer must be at least 23 bytes.
+#endif
+
+// Pick reasonable defaults if nothing's been configured.
+#if !defined(NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS) && \
+    !defined(NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS) && \
+    !defined(NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS) && \
+    !defined(NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS) && \
+    !defined(NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS) && \
+    !defined(NANOPRINTF_USE_WRITEBACK_FORMAT_SPECIFIERS)
+  #define NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS 1
+  #define NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS 1
+  #define NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS 1
+  #define NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS 0
+  #define NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS 0
+  #define NANOPRINTF_USE_WRITEBACK_FORMAT_SPECIFIERS 0
+#endif
+
+// If anything's been configured, everything must be configured.
+#ifndef NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS
+  #error NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS must be #defined to 0 or 1
+#endif
+#ifndef NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS
+  #error NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS must be #defined to 0 or 1
+#endif
+#ifndef NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS
+  #error NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS must be #defined to 0 or 1
+#endif
+#ifndef NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS
+  #error NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS must be #defined to 0 or 1
+#endif
+#ifndef NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS
+  #error NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS must be #defined to 0 or 1
+#endif
+#ifndef NANOPRINTF_USE_WRITEBACK_FORMAT_SPECIFIERS
+  #error NANOPRINTF_USE_WRITEBACK_FORMAT_SPECIFIERS must be #defined to 0 or 1
+#endif
+
+// Ensure flags are compatible.
+#if (NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS == 1) && \
+    (NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 0)
+  #error Precision format specifiers must be enabled if float support is enabled.
+#endif
+
+// intmax_t / uintmax_t require stdint from c99 / c++11
+#if NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 1
+  #ifndef _MSC_VER
+    #ifdef __cplusplus
+      #if __cplusplus < 201103L
+        #error large format specifier support requires C++11 or later.
+      #endif
+    #else
+      #if __STDC_VERSION__ < 199409L
+        #error nanoprintf requires C99 or later.
+      #endif
+    #endif
+  #endif
+#endif
+
+// Figure out if we can disable warnings with pragmas.
+#ifdef __clang__
+  #define NANOPRINTF_CLANG 1
+  #define NANOPRINTF_GCC_PAST_4_6 0
+#else
+  #define NANOPRINTF_CLANG 0
+  #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6)))
+    #define NANOPRINTF_GCC_PAST_4_6 1
+  #else
+    #define NANOPRINTF_GCC_PAST_4_6 0
+  #endif
+#endif
+
+#if NANOPRINTF_CLANG || NANOPRINTF_GCC_PAST_4_6
+  #define NANOPRINTF_HAVE_GCC_WARNING_PRAGMAS 1
+#else
+  #define NANOPRINTF_HAVE_GCC_WARNING_PRAGMAS 0
+#endif
+
+#if NANOPRINTF_HAVE_GCC_WARNING_PRAGMAS
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wunused-function"
+  #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+  #ifdef __cplusplus
+    #pragma GCC diagnostic ignored "-Wold-style-cast"
+  #endif
+  #pragma GCC diagnostic ignored "-Wpadded"
+  #pragma GCC diagnostic ignored "-Wfloat-equal"
+  #if NANOPRINTF_CLANG
+    #pragma GCC diagnostic ignored "-Wc++98-compat-pedantic"
+    #pragma GCC diagnostic ignored "-Wcovered-switch-default"
+    #pragma GCC diagnostic ignored "-Wdeclaration-after-statement"
+    #pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
+    #ifndef __APPLE__
+      #pragma GCC diagnostic ignored "-Wunsafe-buffer-usage"
+    #endif
+  #elif NANOPRINTF_GCC_PAST_4_6
+    #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+  #endif
+#endif
+
+#ifdef _MSC_VER
+  #pragma warning(push)
+  #pragma warning(disable:4619) // there is no warning number 'number'
+  // C4619 has to be disabled first!
+  #pragma warning(disable:4127) // conditional expression is constant
+  #pragma warning(disable:4505) // unreferenced local function has been removed
+  #pragma warning(disable:4514) // unreferenced inline function has been removed
+  #pragma warning(disable:4701) // potentially uninitialized local variable used
+  #pragma warning(disable:4706) // assignment within conditional expression
+  #pragma warning(disable:4710) // function not inlined
+  #pragma warning(disable:4711) // function selected for inline expansion
+  #pragma warning(disable:4820) // padding added after struct member
+  #pragma warning(disable:5039) // potentially throwing function passed to extern C function
+  #pragma warning(disable:5045) // compiler will insert Spectre mitigation for memory load
+  #pragma warning(disable:5262) // implicit switch fall-through
+  #pragma warning(disable:26812) // enum type is unscoped
+#endif
+
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+  #define NPF_NOINLINE __attribute__((noinline))
+#elif defined(_MSC_VER)
+  #define NPF_NOINLINE __declspec(noinline)
+#else
+  #define NPF_NOINLINE
+#endif
+
+#if (NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1) || \
+    (NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1)
+enum {
+  NPF_FMT_SPEC_OPT_NONE,
+  NPF_FMT_SPEC_OPT_LITERAL,
+  NPF_FMT_SPEC_OPT_STAR,
+};
+#endif
+
+enum {
+  NPF_FMT_SPEC_LEN_MOD_NONE,
+  NPF_FMT_SPEC_LEN_MOD_SHORT,       // 'h'
+  NPF_FMT_SPEC_LEN_MOD_LONG_DOUBLE, // 'L'
+  NPF_FMT_SPEC_LEN_MOD_CHAR,        // 'hh'
+  NPF_FMT_SPEC_LEN_MOD_LONG,        // 'l'
+#if NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 1
+  NPF_FMT_SPEC_LEN_MOD_LARGE_LONG_LONG, // 'll'
+  NPF_FMT_SPEC_LEN_MOD_LARGE_INTMAX,    // 'j'
+  NPF_FMT_SPEC_LEN_MOD_LARGE_SIZET,     // 'z'
+  NPF_FMT_SPEC_LEN_MOD_LARGE_PTRDIFFT,  // 't'
+#endif
+};
+
+enum {
+  NPF_FMT_SPEC_CONV_NONE,
+  NPF_FMT_SPEC_CONV_PERCENT,      // '%'
+  NPF_FMT_SPEC_CONV_CHAR,         // 'c'
+  NPF_FMT_SPEC_CONV_STRING,       // 's'
+  NPF_FMT_SPEC_CONV_SIGNED_INT,   // 'i', 'd'
+#if NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS == 1
+  NPF_FMT_SPEC_CONV_BINARY,       // 'b'
+#endif
+  NPF_FMT_SPEC_CONV_OCTAL,        // 'o'
+  NPF_FMT_SPEC_CONV_HEX_INT,      // 'x', 'X'
+  NPF_FMT_SPEC_CONV_UNSIGNED_INT, // 'u'
+  NPF_FMT_SPEC_CONV_POINTER,      // 'p'
+#if NANOPRINTF_USE_WRITEBACK_FORMAT_SPECIFIERS == 1
+  NPF_FMT_SPEC_CONV_WRITEBACK,    // 'n'
+#endif
+#if NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS == 1
+  NPF_FMT_SPEC_CONV_FLOAT_DEC,      // 'f', 'F'
+  NPF_FMT_SPEC_CONV_FLOAT_SCI,      // 'e', 'E'
+  NPF_FMT_SPEC_CONV_FLOAT_SHORTEST, // 'g', 'G'
+  NPF_FMT_SPEC_CONV_FLOAT_HEX,      // 'a', 'A'
+#endif
+};
+
+typedef struct npf_format_spec {
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+  int field_width;
+  uint8_t field_width_opt;
+  char left_justified;   // '-'
+  char leading_zero_pad; // '0'
+#endif
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+  int prec;
+  uint8_t prec_opt;
+#endif
+  char prepend;          // ' ' or '+'
+  char alt_form;         // '#'
+  char case_adjust;      // 'a' - 'A'
+  uint8_t length_modifier;
+  uint8_t conv_spec;
+} npf_format_spec_t;
+
+#if NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 0
+  typedef long npf_int_t;
+  typedef unsigned long npf_uint_t;
+#else
+  typedef intmax_t npf_int_t;
+  typedef uintmax_t npf_uint_t;
+#endif
+
+typedef struct npf_bufputc_ctx {
+  char *dst;
+  size_t len;
+  size_t cur;
+} npf_bufputc_ctx_t;
+
+#if NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 1
+  typedef char npf_size_is_ptrdiff[(sizeof(size_t) == sizeof(ptrdiff_t)) ? 1 : -1];
+  typedef ptrdiff_t npf_ssize_t;
+#endif
+
+#ifdef _MSC_VER
+  #include <intrin.h>
+#endif
+
+static int npf_max(int x, int y) { return (x > y) ? x : y; }
+
+static int npf_parse_format_spec(char const *format, npf_format_spec_t *out_spec) {
+  char const *cur = format;
+
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+  out_spec->left_justified = 0;
+  out_spec->leading_zero_pad = 0;
+#endif
+  out_spec->case_adjust = 'a' - 'A'; // lowercase
+  out_spec->prepend = 0;
+  out_spec->alt_form = 0;
+
+  while (*++cur) { // cur points at the leading '%' character
+    switch (*cur) { // Optional flags
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+      case '-': out_spec->left_justified = '-'; out_spec->leading_zero_pad = 0; continue;
+      case '0': out_spec->leading_zero_pad = !out_spec->left_justified; continue;
+#endif
+      case '+': out_spec->prepend = '+'; continue;
+      case ' ': if (out_spec->prepend == 0) { out_spec->prepend = ' '; } continue;
+      case '#': out_spec->alt_form = '#'; continue;
+      default: break;
+    }
+    break;
+  }
+
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+  out_spec->field_width = 0;
+  out_spec->field_width_opt = NPF_FMT_SPEC_OPT_NONE;
+  if (*cur == '*') {
+    out_spec->field_width_opt = NPF_FMT_SPEC_OPT_STAR;
+    ++cur;
+  } else {
+    while ((*cur >= '0') && (*cur <= '9')) {
+      out_spec->field_width_opt = NPF_FMT_SPEC_OPT_LITERAL;
+      out_spec->field_width = (out_spec->field_width * 10) + (*cur++ - '0');
+    }
+  }
+#endif
+
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+  out_spec->prec = 0;
+  out_spec->prec_opt = NPF_FMT_SPEC_OPT_NONE;
+  if (*cur == '.') {
+    ++cur;
+    if (*cur == '*') {
+      out_spec->prec_opt = NPF_FMT_SPEC_OPT_STAR;
+      ++cur;
+    } else {
+      if (*cur == '-') {
+        ++cur;
+      } else {
+        out_spec->prec_opt = NPF_FMT_SPEC_OPT_LITERAL;
+      }
+      while ((*cur >= '0') && (*cur <= '9')) {
+        out_spec->prec = (out_spec->prec * 10) + (*cur++ - '0');
+      }
+    }
+  }
+#endif
+
+  uint_fast8_t tmp_conv = NPF_FMT_SPEC_CONV_NONE;
+  out_spec->length_modifier = NPF_FMT_SPEC_LEN_MOD_NONE;
+  switch (*cur++) { // Length modifier
+    case 'h':
+      out_spec->length_modifier = NPF_FMT_SPEC_LEN_MOD_SHORT;
+      if (*cur == 'h') {
+        out_spec->length_modifier = NPF_FMT_SPEC_LEN_MOD_CHAR;
+        ++cur;
+      }
+      break;
+    case 'l':
+      out_spec->length_modifier = NPF_FMT_SPEC_LEN_MOD_LONG;
+#if NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 1
+      if (*cur == 'l') {
+        out_spec->length_modifier = NPF_FMT_SPEC_LEN_MOD_LARGE_LONG_LONG;
+        ++cur;
+      }
+#endif
+      break;
+#if NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS == 1
+    case 'L': out_spec->length_modifier = NPF_FMT_SPEC_LEN_MOD_LONG_DOUBLE; break;
+#endif
+#if NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 1
+    case 'j': out_spec->length_modifier = NPF_FMT_SPEC_LEN_MOD_LARGE_INTMAX; break;
+    case 'z': out_spec->length_modifier = NPF_FMT_SPEC_LEN_MOD_LARGE_SIZET; break;
+    case 't': out_spec->length_modifier = NPF_FMT_SPEC_LEN_MOD_LARGE_PTRDIFFT; break;
+#endif
+    default: --cur; break;
+  }
+
+  switch (*cur++) { // Conversion specifier
+    case '%': out_spec->conv_spec = NPF_FMT_SPEC_CONV_PERCENT;
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+      out_spec->prec_opt = NPF_FMT_SPEC_OPT_NONE;
+#endif
+      break;
+
+    case 'c': out_spec->conv_spec = NPF_FMT_SPEC_CONV_CHAR;
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+      out_spec->prec_opt = NPF_FMT_SPEC_OPT_NONE;
+#endif
+      break;
+
+    case 's': out_spec->conv_spec = NPF_FMT_SPEC_CONV_STRING;
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+      out_spec->leading_zero_pad = 0;
+#endif
+      break;
+
+    case 'i':
+    case 'd': tmp_conv = NPF_FMT_SPEC_CONV_SIGNED_INT;
+    case 'o':
+      if (tmp_conv == NPF_FMT_SPEC_CONV_NONE) { tmp_conv = NPF_FMT_SPEC_CONV_OCTAL; }
+    case 'u':
+      if (tmp_conv == NPF_FMT_SPEC_CONV_NONE) { tmp_conv = NPF_FMT_SPEC_CONV_UNSIGNED_INT; }
+    case 'X':
+      if (tmp_conv == NPF_FMT_SPEC_CONV_NONE) { out_spec->case_adjust = 0; }
+    case 'x':
+      if (tmp_conv == NPF_FMT_SPEC_CONV_NONE) { tmp_conv = NPF_FMT_SPEC_CONV_HEX_INT; }
+      out_spec->conv_spec = (uint8_t)tmp_conv;
+#if (NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1) && \
+    (NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1)
+      if (out_spec->prec_opt != NPF_FMT_SPEC_OPT_NONE) { out_spec->leading_zero_pad = 0; }
+#endif
+      break;
+
+#if NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS == 1
+    case 'F': out_spec->case_adjust = 0;
+    case 'f':
+      out_spec->conv_spec = NPF_FMT_SPEC_CONV_FLOAT_DEC;
+      if (out_spec->prec_opt == NPF_FMT_SPEC_OPT_NONE) { out_spec->prec = 6; }
+      break;
+
+    case 'E': out_spec->case_adjust = 0;
+    case 'e':
+      out_spec->conv_spec = NPF_FMT_SPEC_CONV_FLOAT_SCI;
+      if (out_spec->prec_opt == NPF_FMT_SPEC_OPT_NONE) { out_spec->prec = 6; }
+      break;
+
+    case 'G': out_spec->case_adjust = 0;
+    case 'g':
+      out_spec->conv_spec = NPF_FMT_SPEC_CONV_FLOAT_SHORTEST;
+      if (out_spec->prec_opt == NPF_FMT_SPEC_OPT_NONE) { out_spec->prec = 6; }
+      break;
+
+    case 'A': out_spec->case_adjust = 0;
+    case 'a':
+      out_spec->conv_spec = NPF_FMT_SPEC_CONV_FLOAT_HEX;
+      if (out_spec->prec_opt == NPF_FMT_SPEC_OPT_NONE) { out_spec->prec = 6; }
+      break;
+#endif
+
+#if NANOPRINTF_USE_WRITEBACK_FORMAT_SPECIFIERS == 1
+    case 'n':
+      // todo: reject string if flags or width or precision exist
+      out_spec->conv_spec = NPF_FMT_SPEC_CONV_WRITEBACK;
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+      out_spec->prec_opt = NPF_FMT_SPEC_OPT_NONE;
+#endif
+      break;
+#endif
+
+    case 'p':
+      out_spec->conv_spec = NPF_FMT_SPEC_CONV_POINTER;
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+      out_spec->prec_opt = NPF_FMT_SPEC_OPT_NONE;
+#endif
+      break;
+
+#if NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS == 1
+    case 'B':
+      out_spec->case_adjust = 0;
+    case 'b':
+      out_spec->conv_spec = NPF_FMT_SPEC_CONV_BINARY;
+      break;
+#endif
+
+    default: return 0;
+  }
+
+  return (int)(cur - format);
+}
+
+static NPF_NOINLINE int npf_utoa_rev(
+    npf_uint_t val, char *buf, uint_fast8_t base, char case_adj) {
+  uint_fast8_t n = 0;
+  do {
+    int_fast8_t const d = (int_fast8_t)(val % base);
+    *buf++ = (char)(((d < 10) ? '0' : ('A' - 10 + case_adj)) + d);
+    ++n;
+    val /= base;
+  } while (val);
+  return (int)n;
+}
+
+#if NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS == 1
+
+#include <float.h>
+
+#if (DBL_MANT_DIG <= 11) && (DBL_MAX_EXP <= 16)
+  typedef uint_fast16_t npf_double_bin_t;
+  typedef int_fast8_t npf_ftoa_exp_t;
+#elif (DBL_MANT_DIG <= 24) && (DBL_MAX_EXP <= 128)
+  typedef uint_fast32_t npf_double_bin_t;
+  typedef int_fast8_t npf_ftoa_exp_t;
+#elif (DBL_MANT_DIG <= 53) && (DBL_MAX_EXP <= 1024)
+  typedef uint_fast64_t npf_double_bin_t;
+  typedef int_fast16_t npf_ftoa_exp_t;
+#else
+  #error Unsupported width of the double type.
+#endif
+
+// The floating point conversion code works with an unsigned integer type of any size.
+#ifndef NANOPRINTF_CONVERSION_FLOAT_TYPE
+  #define NANOPRINTF_CONVERSION_FLOAT_TYPE unsigned int
+#endif
+typedef NANOPRINTF_CONVERSION_FLOAT_TYPE npf_ftoa_man_t;
+
+#if (NANOPRINTF_CONVERSION_BUFFER_SIZE <= UINT_FAST8_MAX) && (UINT_FAST8_MAX <= INT_MAX)
+  typedef uint_fast8_t npf_ftoa_dec_t;
+#else
+  typedef int npf_ftoa_dec_t;
+#endif
+
+enum {
+  NPF_DOUBLE_EXP_MASK = DBL_MAX_EXP * 2 - 1,
+  NPF_DOUBLE_EXP_BIAS = DBL_MAX_EXP - 1,
+  NPF_DOUBLE_MAN_BITS = DBL_MANT_DIG - 1,
+  NPF_DOUBLE_BIN_BITS = sizeof(npf_double_bin_t) * CHAR_BIT,
+  NPF_FTOA_MAN_BITS   = sizeof(npf_ftoa_man_t) * CHAR_BIT,
+  NPF_FTOA_SHIFT_BITS =
+    ((NPF_FTOA_MAN_BITS < DBL_MANT_DIG) ? NPF_FTOA_MAN_BITS : DBL_MANT_DIG) - 1
+};
+
+/* Generally, floating-point conversion implementations use
+   grisu2 (https://bit.ly/2JgMggX) and ryu (https://bit.ly/2RLXSg0) algorithms,
+   which are mathematically exact and fast, but require large lookup tables.
+
+   This implementation was inspired by Wojciech Muła's (zdjęcia@garnek.pl)
+   algorithm (http://0x80.pl/notesen/2015-12-29-float-to-string.html) and
+   extended further by adding dynamic scaling and configurable integer width by
+   Oskars Rubenis (https://github.com/Okarss). */
+
+static int npf_ftoa_rev(char *buf, npf_format_spec_t const *spec, double f) {
+  char const *ret = NULL;
+  npf_double_bin_t bin; { // Union-cast is UB pre-C11, compiler optimizes byte-copy loop.
+    char const *src = (char const *)&f;
+    char *dst = (char *)&bin;
+    for (uint_fast8_t i = 0; i < sizeof(f); ++i) { dst[i] = src[i]; }
+  }
+
+  // Unsigned -> signed int casting is IB and can raise a signal but generally doesn't.
+  npf_ftoa_exp_t exp =
+    (npf_ftoa_exp_t)((npf_ftoa_exp_t)(bin >> NPF_DOUBLE_MAN_BITS) & NPF_DOUBLE_EXP_MASK);
+
+  bin &= ((npf_double_bin_t)0x1 << NPF_DOUBLE_MAN_BITS) - 1;
+  if (exp == (npf_ftoa_exp_t)NPF_DOUBLE_EXP_MASK) { // special value
+    ret = (bin) ? "NAN" : "FNI";
+    goto exit;
+  }
+  if (spec->prec > (NANOPRINTF_CONVERSION_BUFFER_SIZE - 2)) { goto exit; }
+  if (exp) { // normal number
+    bin |= (npf_double_bin_t)0x1 << NPF_DOUBLE_MAN_BITS;
+  } else { // subnormal number
+    ++exp;
+  }
+  exp = (npf_ftoa_exp_t)(exp - NPF_DOUBLE_EXP_BIAS);
+
+  uint_fast8_t carry; carry = 0;
+  npf_ftoa_dec_t end, dec; dec = (npf_ftoa_dec_t)spec->prec;
+  if (dec || spec->alt_form) {
+    buf[dec++] = '.';
+  }
+
+  { // Integer part
+    npf_ftoa_man_t man_i;
+
+    if (exp >= 0) {
+      int_fast8_t shift_i =
+        (int_fast8_t)((exp > NPF_FTOA_SHIFT_BITS) ? (int)NPF_FTOA_SHIFT_BITS : exp);
+      npf_ftoa_exp_t exp_i = (npf_ftoa_exp_t)(exp - shift_i);
+      shift_i = (int_fast8_t)(NPF_DOUBLE_MAN_BITS - shift_i);
+      man_i = (npf_ftoa_man_t)(bin >> shift_i);
+
+      if (exp_i) {
+        if (shift_i) {
+          carry = (bin >> (shift_i - 1)) & 0x1;
+        }
+        exp = NPF_DOUBLE_MAN_BITS; // invalidate the fraction part
+      }
+
+      // Scale the exponent from base-2 to base-10.
+      for (; exp_i; --exp_i) {
+        if (!(man_i & ((npf_ftoa_man_t)0x1 << (NPF_FTOA_MAN_BITS - 1)))) {
+          man_i = (npf_ftoa_man_t)(man_i << 1);
+          man_i = (npf_ftoa_man_t)(man_i | carry); carry = 0;
+        } else {
+          if (dec >= NANOPRINTF_CONVERSION_BUFFER_SIZE) { goto exit; }
+          buf[dec++] = '0';
+          carry = (((uint_fast8_t)(man_i % 5) + carry) > 2);
+          man_i /= 5;
+        }
+      }
+    } else {
+      man_i = 0;
+    }
+    end = dec;
+
+    do { // Print the integer
+      if (end >= NANOPRINTF_CONVERSION_BUFFER_SIZE) { goto exit; }
+      buf[end++] = (char)('0' + (char)(man_i % 10));
+      man_i /= 10;
+    } while (man_i);
+  }
+
+  { // Fraction part
+    npf_ftoa_man_t man_f;
+    npf_ftoa_dec_t dec_f = (npf_ftoa_dec_t)spec->prec;
+
+    if (exp < NPF_DOUBLE_MAN_BITS) {
+      int_fast8_t shift_f = (int_fast8_t)((exp < 0) ? -1 : exp);
+      npf_ftoa_exp_t exp_f = (npf_ftoa_exp_t)(exp - shift_f);
+      npf_double_bin_t bin_f =
+        bin << ((NPF_DOUBLE_BIN_BITS - NPF_DOUBLE_MAN_BITS) + shift_f);
+
+      // This if-else statement can be completely optimized at compile time.
+      if (NPF_DOUBLE_BIN_BITS > NPF_FTOA_MAN_BITS) {
+        man_f = (npf_ftoa_man_t)(bin_f >> ((unsigned)(NPF_DOUBLE_BIN_BITS -
+                                                      NPF_FTOA_MAN_BITS) %
+                                           NPF_DOUBLE_BIN_BITS));
+        carry = (uint_fast8_t)((bin_f >> ((unsigned)(NPF_DOUBLE_BIN_BITS -
+                                                     NPF_FTOA_MAN_BITS - 1) %
+                                          NPF_DOUBLE_BIN_BITS)) & 0x1);
+      } else {
+        man_f = (npf_ftoa_man_t)((npf_ftoa_man_t)bin_f
+                                 << ((unsigned)(NPF_FTOA_MAN_BITS -
+                                                NPF_DOUBLE_BIN_BITS) % NPF_FTOA_MAN_BITS));
+        carry = 0;
+      }
+
+      // Scale the exponent from base-2 to base-10 and prepare the first digit.
+      for (uint_fast8_t digit = 0; dec_f && (exp_f < 4); ++exp_f) {
+        if ((man_f > ((npf_ftoa_man_t)-4 / 5)) || digit) {
+          carry = (uint_fast8_t)(man_f & 0x1);
+          man_f = (npf_ftoa_man_t)(man_f >> 1);
+        } else {
+          man_f = (npf_ftoa_man_t)(man_f * 5);
+          if (carry) { man_f = (npf_ftoa_man_t)(man_f + 3); carry = 0; }
+          if (exp_f < 0) {
+            buf[--dec_f] = '0';
+          } else {
+            ++digit;
+          }
+        }
+      }
+      man_f = (npf_ftoa_man_t)(man_f + carry);
+      carry = (exp_f >= 0);
+      dec = 0;
+    } else {
+      man_f = 0;
+    }
+
+    if (dec_f) {
+      // Print the fraction
+      for (;;) {
+        buf[--dec_f] = (char)('0' + (char)(man_f >> (NPF_FTOA_MAN_BITS - 4)));
+        man_f = (npf_ftoa_man_t)(man_f & ~((npf_ftoa_man_t)0xF << (NPF_FTOA_MAN_BITS - 4)));
+        if (!dec_f) { break; }
+        man_f = (npf_ftoa_man_t)(man_f * 10);
+      }
+      man_f = (npf_ftoa_man_t)(man_f << 4);
+    }
+    if (exp < NPF_DOUBLE_MAN_BITS) {
+      carry &= (uint_fast8_t)(man_f >> (NPF_FTOA_MAN_BITS - 1));
+    }
+  }
+
+  // Round the number
+  for (; carry; ++dec) {
+    if (dec >= NANOPRINTF_CONVERSION_BUFFER_SIZE) { goto exit; }
+    if (dec >= end) { buf[end++] = '0'; }
+    if (buf[dec] == '.') { continue; }
+    carry = (buf[dec] == '9');
+    buf[dec] = (char)(carry ? '0' : (buf[dec] + 1));
+  }
+
+  return (int)end;
+exit:
+  if (!ret) { ret = "RRE"; }
+  uint_fast8_t i;
+  for (i = 0; ret[i]; ++i) { buf[i] = (char)(ret[i] + spec->case_adjust); }
+  return (int)i;
+}
+
+#endif // NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS
+
+#if NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS == 1
+static int npf_bin_len(npf_uint_t u) {
+  // Return the length of the binary string format of 'u', preferring intrinsics.
+  if (!u) { return 1; }
+
+#ifdef _MSC_VER // Win64, use _BSR64 for everything. If x86, use _BSR when non-large.
+  #ifdef _M_X64
+    #define NPF_HAVE_BUILTIN_CLZ
+    #define NPF_CLZ _BitScanReverse64
+  #elif NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 0
+    #define NPF_HAVE_BUILTIN_CLZ
+    #define NPF_CLZ _BitScanReverse
+  #endif
+  #ifdef NPF_HAVE_BUILTIN_CLZ
+    unsigned long idx;
+    NPF_CLZ(&idx, u);
+    return (int)(idx + 1);
+  #endif
+#elif NANOPRINTF_CLANG || NANOPRINTF_GCC_PAST_4_6
+  #define NPF_HAVE_BUILTIN_CLZ
+  #if NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 1
+    #define NPF_CLZ(X) ((sizeof(long long) * CHAR_BIT) - (size_t)__builtin_clzll(X))
+  #else
+    #define NPF_CLZ(X) ((sizeof(long) * CHAR_BIT) - (size_t)__builtin_clzl(X))
+  #endif
+  return (int)NPF_CLZ(u);
+#endif
+
+#ifndef NPF_HAVE_BUILTIN_CLZ
+  int n;
+  for (n = 0; u; ++n, u >>= 1); // slow but small software fallback
+  return n;
+#else
+  #undef NPF_HAVE_BUILTIN_CLZ
+  #undef NPF_CLZ
+#endif
+}
+#endif
+
+static void npf_bufputc(int c, void *ctx) {
+  npf_bufputc_ctx_t *bpc = (npf_bufputc_ctx_t *)ctx;
+  if (bpc->cur < bpc->len) { bpc->dst[bpc->cur++] = (char)c; }
+}
+
+static void npf_bufputc_nop(int c, void *ctx) { (void)c; (void)ctx; }
+
+typedef struct npf_cnt_putc_ctx {
+  npf_putc pc;
+  void *ctx;
+  int n;
+} npf_cnt_putc_ctx_t;
+
+static void npf_putc_cnt(int c, void *ctx) {
+  npf_cnt_putc_ctx_t *pc_cnt = (npf_cnt_putc_ctx_t *)ctx;
+  ++pc_cnt->n;
+  pc_cnt->pc(c, pc_cnt->ctx); // sibling-call optimization
+}
+
+#define NPF_PUTC(VAL) do { npf_putc_cnt((int)(VAL), &pc_cnt); } while (0)
+
+#define NPF_EXTRACT(MOD, CAST_TO, EXTRACT_AS) \
+  case NPF_FMT_SPEC_LEN_MOD_##MOD: val = (CAST_TO)va_arg(args, EXTRACT_AS); break
+
+#define NPF_WRITEBACK(MOD, TYPE) \
+  case NPF_FMT_SPEC_LEN_MOD_##MOD: *(va_arg(args, TYPE *)) = (TYPE)pc_cnt.n; break
+
+int npf_vpprintf(npf_putc pc, void *pc_ctx, char const *format, va_list args) {
+  npf_format_spec_t fs;
+  char const *cur = format;
+  npf_cnt_putc_ctx_t pc_cnt;
+  pc_cnt.pc = pc;
+  pc_cnt.ctx = pc_ctx;
+  pc_cnt.n = 0;
+
+  while (*cur) {
+    int const fs_len = (*cur != '%') ? 0 : npf_parse_format_spec(cur, &fs);
+    if (!fs_len) { NPF_PUTC(*cur++); continue; }
+    cur += fs_len;
+
+    // Extract star-args immediately
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+    if (fs.field_width_opt == NPF_FMT_SPEC_OPT_STAR) {
+      fs.field_width = va_arg(args, int);
+      if (fs.field_width < 0) {
+        fs.field_width = -fs.field_width;
+        fs.left_justified = 1;
+      }
+    }
+#endif
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+    if (fs.prec_opt == NPF_FMT_SPEC_OPT_STAR) {
+      fs.prec = va_arg(args, int);
+      if (fs.prec < 0) { fs.prec_opt = NPF_FMT_SPEC_OPT_NONE; }
+    }
+#endif
+
+    union { char cbuf_mem[NANOPRINTF_CONVERSION_BUFFER_SIZE]; npf_uint_t binval; } u;
+    char *cbuf = u.cbuf_mem, sign_c = 0;
+    int cbuf_len = 0, need_0x = 0;
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+    int field_pad = 0;
+    char pad_c = 0;
+#endif
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+    int prec_pad = 0;
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+    int zero = 0;
+#endif
+#endif
+
+    // Extract and convert the argument to string, point cbuf at the text.
+    switch (fs.conv_spec) {
+      case NPF_FMT_SPEC_CONV_PERCENT:
+        *cbuf = '%';
+        cbuf_len = 1;
+        break;
+
+      case NPF_FMT_SPEC_CONV_CHAR:
+        *cbuf = (char)va_arg(args, int);
+        cbuf_len = 1;
+        break;
+
+      case NPF_FMT_SPEC_CONV_STRING: {
+        cbuf = va_arg(args, char *);
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+        for (char const *s = cbuf;
+             ((fs.prec_opt == NPF_FMT_SPEC_OPT_NONE) || (cbuf_len < fs.prec)) && *s;
+             ++s, ++cbuf_len);
+#else
+        for (char const *s = cbuf; *s; ++s, ++cbuf_len); // strlen
+#endif
+      } break;
+
+      case NPF_FMT_SPEC_CONV_SIGNED_INT: {
+        npf_int_t val = 0;
+        switch (fs.length_modifier) {
+          NPF_EXTRACT(NONE, int, int);
+          NPF_EXTRACT(SHORT, short, int);
+          NPF_EXTRACT(LONG_DOUBLE, int, int);
+          NPF_EXTRACT(CHAR, char, int);
+          NPF_EXTRACT(LONG, long, long);
+#if NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 1
+          NPF_EXTRACT(LARGE_LONG_LONG, long long, long long);
+          NPF_EXTRACT(LARGE_INTMAX, intmax_t, intmax_t);
+          NPF_EXTRACT(LARGE_SIZET, npf_ssize_t, npf_ssize_t);
+          NPF_EXTRACT(LARGE_PTRDIFFT, ptrdiff_t, ptrdiff_t);
+#endif
+          default: break;
+        }
+
+        sign_c = (val < 0) ? '-' : fs.prepend;
+
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+        zero = !val;
+#endif
+        // special case, if prec and value are 0, skip
+        if (!val && (fs.prec_opt != NPF_FMT_SPEC_OPT_NONE) && !fs.prec) {
+          cbuf_len = 0;
+        } else
+#endif
+        {
+          npf_uint_t uval = (npf_uint_t)val;
+          if (val < 0) { uval = 0 - uval; }
+          cbuf_len = npf_utoa_rev(uval, cbuf, 10, fs.case_adjust);
+        }
+      } break;
+
+#if NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS == 1
+      case NPF_FMT_SPEC_CONV_BINARY:
+#endif
+      case NPF_FMT_SPEC_CONV_OCTAL:
+      case NPF_FMT_SPEC_CONV_HEX_INT:
+      case NPF_FMT_SPEC_CONV_UNSIGNED_INT: {
+        npf_uint_t val = 0;
+
+        switch (fs.length_modifier) {
+          NPF_EXTRACT(NONE, unsigned, unsigned);
+          NPF_EXTRACT(SHORT, unsigned short, unsigned);
+          NPF_EXTRACT(LONG_DOUBLE, unsigned, unsigned);
+          NPF_EXTRACT(CHAR, unsigned char, unsigned);
+          NPF_EXTRACT(LONG, unsigned long, unsigned long);
+#if NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 1
+          NPF_EXTRACT(LARGE_LONG_LONG, unsigned long long, unsigned long long);
+          NPF_EXTRACT(LARGE_INTMAX, uintmax_t, uintmax_t);
+          NPF_EXTRACT(LARGE_SIZET, size_t, size_t);
+          NPF_EXTRACT(LARGE_PTRDIFFT, size_t, size_t);
+#endif
+          default: break;
+        }
+
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+        zero = !val;
+#endif
+        if (!val && (fs.prec_opt != NPF_FMT_SPEC_OPT_NONE) && !fs.prec) {
+          // Zero value and explicitly-requested zero precision means "print nothing".
+          if ((fs.conv_spec == NPF_FMT_SPEC_CONV_OCTAL) && fs.alt_form) {
+            fs.prec = 1; // octal special case, print a single '0'
+          }
+        } else
+#endif
+#if NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS == 1
+        if (fs.conv_spec == NPF_FMT_SPEC_CONV_BINARY) {
+          cbuf_len = npf_bin_len(val); u.binval = val;
+        } else
+#endif
+        {
+          uint_fast8_t const base = (fs.conv_spec == NPF_FMT_SPEC_CONV_OCTAL) ?
+            8u : ((fs.conv_spec == NPF_FMT_SPEC_CONV_HEX_INT) ? 16u : 10u);
+          cbuf_len = npf_utoa_rev(val, cbuf, base, fs.case_adjust);
+        }
+
+        if (val && fs.alt_form && (fs.conv_spec == NPF_FMT_SPEC_CONV_OCTAL)) {
+          cbuf[cbuf_len++] = '0'; // OK to add leading octal '0' immediately.
+        }
+
+        if (val && fs.alt_form) { // 0x or 0b but can't write it yet.
+          if (fs.conv_spec == NPF_FMT_SPEC_CONV_HEX_INT) { need_0x = 'X'; }
+#if NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS == 1
+          else if (fs.conv_spec == NPF_FMT_SPEC_CONV_BINARY) { need_0x = 'B'; }
+#endif
+          if (need_0x) { need_0x += fs.case_adjust; }
+        }
+      } break;
+
+      case NPF_FMT_SPEC_CONV_POINTER: {
+        cbuf_len =
+          npf_utoa_rev((npf_uint_t)(uintptr_t)va_arg(args, void *), cbuf, 16, 'a' - 'A');
+        need_0x = 'x';
+      } break;
+
+#if NANOPRINTF_USE_WRITEBACK_FORMAT_SPECIFIERS == 1
+      case NPF_FMT_SPEC_CONV_WRITEBACK:
+        switch (fs.length_modifier) {
+          NPF_WRITEBACK(NONE, int);
+          NPF_WRITEBACK(SHORT, short);
+          NPF_WRITEBACK(LONG, long);
+          NPF_WRITEBACK(LONG_DOUBLE, double);
+          NPF_WRITEBACK(CHAR, signed char);
+#if NANOPRINTF_USE_LARGE_FORMAT_SPECIFIERS == 1
+          NPF_WRITEBACK(LARGE_LONG_LONG, long long);
+          NPF_WRITEBACK(LARGE_INTMAX, intmax_t);
+          NPF_WRITEBACK(LARGE_SIZET, size_t);
+          NPF_WRITEBACK(LARGE_PTRDIFFT, ptrdiff_t);
+#endif
+          default: break;
+        } break;
+#endif
+
+#if NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS == 1
+      case NPF_FMT_SPEC_CONV_FLOAT_DEC:
+      case NPF_FMT_SPEC_CONV_FLOAT_SCI:
+      case NPF_FMT_SPEC_CONV_FLOAT_SHORTEST:
+      case NPF_FMT_SPEC_CONV_FLOAT_HEX: {
+        double val;
+        if (fs.length_modifier == NPF_FMT_SPEC_LEN_MOD_LONG_DOUBLE) {
+          val = (double)va_arg(args, long double);
+        } else {
+          val = va_arg(args, double);
+        }
+
+        sign_c = (val < 0.) ? '-' : fs.prepend;
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+        zero = (val == 0.);
+#endif
+        cbuf_len = npf_ftoa_rev(cbuf, &fs, val);
+      } break;
+#endif
+      default: break;
+    }
+
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+    // Compute the field width pad character
+    if (fs.field_width_opt != NPF_FMT_SPEC_OPT_NONE) {
+      if (fs.leading_zero_pad) { // '0' flag is only legal with numeric types
+        if ((fs.conv_spec != NPF_FMT_SPEC_CONV_STRING) &&
+            (fs.conv_spec != NPF_FMT_SPEC_CONV_CHAR) &&
+            (fs.conv_spec != NPF_FMT_SPEC_CONV_PERCENT)) {
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+          if ((fs.prec_opt != NPF_FMT_SPEC_OPT_NONE) && !fs.prec && zero) {
+            pad_c = ' ';
+          } else
+#endif
+          { pad_c = '0'; }
+        }
+      } else { pad_c = ' '; }
+    }
+#endif
+
+    // Compute the number of bytes to truncate or '0'-pad.
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+    if (fs.conv_spec != NPF_FMT_SPEC_CONV_STRING) {
+#if NANOPRINTF_USE_FLOAT_FORMAT_SPECIFIERS == 1
+      // float precision is after the decimal point
+      if ((fs.conv_spec != NPF_FMT_SPEC_CONV_FLOAT_DEC) &&
+          (fs.conv_spec != NPF_FMT_SPEC_CONV_FLOAT_SCI) &&
+          (fs.conv_spec != NPF_FMT_SPEC_CONV_FLOAT_SHORTEST) &&
+          (fs.conv_spec != NPF_FMT_SPEC_CONV_FLOAT_HEX))
+#endif
+      { prec_pad = npf_max(0, fs.prec - cbuf_len); }
+    }
+#endif
+
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+    // Given the full converted length, how many pad bytes?
+    field_pad = fs.field_width - cbuf_len - !!sign_c;
+    if (need_0x) { field_pad -= 2; }
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+    field_pad -= prec_pad;
+#endif
+    field_pad = npf_max(0, field_pad);
+
+    // Apply right-justified field width if requested
+    if (!fs.left_justified && pad_c) { // If leading zeros pad, sign goes first.
+      if (pad_c == '0') {
+        if (sign_c) { NPF_PUTC(sign_c); sign_c = 0; }
+        // Pad byte is '0', write '0x' before '0' pad chars.
+        if (need_0x) { NPF_PUTC('0'); NPF_PUTC(need_0x); }
+      }
+      while (field_pad-- > 0) { NPF_PUTC(pad_c); }
+      // Pad byte is ' ', write '0x' after ' ' pad chars but before number.
+      if ((pad_c != '0') && need_0x) { NPF_PUTC('0'); NPF_PUTC(need_0x); }
+    } else
+#endif
+    { if (need_0x) { NPF_PUTC('0'); NPF_PUTC(need_0x); } } // no pad, '0x' requested.
+
+    // Write the converted payload
+    if (fs.conv_spec == NPF_FMT_SPEC_CONV_STRING) {
+      for (int i = 0; i < cbuf_len; ++i) { NPF_PUTC(cbuf[i]); }
+    } else {
+      if (sign_c) { NPF_PUTC(sign_c); }
+#if NANOPRINTF_USE_PRECISION_FORMAT_SPECIFIERS == 1
+      while (prec_pad-- > 0) { NPF_PUTC('0'); } // int precision leads.
+#endif
+#if NANOPRINTF_USE_BINARY_FORMAT_SPECIFIERS == 1
+      if (fs.conv_spec == NPF_FMT_SPEC_CONV_BINARY) {
+        while (cbuf_len) { NPF_PUTC('0' + ((u.binval >> --cbuf_len) & 1)); }
+      } else
+#endif
+      { while (cbuf_len-- > 0) { NPF_PUTC(cbuf[cbuf_len]); } } // payload is reversed
+    }
+
+#if NANOPRINTF_USE_FIELD_WIDTH_FORMAT_SPECIFIERS == 1
+    if (fs.left_justified && pad_c) { // Apply left-justified field width
+      while (field_pad-- > 0) { NPF_PUTC(pad_c); }
+    }
+#endif
+  }
+
+  return pc_cnt.n;
+}
+
+#undef NPF_PUTC
+#undef NPF_EXTRACT
+#undef NPF_WRITEBACK
+
+int npf_pprintf(npf_putc pc, void *pc_ctx, char const *format, ...) {
+  va_list val;
+  va_start(val, format);
+  int const rv = npf_vpprintf(pc, pc_ctx, format, val);
+  va_end(val);
+  return rv;
+}
+
+int npf_snprintf(char *buffer, size_t bufsz, const char *format, ...) {
+  va_list val;
+  va_start(val, format);
+  int const rv = npf_vsnprintf(buffer, bufsz, format, val);
+  va_end(val);
+  return rv;
+}
+
+int npf_vsnprintf(char *buffer, size_t bufsz, char const *format, va_list vlist) {
+  npf_bufputc_ctx_t bufputc_ctx;
+  bufputc_ctx.dst = buffer;
+  bufputc_ctx.len = bufsz;
+  bufputc_ctx.cur = 0;
+
+  npf_putc const pc = buffer ? npf_bufputc : npf_bufputc_nop;
+  int const n = npf_vpprintf(pc, &bufputc_ctx, format, vlist);
+  pc('\0', &bufputc_ctx);
+
+  if (buffer && bufsz) {
+#ifdef NANOPRINTF_SNPRINTF_SAFE_EMPTY_STRING_ON_OVERFLOW
+    if (n >= (int)bufsz) { buffer[0] = '\0'; }
+#else
+    buffer[bufsz - 1] = '\0';
+#endif
+  }
+
+  return n;
+}
+
+#if NANOPRINTF_HAVE_GCC_WARNING_PRAGMAS
+  #pragma GCC diagnostic pop
+#endif
+
+#ifdef _MSC_VER
+  #pragma warning(pop)
+#endif
+
+#endif // NANOPRINTF_IMPLEMENTATION_INCLUDED
+#endif // NANOPRINTF_IMPLEMENTATION
+
+/*
+  nanoprintf is dual-licensed under both the "Unlicense" and the
+  "Zero-Clause BSD" (0BSD) licenses. The intent of this dual-licensing
+  structure is to make nanoprintf as consumable as possible in as many
+  environments / countries / companies as possible without any
+  encumberances.
+
+  The text of the two licenses follows below:
+
+  ============================== UNLICENSE ==============================
+
+  This is free and unencumbered software released into the public domain.
+
+  Anyone is free to copy, modify, publish, use, compile, sell, or
+  distribute this software, either in source code form or as a compiled
+  binary, for any purpose, commercial or non-commercial, and by any
+  means.
+
+  In jurisdictions that recognize copyright laws, the author or authors
+  of this software dedicate any and all copyright interest in the
+  software to the public domain. We make this dedication for the benefit
+  of the public at large and to the detriment of our heirs and
+  successors. We intend this dedication to be an overt act of
+  relinquishment in perpetuity of all present and future rights to this
+  software under copyright law.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+  OTHER DEALINGS IN THE SOFTWARE.
+
+  For more information, please refer to <http://unlicense.org>
+
+  ================================ 0BSD =================================
+
+  Copyright (C) 2019- by Charles Nicholson <charles.nicholson+nanoprintf@gmail.com>
+
+  Permission to use, copy, modify, and/or distribute this software for
+  any purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
diff --git a/include/libstd_replacements.h b/include/libstd_replacements.h
new file mode 100644
index 0000000..824d05c
--- /dev/null
+++ b/include/libstd_replacements.h
@@ -0,0 +1,187 @@
+#ifndef _LIBSTD_REPLACEMENTS_H
+#define _LIBSTD_REPLACEMENTS_H
+
+#include <inttypes.h>
+#include <cstring>
+#include <new>
+
+// To reduce the binary size, we need to get rid of libstdc++
+// But we were happily using some functions that made life easier.
+// so this file was created to provide some similar functions/functionalities
+// (although stripped down to the bare minimum we're using)
+
+namespace ptgb
+{
+    /**
+     * This utility/convenience function converts the given value to a string.
+     * WARNING: it AND its other variants always use the same buffer.
+     * So calling it more than once will overwrite the previously returned string!
+     * 
+     * Be careful!
+     * In case you want to convert more than one int to string within the same call,
+     * consider using npf_snprintf instead!
+     * 
+     * Also: if you want to hold on to the converted value, consider copying the returned string
+     */
+    const char* to_string(int intVal);
+    
+    
+    /**
+     * This utility/convenience function converts the given value to a string.
+     * WARNING: it AND its other variants always use the same buffer.
+     * So calling it more than once will overwrite the previously returned string!
+     * 
+     * Be careful!
+     * In case you want to convert more than one int to string within the same call,
+     * consider using npf_snprintf instead!
+     * 
+     * Also: if you want to hold on to the converted value, consider copying the returned string
+     */
+    const char* to_string(unsigned int wordVal);
+
+    template <class ValueType>
+    class vector
+    {
+    public:
+        static constexpr size_t default_capacity = 10;
+
+        vector()
+            : buffer_()
+            , capacity_(default_capacity)
+            , count_(0)
+        {
+            buffer_ = static_cast<ValueType*>(::operator new(capacity_ * sizeof(ValueType)));
+        }
+
+        vector(const ValueType* valueList, size_t listSize)
+            : buffer_()
+            , capacity_(listSize)
+            , count_(0)
+        {
+            buffer_ = static_cast<ValueType*>(::operator new(capacity_ * sizeof(ValueType)));
+            insert(valueList, listSize);
+        }
+
+        ~vector()
+        {
+            clear();
+            ::operator delete(buffer_);
+        }
+
+        void reserve(size_t newSize)
+        {
+            ValueType *oldValue;
+            ValueType *oldBuffer;
+            if(newSize <= capacity_)
+            {
+                return;
+            }
+            oldBuffer = buffer_;
+            buffer_ = static_cast<ValueType*>(::operator new(newSize * sizeof(ValueType)));
+            capacity_ = newSize;
+
+            for (size_t i = 0; i < count_; ++i)
+            {
+                oldValue = oldBuffer + i;
+
+                new(buffer_ + i) ValueType(*oldValue);
+                oldValue->~ValueType();
+            }
+
+            ::operator delete(oldBuffer);
+        }
+
+        void resize(size_t newSize)
+        {
+            resize(newSize, ValueType());
+        }
+
+        void resize(size_t newSize, const ValueType& value)
+        {
+            if(newSize < count_)
+            {
+                for(size_t i=0; i < (count_ - newSize); ++i)
+                {
+                    pop_back();
+                }
+            }
+            else if(newSize > count_)
+            {
+                for(size_t i=0; i < (newSize - count_); ++i)
+                {
+                    push_back(value);
+                }
+            }
+        }
+
+        void push_back(const ValueType& value)
+        {
+            if(count_ == capacity_)
+            {
+                reserve(capacity_ * 2);
+            }
+            new(buffer_ + count_) ValueType(value);
+            ++count_;
+        }
+
+        void pop_back()
+        {
+            ValueType *value = buffer_ + ((count_ - 1));
+            value->~ValueType();
+            --count_;
+        }
+
+        void insert(vector<ValueType>& otherList)
+        {
+            reserve(count_ + otherList.size());
+
+            for(size_t i=0; i < otherList.size(); ++i)
+            {
+                push_back(otherList.at(i));
+            }
+        }
+
+        void insert(const ValueType* list, size_t listSize)
+        {
+            reserve(count_ + listSize);
+            for(size_t i=0; i < listSize; ++i)
+            {
+                push_back(list[i]);
+            }
+        }
+
+        void clear()
+        {
+            resize(0);
+        }
+
+        size_t size() const { return count_; }
+        size_t capacity() const { return capacity_; }
+
+        ValueType& at(size_t index)
+        {
+            return operator[](index);
+        }
+
+        const ValueType& at(size_t index) const
+        {
+            return operator[](index);
+        }
+        
+        ValueType& operator[](size_t index)
+        {
+            return *reinterpret_cast<ValueType*>(buffer_ + index);
+        }
+        
+        const ValueType& operator[](size_t index) const
+        {
+            return *reinterpret_cast<const ValueType*>(buffer_ + index);
+        }
+    private:
+        ValueType *buffer_;
+        size_t capacity_;
+        size_t count_;
+    };
+}
+
+#endif
\ No newline at end of file
diff --git a/include/pokemon_data.h b/include/pokemon_data.h
index 1555d0a..25362bc 100644
--- a/include/pokemon_data.h
+++ b/include/pokemon_data.h
@@ -2,7 +2,6 @@
 #define POKEMON_DATA_H
 
 #include <tonc.h>
-#include <string>
 
 #define erratic_max (u32)600000
 #define fast_max (u32)800000
diff --git a/include/script_var.h b/include/script_var.h
index 05a324c..96fbf1c 100644
--- a/include/script_var.h
+++ b/include/script_var.h
@@ -1,19 +1,19 @@
 #include <tonc.h>
-#include <vector>
+#include "libstd_replacements.h"
 #include <string>
 #include "rom_data.h"
 
 class script_var
 {
 public:
-    script_var(u32 nValue, std::vector<script_var *> &var_list_ref, int *nCurr_loc_ptr);
-    script_var(std::vector<script_var *> &var_list_ref, int *nCurr_loc_ptr);
+    script_var(u32 nValue, ptgb::vector<script_var *> &var_list_ref, int *nCurr_loc_ptr);
+    script_var(ptgb::vector<script_var *> &var_list_ref, int *nCurr_loc_ptr);
     virtual void fill_refrences(u8 mg_array_ptr[]); // goes through all the script locations and updates them to point to the start
     virtual void set_start();                       // Add a pointer to where the start is
     u32 place_word();                               // Place the value in memory
     int *curr_loc_ptr;
     u32 value;
-    std::vector<u32> location_list; // stores all the locations in the script that need to be updated
+    ptgb::vector<u32> location_list; // stores all the locations in the script that need to be updated
     u32 start_location_in_script;
 };
 
@@ -82,8 +82,8 @@ public:
     using xse_var::xse_var;
     void insert_music_data(u8 mg_array[], u8 blockCount, u8 priority, u8 reverb, u32 toneDataPointer);
     void set_start();
-    void add_track(std::vector<byte> track);
+    void add_track(const byte* trackBytes, size_t trackSize);
     int numTracks;
-    std::vector<u32> trackPointers;
-    std::vector<std::vector<byte>> trackArrays;
+    ptgb::vector<u32> trackPointers;
+    ptgb::vector<ptgb::vector<byte>> trackArrays;
 };
\ No newline at end of file
diff --git a/include/select_menu.h b/include/select_menu.h
index f9dd201..bcfdeb8 100644
--- a/include/select_menu.h
+++ b/include/select_menu.h
@@ -2,8 +2,7 @@
 #define SELECT_MENU_H
 
 #include <tonc.h>
-#include <vector>
-#include <string>
+#include "libstd_replacements.h"
 #include "text_engine.h"
 
 #define LANG_MENU 1
@@ -21,8 +20,8 @@ public:
     void set_lang(int nLang);
 
 private:
-    std::vector<const byte*> menu_options;
-    std::vector<int> return_values;
+    ptgb::vector<const byte*> menu_options;
+    ptgb::vector<int> return_values;
     unsigned int curr_selection;
     bool cancel_enabled;
     int menu_type;
diff --git a/include/z80_asm.h b/include/z80_asm.h
index 9af3bae..ac5887e 100644
--- a/include/z80_asm.h
+++ b/include/z80_asm.h
@@ -1,9 +1,8 @@
 #ifndef Z80_ASM_H
 #define Z80_ASM_H
 
-#include <string>
 #include <stdarg.h>
-#include <vector>
+#include "libstd_replacements.h"
 
 /*
 All registers are above 16 to not confuse them with u8 or u16
@@ -56,7 +55,7 @@ class z80_asm_handler
 public:
     int index;
     int memory_offset;
-    std::vector<byte> data_vector;
+    ptgb::vector<byte> data_vector;
 
     z80_asm_handler(int data_size, int mem_offset);
     void add_byte(u8 value);
@@ -110,31 +109,30 @@ public:
 
 private:
     void ROT(int reg, int info);
-    void throw_error(std::string message);
 };
 
 class z80_variable
 {
 public:
-    std::vector<byte> data;
+    ptgb::vector<byte> data;
     int size;
-    z80_variable(std::vector<z80_variable*> *var_vec, int data_size, ...);
-    z80_variable(std::vector<z80_variable*> *var_vec);
+    z80_variable(ptgb::vector<z80_variable*> *var_vec, int data_size, ...);
+    z80_variable(ptgb::vector<z80_variable*> *var_vec);
     void load_data(int data_size, byte array_data[]);
     int place_ptr(z80_asm_handler *z80_instance);
     void insert_variable(z80_asm_handler *var);
     void update_ptrs();
 
 private:
-    std::vector<int> ptr_locations;
-    std::vector<z80_asm_handler *> asm_handlers;
+    ptgb::vector<int> ptr_locations;
+    ptgb::vector<z80_asm_handler *> asm_handlers;
     int var_mem_location;
 };
 
 class z80_jump
 {
 public:
-    z80_jump(std::vector<z80_jump*> *jump_vec);
+    z80_jump(ptgb::vector<z80_jump*> *jump_vec);
     int place_relative_jump(z80_asm_handler *z80_instance);
     int place_direct_jump(z80_asm_handler *z80_instance);
     int place_pointer(z80_asm_handler *z80_instance);
@@ -142,9 +140,9 @@ public:
     void update_jumps();
 
 private:
-    std::vector<int> ptr_locations;
-    std::vector<z80_asm_handler *> asm_handlers;
-    std::vector<bool> jump_types;
+    ptgb::vector<int> ptr_locations;
+    ptgb::vector<z80_asm_handler *> asm_handlers;
+    ptgb::vector<bool> jump_types;
     int jump_mem_location;
 };
 
diff --git a/loader/data/multiboot_rom.bin b/loader/data/multiboot_rom.bin
deleted file mode 100644
index f09f8069a75a8f2169e3cd8cb001ba2086f3a2da..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 201716
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%0D^DIjw3MY!DEyz3IcIHw^;GKkTcu<5H?P
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

diff --git a/source/button_menu.cpp b/source/button_menu.cpp
index df35655..196986d 100644
--- a/source/button_menu.cpp
+++ b/source/button_menu.cpp
@@ -118,9 +118,9 @@ void Button_Menu::show_buttons()
 
 void Button_Menu::hide_buttons()
 {
-    for (Button &curr_btn : button_vector)
+    for(size_t i=0; i < button_vector.size(); ++i)
     {
-        curr_btn.hide();
+        button_vector[i].hide();
     }
 }
 
diff --git a/source/flash_mem.cpp b/source/flash_mem.cpp
index 233fe90..ac835e2 100644
--- a/source/flash_mem.cpp
+++ b/source/flash_mem.cpp
@@ -1,5 +1,5 @@
 #include <tonc.h>
-#include <string>
+#include "libstd_replacements.h"
 #include "flash_mem.h"
 #include "pokemon.h"
 #include "rom_data.h"
@@ -54,7 +54,7 @@ void initalize_memory_locations()
         copy_save_to_ram(memory_section_array[mem_section], &global_memory_buffer[0], 0x1000);
         tte_set_pos(8, 0);
         tte_write("loc: ");
-        tte_write(std::to_string(memory_section_array[mem_section] + mem_start).c_str());
+        tte_write(ptgb::to_string(memory_section_array[mem_section] + mem_start));
         tte_write("\n");
         for (int i = mem_start; i < (128 + mem_start); i++)
         {
@@ -66,7 +66,7 @@ void initalize_memory_locations()
             {
                 tte_write("#{cx:0xD000}");
             }
-            tte_write(std::to_string(global_memory_buffer[i]).c_str());
+            tte_write(ptgb::to_string(global_memory_buffer[i]));
             if (i % 8 == 7)
             {
                 tte_write("\n");
@@ -153,15 +153,15 @@ bool read_flag(u16 flag_id)
     {
         tte_set_pos(0, 0);
         tte_write("#{cx:0xD000}Attempting to read byte ");
-        tte_write(std::to_string((curr_rom.offset_flags + (flag_id / 8)) % 0xF80).c_str());
+        tte_write(ptgb::to_string((curr_rom.offset_flags + (flag_id / 8)) % 0xF80));
         tte_write(" of memory section ");
-        tte_write(std::to_string(1 + ((curr_rom.offset_flags + (flag_id / 8)) / 0xF80)).c_str());
+        tte_write(ptgb::to_string(1 + ((curr_rom.offset_flags + (flag_id / 8)) / 0xF80)));
         tte_write(" for flag ");
-        tte_write(std::to_string(flag_id).c_str());
+        tte_write(ptgb::to_string(flag_id));
         tte_write(". Flag is ");
         copy_save_to_ram(memory_section_array[1 + ((curr_rom.offset_flags + (flag_id / 8)) / 0xF80)], &global_memory_buffer[0], 0x1000);
         u8 flags = global_memory_buffer[(curr_rom.offset_flags + (flag_id / 8)) % 0xF80];
-        tte_write(std::to_string((flags >> (flag_id % 8)) & 0b1).c_str());
+        tte_write(ptgb::to_string((flags >> (flag_id % 8)) & 0b1));
         while (true)
         {
         };
diff --git a/source/gameboy_colour.cpp b/source/gameboy_colour.cpp
index 11d5363..bf66f45 100644
--- a/source/gameboy_colour.cpp
+++ b/source/gameboy_colour.cpp
@@ -2,7 +2,10 @@
 // Source: https://github.com/stevenchaulk/arduino-poke-gen2
 
 #include <tonc.h>
-#include <string>
+#include <stdarg.h>
+#include <inttypes.h>
+#include "libraries/nanoprintf/nanoprintf.h"
+#include "libstd_replacements.h"
 #include "gameboy_colour.h"
 #include "pokemon_trade.h"
 #include "script_array.h"
@@ -71,22 +74,40 @@ bool end_of_data;
 
 byte data_packet[PACKET_SIZE];
 
-std::string spi_text_out_array[10];
+#define SPI_TEXT_OUT_ARRAY_ELEMENT_SIZE 64
+// 10 elements of 64 bytes, zero-initialized.
+char spi_text_out_array[10][SPI_TEXT_OUT_ARRAY_ELEMENT_SIZE] = {
+  {0},
+  {0},
+  {0},
+  {0},
+  {0},
+  {0},
+  {0},
+  {0},
+  {0},
+  {0}
+};
 
-void print(std::string str)
+void print(const char* format, ...)
 {
+  va_list args;
+  va_start(args, format);
+
   for (int i = 10; i > 0; i--)
   {
-    spi_text_out_array[i] = spi_text_out_array[i - 1];
+    strncpy(spi_text_out_array[i], spi_text_out_array[i - 1], SPI_TEXT_OUT_ARRAY_ELEMENT_SIZE);
   }
-  spi_text_out_array[0] = str + "\n";
+
+  npf_vsnprintf(spi_text_out_array[0], SPI_TEXT_OUT_ARRAY_ELEMENT_SIZE, format, args);
+  va_end(args);
 
   tte_erase_rect(LEFT, TOP, RIGHT, BOTTOM);
   tte_set_pos(LEFT, 0);
   for (int j = 0; j < 10; j++)
   {
     ptgb_write("#{cx:0xE000}");
-    ptgb_write(spi_text_out_array[j].c_str());
+    ptgb_write(spi_text_out_array[j]);
   }
 }
 
@@ -314,12 +335,7 @@ int loop(byte *box_data_storage, byte *curr_payload, GB_ROM *curr_gb_rom, Simpli
     if (PRINT_LINK_DATA && false)
     {
       tte_set_margins(0, 0, H_MAX, V_MAX);
-      print(
-          std::to_string(counter) + ": [" +
-          std::to_string(data_counter) + "][" +
-          std::to_string(state) + "][" +
-          std::to_string(in_data) + "][" +
-          std::to_string(out_data) + "]\n");
+      print("%d: [%d][%d][%" PRIu8 "][%" PRIu8 "]\n\n", counter, data_counter, state, in_data, out_data);
     }
     out_data = handleIncomingByte(in_data, box_data_storage, curr_payload, curr_gb_rom, curr_simple_array, cancel_connection);
 
@@ -400,20 +416,20 @@ byte exchange_boxes(byte curr_in, byte *box_data_storage, GB_ROM *curr_gb_rom)
     if (SHOW_DATA_PACKETS)
     {
       ptgb_write("P: ");
-      ptgb_write(std::to_string(data_packet[0]).c_str());
+      ptgb_write(ptgb::to_string(data_packet[0]));
       ptgb_write("\n");
       for (int i = 0; i < DATA_PER_PACKET; i++)
       {
-        ptgb_write(std::to_string(i).c_str());
+        ptgb_write(ptgb::to_string(i));
         ptgb_write(": ");
-        ptgb_write(std::to_string(data_packet[PACKET_DATA_AT(i)]).c_str());
+        ptgb_write(ptgb::to_string(data_packet[PACKET_DATA_AT(i)]));
         ptgb_write(" [");
-        ptgb_write(std::to_string(data_packet[PACKET_FLAG_AT(i)]).c_str());
+        ptgb_write(ptgb::to_string(data_packet[PACKET_FLAG_AT(i)]));
         ptgb_write("]\n");
       }
-      ptgb_write(std::to_string(checksum).c_str());
+      ptgb_write(ptgb::to_string(checksum));
       ptgb_write(" = ");
-      ptgb_write(std::to_string(data_packet[PACKET_CHECKSUM]).c_str());
+      ptgb_write(ptgb::to_string(data_packet[PACKET_CHECKSUM]));
     }
 
     if (checksum == data_packet[PACKET_CHECKSUM] && !init_packet && !(test_packet_fail && received_offset == 128)) // Verify if the data matches the checksum
@@ -452,9 +468,9 @@ byte exchange_boxes(byte curr_in, byte *box_data_storage, GB_ROM *curr_gb_rom)
     if (SHOW_DATA_PACKETS)
     {
       ptgb_write("\nNO: ");
-      ptgb_write(std::to_string(next_offset).c_str());
+      ptgb_write(ptgb::to_string(next_offset));
       ptgb_write("\nFP: ");
-      ptgb_write(std::to_string(failed_packet).c_str());
+      ptgb_write(ptgb::to_string(failed_packet));
     }
 
     if (!init_packet)
@@ -477,9 +493,9 @@ byte exchange_boxes(byte curr_in, byte *box_data_storage, GB_ROM *curr_gb_rom)
     if (SHOW_DATA_PACKETS)
     {
       ptgb_write("\nRO: ");
-      ptgb_write(std::to_string(received_offset).c_str());
+      ptgb_write(ptgb::to_string(received_offset));
       ptgb_write("\nIP: ");
-      ptgb_write(std::to_string(init_packet).c_str());
+      ptgb_write(ptgb::to_string(init_packet));
 
       while (!key_held(KEY_A))
       {
diff --git a/source/global_frame_controller.cpp b/source/global_frame_controller.cpp
index 6859c24..883f2c9 100644
--- a/source/global_frame_controller.cpp
+++ b/source/global_frame_controller.cpp
@@ -1,6 +1,6 @@
 #include <tonc.h>
 #include <cmath>
-
+#include "libstd_replacements.h"
 #include "global_frame_controller.h"
 #include "random.h"
 #include "background_engine.h"
@@ -22,7 +22,7 @@ void global_next_frame()
     key_poll();
     rand_next_frame();
     // tte_set_pos(0, 0);
-    // tte_write(std::to_string(get_rand_u32()).c_str());
+    // tte_write(ptgb::to_string(get_rand_u32()));
     background_frame(global_frame_count);
     determine_fennel_blink();
     if (missingno_enabled)
diff --git a/source/libstd_replacements.cpp b/source/libstd_replacements.cpp
new file mode 100644
index 0000000..9fe3421
--- /dev/null
+++ b/source/libstd_replacements.cpp
@@ -0,0 +1,117 @@
+#define NANOPRINTF_IMPLEMENTATION 1
+
+#include "libstd_replacements.h"
+#include "libraries/nanoprintf/nanoprintf.h"
+#include <cstdlib>
+#include <stdarg.h>
+#include <ctype.h>
+
+// recommended for a 32 bit system to have at least 33 bytes available
+// source: https://cplusplus.com/reference/cstdlib/itoa/
+// unfortunately itoa is not standardized, so we'll have to make do with snprintf
+static char conversion_buffer[33];
+
+extern "C"
+{
+// HACK:
+// Unfortunately, libtonc references siscanf, which in turn causes a "lot" of binary bloat from newlibc (in regards to locale support)
+// to be pulled in by the linker.
+// However, if you look at what it is actually used for (in libtonc's tte_iohook.c), is just to extract 1 or 2 integers from a string
+// by specifying a custom -extremely simplified- version, we can avoid pulling in the version from libc (alongside all the symbols IT references)
+// Obviously it doesn't support everything it should. Just enough to support libtonc's current iteration.
+//
+// Anyway, doing this optimizes away a lot of scanf related functions from newlib and locale support among which a 13KB "categories" symbol.
+int siscanf(const char *str, const char *format, ...)
+{
+    bool expectingFormatSpecifier = false;
+    va_list args;
+    int* resultVal;
+    int ret = 0;
+    va_start(args, format);
+
+    while(*format != '\0')
+    {
+        if(*str == '\0')
+        {
+            //EOF encountered.
+            return -1;
+        }
+
+        if(expectingFormatSpecifier)
+        {
+            if(*format == 'd')
+            {
+                resultVal = va_arg(args, int*);
+                (*resultVal) = 0;
+                while(isdigit(*str))
+                {
+                    (*resultVal) *= 10;
+                    (*resultVal) += (*str) - '0';
+                    ++str;
+                }
+                // go back to the last character of the int, because we'll forward by one again at the end of the outer loop
+                --str;
+                ++ret;
+            }
+            expectingFormatSpecifier = false;
+        }
+        else if((*format) == '%')
+        {
+            expectingFormatSpecifier = true;
+        }
+
+        ++format;
+        ++str;
+    }
+
+    va_end(args);
+    return ret;
+}
+}
+
+const char* ptgb::to_string(int intVal)
+{
+    npf_snprintf(conversion_buffer, sizeof(conversion_buffer), "%d", intVal);
+    return conversion_buffer;
+}
+
+const char* ptgb::to_string(unsigned int wordVal)
+{
+    npf_snprintf(conversion_buffer, sizeof(conversion_buffer), "%u", wordVal);
+    return conversion_buffer;
+}
+
+// when compiling with -nostdlib++, we need to provide our own operator new and delete implementations
+// Regular operator new
+void* operator new(std::size_t size) {
+    void* ptr = std::malloc(size);
+    if (!ptr) {
+        // mimic standard behavior: throw std::bad_alloc
+        // but we can't use std::bad_alloc without libstdc++
+        // so instead we can abort or return nullptr
+        // You can also implement a custom exception if needed
+        std::abort();
+    }
+    return ptr;
+}
+
+// nothrow version
+void* operator new(std::size_t size, const std::nothrow_t&) noexcept {
+    return std::malloc(size);
+}
+
+// operator delete
+void operator delete(void* ptr) noexcept {
+    std::free(ptr);
+}
+
+// nothrow delete
+void operator delete(void* ptr, const std::nothrow_t&) noexcept {
+    std::free(ptr);
+}
+
+// sized delete (optional, for C++14 and newer)
+void operator delete(void* ptr, std::size_t size) noexcept {
+    (void)size;
+    std::free(ptr);
+}
\ No newline at end of file
diff --git a/source/main.cpp b/source/main.cpp
index 1701578..23b6902 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -1,8 +1,7 @@
 #include <tonc.h>
-#include <string>
 #include <cstring>
 // #include <maxmod.h> //Music
-
+#include "libstd_replacements.h"
 #include "flash_mem.h"
 #include "interrupt.h"
 #include "gb_link.h"
@@ -85,14 +84,16 @@ int test_main(void) Music
 // (R + G*32 + B*1024)
 #define RGB(r, g, b) (r + (g * 32) + (b * 1024))
 
+// make sure outBuffer is large enough! Should be at least hex_len + 1
 template <typename I>
-std::string n2hexstr(I w, size_t hex_len = sizeof(I) << 1)
+void n2hexstr(char* outBuffer, I w, size_t hex_len = sizeof(I) << 1)
 {
 	static const char *digits = "0123456789ABCDEF";
-	std::string rc(hex_len, '0');
+	memset(outBuffer, '0', hex_len);
+	outBuffer[hex_len] = '\0'; // we must make sure to terminate the string
+
 	for (size_t i = 0, j = (hex_len - 1) * 4; i < hex_len; ++i, j -= 4)
-		rc[i] = digits[(w >> j) & 0x0f];
-	return rc;
+		outBuffer[i] = digits[(w >> j) & 0x0f];
 }
 
 void load_graphics()
@@ -196,6 +197,7 @@ void first_load_message(void)
 
 int credits()
 {
+	char hexBuffer[16];
 #define CREDITS_ARRAY_SIZE 19
 	int curr_credits_num = 0;
 	const byte *credits_array[CREDITS_ARRAY_SIZE] = {
@@ -269,9 +271,7 @@ int credits()
 
 			create_textbox(4, 1, 160, 80, true);
 			ptgb_write_debug("Debug info:\n\nG: ", true);
-			std::string lang;
-			lang += curr_rom.language;
-			ptgb_write_debug(lang.c_str(), true);
+			ptgb_write_debug(ptgb::to_string(curr_rom.language), true);
 			switch (curr_rom.gamecode)
 			{
 			case RUBY_ID:
@@ -290,18 +290,22 @@ int credits()
 				ptgb_write_debug("-E-", true);
 				break;
 			}
-			ptgb_write_debug(std::to_string(curr_rom.version).c_str(), true);
+
+			ptgb_write_debug(ptgb::to_string(curr_rom.version), true);
 
 			ptgb_write_debug("\nF: ", true);
-			ptgb_write_debug(std::to_string(e4_flag).c_str(), true);
-			ptgb_write_debug(std::to_string(mg_flag).c_str(), true);
-			ptgb_write_debug(std::to_string(all_collected_flag).c_str(), true);
+			ptgb_write_debug(ptgb::to_string(e4_flag), true);
+			ptgb_write_debug(ptgb::to_string(mg_flag), true);
+			ptgb_write_debug(ptgb::to_string(all_collected_flag), true);
 			ptgb_write_debug("-", true);
-			ptgb_write_debug((n2hexstr(pkmn_flags)).c_str(), true);
+
+			n2hexstr(hexBuffer, pkmn_flags);
+			ptgb_write_debug(hexBuffer, true);
 			ptgb_write_debug("\nS:   ", true);
-			ptgb_write_debug(std::to_string(tutorial).c_str(), true);
+			ptgb_write_debug(ptgb::to_string(tutorial), true);
 			ptgb_write_debug("-", true);
-			ptgb_write_debug((n2hexstr(def_lang)).c_str(), true);
+			n2hexstr(hexBuffer, def_lang);
+			ptgb_write_debug(hexBuffer, true);
 
 			ptgb_write_debug("\n", true);
 			ptgb_write_debug(VERSION, true);
diff --git a/source/mystery_gift_builder.cpp b/source/mystery_gift_builder.cpp
index aff437b..09ef517 100644
--- a/source/mystery_gift_builder.cpp
+++ b/source/mystery_gift_builder.cpp
@@ -1,5 +1,5 @@
 #include <tonc.h>
-#include <vector>
+#include "libstd_replacements.h"
 #include "mystery_gift_builder.h"
 #include "pokemon_party.h"
 #include "pokemon_data.h"
@@ -63,8 +63,8 @@ mystery_gift_script::mystery_gift_script()
 
 void mystery_gift_script::build_script(Pokemon_Party &incoming_box_data)
 {
-    std::vector<script_var *> mg_variable_list;
-    std::vector<script_var *> sec30_variable_list;
+    ptgb::vector<script_var *> mg_variable_list;
+    ptgb::vector<script_var *> sec30_variable_list;
 
     asm_var sendMonToPC_ptr(curr_rom.loc_sendMonToPC + READ_AS_THUMB, sec30_variable_list, &curr_section30_index);
     asm_var returned_box_success_ptr(ptr_box_return, sec30_variable_list, &curr_section30_index);
@@ -283,13 +283,26 @@ void mystery_gift_script::build_script(Pokemon_Party &incoming_box_data)
     const int movementGoDownArray[2] = {MOVEMENT_ACTION_WALK_FAST_DOWN, MOVEMENT_ACTION_FACE_UP};
     movementGoDown.set_movement(movementGoDownArray, 2);
 
-    // songLooker.add_track({0xBC, 0x00, 0xBB, 0x38, 0xBD, 0x38, 0xC4, 0x00, 0xBE, 0x60, 0xBF, 0x3D, 0xC0, 0x40, 0xD4, 0x51, 0x70, 0x86, 0xD4, 0x8C, 0x53, 0x86, 0xD4, 0x8C, 0x54, 0x86, 0xD4, 0x92, 0xE8, 0x55, 0x92, 0xBE, 0x64, 0x82, 0x6C, 0x84, 0x74, 0x85, 0xB1});
-    songLooker.add_track({0xBC, 0x00, 0xBD, 0x38, 0xC4, 0x00, 0xBE, 0x60, 0xBF, 0x46, 0xC0, 0x40, 0x83, 0xD4, 0x51, 0x3C, 0x86, 0xD4, 0x8C, 0x53, 0x86, 0xD4, 0x8C, 0x54, 0x86, 0xD4, 0x92, 0xE8, 0x55, 0x99, 0x81, 0xB1});
-    songLooker.add_track({0xBC, 0x00, 0xBD, 0x38, 0xC4, 0x00, 0xBF, 0x34, 0xBE, 0x6E, 0xC0, 0x40, 0xD4, 0x3C, 0x70, 0x86, 0xD4, 0x8C, 0x3B, 0x86, 0xD4, 0x8C, 0x3C, 0x86, 0xD4, 0x92, 0xEA, 0x3D, 0x9B, 0x83, 0xB1});
-    songLooker.add_track({0xBC, 0x00, 0xBD, 0x38, 0xC4, 0x00, 0xBF, 0x34, 0xBE, 0x6E, 0xC0, 0x40, 0xD4, 0x39, 0x70, 0x86, 0xD4, 0x8C, 0x36, 0x86, 0xD4, 0x8C, 0x37, 0x86, 0xD4, 0x92, 0xEA, 0x39, 0x9B, 0x83, 0xB1});
-    songLooker.add_track({0xBC, 0x00, 0xBD, 0x38, 0xC4, 0x00, 0xBF, 0x34, 0xBE, 0x6E, 0xC0, 0x40, 0xD4, 0x34, 0x70, 0x86, 0xD4, 0x8C, 0x32, 0x86, 0xD4, 0x8C, 0x34, 0x86, 0xD4, 0x92, 0xEA, 0x37, 0x9B, 0x83, 0xB1});
-    // songLooker.add_track({0xBC, 0x00, 0xBD, 0x3C, 0xC4, 0x00, 0xBF, 0x58, 0xBE, 0x3B, 0xC0, 0x40, 0xD4, 0x40, 0x70, 0x86, 0xD4, 0x8C, 0x42, 0x86, 0xD4, 0x8C, 0x43, 0x86, 0xD4, 0x92, 0xE8, 0x99, 0x81, 0xB1});
-    // songLooker.add_track({0xBC, 0x00, 0xBD, 0x18, 0xC4, 0x00, 0xBE, 0x48, 0xBF, 0x1E, 0xC0, 0x40, 0xA0, 0xD0, 0x43, 0x70, 0x86, 0x45, 0x8C, 0x46, 0x8C, 0x45, 0x86, 0x47, 0x86, 0x49, 0x81, 0xB1});
+    // const byte track_1[] = {0xBC, 0x00, 0xBB, 0x38, 0xBD, 0x38, 0xC4, 0x00, 0xBE, 0x60, 0xBF, 0x3D, 0xC0, 0x40, 0xD4, 0x51, 0x70, 0x86, 0xD4, 0x8C, 0x53, 0x86, 0xD4, 0x8C, 0x54, 0x86, 0xD4, 0x92, 0xE8, 0x55, 0x92, 0xBE, 0x64, 0x82, 0x6C, 0x84, 0x74, 0x85, 0xB1};
+    // songLooker.add_track(track_1, sizeof(track_1));
+
+    const byte track_2[] = {0xBC, 0x00, 0xBD, 0x38, 0xC4, 0x00, 0xBE, 0x60, 0xBF, 0x46, 0xC0, 0x40, 0x83, 0xD4, 0x51, 0x3C, 0x86, 0xD4, 0x8C, 0x53, 0x86, 0xD4, 0x8C, 0x54, 0x86, 0xD4, 0x92, 0xE8, 0x55, 0x99, 0x81, 0xB1};
+    songLooker.add_track(track_2, sizeof(track_2));
+
+    const byte track_3[] = {0xBC, 0x00, 0xBD, 0x38, 0xC4, 0x00, 0xBF, 0x34, 0xBE, 0x6E, 0xC0, 0x40, 0xD4, 0x3C, 0x70, 0x86, 0xD4, 0x8C, 0x3B, 0x86, 0xD4, 0x8C, 0x3C, 0x86, 0xD4, 0x92, 0xEA, 0x3D, 0x9B, 0x83, 0xB1};
+    songLooker.add_track(track_3, sizeof(track_3));
+
+    const byte track_4[] = {0xBC, 0x00, 0xBD, 0x38, 0xC4, 0x00, 0xBF, 0x34, 0xBE, 0x6E, 0xC0, 0x40, 0xD4, 0x39, 0x70, 0x86, 0xD4, 0x8C, 0x36, 0x86, 0xD4, 0x8C, 0x37, 0x86, 0xD4, 0x92, 0xEA, 0x39, 0x9B, 0x83, 0xB1};
+    songLooker.add_track(track_4, sizeof(track_4));
+
+    const byte track_5[] = {0xBC, 0x00, 0xBD, 0x38, 0xC4, 0x00, 0xBF, 0x34, 0xBE, 0x6E, 0xC0, 0x40, 0xD4, 0x34, 0x70, 0x86, 0xD4, 0x8C, 0x32, 0x86, 0xD4, 0x8C, 0x34, 0x86, 0xD4, 0x92, 0xEA, 0x37, 0x9B, 0x83, 0xB1};
+    songLooker.add_track(track_5, sizeof(track_5));
+
+    // const byte track_6[] = {0xBC, 0x00, 0xBD, 0x3C, 0xC4, 0x00, 0xBF, 0x58, 0xBE, 0x3B, 0xC0, 0x40, 0xD4, 0x40, 0x70, 0x86, 0xD4, 0x8C, 0x42, 0x86, 0xD4, 0x8C, 0x43, 0x86, 0xD4, 0x92, 0xE8, 0x99, 0x81, 0xB1};
+    // songLooker.add_track(track_6, sizeof(track_6));
+
+    // const byte track_7[] = {0xBC, 0x00, 0xBD, 0x18, 0xC4, 0x00, 0xBE, 0x48, 0xBF, 0x1E, 0xC0, 0x40, 0xA0, 0xD0, 0x43, 0x70, 0x86, 0x45, 0x8C, 0x46, 0x8C, 0x45, 0x86, 0x47, 0x86, 0x49, 0x81, 0xB1};
+    // songLooker.add_track(track_7, sizeof(track_7));
 
     unsigned char instrument;
     switch (curr_rom.gamecode)
@@ -307,8 +320,12 @@ void mystery_gift_script::build_script(Pokemon_Party &incoming_box_data)
         instrument = 0x26;
         break;
     };
-    songLooker.add_track({0xBC, 0x00, 0xBD, instrument, 0xC4, 0x00, 0xBE, 0x7F, 0xBF, 0x40, 0xC0, 0x40, 0xD4, 0x21, 0x70, 0x86, 0xD4, 0x8C, 0x20, 0x86, 0xD4, 0x8C, 0x1F, 0x86, 0xDA, 0x8C, 0xD4, 0x2D, 0x86, 0x21, 0x8C, 0xD4, 0x86, 0xD4, 0x8C, 0xD4, 0x85, 0xB1});
-    // songLooker.add_track({0xBC, 0x00, 0xBD, 0x7E, 0xC4, 0x00, 0xBE, 0x53, 0xBF, 0x40, 0xD4, 0x24, 0x70, 0x8C, 0xD4, 0x98, 0x32, 0x86, 0xD4, 0x86, 0x30, 0x86, 0xD4, 0x86, 0xD4, 0x86, 0xD4, 0x86, 0x2D, 0x86, 0xD4, 0x86, 0xD4, 0x86, 0xD4, 0x85, 0xB1});
+
+    const byte track_instrument_1[] = {0xBC, 0x00, 0xBD, instrument, 0xC4, 0x00, 0xBE, 0x7F, 0xBF, 0x40, 0xC0, 0x40, 0xD4, 0x21, 0x70, 0x86, 0xD4, 0x8C, 0x20, 0x86, 0xD4, 0x8C, 0x1F, 0x86, 0xDA, 0x8C, 0xD4, 0x2D, 0x86, 0x21, 0x8C, 0xD4, 0x86, 0xD4, 0x8C, 0xD4, 0x85, 0xB1};
+    songLooker.add_track(track_instrument_1, sizeof(track_instrument_1));
+
+    // const byte track_unused[] = {0xBC, 0x00, 0xBD, 0x7E, 0xC4, 0x00, 0xBE, 0x53, 0xBF, 0x40, 0xD4, 0x24, 0x70, 0x8C, 0xD4, 0x98, 0x32, 0x86, 0xD4, 0x86, 0x30, 0x86, 0xD4, 0x86, 0xD4, 0x86, 0xD4, 0x86, 0x2D, 0x86, 0xD4, 0x86, 0xD4, 0x86, 0xD4, 0x85, 0xB1};
+    // songLooker.add_track(track_unused, sizeof(track_unused));
 
     int dex_nums[MAX_PKMN_IN_BOX] = {};
 
@@ -785,7 +802,7 @@ void mystery_gift_script::build_script(Pokemon_Party &incoming_box_data)
         tte_erase_screen();
         int val = (curr_mg_index - MG_SCRIPT_SIZE) - four_align_value;
         tte_write("MG Script exceeded by ");
-        tte_write(std::to_string(val).c_str());
+        tte_write(ptgb::to_string(val));
         tte_write(" bytes");
         while (true)
         {
@@ -797,7 +814,7 @@ void mystery_gift_script::build_script(Pokemon_Party &incoming_box_data)
         tte_erase_screen();
         int val = (curr_section30_index - 0x4096) - four_align_value;
         tte_write("S30 Script exceeded by ");
-        tte_write(std::to_string(val).c_str());
+        tte_write(ptgb::to_string(val));
         tte_write(" bytes");
         while (true)
         {
@@ -808,7 +825,7 @@ void mystery_gift_script::build_script(Pokemon_Party &incoming_box_data)
 /*
 void mystery_gift_script::build_script_old(Pokemon_Party &incoming_box_data)
 {
-    std::vector<script_var *> asm_variable_list;
+    ptgb::vector<script_var *> asm_variable_list;
     asm_var sendMonToPC_ptr(curr_rom.loc_sendMonToPC + READ_AS_THUMB, asm_variable_list, &curr_mg_index);
     asm_var returned_box_success_ptr(ptr_box_return, asm_variable_list, &curr_mg_index);
     asm_var curr_pkmn_index_ptr(ptr_pkmn_offset, asm_variable_list, &curr_mg_index);
@@ -1013,7 +1030,7 @@ void mystery_gift_script::build_script_old(Pokemon_Party &incoming_box_data)
         tte_erase_screen();
         int val = (curr_mg_index - MG_SCRIPT_SIZE) - four_align_value;
         tte_write("Script exceeded by ");
-        tte_write(std::to_string(val).c_str());
+        tte_write(ptgb::to_string(val));
         tte_write(" bytes");
         while (true)
         {
diff --git a/source/payload_builder.cpp b/source/payload_builder.cpp
index 92db6c3..6c9e1af 100644
--- a/source/payload_builder.cpp
+++ b/source/payload_builder.cpp
@@ -4,10 +4,6 @@
 #include "debug_mode.h"
 #include "z80_asm.h"
 
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-
 #define DATA_LOC (SHOW_DATA_PACKETS ? curr_rom.transferStringLocation : curr_rom.wEnemyMonSpecies)
 
 byte out_array[PAYLOAD_SIZE] = {};
@@ -25,8 +21,8 @@ byte *generate_payload(GB_ROM curr_rom, int type, bool debug)
 
     if ((curr_rom.generation == 1 && curr_rom.version != YELLOW_ID))
     {
-        std::vector<z80_jump *> jump_vector;
-        std::vector<z80_variable *> var_vector;
+        ptgb::vector<z80_jump *> jump_vector;
+        ptgb::vector<z80_variable *> var_vector;
 
         z80_asm_handler z80_rng_seed(0x0A, curr_rom.wSerialOtherGameboyRandomNumberListBlock + 8);
         z80_asm_handler z80_payload(0x1AA, curr_rom.wSerialEnemyDataBlock);
@@ -280,21 +276,24 @@ byte *generate_payload(GB_ROM curr_rom, int type, bool debug)
         }
 
         // Combine the vectors into the full payload
-        std::vector<byte> full_data;
+        ptgb::vector<byte> full_data;
         full_data.reserve(z80_rng_seed.data_vector.size() + z80_payload.data_vector.size() + z80_patchlist.data_vector.size());
-        full_data.insert(full_data.end(), z80_rng_seed.data_vector.begin(), z80_rng_seed.data_vector.end());
-        full_data.insert(full_data.end(), z80_payload.data_vector.begin(), z80_payload.data_vector.end());
-        full_data.insert(full_data.end(), z80_patchlist.data_vector.begin(), z80_patchlist.data_vector.end());
+        full_data.insert(z80_rng_seed.data_vector);
+        full_data.insert(z80_payload.data_vector);
+        full_data.insert(z80_patchlist.data_vector);
 
-        std::copy(full_data.begin(), full_data.end(), out_array);
+        for(size_t i=0; i < full_data.size(); ++i)
+        {
+            out_array[i] = full_data[i];
+        }
 
         return out_array;
     }
 
     else if ((curr_rom.generation == 1 && curr_rom.version == YELLOW_ID))
     {
-        std::vector<z80_jump *> jump_vector;
-        std::vector<z80_variable *> var_vector;
+        ptgb::vector<z80_jump *> jump_vector;
+        ptgb::vector<z80_variable *> var_vector;
 
         z80_asm_handler z80_rng_seed(0x0A, curr_rom.wSerialOtherGameboyRandomNumberListBlock + 8);
         z80_asm_handler z80_payload(0x1AA, curr_rom.wSerialEnemyDataBlock - 8); // Subtracting 8 is because the data is shifted after patching, removing part of the enemy name. May change depending on language
@@ -591,13 +590,16 @@ byte *generate_payload(GB_ROM curr_rom, int type, bool debug)
         }
 
         // Combine the vectors into the full payload
-        std::vector<byte> full_data;
+        ptgb::vector<byte> full_data;
         full_data.reserve(z80_rng_seed.data_vector.size() + z80_payload.data_vector.size() + z80_patchlist.data_vector.size());
-        full_data.insert(full_data.end(), z80_rng_seed.data_vector.begin(), z80_rng_seed.data_vector.end());
-        full_data.insert(full_data.end(), z80_payload.data_vector.begin(), z80_payload.data_vector.end());
-        full_data.insert(full_data.end(), z80_patchlist.data_vector.begin(), z80_patchlist.data_vector.end());
+        full_data.insert(z80_rng_seed.data_vector);
+        full_data.insert(z80_payload.data_vector);
+        full_data.insert(z80_patchlist.data_vector);
 
-        std::copy(full_data.begin(), full_data.end(), out_array);
+        for(size_t i=0; i < full_data.size(); ++i)
+        {
+            out_array[i] = full_data[i];
+        }
 
         return out_array;
 
@@ -664,8 +666,8 @@ byte *generate_payload(GB_ROM curr_rom, int type, bool debug)
 
     else if (curr_rom.generation == 2)
     {
-        std::vector<z80_jump *> jump_vector;
-        std::vector<z80_variable *> var_vector;
+        ptgb::vector<z80_jump *> jump_vector;
+        ptgb::vector<z80_variable *> var_vector;
 
         z80_asm_handler z80_rng_seed(0x0A, curr_rom.wSerialOtherGameboyRandomNumberListBlock);
         z80_asm_handler z80_payload(0x1CD, curr_rom.wSerialEnemyDataBlock);      // wOTPartyData
@@ -935,13 +937,16 @@ byte *generate_payload(GB_ROM curr_rom, int type, bool debug)
         }
 
         // Combine the vectors into the full payload
-        std::vector<byte> full_data;
+        ptgb::vector<byte> full_data;
         full_data.reserve(z80_rng_seed.data_vector.size() + z80_payload.data_vector.size() + z80_patchlist.data_vector.size());
-        full_data.insert(full_data.end(), z80_rng_seed.data_vector.begin(), z80_rng_seed.data_vector.end());
-        full_data.insert(full_data.end(), z80_payload.data_vector.begin(), z80_payload.data_vector.end());
-        full_data.insert(full_data.end(), z80_patchlist.data_vector.begin(), z80_patchlist.data_vector.end());
+        full_data.insert(z80_rng_seed.data_vector);
+        full_data.insert(z80_payload.data_vector);
+        full_data.insert(z80_patchlist.data_vector);
 
-        std::copy(full_data.begin(), full_data.end(), out_array);
+        for(size_t i = 0; i < full_data.size(); ++i)
+        {
+            out_array[i] = full_data[i];
+        }
 
         return out_array;
 
@@ -953,21 +958,23 @@ byte *generate_payload(GB_ROM curr_rom, int type, bool debug)
     return nullptr;
 };
 
-int test_main() // Rename to "main" to send the payload to test_payload.txt
+
+// Uncomment to send the payload to test_payload.txt
+#if 0
+#include <cstdio>
+int main()
 {
     freopen("test_payload.txt", "w", stdout);
-    std::cout << std::endl;
+    printf("\n");
     byte *payload = generate_payload(ENG_RED, TRANSFER, true);
     if (true)
     {
         for (int i = 0; i < 0x2A0; i++)
         {
-
-            std::cout << "0x" << std::setfill('0') << std::setw(2) << std::hex << std::uppercase << (unsigned int)payload[i] << ", ";
+            printf("0x%02X, ", (unsigned int)payload[i]);
             if (i % 0x10 == 0xF)
             {
-                std::cout << std::endl
-                          << "# 0x" << std::hex << i + 1 << std::endl;
+                printf("\n# 0x%X\n", i + 1);
             }
         }
         return 0;
@@ -976,12 +983,13 @@ int test_main() // Rename to "main" to send the payload to test_payload.txt
     {
         for (int i = 0; i < 0x150; i++)
         {
-            std::cout << std::setfill('0') << std::setw(2) << std::hex << std::uppercase << (unsigned int)payload[i + ((0x10 * 28) + 9)] << " ";
+            printf("%02X ", (unsigned int)payload[i + ((0x10 * 28) + 9)]);
             if (i % 0x10 == 0xF)
             {
-                std::cout << std::endl;
+                printf("\n");
             }
         }
         return 0;
     }
-}
\ No newline at end of file
+}
+#endif
\ No newline at end of file
diff --git a/source/pokemon.cpp b/source/pokemon.cpp
index cc4cd3b..570f071 100644
--- a/source/pokemon.cpp
+++ b/source/pokemon.cpp
@@ -1,4 +1,5 @@
 #include <tonc.h>
+#include "libstd_replacements.h"
 #include "pokemon.h"
 #include "pokemon_data.h"
 #include "random.h"
@@ -93,7 +94,7 @@ void Pokemon::load_data(int index, const byte *party_data, int game, int lang)
     switch (gen)
     {
     case 1:
-        // ptgb_write(std::to_string(party_data[1121]).c_str());
+        // ptgb_write(ptgb::to_string(party_data[1121]));
         // while (true){};
         species_index_party = party_data[party_species_offset];
         species_index_struct = party_data[box_struct_offset + 0x00];
@@ -142,15 +143,15 @@ void Pokemon::load_data(int index, const byte *party_data, int game, int lang)
     {
         tte_set_pos(8, 120);
         ptgb_write("struct offset: ");
-        ptgb_write(std::to_string(box_struct_offset).c_str());
+        ptgb_write(ptgb::to_string(box_struct_offset));
         ptgb_write("\nbox_size: ");
-        ptgb_write(std::to_string(box_size).c_str());
+        ptgb_write(ptgb::to_string(box_size));
         ptgb_write("\npkmn_size: ");
-        ptgb_write(std::to_string(pkmn_size).c_str());
+        ptgb_write(ptgb::to_string(pkmn_size));
         ptgb_write("\nindex: ");
-        ptgb_write(std::to_string(index).c_str());
+        ptgb_write(ptgb::to_string(index));
         ptgb_write(", game: ");
-        ptgb_write(std::to_string(game).c_str());
+        ptgb_write(ptgb::to_string(game));
         while (!key_hit(KEY_A))
         {
             global_next_frame();
diff --git a/source/rom_data.cpp b/source/rom_data.cpp
index ae04d64..0ab2877 100644
--- a/source/rom_data.cpp
+++ b/source/rom_data.cpp
@@ -9,6 +9,7 @@
 #include "gba_rom_values/ger_gba_rom_values.h"
 #include "gba_rom_values/ita_gba_rom_values.h"
 #include "gba_rom_values/spa_gba_rom_values.h"
+#include "libraries/nanoprintf/nanoprintf.h"
 
 extern rom_data curr_rom;
 
@@ -162,31 +163,34 @@ bool rom_data::is_ruby_sapphire()
 
 void rom_data::print_rom_info()
 {
-    std::string out;
+    char buffer[64];
+    char gameTypeChar;
     switch (gamecode)
     {
     case (RUBY_ID):
-        out += "R";
+        gameTypeChar = 'R';
         break;
     case (SAPPHIRE_ID):
-        out += "S";
+        gameTypeChar = 'S';
         break;
     case (FIRERED_ID):
-        out += "F";
+        gameTypeChar = 'F';
         break;
     case (LEAFGREEN_ID):
-        out += "L";
+        gameTypeChar = 'L';
         break;
     case (EMERALD_ID):
-        out += "E";
+        gameTypeChar = 'E';
+        break;
+    default:
+        gameTypeChar = '0';
         break;
     }
-    out += "-";
-    out += std::to_string(version);
-    out += "-";
-    out += char(language);
+
+    npf_snprintf(buffer, sizeof(buffer), "%c-%d-%c", gameTypeChar, version, language);
+
     tte_set_pos(0, 8);
-    ptgb_write(out.c_str());
+    ptgb_write(buffer);
 }
 
 bool rom_data::verify_rom()
diff --git a/source/script_var.cpp b/source/script_var.cpp
index cd1f782..707c295 100644
--- a/source/script_var.cpp
+++ b/source/script_var.cpp
@@ -1,5 +1,5 @@
 #include <tonc.h>
-#include <string>
+#include "libstd_replacements.h"
 #include "script_var.h"
 #include "pokemon_data.h"
 #include "debug_mode.h"
@@ -7,14 +7,14 @@
 
 extern rom_data curr_rom;
 
-script_var::script_var(u32 nValue, std::vector<script_var *> &var_list_ref, int *nCurr_loc_ptr)
+script_var::script_var(u32 nValue, ptgb::vector<script_var *> &var_list_ref, int *nCurr_loc_ptr)
 {
     var_list_ref.push_back(this); // Place the new object in the var_list
     value = nValue;
     curr_loc_ptr = nCurr_loc_ptr;
 };
 
-script_var::script_var(std::vector<script_var *> &var_list_ref, int *nCurr_loc_ptr)
+script_var::script_var(ptgb::vector<script_var *> &var_list_ref, int *nCurr_loc_ptr)
 {
     var_list_ref.push_back(this); // Place the new object in the var_list
     curr_loc_ptr = nCurr_loc_ptr;
@@ -256,8 +256,9 @@ void music_var::set_start()
     start_location_in_script = *curr_loc_ptr;
 }
 
-void music_var::add_track(std::vector<byte> track)
+void music_var::add_track(const byte* trackBytes, size_t trackSize)
 {
+    const ptgb::vector track(trackBytes, trackSize);
     trackArrays.push_back(track);
 }
 
diff --git a/source/z80_asm.cpp b/source/z80_asm.cpp
index ca64559..2f5bf93 100644
--- a/source/z80_asm.cpp
+++ b/source/z80_asm.cpp
@@ -1,11 +1,30 @@
 #include "z80_asm.h"
-#include <stdexcept>
-#include <string>
-#include <vector>
+#include <stdarg.h>
+#include "libraries/nanoprintf/nanoprintf.h"
+#include "libstd_replacements.h"
 
 #define DIRECT false
 #define RELATIVE true
 
+// this function generates an error message based on vsnprintf
+// and throws it.
+static void throw_error(const char* format, ...)
+{
+    // reserved 33 bytes for 2 ints alongside a format string
+    char error_msg_buffer[96];
+    va_list args;
+
+    va_start(args, format);
+    npf_vsnprintf(error_msg_buffer, sizeof(error_msg_buffer), format, args);
+    va_end(args);
+
+    // we should avoid exceptions and <stdexcept>
+    // throw std::runtime_error(message);
+    while (true)
+    {
+    }
+}
+
 z80_asm_handler::z80_asm_handler(int data_size, int mem_offset)
 {
     data_vector.resize(data_size, 0x00);
@@ -44,15 +63,6 @@ void z80_asm_handler::generate_patchlist(z80_asm_handler *bytes_to_patch){
     add_byte(0xFF);
 }
 
-void z80_asm_handler::throw_error(std::string message)
-{
-
-    // throw std::runtime_error(message);
-    while (true)
-    {
-    }
-}
-
 /* Figuring out pointers automatically is tricky since there are two seperate sections where our code is going. One is wSerialEnemyDataBlock, and the other is wSerialPartyMonsPatchList (0xC5D0)
 However, theoretically all of our code should be in the patch list and all of the payload hijack stuff should be in the enemy data block.
 Yellow is (currently) weird, but that will be fixed. The only time they cross over outside of that is in Gen 2 due to the box saving corrupting the code we're reading.
@@ -129,7 +139,7 @@ void z80_asm_handler::LD(int destination, int source)
     }
     else
     {
-        throw_error("Invalid Z80 LD command: " + std::to_string(source) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 LD command: %d, %d", source, destination);
     }
 }
 void z80_asm_handler::HALT()
@@ -163,7 +173,7 @@ void z80_asm_handler::ADD(int destination, int source)
     }
     else
     {
-        throw_error("Invalid Z80 ADD command: " + std::to_string(source) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 ADD command: %d, %d", source, destination);
     }
 }
 void z80_asm_handler::ADC(int destination, int source)
@@ -181,7 +191,7 @@ void z80_asm_handler::ADC(int destination, int source)
     }
     else
     {
-        throw_error("Invalid Z80 ADC command: " + std::to_string(source) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 ADC command: %d, %d", source, destination);
     }
 }
 void z80_asm_handler::SUB(int destination, int source)
@@ -199,7 +209,7 @@ void z80_asm_handler::SUB(int destination, int source)
     }
     else
     {
-        throw_error("Invalid Z80 SUB command: " + std::to_string(source) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 SUB command: %d, %d", source, destination);
     }
 }
 void z80_asm_handler::SBC(int destination, int source)
@@ -217,7 +227,7 @@ void z80_asm_handler::SBC(int destination, int source)
     }
     else
     {
-        throw_error("Invalid Z80 SBC command: " + std::to_string(source) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 SBC command: %d, %d", source, destination);
     }
 }
 void z80_asm_handler::AND(int destination, int source)
@@ -235,7 +245,7 @@ void z80_asm_handler::AND(int destination, int source)
     }
     else
     {
-        throw_error("Invalid Z80 AND command: " + std::to_string(source) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 AND command: %d, %d", source, destination);
     }
 }
 void z80_asm_handler::XOR(int destination, int source)
@@ -253,7 +263,7 @@ void z80_asm_handler::XOR(int destination, int source)
     }
     else
     {
-        throw_error("Invalid Z80 XOR command: " + std::to_string(source) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 XOR command: %d, %d", source, destination);
     }
 }
 void z80_asm_handler::OR(int destination, int source)
@@ -271,7 +281,7 @@ void z80_asm_handler::OR(int destination, int source)
     }
     else
     {
-        throw_error("Invalid Z80 OR command: " + std::to_string(source) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 OR command: %d, %d", source, destination);
     }
 }
 void z80_asm_handler::CP(int destination, int source)
@@ -289,7 +299,7 @@ void z80_asm_handler::CP(int destination, int source)
     }
     else
     {
-        throw_error("Invalid Z80 CP command: " + std::to_string(source) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 CP command: %d, %d", source, destination);
     }
 }
 void z80_asm_handler::NOP()
@@ -316,7 +326,7 @@ void z80_asm_handler::INC(int reg)
     }
     else
     {
-        throw_error("Invalid Z80 INC command: " + std::to_string(reg));
+        throw_error("Invalid Z80 INC command: %d", reg);
     }
 }
 void z80_asm_handler::DEC(int reg)
@@ -333,7 +343,7 @@ void z80_asm_handler::DEC(int reg)
     }
     else
     {
-        throw_error("Invalid Z80 DEC command: " + std::to_string(reg));
+        throw_error("Invalid Z80 DEC command: %d", reg);
     }
 }
 void z80_asm_handler::RLC(int reg)
@@ -366,7 +376,7 @@ void z80_asm_handler::ROT(int reg, int info)
     }
     else
     {
-        throw_error("Invalid Z80 ROT command: " + std::to_string(reg));
+        throw_error("Invalid Z80 ROT command: %d", reg);
     }
 }
 void z80_asm_handler::JR(int distance)
@@ -379,7 +389,7 @@ void z80_asm_handler::JR(int distance)
     }
     else
     {
-        throw_error("Invalid Z80 JR command: " + std::to_string(distance));
+        throw_error("Invalid Z80 JR command: %d", distance);
     }
 }
 void z80_asm_handler::JR(int flag, int distance)
@@ -392,7 +402,7 @@ void z80_asm_handler::JR(int flag, int distance)
     }
     else
     {
-        throw_error("Invalid Z80 JR command: " + std::to_string(flag) + ", " + std::to_string(distance));
+        throw_error("Invalid Z80 JR command: %d, %d", flag, distance);
     }
 }
 void z80_asm_handler::DDA()
@@ -423,7 +433,7 @@ void z80_asm_handler::RET(int flag)
     }
     else
     {
-        throw_error("Invalid Z80 RET command: " + std::to_string(flag));
+        throw_error("Invalid Z80 RET command: %d", flag);
     }
 };
 void z80_asm_handler::RETI()
@@ -438,7 +448,7 @@ void z80_asm_handler::PUSH(int source)
     }
     else
     {
-        throw_error("Invalid Z80 PUSH command: " + std::to_string(source));
+        throw_error("Invalid Z80 PUSH command: %d", source);
     }
 }
 void z80_asm_handler::POP(int destination)
@@ -449,7 +459,7 @@ void z80_asm_handler::POP(int destination)
     }
     else
     {
-        throw_error("Invalid Z80 PUSH command: " + std::to_string(destination));
+        throw_error("Invalid Z80 PUSH command: %d", destination);
     }
 }
 void z80_asm_handler::JP(int destination)
@@ -468,7 +478,7 @@ void z80_asm_handler::JP(int destination)
     }
     else
     {
-        throw_error("Invalid Z80 JP command: " + std::to_string(destination));
+        throw_error("Invalid Z80 JP command: %d", destination);
     }
 }
 void z80_asm_handler::JP(int flag, int destination)
@@ -482,7 +492,7 @@ void z80_asm_handler::JP(int flag, int destination)
     }
     else
     {
-        throw_error("Invalid Z80 JP command: " + std::to_string(flag) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 JP command: %d, %d", flag, destination);
     }
 }
 void z80_asm_handler::CALL(int destination)
@@ -496,7 +506,7 @@ void z80_asm_handler::CALL(int destination)
     }
     else
     {
-        throw_error("Invalid Z80 CALL command: " + std::to_string(destination));
+        throw_error("Invalid Z80 CALL command: %d", destination);
     }
 }
 void z80_asm_handler::CALL(int flag, int destination)
@@ -510,7 +520,7 @@ void z80_asm_handler::CALL(int flag, int destination)
     }
     else
     {
-        throw_error("Invalid Z80 CALL command: " + std::to_string(flag) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 CALL command: %d, %d", flag, destination);
     }
 }
 void z80_asm_handler::RST(int value)
@@ -521,7 +531,7 @@ void z80_asm_handler::RST(int value)
     }
     else
     {
-        throw_error("Invalid Z80 RST command: " + std::to_string(value));
+        throw_error("Invalid Z80 RST command: %d", value);
     }
 }
 void z80_asm_handler::LDH(int source, int destination)
@@ -550,7 +560,7 @@ void z80_asm_handler::LDH(int source, int destination)
     }
     else
     {
-        throw_error("Invalid Z80 LDH command: " + std::to_string(source) + ", " + std::to_string(destination));
+        throw_error("Invalid Z80 LDH command: %d, %d", source, destination);
     }
 }
 void z80_asm_handler::DI()
@@ -571,7 +581,7 @@ void z80_asm_handler::LDHL(int offset)
     }
     else
     {
-        throw_error("Invalid Z80 LDHL command: " + std::to_string(offset));
+        throw_error("Invalid Z80 LDHL command: %d", offset);
     }
 }
 void z80_asm_handler::SLA(int reg)
@@ -583,7 +593,7 @@ void z80_asm_handler::SLA(int reg)
     }
     else
     {
-        throw_error("Invalid Z80 SLA command: " + std::to_string(reg));
+        throw_error("Invalid Z80 SLA command: %d", reg);
     }
 }
 void z80_asm_handler::SRA(int reg)
@@ -595,7 +605,7 @@ void z80_asm_handler::SRA(int reg)
     }
     else
     {
-        throw_error("Invalid Z80 SRA command: " + std::to_string(reg));
+        throw_error("Invalid Z80 SRA command: %d", reg);
     }
 }
 void z80_asm_handler::SWAP(int reg)
@@ -607,7 +617,7 @@ void z80_asm_handler::SWAP(int reg)
     }
     else
     {
-        throw_error("Invalid Z80 SWAP command: " + std::to_string(reg));
+        throw_error("Invalid Z80 SWAP command: %d", reg);
     }
 }
 void z80_asm_handler::SRL(int reg)
@@ -619,7 +629,7 @@ void z80_asm_handler::SRL(int reg)
     }
     else
     {
-        throw_error("Invalid Z80 SRL command: " + std::to_string(reg));
+        throw_error("Invalid Z80 SRL command: %d", reg);
     }
 }
 void z80_asm_handler::BIT(int bit, int reg)
@@ -631,7 +641,7 @@ void z80_asm_handler::BIT(int bit, int reg)
     }
     else
     {
-        throw_error("Invalid Z80 BIT command: " + std::to_string(reg));
+        throw_error("Invalid Z80 BIT command: %d", reg);
     }
 }
 void z80_asm_handler::RES(int bit, int reg)
@@ -643,7 +653,7 @@ void z80_asm_handler::RES(int bit, int reg)
     }
     else
     {
-        throw_error("Invalid Z80 RES command: " + std::to_string(reg));
+        throw_error("Invalid Z80 RES command: %d", reg);
     }
 }
 void z80_asm_handler::SET(int bit, int reg)
@@ -655,16 +665,16 @@ void z80_asm_handler::SET(int bit, int reg)
     }
     else
     {
-        throw_error("Invalid Z80 SET command: " + std::to_string(reg));
+        throw_error("Invalid Z80 SET command: %d", reg);
     }
 }
 
-z80_variable::z80_variable(std::vector<z80_variable *> *var_vec)
+z80_variable::z80_variable(ptgb::vector<z80_variable *> *var_vec)
 {
     var_vec->push_back(this);
 }
 
-z80_variable::z80_variable(std::vector<z80_variable *> *var_vec, int data_size, ...)
+z80_variable::z80_variable(ptgb::vector<z80_variable *> *var_vec, int data_size, ...)
 {
     var_vec->push_back(this);
     data.resize(data_size);
@@ -713,7 +723,7 @@ void z80_variable::update_ptrs()
     }
 }
 
-z80_jump::z80_jump(std::vector<z80_jump *> *jump_vec)
+z80_jump::z80_jump(ptgb::vector<z80_jump *> *jump_vec)
 {
     jump_vec->push_back(this);
 }