diff --git a/screenshot.png b/screenshot.png
new file mode 100644
index 0000000..1a6a9e6
Binary files /dev/null and b/screenshot.png differ
diff --git a/xanguage.h b/xanguage.h
new file mode 100644
index 0000000..e6c8c73
--- /dev/null
+++ b/xanguage.h
@@ -0,0 +1,188 @@
+/// __  ____ _ _ __   __ _ _   _  __ _  __ _  ___
+/// \ \/ / _` | '_ \ / _` | | | |/ _` |/ _` |/ _ \
+///  >  < (_| | | | | (_| | |_| | (_| | (_| |  __/
+/// /_/\_\__,_|_| |_|\__, |\__,_|\__,_|\__, |\___|
+///                  |___/             |___/
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xanguage - Syntax definitions of programming languages that I care about (and some that I don't care about).
+///
+/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
+/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
+///
+/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
+/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
+/// for more details, if you dare, it is a lot of text that nobody wants to read...
+
+typedef enum {
+	language_common,                language_ada,                   language_c,                     language_cpp,
+	language_d,                     language_eaxhla,                language_flat,                  language_fortran,
+	language_pascal,                language_python,                language_go,                    language_lua,
+	language_bash,                  language_haskell,               language_valgrind,              language_holy_c,
+	language_count
+} language_enumeration;
+
+typedef struct {
+	natural comment_colour;
+	natural processor_colour;
+	natural character_colour;
+	natural string_colour;
+	natural keyword_colour;
+	natural type_colour;
+	natural bracket_colour;
+	natural operator_colour;
+	natural number_colour;
+	natural lowercase_colour;
+	natural uppercase_colour;
+	natural underscore_colour;
+	natural register_colour;
+	natural extension_colour;
+	natural fatal_colour;
+	natural comment_effect;
+	natural processor_effect;
+	natural character_effect;
+	natural string_effect;
+	natural keyword_effect;
+	natural type_effect;
+	natural bracket_effect;
+	natural operator_effect;
+	natural number_effect;
+	natural lowercase_effect;
+	natural uppercase_effect;
+	natural underscore_effect;
+	natural register_effect;
+	natural extension_effect;
+	natural fatal_effect;
+} language_structure;
+
+#define language_lowercase "abcdefghijklmnopqrstuvwxyz"
+#define language_uppercase "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+#define language_letters   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+#define language_digits    "0123456789"
+
+#include "xanguage/common.h"
+#include "xanguage/ada.h"
+#include "xanguage/c.h"
+#include "xanguage/c++.h"
+#include "xanguage/d.h"
+#include "xanguage/eaxhla.h"
+#include "xanguage/flat.h"
+#include "xanguage/fortran.h"
+#include "xanguage/pascal.h"
+#include "xanguage/python.h"
+#include "xanguage/go.h"
+#include "xanguage/holy_c.h"
+#include "xanguage/lua.h"
+#include "xanguage/bash.h"
+#include "xanguage/haskell.h"
+#include "xanguage/valgrind.h"
+
+#undef language_lowercase
+#undef language_uppercase
+#undef language_letters
+#undef language_digits
+
+static procedure (* language_highlighter [language_count]) (language_structure * language, syntax_structure * syntax) = {
+	language_highlight_common,      language_highlight_ada,         language_highlight_c,           language_highlight_cpp,
+	language_highlight_d,           language_highlight_eaxhla,      language_highlight_flat,        language_highlight_fortran,
+	language_highlight_pascal,      language_highlight_python,      language_highlight_go,          language_highlight_lua,
+	language_highlight_bash,        language_highlight_haskell,     language_highlight_valgrind,    language_highlight_holy_c
+};
+
+static character * language_short_option [language_count] = {
+	"-X",   "-A",   "-C",   "-S",   "-D",   "-E",   "-T",   "-F",   "-P",   "-Y",   "-G",   "-L",   "-B",   "-H",   "-V",   "-O"
+};
+
+static character * language_long_option [language_count] = {
+	"--common",     "--ada",        "--c",          "--cpp",        "--d",          "--eaxhla",     "--flat",       "--fortran",
+	"--pascal",     "--python",     "--go",         "--lua",        "--bash",       "--haskell",    "--valgrind",   "--holyc"
+};
+
+static character * language_identifier [language_count] = {
+	"Common",       "Ada",          "C",            "C++",          "D",            "EAXHLA",       "Flat",         "Fortran",
+	"Pascal",       "Python",       "Go",           "Lua",          "Bash",         "Haskell",      "Valgrind",     "Holy C"
+};
+
+static language_structure * language_initialize (boolean true_colour) {
+	language_structure * language = allocate (sizeof (* language));
+
+	if (true_colour == true) {
+		language->comment_colour    = 0xff777777u;
+		language->processor_colour  = 0xff3377aau;
+		language->character_colour  = 0xff7733ccu;
+		language->string_colour     = 0xffcc3377u;
+		language->keyword_colour    = 0xff33cceeu;
+		language->type_colour       = 0xff55cceeu;
+		language->bracket_colour    = 0xffee5533u;
+		language->operator_colour   = 0xffeeaa33u;
+		language->number_colour     = 0xffee33aau;
+		language->lowercase_colour  = 0xffccccccu;
+		language->uppercase_colour  = 0xffeeeeeeu;
+		language->underscore_colour = 0xffaaaaaau;
+		language->register_colour   = 0xff5577aau;
+		language->extension_colour  = 0xff55aaccu;
+		language->fatal_colour      = 0xffcc7755u;
+	} else {
+		language->comment_colour    = colour_grey;
+		language->processor_colour  = colour_cyan;
+		language->character_colour  = colour_pink;
+		language->string_colour     = colour_pink;
+		language->keyword_colour    = colour_yellow;
+		language->type_colour       = colour_yellow;
+		language->bracket_colour    = colour_blue;
+		language->operator_colour   = colour_cyan;
+		language->number_colour     = colour_pink;
+		language->lowercase_colour  = colour_white;
+		language->uppercase_colour  = colour_white;
+		language->underscore_colour = colour_white;
+		language->register_colour   = colour_cyan;
+		language->extension_colour  = colour_yellow;
+		language->fatal_colour      = colour_red;
+		language->comment_effect    = effect_bold;
+		language->processor_effect  = effect_italic;
+		language->character_effect  = effect_bold;
+		language->string_effect     = effect_normal;
+		language->keyword_effect    = effect_bold;
+		language->type_effect       = effect_normal;
+		language->bracket_effect    = effect_bold;
+		language->operator_effect   = effect_normal;
+		language->number_effect     = effect_bold;
+		language->lowercase_effect  = effect_normal;
+		language->uppercase_effect  = effect_bold;
+		language->underscore_effect = effect_italic;
+		language->register_effect   = effect_italic;
+		language->extension_effect  = effect_italic;
+		language->fatal_effect      = effect_bold;
+	}
+
+	return (language);
+}
+
+static language_structure * language_deinitialize (language_structure * language) {
+	return (deallocate (language));
+}
+
+static procedure language_conditionally_select (language_structure * language, syntax_structure * syntax, natural select) {
+	if (syntax->count == 0) {
+		if ((select == file_type_c_source) || (select == file_type_c_header)) {
+			language_highlight_c (language, syntax);
+		} else if ((select == file_type_ada_sexy_body) || (select == file_type_ada_specification)) {
+			language_highlight_ada (language, syntax);
+		} else if ((select == file_type_cpp_source) || (select == file_type_cpp_header)) {
+			language_highlight_cpp (language, syntax);
+		} else if (select == file_type_flat_assembly) {
+			language_highlight_flat (language, syntax);
+		} else if (select == file_type_fortran_90_source) {
+			language_highlight_fortran (language, syntax);
+		} else if (select == file_type_pascal_source) {
+			language_highlight_pascal (language, syntax);
+		} else if (select == file_type_eax_assembly) {
+			language_highlight_eaxhla (language, syntax);
+		} else if (select == file_type_python_script) {
+			language_highlight_python (language, syntax);
+		} else {
+			language_highlight_common (language, syntax);
+		}
+	}
+}
diff --git a/xighlight.c b/xighlight.c
new file mode 100644
index 0000000..3faa370
--- /dev/null
+++ b/xighlight.c
@@ -0,0 +1,123 @@
+///       _       _     _ _       _     _
+/// __  _(_) __ _| |__ | (_) __ _| |__ | |_
+/// \ \/ / |/ _` | '_ \| | |/ _` | '_ \| __|
+///  >  <| | (_| | | | | | | (_| | | | | |_
+/// /_/\_\_|\__, |_| |_|_|_|\__, |_| |_|\__|
+///         |___/           |___/
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xighlight - Generic source code terminal highlighter using VT100 escape sequences, very very slow...
+///
+/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
+/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
+///
+/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
+/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
+/// for more details, if you dare, it is a lot of text that nobody wants to read...
+
+#include "xtandard.h"
+#include "xyntax.h"
+#include "xanguage.h"
+
+static procedure conditionally_exit (language_structure * language, syntax_structure * syntax, boolean terminate) {
+	syntax   = syntax_deinitialize   (syntax);
+	language = language_deinitialize (language);
+
+	if (terminate == true) {
+		exit (log_success);
+	}
+}
+
+static procedure print_common (none) {
+	print ("/B/4xighlight/-: /4Terminal syntax highlighter/-\n\n");
+	print ("\tAuthor:  /4Ognjen 'xolatile' Milan Robovic/-\n");
+	print ("\tLicense: /4GNU//GPLv3/-\n\n");
+}
+
+static procedure print_help (none) {
+	print_common ();
+
+	print ("Example usage:\n\n");
+	print ("\t/6$ cat file.ext | xighlight [flags]/- /0---/- You need to pass language flag in this case.\n");
+	print ("\t/6$ xighlight [flags] < file.ext/-     /0---/- You need to pass language flag in this case.\n");
+	print ("\t/6$ xighlight file.ext/-               /0---/- Language is automatically detected in this case.\n\n");
+	print ("Supported languages:\n\n");
+
+	for (language_enumeration index = 0; index < language_count; ++index) {
+		character align [32] = "";
+
+		print ("\t/B/4%s/- /4%s/- /0---/- %s syntax highlighting\n",
+		       language_short_option [index],
+		       string_align_left (string_copy (align, language_long_option [index]), 9, ' '),
+		       language_identifier [index]);
+	}
+}
+
+static procedure print_version (none) {
+	print_common ();
+
+	print ("\tVersion: /40 (Zero)/-\n");
+}
+
+integer main (integer argc, character * * argv) {
+	natural     select = language_count;
+	natural     length = 0;
+	character * buffer = null;
+
+	syntax_structure   * syntax   = syntax_initialize   (360);
+	language_structure * language = language_initialize (false);
+
+	for (integer argument = 1; argument < argc; ++argument) {
+		if (argument_compare (argv [argument], "-h", "--help") == true) {
+			print_help         ();
+			conditionally_exit (language, syntax, true);
+		} else if (argument_compare (argv [argument], "-v", "--version") == true) {
+			print_version      ();
+			conditionally_exit (language, syntax, true);
+		}
+
+		for (natural index = 0; index < language_count; ++index) {
+			if (argument_compare (argv [argument], language_short_option [index], language_long_option [index]) == true) {
+				(* (language_highlighter [index])) (language, syntax);
+				select = index;
+				break;
+			}
+		}
+
+		if (file_exists (argv [argument]) == true) {
+			if (select == language_count) {
+				select = (natural) file_type (argv [argument]);
+			}
+			if (buffer == null) {
+				buffer = file_import (argv [argument]);
+			}
+		}
+	}
+
+	if (buffer == null) {
+		buffer = record ();
+	}
+
+	language_conditionally_select (language, syntax, select);
+
+	for (natural offset = 0; buffer [offset] != '\0'; offset += length) {
+		select = syntax_select (syntax, & buffer [offset], & length);
+
+		if (select >= syntax->count) {
+			echo_colour (colour_white, effect_normal);
+		} else {
+			echo_colour (syntax->colour [select], syntax->effect [select]);
+		}
+
+		output (& buffer [offset], length);
+
+		echo_cancel ();
+	}
+
+	conditionally_exit (language, syntax, false);
+
+	buffer = deallocate (buffer);
+
+	return (log_success);
+}
diff --git a/xtandard.h b/xtandard.h
new file mode 100644
index 0000000..b4d592c
--- /dev/null
+++ b/xtandard.h
@@ -0,0 +1,1238 @@
+///       _                  _               _
+///      | |                | |             | |
+/// __  _| |_ __ _ _ __   __| | __ _ _ __ __| |
+/// \ \/ / __/ _` | '_ \ / _` |/ _` | '__/ _` |
+///  >  <| || (_| | | | | (_| | (_| | | | (_| |
+/// /_/\_\\__\__,_|_| |_|\__,_|\__,_|_|  \__,_|
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xtandard - Tiny, safe and somewhat sane unity header for what GNU/Linux already provides.
+///
+/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
+/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
+///
+/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
+/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
+/// for more details, if you dare, it is a lot of text that nobody wants to read...
+
+#define _GNU_SOURCE
+
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <time.h>
+#include <dirent.h>
+
+#define null ((generic *) 0)
+
+#define standard_input  (STDIN_FILENO)
+#define standard_output (STDOUT_FILENO)
+#define standard_error  (STDERR_FILENO)
+
+#define file_flag_read     (O_RDONLY)
+#define file_flag_write    (O_WRONLY)
+#define file_flag_edit     (O_RDWR)
+#define file_flag_create   (O_CREAT)
+#define file_flag_append   (O_APPEND)
+#define file_flag_truncate (O_TRUNC)
+
+#define file_seek_current (SEEK_CUR)
+#define file_seek_set     (SEEK_SET)
+#define file_seek_end     (SEEK_END)
+
+#define pstring_length (256)
+
+#define echo(text) output ((text), sizeof ((text)) - 1)
+
+#define maximum(x, y) (((x) > (y)) ? (x) : (y))
+#define minimum(x, y) (((x) < (y)) ? (x) : (y))
+
+#define array_length(array) (sizeof ((array)) / sizeof (* (array)))
+
+typedef void  procedure;
+typedef void  none;
+typedef void  generic;
+typedef char  character;
+typedef float real;
+
+typedef signed   int integer;
+typedef unsigned int natural;
+
+typedef float  real_32;
+typedef double real_64;
+
+typedef signed char  integer_8;
+typedef signed short integer_16;
+typedef signed int   integer_32;
+typedef signed long  integer_64;
+
+typedef unsigned char  natural_8;
+typedef unsigned short natural_16;
+typedef unsigned int   natural_32;
+typedef unsigned long  natural_64;
+
+typedef char pstring [pstring_length];
+
+typedef enum {
+	false,
+	true
+} boolean;
+
+typedef enum {
+	log_success,                    log_warning,                    log_failure,                    log_comment,
+	log_count
+} log_enumeration;
+
+typedef enum {
+	file_type_c_source,             file_type_c_header,             file_type_ada_sexy_body,        file_type_ada_specification,
+	file_type_cpp_source,           file_type_cpp_header,           file_type_fortran_90_source,    file_type_fortran_90_module,
+	file_type_pascal_source,        file_type_d_source,             file_type_go_source,            file_type_jai_source,
+	file_type_assembly,             file_type_eax_assembly,         file_type_gnu_assembly,         file_type_flat_assembly,
+	file_type_haskell_script,       file_type_perl_script,          file_type_cube_script,          file_type_lua_script,
+	file_type_shell_script,         file_type_python_script,        file_type_tcl_script,           file_type_forth_source,
+	file_type_text,                 file_type_markdown,             file_type_html,                 file_type_glsl,
+	file_type_xrocessor,            file_type_xhla,                 file_type_xcript,               file_type_xocument,
+	file_type_xiri,                 file_type_xofya,                file_type_xienna,               file_type_xenka,
+	file_type_xiyagi,               file_type_xoule,                file_type_xikoku,               file_type_xdo,
+	file_type_png_image,            file_type_jxl_image,            file_type_jpg_image,            file_type_tga_image,
+	file_type_wav_sound,            file_type_ogg_sound,            file_type_flac_sound,           file_type_mp3_sound,
+	file_type_obj_model,            file_type_iqm_model,            file_type_md5_model,            file_type_ply_model,
+	file_type_elf_object,           file_type_spir_v_bytecode,
+	file_type_count
+} file_type_enumeration;
+
+typedef enum {
+	effect_normal,                  effect_bold,                    effect_italic,                  effect_undefined_code,
+	effect_underline,               effect_blink,                   effect_reverse,                 effect_invisible_text,
+	effect_count
+} effect_enumeration;
+
+typedef enum {
+	colour_grey,                    colour_red,                     colour_green,                   colour_yellow,
+	colour_blue,                    colour_pink,                    colour_cyan,                    colour_white,
+	colour_count
+} colour_enumeration;
+
+typedef enum {
+	character_null,                 character_start_header,         character_start_text,           character_end_text,
+	character_end_transmission,     character_enquiry,              character_acknowledge,          character_bell,
+	character_backspace,            character_tab_horizontal,       character_line_feed,            character_tab_vertical,
+	character_form_feed,            character_carriage_return,      character_shift_out,            character_shift_in,
+	character_data_link_escape,     character_device_control_1,     character_device_control_2,     character_device_control_3,
+	character_device_control_4,     character_not_acknowledge,      character_synchronous_idle,     character_end_transmission_block,
+	character_cancel,               character_end_medium,           character_substitute,           character_escape,
+	character_file_separator,       character_group_separator,      character_record_separator,     character_unit_separator
+} character_enumeration;
+
+typedef enum {
+	cursor_none,
+	cursor_left,                    cursor_middle,                  cursor_right,
+	cursor_wheel_up,                cursor_wheel_down,
+	cursor_count
+} cursor_enumeration;
+
+typedef enum {
+	signal_none,
+	signal_a,                       signal_b,                       signal_c,                       signal_d,
+	signal_e,                       signal_f,                       signal_g,                       signal_h,
+	signal_i,                       signal_j,                       signal_k,                       signal_l,
+	signal_m,                       signal_n,                       signal_o,                       signal_p,
+	signal_q,                       signal_r,                       signal_s,                       signal_t,
+	signal_u,                       signal_v,                       signal_w,                       signal_x,
+	signal_y,                       signal_z,                       signal_0,                       signal_1,
+	signal_2,                       signal_3,                       signal_4,                       signal_5,
+	signal_6,                       signal_7,                       signal_8,                       signal_9,
+	signal_escape,                  signal_tabulator,               signal_return,                  signal_new_line,
+	signal_slash,                   signal_backslash,               signal_semicolon,               signal_backquote,
+	signal_space,                   signal_backspace,               signal_dot,                     signal_comma,
+	signal_cite,                    signal_caps_lock,               signal_minus,                   signal_equal,
+	signal_left_bracket,            signal_right_bracket,           signal_left_control,            signal_right_control,
+	signal_left_shift,              signal_right_shift,             signal_left_alt,                signal_right_alt,
+	signal_f1,                      signal_f2,                      signal_f3,                      signal_f4,
+	signal_f5,                      signal_f6,                      signal_f7,                      signal_f8,
+	signal_f9,                      signal_f10,                     signal_f11,                     signal_f12,
+	signal_arrow_up,                signal_arrow_down,              signal_arrow_left,              signal_arrow_right,
+	signal_num_lock,                signal_pause_break,             signal_insert,                  signal_home,
+	signal_page_up,                 signal_delete,                  signal_end,                     signal_page_down,
+	signal_key_add,                 signal_key_subtract,            signal_key_multiply,            signal_key_divide,
+	signal_key_enter,               signal_key_dot,                 signal_key_0,                   signal_key_1,
+	signal_key_2,                   signal_key_3,                   signal_key_4,                   signal_key_5,
+	signal_key_6,                   signal_key_7,                   signal_key_8,                   signal_key_9,
+	signal_count
+} signal_enumeration;
+
+static character * cursor_name [cursor_count] = {
+	"---",
+	"Left button",                  "Middle button",                "Right button",
+	"Scroll up",                    "Scroll down"
+
+};
+
+static character * signal_name [signal_count] = {
+	"---",
+	"A",                            "B",                            "C",                            "D",
+	"E",                            "F",                            "G",                            "H",
+	"I",                            "J",                            "K",                            "L",
+	"M",                            "N",                            "O",                            "P",
+	"Q",                            "R",                            "S",                            "T",
+	"U",                            "V",                            "W",                            "X",
+	"Y",                            "Z",                            "0",                            "1",
+	"2",                            "3",                            "4",                            "5",
+	"6",                            "7",                            "8",                            "9",
+	"Escape",                       "Tabulator",                    "Return",                       "New line",
+	"Slash",                        "Backslash",                    "Semicolon",                    "Backquote",
+	"Space",                        "Backspace",                    "Dot",                          "Comma",
+	"Cite",                         "Caps lock",                    "Minus",                        "Equal",
+	"Left bracket",                 "Right bracket",                "Left control",                 "Right control",
+	"Left shift",                   "Right shift",                  "Left alt",                     "Right alt",
+	"F1",                           "F2",                           "F3",                           "F4",
+	"F5",                           "F6",                           "F7",                           "F8",
+	"F9",                           "F10",                          "F11",                          "F12",
+	"Arrow up",                     "Arrow down",                   "Arrow left",                   "Arrow right",
+	"Num lock",                     "Pause break",                  "Insert",                       "Home",
+	"Page up",                      "Delete",                       "End",                          "Page down",
+	"Key add",                      "Key subtract",                 "Key multiply",                 "Key divide",
+	"Key enter",                    "Key dot",                      "Key 0",                        "Key 1",
+	"Key 2",                        "Key 3",                        "Key 4",                        "Key 5",
+	"Key 6",                        "Key 7",                        "Key 8",                        "Key 9"
+};
+
+static procedure random_integer_seed_by_time (none) {
+	srand ((natural) time (null));
+}
+
+static integer random_integer (integer from, integer to) {
+	return (rand () % (to - from + 1) + from);
+}
+
+static natural random_natural (natural from, natural to) {
+	return ((natural) rand () % (to - from + 1) + from);
+}
+
+static real random_real (real from, real to) {
+	return (((real) rand () / (real) RAND_MAX) * (to - from) + from);
+}
+
+static procedure input (generic * data, natural_64 size) {
+	read (standard_input, data, size);
+}
+
+static procedure output (generic * data, natural_64 size) {
+	write (standard_output, data, size);
+}
+
+static procedure clean_up (procedure (* procedure_pointer) (none)) {
+	atexit (procedure_pointer);
+}
+
+#ifdef use_fatal_failure
+static procedure fatal_failure (boolean condition, character * message) {
+	if (condition == true) {
+		echo ("[\x1b[1;31m FATAL \x1b[0m] ");
+
+		for (integer index = 0; message [index] != '\0'; ++index) {
+			output (& message [index], 1);
+		}
+
+		echo ("\n");
+
+		exit (log_failure);
+	}
+}
+#else
+#define fatal_failure(...)
+#endif
+
+static procedure execute (character * command) {
+	integer status = 0;
+
+	system (command);
+
+	fatal_failure (status != 0, "execute: System returned an error code.");
+}
+
+static natural tick_tock (none) {
+	return ((natural) clock ());
+}
+
+static natural_64 nano_time (none) {
+	struct timespec time = { 0 };
+
+	natural_64 result = 0;
+
+	clock_gettime (CLOCK_MONOTONIC, & time);
+
+	result = 1000000000ul * (natural_64) time.tv_sec + (natural_64) time.tv_nsec;
+
+	return (result);
+}
+
+static procedure nano_wait (natural_64 time) {
+	struct timespec wait = {
+		time / 1000000000,
+		time % 1000000000
+	};
+
+	while (nanosleep (& wait, null)) continue;
+}
+
+static procedure exchange_integer (integer * a, integer * b) { integer c = * a; * a = * b; * b = c; }
+static procedure exchange_natural (natural * a, natural * b) { natural c = * a; * a = * b; * b = c; }
+static procedure exchange_real    (real    * a, real    * b) { real    c = * a; * a = * b; * b = c; }
+
+static procedure clamp_integer (integer * x, integer lower, integer upper) { if (* x < lower) * x = lower; if (* x > upper) * x = upper; }
+static procedure clamp_natural (natural * x, natural lower, natural upper) { if (* x < lower) * x = lower; if (* x > upper) * x = upper; }
+static procedure clamp_real    (real    * x, real    lower, real    upper) { if (* x < lower) * x = lower; if (* x > upper) * x = upper; }
+
+static real normal_r (natural colour) { return ((real) ((colour >> 24) & 0xff) / 255.0f); }
+static real normal_g (natural colour) { return ((real) ((colour >> 16) & 0xff) / 255.0f); }
+static real normal_b (natural colour) { return ((real) ((colour >>  8) & 0xff) / 255.0f); }
+static real normal_a (natural colour) { return ((real) ((colour >>  0) & 0xff) / 255.0f); }
+
+static natural channel_r (natural colour) { return ((colour >> 24) & 0xff); }
+static natural channel_g (natural colour) { return ((colour >> 16) & 0xff); }
+static natural channel_b (natural colour) { return ((colour >>  8) & 0xff); }
+static natural channel_a (natural colour) { return ((colour >>  0) & 0xff); }
+
+static natural colour_channel_reverse (natural colour) {
+	natural r = channel_r (colour);
+	natural g = channel_g (colour);
+	natural b = channel_b (colour);
+	natural a = channel_a (colour);
+
+	return ((a << 24) | (b << 16) | (g << 8) | (r << 0));
+}
+
+static natural colour_linear_interpolation (natural colour_a, natural colour_b, real scale) {
+	if (scale <= 0.0f) {
+		return (colour_a);
+	}
+
+	if (scale >= 1.0f) {
+		return (colour_b);
+	}
+
+	natural r = (natural) ((1.0f - scale) * channel_r (colour_a) + scale * channel_r (colour_b));
+	natural g = (natural) ((1.0f - scale) * channel_g (colour_a) + scale * channel_g (colour_b));
+	natural b = (natural) ((1.0f - scale) * channel_b (colour_a) + scale * channel_b (colour_b));
+	natural a = (natural) ((1.0f - scale) * channel_a (colour_a) + scale * channel_a (colour_b));
+
+	return ((r << 24) | (g << 16) | (b << 8) | (a << 0));
+}
+
+static generic * allocate (natural_64 size) {
+	character * data = null;
+
+	fatal_failure (size <= 0, "allocate: Size is equal or below zero.");
+
+	data = calloc (size, sizeof (* data));
+
+	fatal_failure (data == null, "allocate: Function 'calloc' returned null pointer.");
+
+	return (data);
+}
+
+static generic * reallocate (generic * data, natural_64 size) {
+	fatal_failure (size <= 0, "reallocate: Size is equal or below zero.");
+
+	data = realloc (data, size);
+
+	fatal_failure (data == null, "reallocate: Function 'realloc' returned null pointer.");
+
+	return (data);
+}
+
+static generic * deallocate (generic * data) {
+	fatal_failure (data == null, "deallocate: Data is null pointer.");
+
+	free (data);
+
+	return (null);
+}
+
+static generic * record (none) {
+	character  * buffer = null;
+	natural_64   offset = 0;
+	natural_64   memory = 64 * 1024;
+
+	buffer = reallocate (buffer, memory);
+
+	do {
+		if ((offset + 1) % memory == 0) {
+			buffer = reallocate (buffer, ((offset + 1) / memory + 1) * memory);
+		}
+
+		buffer [offset] = '\0';
+
+		input (& buffer [offset], sizeof (* buffer));
+
+		++offset;
+	} while (buffer [offset - 1] != '\0');
+
+	buffer [offset - 1] = '\0';
+
+	return (buffer);
+}
+
+static boolean character_compare_array (character c, character * character_array) {
+	for (natural_64 index = 0; character_array [index] != '\0'; ++index) {
+		if (c == character_array [index]) {
+			return (true);
+		}
+	}
+
+	return (false);
+}
+
+static boolean character_is_uppercase (character c) {
+	return ((c >= 'A') && (c <= 'Z'));
+}
+
+static boolean character_is_lowercase (character c) {
+	return ((c >= 'a') && (c <= 'z'));
+}
+
+static boolean character_is_digit (character c) {
+	return ((c >= '0') && (c <= '9'));
+}
+
+static boolean character_is_letter (character c) {
+	return (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')));
+}
+
+static boolean character_is_blank (character c) {
+	return ((c == ' ') || (c == '\t') || (c == '\r') || (c == '\n'));
+}
+
+static boolean character_is_symbol (character c) {
+	return (((c >= '!') && (c <= '/')) || ((c >= ':') && (c <= '@')) || ((c >= '[') && (c <= '`')) || ((c >= '{') && (c <= '~')));
+}
+
+static boolean character_is_separator (character c) {
+	return ((c != '_') && ((character_is_blank (c) == true) || (character_is_symbol (c) == true)));
+}
+
+static boolean character_is_identifier (character c) {
+	return ((c == '_') || (character_is_letter (c) == true) || (character_is_digit (c) == true));
+}
+
+static boolean character_is_visible (character c) {
+	return ((c >= '!') && (c <= '~'));
+}
+
+static boolean character_is_invisible (character c) {
+	return (character_is_visible (c) == false);
+}
+
+static character * capitalize (character * string) {
+	fatal_failure (string == null, "capitalize: String is null pointer.");
+
+	string [0] -= (character_is_lowercase (string [0]) == true) ? ' ' : '\0';
+
+	return (string);
+}
+
+static character * uppercase (character * string) {
+	fatal_failure (string == null, "uppercase: String is null pointer.");
+
+	for (natural index = 0; string [index] != '\0'; ++index) {
+		string [index] += (character_is_lowercase (string [index]) == true) ? ' ' : '\0';
+	}
+
+	return (string);
+}
+
+static character * lowercase (character * string) {
+	fatal_failure (string == null, "lowercase: String is null pointer.");
+
+	for (natural index = 0; string [index] != '\0'; ++index) {
+		string [index] -= (character_is_uppercase (string [index]) == true) ? ' ' : '\0';
+	}
+
+	return (string);
+}
+
+static natural_64 string_length (character * string) {
+	natural_64 length = 0;
+
+	fatal_failure (string == null, "string_length: String is null pointer.");
+
+	for (length = 0; string [length] != '\0'; ++length);
+
+	return (length);
+}
+
+static character * string_nullify (character * destination, natural_64 length) {
+	fatal_failure (destination == null, "string_reverse_limit: Destination string is null pointer.");
+	fatal_failure (length      <= 0,    "string_reverse_limit: Length is equal or below zero.");
+
+	for (natural_64 index = 0; index < length; ++index) {
+		destination [index] = '\0';
+	}
+
+	return (destination);
+}
+
+static character * string_reverse_limit (character * destination, natural_64 limit) {
+	fatal_failure (destination == null, "string_reverse_limit: Destination string is null pointer.");
+	fatal_failure (limit       <= 0,    "string_reverse_limit: Limit is equal or below zero.");
+
+	for (natural_64 index = 0; index < limit / 2; ++index) {
+		character temporary = destination [index];
+
+		destination [index]             = destination [limit - 1 - index];
+		destination [limit - 1 - index] = temporary;
+	}
+
+	return (destination);
+}
+
+static character * string_reverse (character * destination) {
+	return (string_reverse_limit (destination, string_length (destination)));
+}
+
+static boolean string_compare_limit (character * string_a, character * string_b, natural_64 limit) {
+	fatal_failure (string_a == null, "string_compare_limit: First source string is null pointer.");
+	fatal_failure (string_b == null, "string_compare_limit: Second source string is null pointer.");
+	fatal_failure (limit    <= 0,    "string_compare_limit: Limit is equal or below zero.");
+
+	for (natural_64 index = 0; index < limit; ++index) {
+		if (string_a [index] != string_b [index]) {
+			return (false);
+		}
+	}
+
+	return (true);
+}
+
+static boolean string_compare (character * string_a, character * string_b) {
+	return (string_compare_limit (string_a, string_b, string_length (string_a) + 1));
+}
+
+static character * string_copy_limit (character * destination, character * source, natural_64 limit) {
+	fatal_failure (destination == null, "string_copy_limit: Destination string is null pointer.");
+	fatal_failure (source      == null, "string_copy_limit: Source string is null pointer.");
+	fatal_failure (limit       <= 0,    "string_copy_limit: Limit is equal or below zero.");
+
+	for (natural_64 index = 0; index < limit; ++index) {
+		destination [index] = source [index];
+	}
+
+	return (destination);
+}
+
+static character * string_copy (character * destination, character * source) {
+	return (string_copy_limit (destination, source, string_length (source) + 1));
+}
+
+static character * string_concatenate_limit (character * destination, character * source, natural_64 limit) {
+	natural_64 offset = string_length (destination);
+
+	fatal_failure (destination == null, "string_concatenate_limit: Destination string is null pointer.");
+	fatal_failure (source      == null, "string_concatenate_limit: Source string is null pointer.");
+	fatal_failure (limit       <= 0,    "string_concatenate_limit: Limit is equal or below zero.");
+
+	for (natural_64 index = 0; index < limit; ++index) {
+		destination [offset + index] = source [index];
+	}
+
+	return (destination);
+}
+
+static character * string_concatenate (character * destination, character * source) {
+	return (string_concatenate_limit (destination, source, string_length (source) + 1));
+}
+
+static character * string_duplicate (character * source) {
+	character * duplicate = allocate ((string_length (source) + 1) * sizeof (* duplicate));
+
+	string_copy (duplicate, source);
+
+	return (duplicate);
+}
+
+static character * string_duplicate_limit (character * source, natural limit) {
+	character * duplicate = allocate ((limit + 1) * sizeof (* duplicate));
+
+	string_copy_limit (duplicate, source, limit);
+
+	return (duplicate);
+}
+
+static character * string_align_left (character * destination, natural_64 amount, character with) {
+	for (natural_64 offset = string_length (destination); offset < amount; ++offset) {
+		destination [offset] = with;
+	}
+
+	destination [amount] = '\0';
+
+	return (destination);
+}
+
+static character * string_remove_extension (character * destination) {
+	natural_64 length = string_length (destination);
+
+	for (--length; destination [length] != '.'; --length);
+
+	destination [length] = '\0';
+
+	return (destination);
+}
+
+static procedure memory_nullify (generic * memory, natural_64 size) {
+	character * cast = (character *) memory;
+
+	fatal_failure (memory == null, "memory_nullify: Memory is null pointer.");
+
+	for (natural_64 offset = 0; offset < size; ++offset) {
+		cast [offset] = (character) 0;
+	}
+}
+
+static integer memory_compare (generic * memory_0, generic * memory_1, natural_64 size) {
+	character * cast_0 = (character *) memory_0;
+	character * cast_1 = (character *) memory_1;
+
+	fatal_failure (memory_0 == null, "memory_compare: Memory is null pointer.");
+	fatal_failure (memory_1 == null, "memory_compare: Source is null pointer.");
+
+	for (natural_64 offset = 0; offset < size; ++offset) {
+		if (cast_0 [offset] != cast_1 [offset]) {
+			return (false);
+		}
+	}
+
+	return (true);
+}
+
+static procedure memory_copy (generic * destination, generic * source, natural_64 size) {
+	      character * cast_0 = (      character *) destination;
+	character * cast_1 = (character *) source;
+
+	fatal_failure (destination == null, "memory_copy: Destination is null pointer.");
+	fatal_failure (source      == null, "memory_copy: Source is null pointer.");
+
+	for (natural_64 offset = 0; offset < size; ++offset) {
+		cast_0 [offset] = cast_1 [offset];
+	}
+}
+
+static procedure echo_clear (none) {
+	echo ("\033[2J\033[H");
+}
+
+static procedure echo_colour (colour_enumeration colour, effect_enumeration effect) {
+	character format [8] = "\033[ ;3 m";
+
+	format [2] = (character) (effect % effect_count) + '0';
+	format [5] = (character) (colour % colour_count) + '0';
+
+	echo (format);
+}
+
+static procedure echo_cancel (none) {
+	echo ("\033[0m");
+}
+
+static procedure show_cursor (boolean show) {
+	if (show == true) {
+		echo ("\033[?25h");
+	} else {
+		echo ("\033[?25l");
+	}
+}
+
+static integer file_open (character * path, integer mode) {
+	fatal_failure (path == null, "file_open: File path is null pointer.");
+
+	return (open (path, mode, 0777));
+}
+
+static integer file_close (integer file) {
+	fatal_failure (file == -1, "file_close: Invalid file descriptor.");
+
+	close (file);
+
+	return (-1);
+}
+
+static procedure file_read (integer file, generic * data, natural_64 size) {
+	fatal_failure (file <= -1,   "file_read: File descriptor is closed or invalid.");
+	fatal_failure (data == null, "file_read: Data is null pointer.");
+	fatal_failure (size == 0,    "file_read: Size is zero.");
+
+	read (file, data, size);
+}
+
+static procedure file_write (integer file, generic * data, natural_64 size) {
+	fatal_failure (file <= -1,   "file_write: File descriptor is closed or invalid.");
+	fatal_failure (data == null, "file_write: Data is null pointer.");
+	fatal_failure (size == 0,    "file_write: Size is zero.");
+
+	write (file, data, size);
+}
+
+static procedure file_echo (integer file, character * data) {
+	file_write (file, data, string_length (data));
+}
+
+static natural_64 file_seek (integer file, integer whence) {
+	fatal_failure (file == -1, "file_seek: Invalid file descriptor.");
+
+	return ((natural_64) lseek (file, 0, whence));
+}
+
+static natural_64 file_size (character * path) {
+	struct stat data = { 0 };
+
+	fatal_failure (path == null, "file_size: File path is null pointer.");
+
+	lstat (path, & data);
+
+	return ((natural_64) data.st_size);
+}
+
+static boolean file_exists (character * path) {
+	fatal_failure (path == null, "file_record: File path is null pointer.");
+
+	return ((access (path, F_OK) == 0) ? true : false);
+}
+
+static file_type_enumeration file_type (character * path) {
+	character * extensions [file_type_count] = {
+		".c",           ".h",           ".adb",         ".ads",         ".cpp",         ".hpp",         ".f90",         ".mod",
+		".pas",         ".d",           ".go",          ".jai",         ".asm",         ".eax",         ".gas",         ".fasm",
+		".hs",          ".el",          ".cfg",         ".lua",         ".sh",          ".py",          ".tcl",         ".4th",
+		".txt",         ".md",          ".html",        ".glsl",        ".x",           ".xhla",        ".xs",          ".xd",
+		".xiri",        ".xofya",       ".xienna",      ".xenka",       ".xiyagi",      ".xoule",       ".xikoku",      ".xdo",
+		".png",         ".jxl",         ".jpg",         ".tga",         ".wav",         ".ogg",         ".flac",        ".mp3",
+		".obj",         ".iqm",         ".md5",         ".ply",         ".o",           ".spv"
+	};
+
+	natural cut_at = 0;
+
+	fatal_failure ((path == null) || (* path == '\0'), "file_type: File path is null pointer.");
+
+	for (cut_at = string_length (path) - 1; cut_at != 0; --cut_at) {
+		if (path [cut_at] == '.') break;
+	}
+
+	for (file_type_enumeration type = 0; type != file_type_count; ++type) {
+		if (string_compare (& path [cut_at], extensions [type])) {
+			return (type);
+		}
+	}
+
+	return (file_type_count);
+}
+
+static procedure file_remove (character * path) {
+	unlink (path);
+}
+
+static generic * file_record (character * path) {
+	integer      file = -1;
+	natural_64   size = 0;
+	character  * data = null;
+
+	fatal_failure (path == null, "file_record: File path is null pointer.");
+
+	file = file_open (path, file_flag_read);
+	size = file_size (path);
+	data = allocate  (size);
+
+	file_read (file, data, size);
+
+	file = file_close (file);
+
+	return (data);
+}
+
+static character * file_import (character * path) {
+	integer      file = -1;
+	natural_64   size = 0;
+	character  * data = null;
+
+	fatal_failure (path == null, "file_import: File path is null pointer.");
+
+	file = file_open (path, file_flag_edit);
+	size = file_size (path) + 1;
+	data = allocate  (size);
+
+	file_read (file, data, size - 1);
+
+	data [size - 1] = '\0';
+
+	file = file_close (file);
+
+	return (data);
+}
+
+static procedure file_export (character * path, character * data) {
+	integer file = -1;
+
+	fatal_failure (path == null, "file_export: File path is null pointer.");
+	fatal_failure (data == null, "file_export: Data is null pointer.");
+
+	file = file_open (path, file_flag_write | file_flag_create | file_flag_truncate);
+
+	file_write (file, data, string_length (data));
+
+	file = file_close (file);
+}
+
+static generic * folder_open (character * path) {
+	DIR * folder = null;
+
+	fatal_failure (path == null, "folder_open: Folder path is null pointer.");
+
+	folder = opendir (path);
+
+	return ((generic *) folder);
+}
+
+static character * folder_read (generic * handle) {
+	struct dirent * file = null;
+
+	DIR * folder = (DIR *) handle;
+
+	fatal_failure (handle == null, "folder_read: Folder handle is null pointer.");
+
+	file = readdir (folder);
+
+	if (file == null) {
+		return (null);
+	} else {
+		return (file->d_name);
+	}
+}
+
+static generic * folder_close (generic * handle) {
+	DIR * folder = (DIR *) handle;
+
+	fatal_failure (handle == null, "folder_read: Folder handle is null pointer.");
+
+	closedir (folder);
+
+	return (null);
+}
+
+static character * * folder_create_path_list (character * folder, natural * path_count, boolean sort) {
+	procedure   * handle     = null;
+	character * * path_array = 0;
+
+	(none) sort;
+
+	fatal_failure (folder     == null, "folder_create_path_list: Folder handle is null pointer.");
+	fatal_failure (path_count == null, "folder_create_path_list: Path count address is null pointer.");
+
+	handle = folder_open (folder);
+
+	for (character * path = folder_read (handle); path != null; path = folder_read (handle)) {
+		if (path [0] != '.') {
+			(* path_count) += 1;
+
+			path_array = reallocate (path_array, (* path_count) * sizeof (* path_array));
+
+			path_array [(* path_count) - 1] = allocate ((string_length (path) + 1) * sizeof (* * path_array));
+
+			string_copy (path_array [(* path_count) - 1], path);
+		}
+	}
+
+	handle = folder_close (handle);
+
+	return (path_array);
+}
+
+static character * * folder_remove_path_list (character * * path_array, natural path_count) {
+	for (natural index = 0; index < path_count; ++index) {
+		path_array [index] = deallocate (path_array [index]);
+	}
+
+	return (deallocate (path_array));
+}
+
+static character * configuration_format (character * path) {
+	static character buffer [512] = "";
+
+	string_copy (buffer, getenv ("HOME"));
+	string_concatenate (buffer, "/.config/xolatile/");
+	string_concatenate (buffer, path);
+
+	return (buffer);
+}
+
+static boolean configuration_exists (character * path) {
+	return (file_exists (configuration_format (path)));
+}
+
+static procedure configuration_remove (character * path) {
+	file_remove (configuration_format (path));
+}
+
+static character * configuration_import (character * path) {
+	return (file_import (configuration_format (path)));
+}
+
+static procedure configuration_export (character * path, character * data) {
+	file_export (configuration_format (path), data);
+}
+
+static boolean argument_compare (character * argument, character * short_option, character * long_option) {
+	return ((string_compare (argument, short_option) == true) || (string_compare (argument, long_option) == true));
+}
+
+static natural string_full_width (character * string, natural tab_width) {
+	natural width = 0;
+	natural count = 0;
+
+	do {
+		if (* string == '\t') {
+			count += tab_width;
+		} else if (* string == '\n') {
+			width = (++count > width) ? count : width;
+			count = 0;
+		} else {
+			++count;
+		}
+	} while (* (++string) != '\0');
+
+	return (width - 1);
+}
+
+static natural string_full_height (character * string) {
+	natural height = 0;
+
+	do {
+		if (* string == '\n') {
+			++height;
+		}
+	} while (* (++string) != '\0');
+
+	return (height + 1);
+}
+
+static natural string_limit_to_number (character * string, natural limit) {
+	natural number = 0;
+
+	for (natural index = 0; (string [index] != '\0') && (index < limit); ++index) {
+		number *= 10;
+		number += (natural) (string [index] - '0');
+	}
+
+	return (number);
+}
+
+static natural string_to_number (character * string) {
+	return (string_limit_to_number (string, string_length (string)));
+}
+
+static character * number_to_string (integer number) {
+	static character string [34] = "";
+
+	natural index = 0;
+	boolean sign  = false;
+
+	string_nullify (string, sizeof (string));
+
+	if (number == 0) {
+		string [0] = '0';
+		string [1] = '\0';
+		return (string);
+	}
+
+	if (number < 0) {
+		number *= -1;
+		sign = true;
+	} else {
+		sign = false;
+	}
+
+	for (index = 0; (number != 0) && (index < (natural) sizeof (string) - 1); ++index) {
+		string [index] = (character) (number % 10) + '0';
+		number /= 10;
+	}
+
+	if (sign == true) {
+		string [index] = '-';
+		++index;
+	}
+
+	string [index] = '\0';
+
+	string_reverse (string);
+
+	return (string);
+}
+
+static character * format_to_string (integer number, boolean sign, natural base, natural_64 amount, character with) {
+	static character string [36];
+
+	integer i;
+
+	string_nullify (string, sizeof (string));
+
+	if (number == 0) {
+		string [0] = '0';
+		string [1] = '\0';
+
+		string_align_left (string, amount, with);
+
+		return (string);
+	}
+
+	if (number < 0) {
+		number *= -1;
+	}
+
+	for (i = (string [0] == '-'); number != 0; ++i) {
+		string [i] = "0123456789ABCDEF" [number % base];
+		number /= base;
+	}
+
+	if (sign == true) {
+		string [i] = '-';
+		++i;
+	}
+
+	string [i] = '\0';
+
+	string_reverse (string);
+
+	string_align_left (string, amount, with);
+
+	return (string);
+}
+
+static character * format (character * base, ...) {
+	static character string [1024];
+
+	va_list list;
+
+	string_nullify (string, 1024);
+
+	va_start (list, base);
+
+	for (; * base != character_null; ++base) {
+		switch (* base) {
+			case ('%'): {
+				++base;
+				switch (* base) {
+					case ('%'): string_concatenate (string, "%");                                        break;
+					case ('i'): string_concatenate (string, number_to_string (va_arg (list, integer)));  break;
+					case ('s'): string_concatenate (string, va_arg (list, character *));                 break;
+					default:    string_concatenate (string, "?");                                        break;
+				}
+			} break;
+			default: {
+				string_concatenate_limit (string, base, 1);
+			} break;
+		}
+	}
+
+	va_end (list);
+
+	return (string);
+}
+
+static procedure print (character * format, ...) {
+	va_list list;
+
+	va_start (list, format);
+
+	for (; * format != character_null; ++format) {
+		switch (* format) {
+			case ('%'): {
+				++format;
+				switch (* format) {
+					case ('%'): {
+						output ("%", 1);
+					} break;
+					case ('i'): {
+						character * string = number_to_string (va_arg (list, integer));
+						output (string, string_length (string));
+					} break;
+					case ('f'): {
+						real data = (real) va_arg (list, real_64);
+						character * upper = number_to_string ((integer) data);
+						character * lower = number_to_string ((integer) (data * 1000.0f) % 1000);
+						output (upper, string_length (upper));
+						output (".", 1);
+						output (lower, string_length (lower));
+					} break;
+					case ('t'): {
+						integer data = (va_arg (list, integer));
+						echo_colour ((data == true) ? colour_green : colour_red, effect_normal);
+						output ((data == true) ? "+" : "-", 1);
+						echo_cancel ();
+					} break;
+					case ('b'): {
+						integer data = (va_arg (list, integer));
+						output ((data == true) ? "true" : "false", (data == true) ? 4 : 5);
+					} break;
+					case ('c'): {
+						character data = (character) va_arg (list, integer);
+						output (& data, 1);
+					} break;
+					case ('s'): {
+						character * data = va_arg (list, character *);
+						output (data, string_length (data));
+					} break;
+					default: {
+						output ("?", 1);
+					} break;
+				}
+			} break;
+			case ('/'): {
+				++format;
+				switch (* format) {
+					case ('/'): echo ("/");                          break;
+					case ('s'): echo ("[\x1b[1;32mSuccess\x1b[0m]"); break;
+					case ('f'): echo ("[\x1b[1;31mFailure\x1b[0m]"); break;
+					case ('w'): echo ("[\x1b[1;33mWarning\x1b[0m]"); break;
+					case ('c'): echo ("[\x1b[1;30mComment\x1b[0m]"); break;
+					case ('A'): echo ("\x1b[0m");                    break;
+					case ('B'): echo ("\x1b[1m");                    break;
+					case ('C'): echo ("\x1b[2m");                    break;
+					case ('D'): echo ("\x1b[3m");                    break;
+					case ('E'): echo ("\x1b[4m");                    break;
+					case ('F'): echo ("\x1b[5m");                    break;
+					case ('G'): echo ("\x1b[6m");                    break;
+					case ('H'): echo ("\x1b[7m");                    break;
+					case ('0'): echo ("\x1b[30m");                   break;
+					case ('1'): echo ("\x1b[31m");                   break;
+					case ('2'): echo ("\x1b[32m");                   break;
+					case ('3'): echo ("\x1b[33m");                   break;
+					case ('4'): echo ("\x1b[34m");                   break;
+					case ('5'): echo ("\x1b[35m");                   break;
+					case ('6'): echo ("\x1b[36m");                   break;
+					case ('7'): echo ("\x1b[37m");                   break;
+					case ('-'): echo ("\x1b[0m");                    break;
+					default:    echo ("?");                          break;
+				}
+			} break;
+			default: {
+				output (format, 1);
+			} break;
+		}
+	}
+
+	va_end (list);
+}
+
+static procedure conditional_print (boolean condition, character * format, ...) {
+	va_list list;
+
+	if (condition == false) return;
+
+	va_start (list, format);
+
+	for (; * format != character_null; ++format) {
+		switch (* format) {
+			case ('%'): {
+				++format;
+				switch (* format) {
+					case ('%'): {
+						output ("%", 1);
+					} break;
+					case ('i'): {
+						character * string = number_to_string (va_arg (list, integer));
+						output (string, string_length (string));
+					} break;
+					case ('f'): {
+						real data = (real) va_arg (list, real_64);
+						character * upper = number_to_string ((integer) data);
+						character * lower = number_to_string ((integer) (data * 1000.0f) % 1000);
+						output (upper, string_length (upper));
+						output (".", 1);
+						output (lower, string_length (lower));
+					} break;
+					case ('t'): {
+						integer data = (va_arg (list, integer));
+						echo_colour ((data == true) ? colour_green : colour_red, effect_normal);
+						output ((data == true) ? "+" : "-", 1);
+						echo_cancel ();
+					} break;
+					case ('b'): {
+						integer data = (va_arg (list, integer));
+						output ((data == true) ? "true" : "false", (data == true) ? 4 : 5);
+					} break;
+					case ('c'): {
+						character data = (character) va_arg (list, integer);
+						output (& data, 1);
+					} break;
+					case ('s'): {
+						character * data = va_arg (list, character *);
+						output (data, string_length (data));
+					} break;
+					default: {
+						output ("?", 1);
+					} break;
+				}
+			} break;
+			case ('/'): {
+				++format;
+				switch (* format) {
+					case ('/'): echo ("/");                          break;
+					case ('s'): echo ("[\x1b[1;32mSuccess\x1b[0m]"); break;
+					case ('f'): echo ("[\x1b[1;31mFailure\x1b[0m]"); break;
+					case ('w'): echo ("[\x1b[1;33mWarning\x1b[0m]"); break;
+					case ('c'): echo ("[\x1b[1;30mComment\x1b[0m]"); break;
+					case ('A'): echo ("\x1b[0m");                    break;
+					case ('B'): echo ("\x1b[1m");                    break;
+					case ('C'): echo ("\x1b[2m");                    break;
+					case ('D'): echo ("\x1b[3m");                    break;
+					case ('E'): echo ("\x1b[4m");                    break;
+					case ('F'): echo ("\x1b[5m");                    break;
+					case ('G'): echo ("\x1b[6m");                    break;
+					case ('H'): echo ("\x1b[7m");                    break;
+					case ('0'): echo ("\x1b[30m");                   break;
+					case ('1'): echo ("\x1b[31m");                   break;
+					case ('2'): echo ("\x1b[32m");                   break;
+					case ('3'): echo ("\x1b[33m");                   break;
+					case ('4'): echo ("\x1b[34m");                   break;
+					case ('5'): echo ("\x1b[35m");                   break;
+					case ('6'): echo ("\x1b[36m");                   break;
+					case ('7'): echo ("\x1b[37m");                   break;
+					case ('-'): echo ("\x1b[0m");                    break;
+					default:    echo ("?");                          break;
+				}
+			} break;
+			default: {
+				output (format, 1);
+			} break;
+		}
+	}
+
+	va_end (list);
+}
+
+#ifdef use_mathematics
+
+#include <math.h>
+
+#define pi (3.14159265f)
+
+static real sign        (real    x) { return ((x > 0.0f) ? + 1.0f : - 1.0f); }
+static real binary_sign (natural x) { return ((x > 0)    ? + 1.0f : - 1.0f); }
+
+static real square_root (real x) { return (sqrtf (x)); }
+static real cube_root   (real x) { return (cbrtf (x)); }
+
+static real sine    (real x) { return (sinf (x)); }
+static real cosine  (real x) { return (cosf (x)); }
+static real tangent (real x) { return (tanf (x)); }
+
+static real arc_sine    (real x) { return (asinf (x)); }
+static real arc_cosine  (real x) { return (acosf (x)); }
+static real arc_tangent (real x) { return (atanf (x)); }
+
+static real cosecant  (real x) { return (1.0f / sinf (x)); }
+static real secant    (real x) { return (1.0f / cosf (x)); }
+static real cotangent (real x) { return (1.0f / tanf (x)); }
+
+#endif
diff --git a/xyntax.h b/xyntax.h
new file mode 100644
index 0000000..2572c2d
--- /dev/null
+++ b/xyntax.h
@@ -0,0 +1,175 @@
+///                   _
+/// __  ___   _ _ __ | |_ __ ___  __
+/// \ \/ / | | | '_ \| __/ _` \ \/ /
+///  >  <| |_| | | | | || (_| |>  <
+/// /_/\_\\__, |_| |_|\__\__,_/_/\_\
+///       |___/
+///
+/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
+///
+/// xolatile@chud.cyou - xyntax - Tiny, unsafe and somewhat insane unity header for generic syntax definition.
+///
+/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
+/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
+///
+/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
+/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
+/// for more details, if you dare, it is a lot of text that nobody wants to read...
+
+typedef struct {
+	natural     count;
+	natural     limit;
+	boolean   * enrange;
+	boolean   * derange;
+	character * * begin;
+	character * * end;
+	character   * escape;
+	natural   * colour;
+	natural   * effect;
+} syntax_structure;
+
+static syntax_structure * syntax_initialize (natural limit) {
+	syntax_structure * syntax = allocate (sizeof (* syntax));
+
+	syntax->limit = limit;
+
+	if (limit != 0) {
+		syntax->enrange = allocate (syntax->limit * sizeof (* syntax->enrange));
+		syntax->derange = allocate (syntax->limit * sizeof (* syntax->derange));
+		syntax->begin   = allocate (syntax->limit * sizeof (* syntax->begin));
+		syntax->end     = allocate (syntax->limit * sizeof (* syntax->end));
+		syntax->escape  = allocate (syntax->limit * sizeof (* syntax->escape));
+		syntax->colour  = allocate (syntax->limit * sizeof (* syntax->colour));
+		syntax->effect  = allocate (syntax->limit * sizeof (* syntax->effect));
+	}
+
+	return (syntax);
+}
+
+static syntax_structure * syntax_deinitialize (syntax_structure * syntax) {
+	for (natural index = 0; index < syntax->count; ++index) {
+		syntax->begin [index] = deallocate (syntax->begin [index]);
+		syntax->end   [index] = deallocate (syntax->end   [index]);
+	}
+
+	syntax->enrange = deallocate (syntax->enrange);
+	syntax->derange = deallocate (syntax->derange);
+	syntax->begin   = deallocate (syntax->begin);
+	syntax->end     = deallocate (syntax->end);
+	syntax->escape  = deallocate (syntax->escape);
+	syntax->colour  = deallocate (syntax->colour);
+	syntax->effect  = deallocate (syntax->effect);
+
+	return (deallocate (syntax));
+}
+
+static natural syntax_define (syntax_structure * syntax, boolean enrange, boolean derange, character * begin, character * end, character escape,
+                           natural colour, natural effect) {
+	++syntax->count;
+
+	natural current = syntax->count - 1;
+
+	fatal_failure (begin == null, "syntax_define: Begin string is null pointer.");
+	fatal_failure (end   == null, "syntax_define: End string is null pointer.");
+
+	fatal_failure (syntax->count >= syntax->limit, "syntax_define: Reached the hardcoded limit.");
+
+	if (syntax->limit == 0) {
+		syntax->enrange = reallocate (syntax->enrange, syntax->count * sizeof (* syntax->enrange));
+		syntax->derange = reallocate (syntax->derange, syntax->count * sizeof (* syntax->derange));
+		syntax->begin   = reallocate (syntax->begin,   syntax->count * sizeof (* syntax->begin));
+		syntax->end     = reallocate (syntax->end,     syntax->count * sizeof (* syntax->end));
+		syntax->escape  = reallocate (syntax->escape,  syntax->count * sizeof (* syntax->escape));
+		syntax->colour  = reallocate (syntax->colour,  syntax->count * sizeof (* syntax->colour));
+		syntax->effect  = reallocate (syntax->effect,  syntax->count * sizeof (* syntax->effect));
+	}
+
+	syntax->begin [current] = allocate ((string_length (begin) + 1) * sizeof (* * syntax->begin));
+	syntax->end   [current] = allocate ((string_length (end)   + 1) * sizeof (* * syntax->end));
+
+	syntax->enrange [current] = enrange;
+	syntax->derange [current] = derange;
+	syntax->escape  [current] = escape;
+	syntax->colour  [current] = colour;
+	syntax->effect  [current] = effect;
+
+	string_copy (syntax->begin [current], begin);
+	string_copy (syntax->end   [current], end);
+
+	return (current);
+}
+
+static natural syntax_select (syntax_structure * syntax, character * string, natural * length) {
+	natural offset = 0;
+	natural subset = 0;
+	natural select = 0;
+
+	natural_64 begin_length = 0;
+	natural_64 end_length   = 0;
+
+	for (; select != syntax->count; ++select) {
+		begin_length = string_length (syntax->begin [select]);
+
+		if (! syntax->enrange [select]) {
+			if (! syntax->derange [select]) {
+				if (string_compare_limit (string, syntax->begin [select], begin_length)) {
+					break;
+				}
+			} else {
+				if ((string_compare_limit    (string, syntax->begin [select], begin_length))
+				&&  (character_compare_array (string [offset + begin_length], syntax->end [select]))) {
+					break;
+				}
+			}
+		} else {
+			for (subset = 0; subset != begin_length; ++subset) {
+				if (string [offset] == syntax->begin [select] [subset]) {
+					goto selected;
+				}
+			}
+		}
+	}
+
+	selected:
+
+	if (select >= syntax->count) {
+		* length = 1;
+
+		return (syntax->count);
+	}
+
+	end_length = string_length (syntax->end [select]);
+
+	for (offset = 1; string [offset - 1] != character_null; ++offset) {
+		if (string [offset] == syntax->escape [select]) {
+			++offset;
+			continue;
+		}
+
+		if (syntax->derange [select]) {
+			subset = 0;
+			if (end_length == 0) {
+				break;
+			} do {
+				if (string [offset] == syntax->end [select] [subset]) {
+					* length = offset;
+					goto finished;
+				}
+			} while (++subset != end_length);
+		} else {
+			if (end_length != 0) {
+				if (string_compare_limit (& string [offset], syntax->end [select], end_length)) {
+					* length = offset + end_length;
+					return (select);
+				}
+			} else {
+				* length = 1;
+				return (select);
+			}
+		}
+	}
+
+	finished:
+
+	return (select);
+}