Add SQLite again (still heavy WIP)

2016-02-06 00:18:01 +01:00
parent 95deb4e99d
commit f0f4248160
36 changed files with 42965 additions and 9627 deletions
@@ -1,5 +1,5 @@
 ;	BlitzUtility - Expanding the normal Blitz functionality.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 ;
 ;	This program is free software: you can redistribute it and/or modify
 ;	it under the terms of the GNU Lesser General Public License as
@@ -146,12 +146,6 @@ Function BU_Helper_Window_MakeBorderless(HWND=0)
 	newW = clientW
 	newH = clientH
 	
-;	DebugLog "Window:     " + RSet(windowX,8) + "," + RSet(windowY,8) + ":" + RSet(windowW,8) + "," + RSet(windowH,8)
-;	DebugLog "Client:     " + RSet(clientX,8) + "," + RSet(clientY,8) + ":" + RSet(clientW,8) + "," + RSet(clientH,8)
-;	DebugLog "RealClient: " + RSet(realClientX,8) + "," + RSet(realClientY,8)
-;	DebugLog "Diff:       " + RSet(realClientX - windowX,8) + "," + RSet(realClientY - windowY,8) + ":" + RSet(windowW - clientW,8) + "," + RSet(windowH - clientH,8)
-;	DebugLog "New:        " + RSet(newX,8) + "," + RSet(newY,8) + ":" + RSet(newW,8) + "," + RSet(newH,8)
-	
 	; Apply changes
 	BU_User32_SetWindowLong HWND, -16, $01000000
 	BU_User32_SetWindowPos HWND, 0, newX, newY, newW, newH, $4 + $10 + $20 + $40
@@ -189,138 +183,317 @@ Function BU_Helper_Window_Center(HWND=0, Monitor=0)
 	newW = windowW
 	newH = windowH
 	
-;	DebugLog "New:        " + RSet(newX,8) + "," + RSet(newY,8) + ":" + RSet(newW,8) + "," + RSet(newH,8)
-	
 	; Apply changes
 	BU_User32_SetWindowPos HWND, 0, newX, newY, newW, newH, $1 + $4 + $10 + $20 + $40 
 End Function

+Function BU_Helper_Window_Fill(HWND=0, Monitor=0)
+	Local displayEnumerator = BU_DisplayEnumerator_Create()
+	Local displayAmount = BU_DisplayEnumerator_Enumerate(displayEnumerator)
+	If Monitor >= displayAmount Then Monitor = displayAmount - 1
+	If Monitor < 0 Then Monitor = 0
+	
+	; Get Display Information
+	Local displayRectangle.BU_Rectangle = New BU_Rectangle
+	BU_DisplayEnumerator_Retrieve displayEnumerator, Monitor, displayRectangle
+	BU_DisplayEnumerator_Destroy displayEnumerator
+	Local displayX, displayY, displayW, displayH
+	displayX = displayRectangle\X
+	displayY = displayRectangle\Y
+	displayW = displayRectangle\X2 - displayRectangle\X
+	displayH = displayRectangle\Y2 - displayRectangle\Y
+	Delete displayRectangle
+	
+	; Calculate new position and size.
+	Local newX, newY, newW, newH
+	newX = displayX
+	newY = displayY
+	newW = displayW
+	newH = displayH
+	
+	; Apply changes
+	BU_User32_SetWindowPos HWND, 0, newX, newY, newW, newH, $4 + $10 + $20 + $40 
+End Function
+
 ; Database ---------------------------------------------------------------------
 ;-- SQLite3
-;;[Block] Return Codes / Error Codes
-;; Many SQLite functions return an integer result code from the set shown
-;; here in order to indicate success or failure.
-;;
-;; New error codes may be added in future versions of SQLite.
-;Const SQLITE_OK%			= 0   ; Successful result
-;Const SQLITE_ERROR%			= 1   ; SQL error or missing database
-;Const SQLITE_INTERNAL%		= 2   ; Internal logic error in SQLite
-;Const SQLITE_PERM%			= 3   ; Access permission denied
-;Const SQLITE_ABORT%			= 4   ; Callback routine requested an abort
-;Const SQLITE_BUSY%			= 5   ; The database file is locked
-;Const SQLITE_LOCKED%		= 6   ; A table in the database is locked
-;Const SQLITE_NOMEM%			= 7   ; A malloc() failed
-;Const SQLITE_READONLY%		= 8   ; Attempt to write a readonly database
-;Const SQLITE_INTERRUPT%		= 9   ; Operation terminated by SQLite3_Interrupt()
-;Const SQLITE_IOERR%			= 10   ; Some kind of disk I/O error occurred
-;Const SQLITE_CORRUPT%		= 11   ; The database disk image is malformed
-;Const SQLITE_NOTFOUND%		= 12   ; Unknown opcode in sqlite3_file_control()
-;Const SQLITE_FULL%			= 13   ; Insertion failed because database is full
-;Const SQLITE_CANTOPEN%		= 14   ; Unable to open the database file
-;Const SQLITE_PROTOCOL%		= 15   ; Database lock protocol error
-;Const SQLITE_EMPTY%			= 16   ; Database is empty
-;Const SQLITE_SCHEMA%		= 17   ; The database schema changed
-;Const SQLITE_TOOBIG%		= 18   ; String or BLOB exceeds size limit
-;Const SQLITE_CONSTRAINT%	= 19   ; Abort due to constraint violation
-;Const SQLITE_MISMATCH%		= 20   ; Data type mismatch
-;Const SQLITE_MISUSE%		= 21   ; Library used incorrectly
-;Const SQLITE_NOLFS%			= 22   ; Uses OS features not supported on host
-;Const SQLITE_AUTH%			= 23   ; Authorization denied
-;Const SQLITE_FORMAT%		= 24   ; Auxiliary database format error
-;Const SQLITE_RANGE%			= 25   ; 2nd parameter to sqlite3_bind out of range
-;Const SQLITE_NOTADB%		= 26   ; File opened that is not a database file
-;Const SQLITE_NOTICE%		= 27   ; Notifications from sqlite3_log()
-;Const SQLITE_WARNING%		= 28   ; Warnings from sqlite3_log()
-;Const SQLITE_ROW%			= 100  ; sqlite3_step() has another row ready
-;Const SQLITE_DONE%			= 101  ; sqlite3_step() has finished executing
-;;[End Block]
+;[Block] Return Codes / Error Codes
+; Many SQLite functions return an integer result code from the set shown
+; here in order to indicate success or failure.
 ;
-;;[Block] SQLite_Open Flags
-;; These bit values are intended for use in the
-;; 3rd parameter to the [sqlite3_open_v2()] interface.
-;Const SQLITE_OPEN_READONLY%		= $00000001
-;Const SQLITE_OPEN_READWRITE%	= $00000002
-;Const SQLITE_OPEN_CREATE%		= $00000004
-;Const SQLITE_OPEN_URI%			= $00000040
-;Const SQLITE_OPEN_MEMORY%		= $00000080
-;Const SQLITE_OPEN_NOMUTEX%		= $00008000
-;Const SQLITE_OPEN_FULLMUTEX%	= $00010000
-;Const SQLITE_OPEN_SHAREDCACHE%	= $00020000
-;Const SQLITE_OPEN_PRIVATECACHE%	= $00040000
-;;[End Block]
+; New error codes may be added in future versions of SQLite.
+Const BU_SQLITE_OK%											= 0   ; Successful result
+Const BU_SQLITE_ERROR%										= 1   ; SQL error or missing database
+Const BU_SQLITE_INTERNAL%									= 2   ; Internal logic error in SQLite
+Const BU_SQLITE_PERM%										= 3   ; Access permission denied
+Const BU_SQLITE_ABORT%										= 4   ; Callback routine requested an abort
+Const BU_SQLITE_BUSY%										= 5   ; The database file is locked
+Const BU_SQLITE_LOCKED%										= 6   ; A table in the database is locked
+Const BU_SQLITE_NOMEM%										= 7   ; A malloc() failed
+Const BU_SQLITE_READONLY%									= 8   ; Attempt to write a readonly database
+Const BU_SQLITE_INTERRUPT%									= 9   ; Operation terminated by SQLite3_Interrupt()
+Const BU_SQLITE_IOERR%										= 10   ; Some kind of disk I/O error occurred
+Const BU_SQLITE_CORRUPT%									= 11   ; The database disk image is malformed
+Const BU_SQLITE_NOTFOUND%									= 12   ; Unknown opcode in sqlite3_file_control()
+Const BU_SQLITE_FULL%										= 13   ; Insertion failed because database is full
+Const BU_SQLITE_CANTOPEN%									= 14   ; Unable to open the database file
+Const BU_SQLITE_PROTOCOL%									= 15   ; Database lock protocol error
+Const BU_SQLITE_EMPTY%										= 16   ; Database is empty
+Const BU_SQLITE_SCHEMA%										= 17   ; The database schema changed
+Const BU_SQLITE_TOOBIG%										= 18   ; String or BLOB exceeds size limit
+Const BU_SQLITE_CONSTRAINT%									= 19   ; Abort due to constraint violation
+Const BU_SQLITE_MISMATCH%									= 20   ; Data type mismatch
+Const BU_SQLITE_MISUSE%										= 21   ; Library used incorrectly
+Const BU_SQLITE_NOLFS%										= 22   ; Uses OS features not supported on host
+Const BU_SQLITE_AUTH%										= 23   ; Authorization denied
+Const BU_SQLITE_FORMAT%										= 24   ; Auxiliary database format error
+Const BU_SQLITE_RANGE%										= 25   ; 2nd parameter to sqlite3_bind out of range
+Const BU_SQLITE_NOTADB%										= 26   ; File opened that is not a database file
+Const BU_SQLITE_NOTICE%										= 27   ; Notifications from sqlite3_log()
+Const BU_SQLITE_WARNING%									= 28   ; Warnings from sqlite3_log()
+Const BU_SQLITE_ROW%										= 100  ; sqlite3_step() has another row ready
+Const BU_SQLITE_DONE%										= 101  ; sqlite3_step() has finished executing
+;[End Block]
+
+;[Block] Extended Result Codes
+; In its default configuration, SQLite API routines return one of 30 integer
+; [result codes].  However, experience has shown that many of
+; these result codes are too coarse-grained.  They do not provide as
+; much information about problems as programmers might like.  In an effort to
+; address this, newer versions of SQLite (version 3.3.8 and later) include
+; support for additional result codes that provide more detailed information
+; about errors. These [extended result codes] are enabled or disabled
+; on a per database connection basis using the [sqlite3_extended_result_codes()]
+; API. Or, the extended code for the most recent error can be obtained using
+; [sqlite3_extended_errcode()].
+Const BU_SQLITE_IOERR_READ									= (BU_SQLITE_IOERR Or (1 Shl 8))
+Const BU_SQLITE_IOERR_SHORT_READ							= (BU_SQLITE_IOERR Or (2 Shl 8))
+Const BU_SQLITE_IOERR_WRITE									= (BU_SQLITE_IOERR Or (3 Shl 8))
+Const BU_SQLITE_IOERR_FSYNC									= (BU_SQLITE_IOERR Or (4 Shl 8))
+Const BU_SQLITE_IOERR_DIR_FSYNC								= (BU_SQLITE_IOERR Or (5 Shl 8))
+Const BU_SQLITE_IOERR_TRUNCATE								= (BU_SQLITE_IOERR Or (6 Shl 8))
+Const BU_SQLITE_IOERR_FSTAT									= (BU_SQLITE_IOERR Or (7 Shl 8))
+Const BU_SQLITE_IOERR_UNLOCK								= (BU_SQLITE_IOERR Or (8 Shl 8))
+Const BU_SQLITE_IOERR_RDLOCK								= (BU_SQLITE_IOERR Or (9 Shl 8))
+Const BU_SQLITE_IOERR_DELETE								= (BU_SQLITE_IOERR Or (10 Shl 8))
+Const BU_SQLITE_IOERR_BLOCKED								= (BU_SQLITE_IOERR Or (11 Shl 8))
+Const BU_SQLITE_IOERR_NOMEM									= (BU_SQLITE_IOERR Or (12 Shl 8))
+Const BU_SQLITE_IOERR_ACCESS								= (BU_SQLITE_IOERR Or (13 Shl 8))
+Const BU_SQLITE_IOERR_CHECKRESERVEDLOCK						= (BU_SQLITE_IOERR Or (14 Shl 8))
+Const BU_SQLITE_IOERR_LOCK									= (BU_SQLITE_IOERR Or (15 Shl 8))
+Const BU_SQLITE_IOERR_CLOSE									= (BU_SQLITE_IOERR Or (16 Shl 8))
+Const BU_SQLITE_IOERR_DIR_CLOSE								= (BU_SQLITE_IOERR Or (17 Shl 8))
+Const BU_SQLITE_IOERR_SHMOPEN								= (BU_SQLITE_IOERR Or (18 Shl 8))
+Const BU_SQLITE_IOERR_SHMSIZE								= (BU_SQLITE_IOERR Or (19 Shl 8))
+Const BU_SQLITE_IOERR_SHMLOCK								= (BU_SQLITE_IOERR Or (20 Shl 8))
+Const BU_SQLITE_IOERR_SHMMAP								= (BU_SQLITE_IOERR Or (21 Shl 8))
+Const BU_SQLITE_IOERR_SEEK									= (BU_SQLITE_IOERR Or (22 Shl 8))
+Const BU_SQLITE_IOERR_DELETE_NOENT							= (BU_SQLITE_IOERR Or (23 Shl 8))
+Const BU_SQLITE_IOERR_MMAP									= (BU_SQLITE_IOERR Or (24 Shl 8))
+Const BU_SQLITE_IOERR_GETTEMPPATH							= (BU_SQLITE_IOERR Or (25 Shl 8))
+Const BU_SQLITE_IOERR_CONVPATH								= (BU_SQLITE_IOERR Or (26 Shl 8))
+Const BU_SQLITE_IOERR_VNODE									= (BU_SQLITE_IOERR Or (27 Shl 8))
+Const BU_SQLITE_IOERR_AUTH									= (BU_SQLITE_IOERR Or (28 Shl 8))
+Const BU_SQLITE_LOCKED_SHAREDCACHE							= (BU_SQLITE_LOCKED Or  (1 Shl 8))
+Const BU_SQLITE_BUSY_RECOVERY								= (BU_SQLITE_BUSY   Or  (1 Shl 8))
+Const BU_SQLITE_BUSY_SNAPSHOT								= (BU_SQLITE_BUSY   Or  (2 Shl 8))
+Const BU_SQLITE_CANTOPEN_NOTEMPDIR							= (BU_SQLITE_CANTOPEN Or (1 Shl 8))
+Const BU_SQLITE_CANTOPEN_ISDIR								= (BU_SQLITE_CANTOPEN Or (2 Shl 8))
+Const BU_SQLITE_CANTOPEN_FULLPATH							= (BU_SQLITE_CANTOPEN Or (3 Shl 8))
+Const BU_SQLITE_CANTOPEN_CONVPATH							= (BU_SQLITE_CANTOPEN Or (4 Shl 8))
+Const BU_SQLITE_CORRUPT_VTAB								= (BU_SQLITE_CORRUPT Or (1 Shl 8))
+Const BU_SQLITE_READONLY_RECOVERY							= (BU_SQLITE_READONLY Or (1 Shl 8))
+Const BU_SQLITE_READONLY_CANTLOCK							= (BU_SQLITE_READONLY Or (2 Shl 8))
+Const BU_SQLITE_READONLY_ROLLBACK							= (BU_SQLITE_READONLY Or (3 Shl 8))
+Const BU_SQLITE_READONLY_DBMOVED							= (BU_SQLITE_READONLY Or (4 Shl 8))
+Const BU_SQLITE_ABORT_ROLLBACK								= (BU_SQLITE_ABORT Or (2 Shl 8))
+Const BU_SQLITE_CONSTRAINT_CHECK							= (BU_SQLITE_CONSTRAINT Or (1 Shl 8))
+Const BU_SQLITE_CONSTRAINT_COMMITHOOK						= (BU_SQLITE_CONSTRAINT Or (2 Shl 8))
+Const BU_SQLITE_CONSTRAINT_FOREIGNKEY						= (BU_SQLITE_CONSTRAINT Or (3 Shl 8))
+Const BU_SQLITE_CONSTRAINT_FUNCTION							= (BU_SQLITE_CONSTRAINT Or (4 Shl 8))
+Const BU_SQLITE_CONSTRAINT_NOTNULL							= (BU_SQLITE_CONSTRAINT Or (5 Shl 8))
+Const BU_SQLITE_CONSTRAINT_PRIMARYKEY						= (BU_SQLITE_CONSTRAINT Or (6 Shl 8))
+Const BU_SQLITE_CONSTRAINT_TRIGGER							= (BU_SQLITE_CONSTRAINT Or (7 Shl 8))
+Const BU_SQLITE_CONSTRAINT_UNIQUE							= (BU_SQLITE_CONSTRAINT Or (8 Shl 8))
+Const BU_SQLITE_CONSTRAINT_VTAB								= (BU_SQLITE_CONSTRAINT Or (9 Shl 8))
+Const BU_SQLITE_CONSTRAINT_ROWID							= (BU_SQLITE_CONSTRAINT Or (10 Shl 8))
+Const BU_SQLITE_NOTICE_RECOVER_WAL							= (BU_SQLITE_NOTICE Or (1 Shl 8))
+Const BU_SQLITE_NOTICE_RECOVER_ROLLBACK						= (BU_SQLITE_NOTICE Or (2 Shl 8))
+Const BU_SQLITE_WARNING_AUTOINDEX							= (BU_SQLITE_WARNING Or (1 Shl 8))
+Const BU_SQLITE_AUTH_USER									= (BU_SQLITE_AUTH Or (1 Shl 8))
+;[End Block]
+
+;[Block] Flags For File Open Operations
+; These bit values are intended for use in the
+; 3rd parameter to the [sqlite3_open_v2()] interface.
+Const BU_SQLITE_OPEN_READONLY								= $00000001  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_READWRITE								= $00000002  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_CREATE									= $00000004  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_DELETEONCLOSE							= $00000008  ;  VFS only */
+Const BU_SQLITE_OPEN_EXCLUSIVE								= $00000010  ;  VFS only */
+Const BU_SQLITE_OPEN_AUTOPROXY								= $00000020  ;  VFS only */
+Const BU_SQLITE_OPEN_URI									= $00000040  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_MEMORY									= $00000080  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_MAIN_DB								= $00000100  ;  VFS only */
+Const BU_SQLITE_OPEN_TEMP_DB								= $00000200  ;  VFS only */
+Const BU_SQLITE_OPEN_TRANSIENT_DB							= $00000400  ;  VFS only */
+Const BU_SQLITE_OPEN_MAIN_JOURNAL							= $00000800  ;  VFS only */
+Const BU_SQLITE_OPEN_TEMP_JOURNAL							= $00001000  ;  VFS only */
+Const BU_SQLITE_OPEN_SUBJOURNAL								= $00002000  ;  VFS only */
+Const BU_SQLITE_OPEN_MASTER_JOURNAL							= $00004000  ;  VFS only */
+Const BU_SQLITE_OPEN_NOMUTEX								= $00008000  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_FULLMUTEX								= $00010000  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_SHAREDCACHE							= $00020000  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_PRIVATECACHE							= $00040000  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_WAL									= $00080000  ;  VFS only */
+;[End Block]
+
+;[Block] Authorizer Return Codes
+; The [sqlite3_set_authorizer | authorizer callback function] must
+; return either [SQLITE_OK] or one of these two constants in order
+; to signal SQLite whether or not the action is permitted.  See the
+; [sqlite3_set_authorizer | authorizer documentation] for additional
+; information.
 ;
-;;[Block] Column Type
-;Const SQLITE_UNKNOWN	= 0
-;Const SQLITE_INTEGER	= 1
-;Const SQLITE_REAL		= 2
-;Const SQLITE_FLOAT		= 2
-;Const SQLITE_DOUBLE		= 2
-;Const SQLITE_TEXT		= 3
-;Const SQLITE_STRING		= 3
-;Const SQLITE_BLOB		= 4
-;Const SQLITE_NULL		= 5
-;;[End Block]
+; Note that SQLITE_IGNORE is also used as a [conflict resolution mode]
+; returned from the [sqlite3_vtab_on_conflict()] interface.
+Const BU_SQLITE_DENY										= 1 ; Abort the SQL statement with an error */
+Const BU_SQLITE_IGNORE										= 2 ; Don't allow access, but don't generate an error */
+;[End Block]
+
+;[Block] Authorizer Action Codes
+; The [sqlite3_set_authorizer()] interface registers a callback function
+; that is invoked to authorize certain SQL statement actions.  The
+; second parameter to the callback is an integer code that specifies
+; what action is being authorized.  These are the integer action codes that
+; the authorizer callback may be passed.
 ;
-;;[Block] Internal Types
-;Type SQLite_Container
-;	Field Pointer%
-;End Type
+; These action code values signify what kind of operation is to be
+; authorized.  The 3rd and 4th parameters to the authorization
+; callback function will be parameters or NULL depending on which of these
+; codes is used as the second parameter.  ^(The 5th parameter to the
+; authorizer callback is the name of the database ("main", "temp",
+; etc.) if applicable.)^  ^The 6th parameter to the authorizer callback
+; is the name of the inner-most trigger or view that is responsible for
+; the access attempt or NULL if this access attempt is directly from
+; top-level SQL code.
+; ;;;;;;;;;;;;;;;;;;;;; 3rd ;;;;;; 4th ;;;;;*/
+Const BU_SQLITE_CREATE_INDEX         =  1   ;  Index Name      Table Name      */
+Const BU_SQLITE_CREATE_TABLE         =  2   ;  Table Name      NULL            */
+Const BU_SQLITE_CREATE_TEMP_INDEX    =  3   ;  Index Name      Table Name      */
+Const BU_SQLITE_CREATE_TEMP_TABLE    =  4   ;  Table Name      NULL            */
+Const BU_SQLITE_CREATE_TEMP_TRIGGER  =  5   ;  Trigger Name    Table Name      */
+Const BU_SQLITE_CREATE_TEMP_VIEW     =  6   ;  View Name       NULL            */
+Const BU_SQLITE_CREATE_TRIGGER       =  7   ;  Trigger Name    Table Name      */
+Const BU_SQLITE_CREATE_VIEW          =  8   ;  View Name       NULL            */
+Const BU_SQLITE_DELETE               =  9   ;  Table Name      NULL            */
+Const BU_SQLITE_DROP_INDEX           = 10   ;  Index Name      Table Name      */
+Const BU_SQLITE_DROP_TABLE           = 11   ;  Table Name      NULL            */
+Const BU_SQLITE_DROP_TEMP_INDEX      = 12   ;  Index Name      Table Name      */
+Const BU_SQLITE_DROP_TEMP_TABLE      = 13   ;  Table Name      NULL            */
+Const BU_SQLITE_DROP_TEMP_TRIGGER    = 14   ;  Trigger Name    Table Name      */
+Const BU_SQLITE_DROP_TEMP_VIEW       = 15   ;  View Name       NULL            */
+Const BU_SQLITE_DROP_TRIGGER         = 16   ;  Trigger Name    Table Name      */
+Const BU_SQLITE_DROP_VIEW            = 17   ;  View Name       NULL            */
+Const BU_SQLITE_INSERT               = 18   ;  Table Name      NULL            */
+Const BU_SQLITE_PRAGMA               = 19   ;  Pragma Name     1st arg or NULL */
+Const BU_SQLITE_READ                 = 20   ;  Table Name      Column Name     */
+Const BU_SQLITE_SELECT               = 21   ;  NULL            NULL            */
+Const BU_SQLITE_TRANSACTION          = 22   ;  Operation       NULL            */
+Const BU_SQLITE_UPDATE               = 23   ;  Table Name      Column Name     */
+Const BU_SQLITE_ATTACH               = 24   ;  Filename        NULL            */
+Const BU_SQLITE_DETACH               = 25   ;  Database Name   NULL            */
+Const BU_SQLITE_ALTER_TABLE          = 26   ;  Database Name   Table Name      */
+Const BU_SQLITE_REINDEX              = 27   ;  Index Name      NULL            */
+Const BU_SQLITE_ANALYZE              = 28   ;  Table Name      NULL            */
+Const BU_SQLITE_CREATE_VTABLE        = 29   ;  Table Name      Module Name     */
+Const BU_SQLITE_DROP_VTABLE          = 30   ;  Table Name      Module Name     */
+Const BU_SQLITE_FUNCTION             = 31   ;  NULL            Function Name   */
+Const BU_SQLITE_SAVEPOINT            = 32   ;  Operation       Savepoint Name  */
+Const BU_SQLITE_COPY                 =  0   ;  No longer used */
+Const BU_SQLITE_RECURSIVE            = 33   ;  NULL            NULL            */
+;[End Block]
+
+;[Block] Run-Time Limit Categories
+; KEYWORDS: {limit category} {*limit categories}
 ;
-;Type SQLite_Int64
-;	Field Left%, Right%
-;End Type
-;;[End Block]
+; These constants define various performance limits
+; that can be lowered at run-time using [sqlite3_limit()].
+; The synopsis of the meanings of the various limits is shown below.
+; Additional information is available at [limits | Limits in SQLite].
 ;
-;Function SQLite_Open%(File$, Flags% = $00000006)
-;	; Create a Container to hold the database pointer.
-;	Local Container.SQLite_Container = New SQLite_Container
-;	Local ErrCode = SQLite3_Open_V2(File, Container, Flags, 0)
-;	Local Database = Container\Pointer
-;	Delete Container
+; <dl>
+; [[SQLITE_LIMIT_LENGTH]] ^(<dt>SQLITE_LIMIT_LENGTH</dt>
+; <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
 ;
-;	If ErrCode = SQLITE_OK
-;		Return Database
-;	Else
-;		Return False
-;	EndIf
-;End Function
+; [[SQLITE_LIMIT_SQL_LENGTH]] ^(<dt>SQLITE_LIMIT_SQL_LENGTH</dt>
+; <dd>The maximum length of an SQL statement, in bytes.</dd>)^
 ;
-;Function SQLite_Execute(Database, SQL$)
-;	Return SQLite3_Exec(Database, SQL, 0, 0, 0)
-;End Function
+; [[SQLITE_LIMIT_COLUMN]] ^(<dt>SQLITE_LIMIT_COLUMN</dt>
+; <dd>The maximum number of columns in a table definition or in the
+; result set of a [SELECT] or the maximum number of columns in an index
+; or in an ORDER BY or GROUP BY clause.</dd>)^
 ;
-;Function SQLite_Prepare(Database, SQL$)
-;	Local Container.SQLite_Container = New SQLite_Container
-;	Local ErrCode = SQLite3_Prepare(Database, SQL$, -1, Container, 0)
-;	Local Statement = Container\Pointer
-;	Delete Container
+; [[SQLITE_LIMIT_EXPR_DEPTH]] ^(<dt>SQLITE_LIMIT_EXPR_DEPTH</dt>
+; <dd>The maximum depth of the parse tree on any expression.</dd>)^
 ;
-;	If ErrCode = SQLITE_OK
-;		Return Statement
-;	Else
-;		Return False
-;	EndIf
-;End Function
+; [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>
+; <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
 ;
-;Global SQLite_Column_Int64_L%, SQLite_Column_Int64_R%
-;Function SQLite_Column_Int64(Statement, ColumnIndex%)
-;	Local Result.SQLite_Int64 = New SQLite_Int64
-;	SQLite3_Column_Int64(Statement, ColumnIndex, Result)
-;	SQLite_Column_Int64_L = Result\Left
-;	SQLite_Column_Int64_R = Result\Right
-;	Delete Result
-;End Function
+; [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
+; <dd>The maximum number of instructions in a virtual machine program
+; used to implement an SQL statement.  This limit is not currently
+; enforced, though that might be added in some future release of
+; SQLite.</dd>)^
 ;
-;Function SQLite_Bind_Text(Statement, ColumnIndex%, Value$)
-;	Return SQLite3_Bind_Text(Statement, ColumnIndex, Value, -1, -1)
-;End Function
+; [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
+; <dd>The maximum number of arguments on a function.</dd>)^
 ;
-;Function SQLite_Bind_Blob(Statement, ColumnIndex%, Bank)
-;	If Bank <> 0 Then
-;		Local Size% = BankSize(Bank)
-;		Return SQLite3_Bind_Blob(Statement, ColumnIndex, Bank, Size, 0)
-;	EndIf
-;End Function
+; [[SQLITE_LIMIT_ATTACHED]] ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
+; <dd>The maximum number of [ATTACH | attached databases].)^</dd>
+;
+; [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]]
+; ^(<dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>
+; <dd>The maximum length of the pattern argument to the [LIKE] or
+; [GLOB] operators.</dd>)^
+;
+; [[SQLITE_LIMIT_VARIABLE_NUMBER]]
+; ^(<dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>
+; <dd>The maximum index number of any [parameter] in an SQL statement.)^
+;
+; [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
+; <dd>The maximum depth of recursion for triggers.</dd>)^
+;
+; [[SQLITE_LIMIT_WORKER_THREADS]] ^(<dt>SQLITE_LIMIT_WORKER_THREADS</dt>
+; <dd>The maximum number of auxiliary worker threads that a single
+; [prepared statement] may start.</dd>)^
+; </dl>
+Const BU_SQLITE_LIMIT_LENGTH                   =  0
+Const BU_SQLITE_LIMIT_SQL_LENGTH               =  1
+Const BU_SQLITE_LIMIT_COLUMN                   =  2
+Const BU_SQLITE_LIMIT_EXPR_DEPTH               =  3
+Const BU_SQLITE_LIMIT_COMPOUND_SELECT          =  4
+Const BU_SQLITE_LIMIT_VDBE_OP                  =  5
+Const BU_SQLITE_LIMIT_FUNCTION_ARG             =  6
+Const BU_SQLITE_LIMIT_ATTACHED                 =  7
+Const BU_SQLITE_LIMIT_LIKE_PATTERN_LENGTH      =  8
+Const BU_SQLITE_LIMIT_VARIABLE_NUMBER          =  9
+Const BU_SQLITE_LIMIT_TRIGGER_DEPTH            = 10
+Const BU_SQLITE_LIMIT_WORKER_THREADS           = 11
+;[End Block]
+
+;[Block] Column Type
+Const BU_SQLITE_UNKNOWN											= 0
+Const BU_SQLITE_INTEGER											= 1
+Const BU_SQLITE_REAL											= 2
+Const BU_SQLITE_FLOAT											= 2
+Const BU_SQLITE_DOUBLE											= 2
+Const BU_SQLITE_TEXT											= 3
+Const BU_SQLITE_STRING											= 3
+Const BU_SQLITE_BLOB											= 4
+Const BU_SQLITE_BANK											= 4
+Const BU_SQLITE_NULL											= 5
+;[End Block]

 ; Math -------------------------------------------------------------------------
 ;-- Vector2
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -16,7 +16,7 @@

 #pragma once
 #include <list>
-#include "dllmain.h"
+#include "BlitzUtility.h"
 #include "Database\SQLite\SQLite.h"
 #include "Utility\WindowMessageHandler.h"

@@ -1,5 +1,5 @@
 ;	BlitzUtility - Expanding the normal Blitz functionality.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 ;
 ;	This program is free software: you can redistribute it and/or modify
 ;	it under the terms of the GNU Lesser General Public License as
@@ -15,7 +15,7 @@
 ;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.

 .lib "BlitzUtility.dll"
-; Container --------------------------------------------------------------------
+; Container -------------------------------------------------------------------
 ; -- List (Single Element)
 BU_List_Create%(element*)
 BU_List_Destroy%(list%)
@@ -34,7 +34,131 @@ BU_TypeList_Activate(list%)
 BU_TypeList_Deactivate(list%)
 BU_TypeList_Destroy(list%)

-; Types ------------------------------------------------------------------------
+; Database --------------------------------------------------------------------
+; -- SQLite3
+; Core
+BU_SQLite_Version$()
+BU_SQLite_Version_Number%()
+BU_SQLite_SourceID$()
+BU_SQLite_CompileOption_Used%(zOptName$)
+BU_SQLite_CompileOption_Get$(n%)
+BU_SQLite_ThreadSafe%()
+BU_SQLite_Initialize%()
+BU_SQLite_Shutdown%()
+BU_SQLite_Sleep%(ms%)
+; Open & Close
+BU_SQLite_Open%(file$, db*)
+BU_SQLite_Open_V2%(file$, db*, flags%, zVfs$)
+BU_SQLite_Close%(db%)
+BU_SQLite_Close_V2%(db%)
+BU_SQLite_OpenSimple%(file$)
+BU_SQLite_OpenSimple_V2%(file$, flags%, zVfs$)
+BU_SQLite_OpenSimpleError%()
+; Error Handling
+BU_SQLite_Error_Code%(db%)
+BU_SQLite_Extended_Error_Code%(db%)
+BU_SQLite_Error_Message$(db%)
+BU_SQLite_Error_String$(errorCode%)
+BU_SQLite_Extended_Result_Codes%(db%, onoff%)
+; Busy Handler
+BU_SQLite_Busy_Timeout%(db%, timeout%)
+BU_SQLite_Busy_Handler%(db%, pHandlerFunction3IPI%, param%)
+BU_SQLite_Busy_Handler_Simple%(db%, pHandlerFunc2II%)
+; Memory Management
+BU_SQLite_Memory_Used%()
+BU_SQLite_Memory_Highwater%(bReset%)
+BU_SQLite_Release_Memory%(bytes%)
+BU_SQLite_DB_Release_Memory%(db%)
+BU_SQLite_Randomness(n%, pBank*)
+; Database Management & Modification
+BU_SQLite_Exec%(db%, sql$, pCallback3PIPP, param%, errMsg*)
+BU_SQLite_Last_Insert_RowId%(db%)
+BU_SQLite_Changes%(db%)
+BU_SQLite_Total_Changes%(db%)
+BU_SQLite_Interrupt(db%)
+BU_SQLite_Complete%(sql$)
+BU_SQLite_Get_Table%(db, zSql$, pazResult*, pnRow*, pnColumn*, pzErrMessage*)
+BU_SQLite_Free_Table%(result*)
+BU_SQLite_Set_Authorizer%(db%, pAuth5PIPPPP, pArg%)
+BU_SQLite_Trace%(db%, pTrace1PP, pArg%)
+BU_SQLite_Profile%(db%, pProfile2PPI, pArg%)
+BU_SQLite_Progress_Handler%(db%, nOps%, pProgress1IP%, pArg%)
+BU_SQLite_URI_Parameter$(zFilename$, zParam$)
+BU_SQLite_URI_Boolean%(zFilename$, zParam$, bDefault%)
+BU_SQLite_URI_LongLong%(zFilename$, zParam$, bDefault%)
+BU_SQLite_Limit%(db%, id%, newVal%)
+; Prepared Statements
+BU_SQLite_Next_Statement%(db%, pStmt%)
+BU_SQLite_Prepare%(db%, zSql$, nByte%, ppStmt*)
+BU_SQLite_Prepare_V2%(db%, zSql$, nByte%, ppStmt*)
+BU_SQLite_Statement_ReadOnly%(pStmt%)
+BU_SQLite_Statement_Busy%(pStmt%)
+BU_SQLite_Statement_Status%(pStmt%, op%, resetFlag%)
+BU_SQLite_SQL$(pStmt%)
+BU_SQLite_Database_Handle%(pStmt%)
+BU_SQLite_Bind_Null%(pStmt%, index%)
+BU_SQLite_Bind_Int%(pStmt%, index%, value%)
+BU_SQLite_Bind_LongLong%(pStmt%, index%, pValue%)
+BU_SQLite_Bind_Float%(pStmt%, index%, value#)
+BU_SQLite_Bind_Double%(pStmt%, index%, pValue%)
+BU_SQLite_Bind_Text%(pStmt%, index%, zData$, nData%)
+BU_SQLite_Bind_Blob%(pStmt%, index%, zData$, nData%)
+BU_SQLite_Bind_Value%(pStmt%, index%, pValue%)
+BU_SQLite_Bind_ZeroBlob%(pStmt%, index%, bytes%)
+BU_SQLite_Bind_Parameter_Count%(pStmt%)
+BU_SQLite_Bind_Parameter_Name$(pStmt%, index%)
+BU_SQLite_Bind_Parameter_Index%(pStmt%, zName$)
+BU_SQLite_Clear_Bindings%(pStmt%)
+BU_SQLite_Column_Count%(pStmt%)
+BU_SQLite_Column_Name$(pStmt%, index%)
+BU_SQLite_Column_DeclaredType$(pStmt%, index%)
+BU_SQLite_Step%(pStmt%)
+BU_SQLite_Data_Count%(pStmt%)
+BU_SQLite_Column_Blob%(pStmt%, iCol%)
+BU_SQLite_Column_Bytes%(pStmt%, iCol%)
+BU_SQLite_Column_Float%(pStmt%, iCol%)
+BU_SQLite_Column_Double%(pStmt%, iCol%)
+BU_SQLite_Column_Int%(pStmt%, iCol%)
+BU_SQLite_Column_LongLong%(pStmt%, iCol%)
+BU_SQLite_Column_Text$(pStmt%, iCol%)
+BU_SQLite_Column_Value%(pStmt%, iCol%)
+BU_SQLite_Column_Type%(pStmt%, iCol%)
+BU_SQLite_Finalize%(pStmt%)
+BU_SQLite_Reset%(pStmt%)
+; SQLite Values
+BU_SQLite_Value_Blob%(pValue%)
+BU_SQLite_Value_Bytes%(pValue%)
+BU_SQLite_Value_Int%(pValue%)
+BU_SQLite_Value_LongLong%(pValue%)
+BU_SQLite_Value_Float#(pValue%)
+BU_SQLite_Value_Double%(pValue%)
+BU_SQLite_Value_Text$(pValue%)
+BU_SQLite_Value_Type%(pValue%)
+BU_SQLite_Value_Numeric_Type%(pValue%)
+BU_SQLite_Value_SubType%(pValue%)
+BU_SQLite_Value_Duplicate%(pValue%)
+BU_SQLite_Value_Free(pValue%)
+
+; Time ------------------------------------------------------------------------
+; -- Time
+BU_Time_Now%()
+BU_Time_Create%(seconds%, minutes%, hours%, days%, months%, years%, isDST%)
+BU_Time_Destroy(pTime%)
+BU_Time_Format$(pTime%, formatString$)
+; -- SystemClock
+BU_SystemClock_Now%()
+BU_SystemClock_Destroy(pSystemClock%)
+BU_SystemClock_FromTime%(pTime%)
+BU_SystemClock_AsTime%(pSystemClock%)
+; -- HighResolutionClock
+BU_HighResolutionClock_Now%()
+BU_HighResolutionClock_Destroy(pHighResolutionClock%)
+BU_HighResolutionClock_Duration%(pHighResolutionClock%, pOther%)
+BU_HighResolutionClock_DurationLL%(pHighResolutionClock%, pOther%)
+BU_HighResolutionClock_DurationF#(pHighResolutionClock%, pOther%)
+BU_HighResolutionClock_DurationD%(pHighResolutionClock%, pOther%)
+
+; Types -----------------------------------------------------------------------
 ; -- LongLong
 BU_LongLong_Create%()
 BU_LongLong_Destroy(LongLong%)
@@ -44,17 +168,21 @@ BU_LongLong_TempCopy%(LongLong%)
 BU_LongLong_SetTemp(LongLong%)
 BU_LongLong_UnsetTemp(LongLong%)
 BU_LongLong_TempCleanup()
-BU_LongLong_Set(LongLong%, LongLong%)
+BU_LongLong_Set(LongLong%, LongLongOther%)
 BU_LongLong_SetV(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_Add(LongLong%, LongLong%)
+BU_LongLong_Add(LongLong%, LongLongOther%)
 BU_LongLong_AddV(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_Sub(LongLong%, LongLong%)
+BU_LongLong_Sub(LongLong%, LongLongOther%)
 BU_LongLong_SubV(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_Mul(LongLong%, LongLong%)
+BU_LongLong_Mul(LongLong%, LongLongOther%)
 BU_LongLong_MulV(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_Div(LongLong%, LongLong%)
+BU_LongLong_Div(LongLong%, LongLongOther%)
 BU_LongLong_DivV(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_Compare%(LongLong%, LongLong%)
+BU_LongLong_Modulo(LongLong%, pOther%)
+BU_LongLong_ModuloV(LongLong%, left%, right%)
+BU_LongLong_ShiftLeft(LongLong%, bits%)
+BU_LongLong_ShiftRight(LongLong%, bits%)
+BU_LongLong_Compare%(LongLong%, LongLongOther%)
 BU_LongLong_CompareV%(LongLong%, LongHigh%, LongLow%)
 BU_LongLong_ToString$(LongLong%)
 BU_LongLong_FromString%(String$)
@@ -77,17 +205,17 @@ BU_Double_TempCopy%(Double%)
 BU_Double_SetTemp(Double%)
 BU_Double_UnsetTemp(Double%)
 BU_Double_TempCleanup()
-BU_Double_Set(Double%, Double%)
+BU_Double_Set(Double%, DoubleOther%)
 BU_Double_SetF(Double%, Float#)
-BU_Double_Add(Double%, Double%)
+BU_Double_Add(Double%, DoubleOther%)
 BU_Double_AddF(Double%, Float#)
-BU_Double_Sub(Double%, Double%)
+BU_Double_Sub(Double%, DoubleOther%)
 BU_Double_SubF(Double%, Float#)
-BU_Double_Mul(Double%, Double%)
+BU_Double_Mul(Double%, DoubleOther%)
 BU_Double_MulF(Double%, Float#)
-BU_Double_Div(Double%, Double%)
+BU_Double_Div(Double%, DoubleOther%)
 BU_Double_DivF(Double%, Float#)
-BU_Double_Compare%(Double%, Double%)
+BU_Double_Compare%(Double%, DoubleOther%)
 BU_Double_CompareF%(Double%, Float#)
 BU_Double_ToString$(Double%)
 BU_Double_FromString%(String$)
@@ -98,7 +226,7 @@ BU_Double_FromLongLong%(LongLong%)
 BU_Double_Serialize$(Double%)
 BU_Double_Deserialize%(String$)

-; Utility ----------------------------------------------------------------------
+; Utility ---------------------------------------------------------------------
 ; -- Display Enumerator
 BU_DisplayEnumerator_Create%()
 BU_DisplayEnumerator_Destroy(DisplayEnumerator%)
@@ -143,13 +271,14 @@ BU_WindowMessageHandler_Message_Close%(hwnd%)
 BU_WindowMessageHandler_Message_Destroy%(hwnd%)
 BU_WindowMessageHandler_Message_Resize%(hwnd%, point*)

-; Helpers ----------------------------------------------------------------------
+; Helpers ---------------------------------------------------------------------
 .lib " "
 ; -- Blitz Functions
 BU_Helper_Window_LockPointer(HWND%)
 BU_Helper_Window_LockPointerAuto(HWND%)
 BU_Helper_Window_MakeBorderless(HWND%)
 BU_Helper_Window_Center(HWND%, Monitor%)
+BU_Helper_Window_Fill(HWND%, Monitor%)
 ; -- Windows API (User32)
 .lib "User32.dll"
 BU_User32_ClientToScreen%(hwnd%, point*)										: "ClientToScreen"
@@ -165,7 +294,10 @@ BU_User32_GetWindowRectEx%(hwnd%, rect%)										: "GetWindowRect"
 BU_User32_GetClientRect%(hwnd%, rect*)											: "GetClientRect"
 BU_User32_GetClientRectEx%(hwnd%, rect%)										: "GetClientRect"
 BU_User32_SetWindowPos%(hwnd%, hWndInsertAfter%, x%, y%, cx%, cy%, wFlags%)		: "SetWindowPos" 
+BU_User32_MessageBox%(hwnd%, lpText$, lpCaption$, uType%)						: "MessageBoxA"
 ; -- Windows API (Kernel32)
 .lib "Kernel32.dll"
 BU_Kernel32_FlushFileBuffers%(hFile%)											: "FlushFileBuffers"
 FlushFile%(hFile%)																: "FlushFileBuffers"
+BU_Kernel32_QueryPerformanceCounter%(pLongLong%)								: "QueryPerformanceCounter"
+BU_Kernel32_QueryPerformanceFrequency%(pLongLong%)								: "QueryPerformanceFrequency"
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -16,41 +16,27 @@

 #pragma once

-// Memory Management
+// Standard Library
+#include <time.h>
+#include <exception>
+#include <stdexcept>
 #include <memory>

-// Strings
-#include <string>
-#include <sstream>
-#include <iomanip>
-
 // Platform specific: Windows
 #include <windows.h>

 // Macros
-#define DLL_METHOD extern "C"
-#define DLL_CALL __stdcall
+#define DLL_FUNCTION(type) extern "C" type __stdcall

-//Templates
-template< typename T >
-std::string int_to_hex(T i) {
-	std::stringstream stream;
-	stream
-		<< std::setfill('0')
-		<< std::setw(sizeof(T) * 2)
-		<< std::hex
-		<< i;
-	return stream.str();
-}
-
-template< typename T >
-T hex_to_int(std::string t) {
-	T x;
-	std::stringstream stream;
-	stream
-		<< std::hex
-		<< t;
-	stream
-		>> x;
-	return x;
-}
+// BlitzUtility Includes
+#include "Container/List.h"
+#include "Container/TypeList.h"
+#include "Database/SQLite/SQLite.h"
+#include "Time/HighResolutionClock.h"
+#include "Type/Double.h"
+#include "Type/LongLong.h"
+#include "Utility/DisplayEnumerator.h"
+#include "Utility/IndexerV1.h"
+#include "Utility/IndexerV2.h"
+#include "Utility/MassOp.h"
+#include "Utility/WindowMessageHandler.h"
@@ -13,6 +13,7 @@
  <PropertyGroup Label="Globals">
    <ProjectGuid>{C08C5F9A-0C63-4798-A93F-FE96C014074B}</ProjectGuid>
    <RootNamespace>BlitzUtility</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@@ -39,32 +40,30 @@
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
+    <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
    <LinkIncremental>true</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
+    <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
-      <SDLCheck>
-      </SDLCheck>
      <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
      <StructMemberAlignment>4Bytes</StructMemberAlignment>
      <BufferSecurityCheck>false</BufferSecurityCheck>
      <ForcedIncludeFiles>
      </ForcedIncludeFiles>
      <OpenMPSupport>false</OpenMPSupport>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
-      <CreateHotpatchableImage>false</CreateHotpatchableImage>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
+      <CreateHotpatchableImage>true</CreateHotpatchableImage>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
      <MultiProcessorCompilation>true</MultiProcessorCompilation>
      <CompileAsManaged>false</CompileAsManaged>
@@ -75,8 +74,8 @@
      <IntrinsicFunctions>false</IntrinsicFunctions>
      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
      <StringPooling>true</StringPooling>
-      <EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
-      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
      <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
    </ClCompile>
@@ -101,8 +100,6 @@
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Full</Optimization>
      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>
-      </SDLCheck>
      <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
@@ -115,18 +112,19 @@
      <RuntimeTypeInfo>false</RuntimeTypeInfo>
      <CreateHotpatchableImage>false</CreateHotpatchableImage>
      <MinimalRebuild>false</MinimalRebuild>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
      <MultiProcessorCompilation>true</MultiProcessorCompilation>
      <CompileAsManaged>false</CompileAsManaged>
      <CompileAsWinRT>false</CompileAsWinRT>
      <CallingConvention>Cdecl</CallingConvention>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
      <StringPooling>true</StringPooling>
-      <EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
-      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
      <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DebugInformationFormat>None</DebugInformationFormat>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>false</GenerateDebugInformation>
@@ -148,8 +146,13 @@
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClInclude Include="Container\List.h" />
-    <ClInclude Include="dllmain.h" />
+    <ClInclude Include="BlitzUtility.h" />
    <ClInclude Include="Container\TypeList.h" />
+    <ClInclude Include="Database\SQLite\SQLite.h" />
+    <ClInclude Include="Database\SQLite\sqlite3.h" />
+    <ClInclude Include="Time\HighResolutionClock.h" />
+    <ClInclude Include="Time\SystemClock.h" />
+    <ClInclude Include="Time\Time.h" />
    <ClInclude Include="Utility\MassOp.h" />
    <ClInclude Include="Type\Double.h" />
    <ClInclude Include="Type\LongLong.h" />
@@ -161,10 +164,15 @@
  <ItemGroup>
    <ClCompile Include="Container\TypeList.cpp" />
    <ClCompile Include="Container\List.cpp" />
+    <ClCompile Include="Database\SQLite\SQLite.cpp" />
+    <ClCompile Include="Database\SQLite\sqlite3.c" />
+    <ClCompile Include="Time\HighResolutionClock.cpp" />
+    <ClCompile Include="Time\SystemClock.cpp" />
+    <ClCompile Include="Time\Time.cpp" />
    <ClCompile Include="Type\Double.cpp" />
    <ClCompile Include="Type\LongLong.cpp" />
    <ClCompile Include="Utility\IndexerV1.cpp" />
-    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="BlitzUtility.cpp" />
    <ClCompile Include="Utility\DisplayEnumerator.cpp" />
    <ClCompile Include="Utility\IndexerV2.cpp" />
    <ClCompile Include="Utility\MassOp.cpp" />
@@ -172,11 +180,11 @@
  </ItemGroup>
  <ItemGroup>
    <None Include="LICENSE">
-      <Link>LICENSE</Link>
+      <Link>BlitzUtility.LICENSE</Link>
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
    <None Include="LICENSE.lesser">
-      <Link>LICENSE.lesser</Link>
+      <Link>BlitzUtility.LICENSE.lesser</Link>
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
    <None Include="BlitzUtility.bb">
@@ -18,11 +18,17 @@
    <Filter Include="Source Files\Type">
      <UniqueIdentifier>{605f2cca-0949-4af8-ab67-7042309a2abc}</UniqueIdentifier>
    </Filter>
+    <Filter Include="Source Files\Database">
+      <UniqueIdentifier>{dfe42881-d7cc-4245-8dc4-f56d80f20fa8}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Database\SQLite">
+      <UniqueIdentifier>{82641744-2ff6-4000-9bec-718eb209a2a4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Time">
+      <UniqueIdentifier>{5a129704-2426-422d-8a40-c869f58d94cb}</UniqueIdentifier>
+    </Filter>
  </ItemGroup>
  <ItemGroup>
-    <ClCompile Include="dllmain.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
    <ClCompile Include="Utility\WindowMessageHandler.cpp">
      <Filter>Source Files\Utility</Filter>
    </ClCompile>
@@ -50,11 +56,26 @@
    <ClCompile Include="Utility\DisplayEnumerator.cpp">
      <Filter>Source Files\Utility</Filter>
    </ClCompile>
+    <ClCompile Include="BlitzUtility.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Database\SQLite\SQLite.cpp">
+      <Filter>Source Files\Database\SQLite</Filter>
+    </ClCompile>
+    <ClCompile Include="Time\HighResolutionClock.cpp">
+      <Filter>Source Files\Time</Filter>
+    </ClCompile>
+    <ClCompile Include="Database\SQLite\sqlite3.c">
+      <Filter>Source Files\Database\SQLite</Filter>
+    </ClCompile>
+    <ClCompile Include="Time\SystemClock.cpp">
+      <Filter>Source Files\Time</Filter>
+    </ClCompile>
+    <ClCompile Include="Time\Time.cpp">
+      <Filter>Source Files\Time</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
-    <ClInclude Include="dllmain.h">
-      <Filter>Source Files</Filter>
-    </ClInclude>
    <ClInclude Include="Utility\WindowMessageHandler.h">
      <Filter>Source Files\Utility</Filter>
    </ClInclude>
@@ -82,6 +103,24 @@
    <ClInclude Include="Utility\DisplayEnumerator.h">
      <Filter>Source Files\Utility</Filter>
    </ClInclude>
+    <ClInclude Include="BlitzUtility.h">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Database\SQLite\SQLite.h">
+      <Filter>Source Files\Database\SQLite</Filter>
+    </ClInclude>
+    <ClInclude Include="Time\HighResolutionClock.h">
+      <Filter>Source Files\Time</Filter>
+    </ClInclude>
+    <ClInclude Include="Database\SQLite\sqlite3.h">
+      <Filter>Source Files\Database\SQLite</Filter>
+    </ClInclude>
+    <ClInclude Include="Time\SystemClock.h">
+      <Filter>Source Files\Time</Filter>
+    </ClInclude>
+    <ClInclude Include="Time\Time.h">
+      <Filter>Source Files\Time</Filter>
+    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <None Include="BlitzUtility.bb">
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -17,8 +17,7 @@
 #pragma once
 #include "List.h"

-
-DLL_METHOD List* DLL_CALL BU_List_Create(BBTypeElement* element) {
+DLL_FUNCTION(List*) BU_List_Create(BBTypeElement* element) {
 	// Make sure the given element is valid.
 	if (element == NULL)
 		return NULL;
@@ -56,7 +55,7 @@ DLL_METHOD List* DLL_CALL BU_List_Create(BBTypeElement* element) {
 	return myList;
 }

-DLL_METHOD void DLL_CALL BU_List_Destroy(List* list) {
+DLL_FUNCTION(void) BU_List_Destroy(List* list) {
 	if (list == NULL)
 		return;

@@ -99,7 +98,7 @@ DLL_METHOD void DLL_CALL BU_List_Destroy(List* list) {
 	delete list;
 }

-DLL_METHOD uint32_t DLL_CALL BU_List_First(List* list) {
+DLL_FUNCTION(uint32_t) BU_List_First(List* list) {
 	if (list == NULL)
 		return FALSE;

@@ -117,7 +116,7 @@ DLL_METHOD uint32_t DLL_CALL BU_List_First(List* list) {
 	return TRUE;
 }

-DLL_METHOD uint32_t DLL_CALL BU_List_Last(List* list) {
+DLL_FUNCTION(uint32_t) BU_List_Last(List* list) {
 	if (list == NULL)
 		return FALSE;
 	
@@ -135,7 +134,7 @@ DLL_METHOD uint32_t DLL_CALL BU_List_Last(List* list) {
 	return TRUE;
 }

-DLL_METHOD uint32_t DLL_CALL BU_List_Previous(List* list) {
+DLL_FUNCTION(uint32_t) BU_List_Previous(List* list) {
 	if (list == NULL)
 		return FALSE;

@@ -153,7 +152,7 @@ DLL_METHOD uint32_t DLL_CALL BU_List_Previous(List* list) {
 	return TRUE;
 }

-DLL_METHOD uint32_t DLL_CALL BU_List_Next(List* list) {
+DLL_FUNCTION(uint32_t) BU_List_Next(List* list) {
 	if (list == NULL)
 		return FALSE;

@@ -171,7 +170,7 @@ DLL_METHOD uint32_t DLL_CALL BU_List_Next(List* list) {
 	return TRUE;
 }

-DLL_METHOD uint32_t DLL_CALL BU_List_Before(List* list, BBTypeElement* other) {
+DLL_FUNCTION(uint32_t) BU_List_Before(List* list, BBTypeElement* other) {
 	if (list == NULL)
 		return FALSE;
 	if (other == NULL)
@@ -195,7 +194,7 @@ DLL_METHOD uint32_t DLL_CALL BU_List_Before(List* list, BBTypeElement* other) {
 	return TRUE;
 }

-DLL_METHOD uint32_t DLL_CALL BU_List_After(List* list, BBTypeElement* other) {
+DLL_FUNCTION(uint32_t) BU_List_After(List* list, BBTypeElement* other) {
 	if (list == NULL)
 		return FALSE;
 	if (other == NULL)
@@ -219,11 +218,11 @@ DLL_METHOD uint32_t DLL_CALL BU_List_After(List* list, BBTypeElement* other) {
 	return TRUE;
 }

-DLL_METHOD void DLL_CALL BU_List_Insert(List* list, BBTypeElement* element) {
+DLL_FUNCTION(void) BU_List_Insert(List* list, BBTypeElement* element) {
 	BU_List_InsertEx(list, element, NULL);
 }

-DLL_METHOD void DLL_CALL BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other) {
+DLL_FUNCTION(void) BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other) {
 	if (list == NULL)
 		return;

@@ -253,7 +252,7 @@ DLL_METHOD void DLL_CALL BU_List_InsertEx(List* list, BBTypeElement* element, BB
 	element->type = list->fakeType;
 }

-DLL_METHOD void DLL_CALL BU_List_Remove(List* list, BBTypeElement* element) {
+DLL_FUNCTION(void) BU_List_Remove(List* list, BBTypeElement* element) {
 	if (list == NULL)
 		return;
 	if (element == NULL)
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -15,7 +15,7 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #pragma once
-#include "dllmain.h"
+#include "BlitzUtility.h"

 // Reverse engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp
 enum BBVarType {
@@ -61,25 +61,25 @@ struct List {
 	uint32_t* storageElementFields;
 };

-DLL_METHOD List* DLL_CALL BU_List_Create(BBTypeElement* element);
+DLL_FUNCTION(List*) BU_List_Create(BBTypeElement* element);
 #pragma comment(linker, "/EXPORT:BU_List_Create=_BU_List_Create@4")
-DLL_METHOD void DLL_CALL BU_List_Destroy(List* list);
+DLL_FUNCTION(void) BU_List_Destroy(List* list);
 #pragma comment(linker, "/EXPORT:BU_List_Destroy=_BU_List_Destroy@4")
-DLL_METHOD uint32_t DLL_CALL BU_List_First(List* list);
+DLL_FUNCTION(uint32_t) BU_List_First(List* list);
 #pragma comment(linker, "/EXPORT:BU_List_First=_BU_List_First@4")
-DLL_METHOD uint32_t DLL_CALL BU_List_Last(List* list);
+DLL_FUNCTION(uint32_t) BU_List_Last(List* list);
 #pragma comment(linker, "/EXPORT:BU_List_Last=_BU_List_Last@4")
-DLL_METHOD uint32_t DLL_CALL BU_List_Previous(List* list);
+DLL_FUNCTION(uint32_t) BU_List_Previous(List* list);
 #pragma comment(linker, "/EXPORT:BU_List_Previous=_BU_List_Previous@4")
-DLL_METHOD uint32_t DLL_CALL BU_List_Next(List* list);
+DLL_FUNCTION(uint32_t) BU_List_Next(List* list);
 #pragma comment(linker, "/EXPORT:BU_List_Next=_BU_List_Next@4")
-DLL_METHOD uint32_t DLL_CALL BU_List_Before(List* list, BBTypeElement* other);
+DLL_FUNCTION(uint32_t) BU_List_Before(List* list, BBTypeElement* other);
 #pragma comment(linker, "/EXPORT:BU_List_Before=_BU_List_Before@8")
-DLL_METHOD uint32_t DLL_CALL BU_List_After(List* list, BBTypeElement* other);
+DLL_FUNCTION(uint32_t) BU_List_After(List* list, BBTypeElement* other);
 #pragma comment(linker, "/EXPORT:BU_List_After=_BU_List_After@8")
-DLL_METHOD void DLL_CALL BU_List_Insert(List* list, BBTypeElement* element);
+DLL_FUNCTION(void) BU_List_Insert(List* list, BBTypeElement* element);
 #pragma comment(linker, "/EXPORT:BU_List_Insert=_BU_List_Insert@8")
-DLL_METHOD void DLL_CALL BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other);
+DLL_FUNCTION(void) BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other);
 #pragma comment(linker, "/EXPORT:BU_List_InsertEx=_BU_List_InsertEx@12")
-DLL_METHOD void DLL_CALL BU_List_Remove(List* list, BBTypeElement* element);
+DLL_FUNCTION(void) BU_List_Remove(List* list, BBTypeElement* element);
 #pragma comment(linker, "/EXPORT:BU_List_Remove=_BU_List_Remove@8")
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -17,7 +17,7 @@
 #pragma once;
 #include "TypeList.h"

-DLL_METHOD TypeList* DLL_CALL BU_TypeList_Create(BBTypeElement* element) {
+DLL_FUNCTION(TypeList*) BU_TypeList_Create(BBTypeElement* element) {
 	// Make sure the given element is valid.
 	if (element == NULL)
 		return NULL;
@@ -39,7 +39,7 @@ DLL_METHOD TypeList* DLL_CALL BU_TypeList_Create(BBTypeElement* element) {
 	return list;
 }

-DLL_METHOD void DLL_CALL BU_TypeList_Destroy(TypeList* list) {
+DLL_FUNCTION(void) BU_TypeList_Destroy(TypeList* list) {
 	// Make sure we have a valid list.
 	if (list == NULL)
 		return;
@@ -54,7 +54,7 @@ DLL_METHOD void DLL_CALL BU_TypeList_Destroy(TypeList* list) {
 	delete list;
 }

-DLL_METHOD void DLL_CALL BU_TypeList_Activate(TypeList* list) {
+DLL_FUNCTION(void) BU_TypeList_Activate(TypeList* list) {
 	// Store current pointers
 	list->storedFirstElement = list->type->used.next;
 	list->storedLastElement = list->type->used.prev;
@@ -64,7 +64,7 @@ DLL_METHOD void DLL_CALL BU_TypeList_Activate(TypeList* list) {
 	list->type->used.prev = list->lastElement;
 }

-DLL_METHOD void DLL_CALL BU_TypeList_Deactivate(TypeList* list) {
+DLL_FUNCTION(void) BU_TypeList_Deactivate(TypeList* list) {
 	// Store current pointers
 	list->firstElement = list->type->used.next;
 	list->lastElement = list->type->used.prev;
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -15,10 +15,13 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #pragma once
-#include "dllmain.h"
-#include "List.h"
+#include "BlitzUtility.h"
+#include "Container/List.h"
 #include <list>

+struct BBType;
+struct BBTypeElement;
+
 struct TypeList {
 	BBType *type;

@@ -26,11 +29,11 @@ struct TypeList {
 	BBTypeElement *firstElement, *lastElement;
 };

-DLL_METHOD TypeList* DLL_CALL BU_TypeList_Create(BBTypeElement* element);
+DLL_FUNCTION(TypeList*) BU_TypeList_Create(BBTypeElement* element);
 #pragma comment(linker, "/EXPORT:BU_TypeList_Create=_BU_TypeList_Create@4")
-DLL_METHOD void DLL_CALL BU_TypeList_Destroy(TypeList* list);
+DLL_FUNCTION(void) BU_TypeList_Destroy(TypeList* list);
 #pragma comment(linker, "/EXPORT:BU_TypeList_Destroy=_BU_TypeList_Destroy@4")
-DLL_METHOD void DLL_CALL BU_TypeList_Activate(TypeList* list);
+DLL_FUNCTION(void) BU_TypeList_Activate(TypeList* list);
 #pragma comment(linker, "/EXPORT:BU_TypeList_Activate=_BU_TypeList_Activate@4")
-DLL_METHOD void DLL_CALL BU_TypeList_Deactivate(TypeList* list);
+DLL_FUNCTION(void) BU_TypeList_Deactivate(TypeList* list);
 #pragma comment(linker, "/EXPORT:BU_TypeList_Deactivate=_BU_TypeList_Deactivate@4")
@@ -17,74 +17,481 @@
 #include "SQLite.h"
 #include "..\BlitzPointer\BlitzPointer.h"

-DLL_METHOD const char* DLL_CALL SQLite_Version() {
-	return sqlite3_version;
+static int32_t __BU_SQLite_OpenSimpleError = 0;
+
+#pragma region Core
+DLL_FUNCTION(const char*) BU_SQLite_Version() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Version=_BU_SQLite_Version@0")
+	return sqlite3_libversion();
 }
-DLL_METHOD int32_t DLL_CALL SQLite_ThreadSafe() {
+
+DLL_FUNCTION(int32_t) BU_SQLite_Version_Number() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Version_Number=_BU_SQLite_Version_Number@0")
+	return sqlite3_libversion_number();
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_SourceID() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_SourceID=_BU_SQLite_SourceID@0")
+	return sqlite3_sourceid();
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_CompileOption_Used(const char* zOptName) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_CompileOption_Used=_BU_SQLite_CompileOption_Used@4")
+	return sqlite3_compileoption_used(zOptName);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_CompileOption_Get(int32_t n) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_CompileOption_Get=_BU_SQLite_CompileOption_Get@4")
+	return sqlite3_compileoption_get(n);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_ThreadSafe() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_ThreadSafe=_BU_SQLite_ThreadSafe@0")
 	return sqlite3_threadsafe();
 }

-DLL_METHOD int32_t DLL_CALL SQLite_Initialize() {
+DLL_FUNCTION(int32_t) BU_SQLite_Initialize() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Initialize=_BU_SQLite_Initialize@0")
 	return sqlite3_initialize();
 }

-DLL_METHOD int32_t DLL_CALL SQLite_Shutdown() {
+DLL_FUNCTION(int32_t) BU_SQLite_Shutdown() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Shutdown=_BU_SQLite_Shutdown@0")
 	return sqlite3_shutdown();
 }

-DLL_METHOD int32_t DLL_CALL SQLite_Open(const char* file, sqlite3** db) {
+DLL_FUNCTION(int32_t) BU_SQLite_Sleep(int32_t ms) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Sleep=_BU_SQLite_Sleep@4")
+	return sqlite3_sleep(ms);
+}
+#pragma endregion Core
+
+#pragma region Open & Close
+DLL_FUNCTION(int32_t) BU_SQLite_Open(const char* file, sqlite3** db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Open=_BU_SQLite_Open@8")
 	return sqlite3_open(file, db);
 }

-DLL_METHOD int32_t DLL_CALL SQLite_Open_V2(const char* file, sqlite3** db, int32_t flags, const char* zVfs) {
+DLL_FUNCTION(int32_t) BU_SQLite_Open_V2(const char* file, sqlite3** db, int32_t flags, const char* zVfs) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Open_V2=_BU_SQLite_Open_V2@16")
 	return sqlite3_open_v2(file, db, flags, zVfs);
 }

-DLL_METHOD int32_t DLL_CALL SQLite_Close(sqlite3* db) {
+DLL_FUNCTION(int32_t) BU_SQLite_Close(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Close=_BU_SQLite_Close@4")
 	return sqlite3_close(db);
 }

-DLL_METHOD int32_t DLL_CALL SQLite_Close_V2(sqlite3* db) {
+DLL_FUNCTION(int32_t) BU_SQLite_Close_V2(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Close_V2=_BU_SQLite_Close_V2@4")
 	return sqlite3_close_v2(db);
 }

-DLL_METHOD int32_t DLL_CALL SQLite_ErrCode(sqlite3* db) {
+// Simple Open() and Open_V2()
+DLL_FUNCTION(sqlite3*) BU_SQLite_OpenSimple(const char* file) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_OpenSimple=_BU_SQLite_OpenSimple@4")
+	sqlite3** db = new sqlite3*();
+	__BU_SQLite_OpenSimpleError = sqlite3_open(file, db);
+	sqlite3* ret = *db; delete db; return ret;
+}
+
+DLL_FUNCTION(sqlite3*) BU_SQLite_OpenSimple_V2(const char* file, int32_t flags, const char* zVfs) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_OpenSimple_V2=_BU_SQLite_OpenSimple_V2@12")
+	sqlite3** db = new sqlite3*();
+	__BU_SQLite_OpenSimpleError = sqlite3_open_v2(file, db, flags, zVfs);
+	sqlite3* ret = *db;
+	delete db;
+	return ret;
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_OpenSimpleError() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_OpenSimpleError=_BU_SQLite_OpenSimpleError@0")
+	return __BU_SQLite_OpenSimpleError;
+}
+#pragma endregion Open & Close
+
+#pragma region Error Handling
+DLL_FUNCTION(int32_t) BU_SQLite_Error_Code(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Error_Code=_BU_SQLite_Error_Code@4")
 	return sqlite3_errcode(db);
 }

-DLL_METHOD int32_t DLL_CALL SQLite_Extended_ErrCode(sqlite3* db) {
+DLL_FUNCTION(int32_t) BU_SQLite_Extended_Error_Code(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Extended_Error_Code=_BU_SQLite_Extended_Error_Code@4")
 	return sqlite3_extended_errcode(db);
 }

-DLL_METHOD const char* DLL_CALL SQLite_ErrMsg(sqlite3* db) {
+DLL_FUNCTION(const char*) BU_SQLite_Error_Message(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Error_Message=_BU_SQLite_Error_Message@4")
 	return sqlite3_errmsg(db);
 }

-DLL_METHOD const char* DLL_CALL SQLite_ErrStr(int32_t errCode) {
+DLL_FUNCTION(const char*) BU_SQLite_Error_String(int32_t errCode) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Error_String=_BU_SQLite_Error_String@4")
 	return sqlite3_errstr(errCode);
 }

-DLL_METHOD int32_t DLL_CALL SQLite_Release_Memory(int32_t bytes) {
-	return sqlite3_release_memory(bytes);
+DLL_FUNCTION(int32_t) BU_SQLite_Extended_Result_Codes(sqlite3* db, int32_t onoff) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Extended_Result_Codes=_BU_SQLite_Extended_Result_Codes@8")
+	return sqlite3_extended_result_codes(db, onoff);
 }
+#pragma endregion Error Handling

-DLL_METHOD int32_t DLL_CALL SQLite_DB_Release_Memory(sqlite3* db) {
-	return sqlite3_db_release_memory(db);
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Busy_Timeout(sqlite3* db, int32_t timeout) {
+#pragma region Busy Handler
+DLL_FUNCTION(int32_t) BU_SQLite_Busy_Timeout(sqlite3* db, int32_t timeout) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Busy_Timeout=_BU_SQLite_Busy_Timeout@8")
 	return sqlite3_busy_timeout(db, timeout);
 }

-int __cdecl SQLite3_Busy_Handler_Internal(void* handler, int prm) {
+DLL_FUNCTION(int32_t) BU_SQLite_Busy_Handler(sqlite3* db, int(*phandlerfunc)(void*, int), void* param) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Busy_Handler=_BU_SQLite_Busy_Handler@12")
+	return sqlite3_busy_handler(db, phandlerfunc, param);
+}
+
+int __cdecl BU_SQLite_Busy_Handler_SimpleInternal(void* handler, int prm) {
 	BP_BlitzFunction1_t lpFunctionPointer = (BP_BlitzFunction1_t)handler;
 	return lpFunctionPointer((int32_t)prm);
 }

-DLL_METHOD int32_t DLL_CALL SQLite_Busy_Handler(sqlite3* db, int32_t handler) {
-	return sqlite3_busy_handler(db, SQLite3_Busy_Handler_Internal, (void*)handler);
+DLL_FUNCTION(int32_t) BU_SQLite_Busy_Handler_Simple(sqlite3* db, BP_BlitzFunction1_t handler) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Busy_Handler_Simple=_BU_SQLite_Busy_Handler_Simple@8")
+	return sqlite3_busy_handler(db, BU_SQLite_Busy_Handler_SimpleInternal, (void*)handler);
+}
+#pragma endregion Busy Handler
+
+#pragma region Memory Management
+DLL_FUNCTION(int64_t*) BU_SQLite_Memory_Used() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Memory_Used=_BU_SQLite_Memory_Used@0")
+	return new int64_t(sqlite3_memory_used());
 }

+DLL_FUNCTION(int64_t*) BU_SQLite_Memory_Highwater(int32_t bReset) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Memory_Highwater=_BU_SQLite_Memory_Highwater@4")
+	return new int64_t(sqlite3_memory_highwater(bReset));
+}

+DLL_FUNCTION(int32_t) BU_SQLite_Release_Memory(int32_t bytes) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Release_Memory=_BU_SQLite_Release_Memory@4")
+	return sqlite3_release_memory(bytes);
+}

+DLL_FUNCTION(int32_t) BU_SQLite_DB_Release_Memory(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_DB_Release_Memory=_BU_SQLite_DB_Release_Memory@4")
+	return sqlite3_db_release_memory(db);
+}
+
+DLL_FUNCTION(void) BU_SQLite_Randomness(int32_t n, void* p) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Randomness=_BU_SQLite_Randomness@8")
+	sqlite3_randomness(n, p);
+}
+#pragma endregion Memory Management
+
+#pragma region Database Management & Modification
+DLL_FUNCTION(int32_t) BU_SQLite_Exec(sqlite3* db, const char* sql, int(*callbackp)(void*, int, char**, char**), void* param, char** errMsg) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Exec=_BU_SQLite_Exec@20")
+	return sqlite3_exec(db, sql, callbackp, param, errMsg);
+}
+
+DLL_FUNCTION(int64_t*) BU_SQLite_Last_Insert_RowId(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Last_Insert_RowId=_BU_SQLite_Last_Insert_RowId@4")
+	return new int64_t(sqlite3_last_insert_rowid(db));
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Changes(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Changes=_BU_SQLite_Changes@4")
+	return sqlite3_changes(db);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Total_Changes(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Total_Changes=_BU_SQLite_Total_Changes@4")
+	return sqlite3_total_changes(db);
+}
+
+DLL_FUNCTION(void) BU_SQLite_Interrupt(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Interrupt=_BU_SQLite_Interrupt@4")
+	return sqlite3_interrupt(db);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Complete(const char* sql) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Complete=_BU_SQLite_Complete@4")
+	return sqlite3_complete(sql);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Get_Table(sqlite3* db, const char* zSql, char*** pazResult, int32_t* pnRow, int32_t* pnColumn, char** pzErrMessage) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Get_Table=_BU_SQLite_Get_Table@24")
+	return sqlite3_get_table(db, zSql, pazResult, pnRow, pnColumn, pzErrMessage);
+}
+
+DLL_FUNCTION(void) BU_SQLite_Free_Table(char** result) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Free_Table=_BU_SQLite_Free_Table@4")
+	sqlite3_free_table(result);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Set_Authorizer(sqlite3* db,
+											  int(*xAuth)(void*, int, const char*, const char*, const char*, const char*),
+											  void *pArg) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Set_Authorizer=_BU_SQLite_Set_Authorizer@12")
+	return sqlite3_set_authorizer(db, xAuth, pArg);
+}
+
+DLL_FUNCTION(void*) BU_SQLite_Trace(sqlite3* db,
+								   void(*xTrace)(void*, const char*),
+								   void* param) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Trace=_BU_SQLite_Trace@12")
+	return sqlite3_trace(db, xTrace, param);
+}
+
+DLL_FUNCTION(void*) BU_SQLite_Profile(sqlite3* db,
+									  void(*xProfile)(void*, const char*, sqlite3_uint64),
+									  void* param) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Profile=_BU_SQLite_Profile@12")
+	return sqlite3_profile(db, xProfile, param);
+}
+
+DLL_FUNCTION(void) BU_SQLite_Progress_Handler(sqlite3* db, int32_t nOps, int32_t(*xProgress)(void*), void* pArg) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Progress_Handler=_BU_SQLite_Progress_Handler@16")
+	sqlite3_progress_handler(db, nOps, xProgress, pArg);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_URI_Parameter(const char* zFilename, const char* zParam) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_URI_Parameter=_BU_SQLite_URI_Parameter@8")
+	return sqlite3_uri_parameter(zFilename, zParam);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_URI_Boolean(const char* zFilename, const char* zParam, int32_t bDefault) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_URI_Boolean=_BU_SQLite_URI_Boolean@12")
+	return sqlite3_uri_boolean(zFilename, zParam, bDefault);
+}
+
+DLL_FUNCTION(int64_t*) BU_SQLite_URI_LongLong(const char* zFilename, const char* zParam, int64_t* bDefault) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_URI_LongLong=_BU_SQLite_URI_LongLong@12")
+	return new int64_t(sqlite3_uri_int64(zFilename, zParam, *bDefault));
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Limit(sqlite3* db, int32_t id, int32_t newVal) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Limit=_BU_SQLite_Limit@12")
+	return sqlite3_limit(db, id, newVal);
+}
+#pragma endregion Database Management & Modification
+
+#pragma region Prepared Statements
+DLL_FUNCTION(sqlite3_stmt*) BU_SQLite_Next_Statement(sqlite3* db, sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Next_Statement=_BU_SQLite_Next_Statement@8")
+	return sqlite3_next_stmt(db, pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Prepare(sqlite3* db, const char* zSql, int32_t nByte, sqlite3_stmt** ppStmt, const char** pzTail) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Prepare=_BU_SQLite_Prepare@20")
+	return sqlite3_prepare(db, zSql, nByte, ppStmt, pzTail);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Prepare_V2(sqlite3* db, const char* zSql, int32_t nByte, sqlite3_stmt** ppStmt, const char** pzTail) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Prepare_V2=_BU_SQLite_Prepare_V2@20")
+	return sqlite3_prepare_v2(db, zSql, nByte, ppStmt, pzTail);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Statement_ReadOnly(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Statement_ReadOnly=_BU_SQLite_Statement_ReadOnly@4")
+	return sqlite3_stmt_readonly(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Statement_Busy(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Statement_Busy=_BU_SQLite_Statement_Busy@4")
+	return sqlite3_stmt_busy(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Statement_Status(sqlite3_stmt* pStmt, int32_t op, int32_t resetFlag) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Statement_Status=_BU_SQLite_Statement_Status@12")
+	return sqlite3_stmt_status(pStmt, op, resetFlag);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_SQL(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_SQL=_BU_SQLite_SQL@4")
+	return sqlite3_sql(pStmt);
+}
+
+DLL_FUNCTION(sqlite3*) BU_SQLite_Database_Handle(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Database_Handle=_BU_SQLite_Database_Handle@4")
+	return sqlite3_db_handle(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Null(sqlite3_stmt* pStmt, int32_t index) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Null=_BU_SQLite_Bind_Null@8")
+	return sqlite3_bind_null(pStmt, index);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Int(sqlite3_stmt* pStmt, int32_t index, int32_t value) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Int=_BU_SQLite_Bind_Int@12")
+	return sqlite3_bind_int(pStmt, index, value);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_LongLong(sqlite3_stmt* pStmt, int32_t index, int64_t* pValue) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_LongLong=_BU_SQLite_Bind_LongLong@12")
+	return sqlite3_bind_int64(pStmt, index, *pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Float(sqlite3_stmt* pStmt, int32_t index, float_t value) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Float=_BU_SQLite_Bind_Float@12")
+	return sqlite3_bind_double(pStmt, index, (double_t)value);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Double(sqlite3_stmt* pStmt, int32_t index, double_t* pValue) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Double=_BU_SQLite_Bind_Double@12")
+	return sqlite3_bind_double(pStmt, index, *pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Text(sqlite3_stmt* pStmt, int32_t index, const char* zData, int32_t nData) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Text=_BU_SQLite_Bind_Text@16")
+	return sqlite3_bind_text(pStmt, index, zData, nData, nullptr);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Blob(sqlite3_stmt* pStmt, int32_t index, void* zData, int32_t nData) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Blob=_BU_SQLite_Bind_Blob@16")
+	return sqlite3_bind_blob(pStmt, index, zData, nData, nullptr);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Value(sqlite3_stmt* pStmt, int32_t index, const sqlite3_value* pValue) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Value=_BU_SQLite_Bind_Value@12")
+	return sqlite3_bind_value(pStmt, index, pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_ZeroBlob(sqlite3_stmt* pStmt, int32_t index, int32_t bytes) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_ZeroBlob=_BU_SQLite_Bind_ZeroBlob@12")
+	return sqlite3_bind_zeroblob(pStmt, index, bytes);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Parameter_Count(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Parameter_Count=_BU_SQLite_Bind_Parameter_Count@4")
+	return sqlite3_bind_parameter_count(pStmt);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Bind_Parameter_Name(sqlite3_stmt* pStmt, int32_t index) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Parameter_Name=_BU_SQLite_Bind_Parameter_Name@8")
+	return sqlite3_bind_parameter_name(pStmt, index);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Parameter_Index(sqlite3_stmt* pStmt, const char* zName) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Parameter_Name=_BU_SQLite_Bind_Parameter_Name@8")
+	return sqlite3_bind_parameter_index(pStmt, zName);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Clear_Bindings(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Clear_Bindings=_BU_SQLite_Clear_Bindings@4")
+	return sqlite3_clear_bindings(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Column_Count(sqlite3_stmt* pStmt) {
+	return sqlite3_column_count(pStmt);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Column_Name(sqlite3_stmt* pStmt, int32_t n) {
+	return sqlite3_column_name(pStmt, n);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Column_DeclaredType(sqlite3_stmt* pStmt, int32_t n) {
+	return sqlite3_column_decltype(pStmt, n);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Step(sqlite3_stmt* pStmt) {
+	return sqlite3_step(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Data_Count(sqlite3_stmt* pStmt) {
+	return sqlite3_data_count(pStmt);
+}
+
+DLL_FUNCTION(const void*) BU_SQLite_Column_Blob(sqlite3_stmt* pStmt, int32_t iCol) {
+	return sqlite3_column_blob(pStmt, iCol);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Column_Bytes(sqlite3_stmt* pStmt, int32_t iCol) {
+	return sqlite3_column_bytes(pStmt, iCol);
+}
+
+DLL_FUNCTION(float_t) BU_SQLite_Column_Float(sqlite3_stmt* pStmt, int32_t iCol) {
+	return (float_t)sqlite3_column_double(pStmt, iCol);
+}
+
+DLL_FUNCTION(double_t*) BU_SQLite_Column_Double(sqlite3_stmt* pStmt, int32_t iCol) {
+	return new double_t(sqlite3_column_double(pStmt, iCol));
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Column_Int(sqlite3_stmt* pStmt, int32_t iCol) {
+	return sqlite3_column_int(pStmt, iCol);
+}
+
+DLL_FUNCTION(int64_t*) BU_SQLite_Column_LongLong(sqlite3_stmt* pStmt, int32_t iCol) {
+	return new int64_t(sqlite3_column_int64(pStmt, iCol));
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Column_Text(sqlite3_stmt* pStmt, int32_t iCol) {
+	return (const char*)sqlite3_column_text(pStmt, iCol);
+}
+
+DLL_FUNCTION(sqlite3_value*) BU_SQLite_Column_Value(sqlite3_stmt* pStmt, int32_t iCol) {
+	return sqlite3_column_value(pStmt, iCol);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Column_Type(sqlite3_stmt* pStmt, int32_t iCol) {
+	return sqlite3_column_type(pStmt, iCol);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Finalize(sqlite3_stmt* pStmt) {
+	return sqlite3_finalize(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Reset(sqlite3_stmt* pStmt) {
+	return sqlite3_reset(pStmt);
+}
+#pragma endregion Prepared Statements
+
+#pragma region SQLite Values
+DLL_FUNCTION(const void*) BU_SQLite_Value_Blob(sqlite3_value* pValue) {
+	return sqlite3_value_blob(pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Value_Bytes(sqlite3_value* pValue) {
+	return sqlite3_value_bytes(pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Value_Int(sqlite3_value* pValue) {
+	return sqlite3_value_int(pValue);
+}
+
+DLL_FUNCTION(int64_t*) BU_SQLite_Value_LongLong(sqlite3_value* pValue) {
+	return new int64_t(sqlite3_value_int64(pValue));
+}
+
+DLL_FUNCTION(float_t) BU_SQLite_Value_Float(sqlite3_value* pValue) {
+	return (float_t)sqlite3_value_double(pValue);
+}
+
+DLL_FUNCTION(double_t*) BU_SQLite_Value_Double(sqlite3_value* pValue) {
+	return new double_t(sqlite3_value_double(pValue));
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Value_Text(sqlite3_value* pValue) {
+	return (const char*)sqlite3_value_text(pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Value_Type(sqlite3_value* pValue) {
+	return sqlite3_value_type(pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Value_Numeric_Type(sqlite3_value* pValue) {
+	return sqlite3_value_numeric_type(pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Value_SubType(sqlite3_value* pValue) {
+	return sqlite3_value_subtype(pValue);
+}
+
+DLL_FUNCTION(sqlite3_value*) BU_SQLite_Value_Duplicate(sqlite3_value* pValue) {
+	return sqlite3_value_dup(pValue);
+}
+
+DLL_FUNCTION(void) BU_SQLite_Value_Free(sqlite3_value* pValue) {
+	return sqlite3_value_free(pValue);
+}
+#pragma endregion

@@ -15,51 +15,7 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #pragma once
-#include "dllmain.h"
-#include "sqlite3.h"
 #include <list>
+#include "BlitzUtility.h"
+#include "sqlite3.h"

-// Basic Info
-DLL_METHOD const char* DLL_CALL SQLite_Version();
-DLL_METHOD int32_t DLL_CALL SQLite_ThreadSafe();
-
-// Initialization and Finalization
-DLL_METHOD int32_t DLL_CALL SQLite_Initialize();
-DLL_METHOD int32_t DLL_CALL SQLite_Shutdown();
-
-// Database Handling
-DLL_METHOD int32_t DLL_CALL SQLite_Open(const char* file, sqlite3** db);
-DLL_METHOD int32_t DLL_CALL SQLite_Open_V2(const char* file, sqlite3** db, int32_t flags, const char* zVfs);
-DLL_METHOD int32_t DLL_CALL SQLite_Close(sqlite3* db);
-DLL_METHOD int32_t DLL_CALL SQLite_Close_V2(sqlite3* db);
-
-// Online Backup API
-DLL_METHOD sqlite3_backup* SQLite_Backup_Init(sqlite3* pDest, const char* zDestName, sqlite3* pSource, const char* zSourceName);
-DLL_METHOD int32_t DLL_CALL SQLite_Backup_Step(sqlite3_backup* p, int32_t nPage);
-DLL_METHOD int32_t DLL_CALL SQLite_Backup_Finish(sqlite3_backup* p);
-DLL_METHOD int32_t DLL_CALL SQLite_Backup_Remaining(sqlite3_backup* p);
-DLL_METHOD int32_t DLL_CALL SQLite_Backup_PageCount(sqlite3_backup* p);
-
-// Error Handling
-DLL_METHOD int32_t DLL_CALL SQLite_ErrCode(sqlite3* db);
-DLL_METHOD int32_t DLL_CALL SQLite_Extended_ErrCode(sqlite3* db);
-DLL_METHOD const char* DLL_CALL SQLite_ErrMsg(sqlite3* db);
-DLL_METHOD const char* DLL_CALL SQLite_ErrStr(int32_t errCode);
-
-// Memory Management
-DLL_METHOD int32_t DLL_CALL SQLite_Release_Memory(int32_t bytes);
-DLL_METHOD int32_t DLL_CALL SQLite_DB_Release_Memory(sqlite3* db);
-
-// Busy Timeout
-DLL_METHOD int32_t DLL_CALL SQLite_Busy_Timeout(sqlite3* db, int32_t timeout);
-DLL_METHOD int32_t DLL_CALL SQLite_Busy_Handler(sqlite3* db, int32_t handler);
-
-// Database Settings
-DLL_METHOD int32_t DLL_CALL SQLite_Get_AutoCommit(sqlite3* db);
-
-// Database Information
-DLL_METHOD const char* DLL_CALL SQLite_DB_FileName(sqlite3* db, const char* zDbName);
-DLL_METHOD sqlite3* DLL_CALL SQLite_DB_Handle(sqlite3_stmt* stmt);
-DLL_METHOD sqlite3_mutex* DLL_CALL SQLite_DB_Mutex(sqlite3* db);
-
-//Unsorted (Alphabetical
@@ -0,0 +1,53 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "HighResolutionClock.h"
+using namespace std;
+using namespace std::chrono;
+
+DLL_FUNCTION(high_resolution_clock::time_point*) BU_HighResolutionClock_Now() {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_Now=_BU_HighResolutionClock_Now@0")
+	return new high_resolution_clock::time_point(high_resolution_clock::now());
+}
+
+DLL_FUNCTION(void) BU_HighResolutionClock_Destroy(high_resolution_clock::time_point* pThis) {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_Destroy=_BU_HighResolutionClock_Destroy@4")
+	delete pThis;
+}
+
+DLL_FUNCTION(int32_t) BU_HighResolutionClock_Duration(high_resolution_clock::time_point* pThis, high_resolution_clock::time_point* pOther) {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_Duration=_BU_HighResolutionClock_Duration@8")
+	duration<int32_t, std::nano> temp = chrono::duration_cast<duration<int32_t, std::nano>>(*pThis - *pOther);
+	return temp.count();
+}
+
+DLL_FUNCTION(int64_t*) BU_HighResolutionClock_DurationLL(high_resolution_clock::time_point* pThis, high_resolution_clock::time_point* pOther) {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_DurationLL=_BU_HighResolutionClock_DurationLL@8")
+	duration<int64_t, std::nano> temp = (*pThis - *pOther);
+	return new int64_t(temp.count());
+}
+
+DLL_FUNCTION(float_t) BU_HighResolutionClock_DurationF(high_resolution_clock::time_point* pThis, high_resolution_clock::time_point* pOther) {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_DurationF=_BU_HighResolutionClock_DurationF@8")
+	double_t duration = (chrono::duration_cast<chrono::duration<double_t>>(*pThis - *pOther)).count();
+	return (float_t)(duration);
+}
+
+DLL_FUNCTION(double_t*) BU_HighResolutionClock_DurationD(high_resolution_clock::time_point* pThis, high_resolution_clock::time_point* pOther) {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_DurationD=_BU_HighResolutionClock_DurationD@8")
+	double_t duration = (chrono::duration_cast<chrono::duration<double_t>>(*pThis - *pOther)).count();
+	return new double_t(duration);
+}
@@ -0,0 +1,26 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <chrono>
+
+DLL_FUNCTION(std::chrono::high_resolution_clock::time_point*) BU_HighResolutionClock_Now();
+DLL_FUNCTION(void) BU_HighResolutionClock_Destroy(std::chrono::high_resolution_clock::time_point* pThis);
+DLL_FUNCTION(int32_t) BU_HighResolutionClock_Duration(std::chrono::high_resolution_clock::time_point* pThis, std::chrono::high_resolution_clock::time_point* pOther);
+DLL_FUNCTION(int64_t*) BU_HighResolutionClock_DurationLL(std::chrono::high_resolution_clock::time_point* pThis, std::chrono::high_resolution_clock::time_point* pOther);
+DLL_FUNCTION(float_t) BU_HighResolutionClock_DurationF(std::chrono::high_resolution_clock::time_point* pThis, std::chrono::high_resolution_clock::time_point* pOther);
+DLL_FUNCTION(double_t*) BU_HighResolutionClock_DurationD(std::chrono::high_resolution_clock::time_point* pThis, std::chrono::high_resolution_clock::time_point* pOther);
@@ -0,0 +1,37 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "SystemClock.h"
+
+DLL_FUNCTION(std::chrono::system_clock::time_point*) BU_SystemClock_Now() {
+#pragma comment(linker, "/EXPORT:BU_SystemClock_Now=_BU_SystemClock_Now@0")
+	return new std::chrono::system_clock::time_point(std::chrono::system_clock::now());
+}
+
+DLL_FUNCTION(void) BU_SystemClock_Destroy(std::chrono::system_clock::time_point* pThis) {
+#pragma comment(linker, "/EXPORT:BU_SystemClock_Destroy=_BU_SystemClock_Destroy@4")
+	delete pThis;
+}
+
+DLL_FUNCTION(std::chrono::system_clock::time_point*) BU_SystemClock_FromTime(time_t* pTime) {
+#pragma comment(linker, "/EXPORT:BU_SystemClock_FromTime=_BU_SystemClock_FromTime@4")
+	return new std::chrono::system_clock::time_point(std::chrono::system_clock::from_time_t(*pTime));
+}
+
+DLL_FUNCTION(time_t*) BU_SystemClock_AsTime(std::chrono::system_clock::time_point* pThis) {
+#pragma comment(linker, "/EXPORT:BU_SystemClock_AsTime=_BU_SystemClock_AsTime@4")
+	return new time_t(std::chrono::system_clock::to_time_t(*pThis));
+}
@@ -0,0 +1,24 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <chrono>
+
+DLL_FUNCTION(std::chrono::system_clock::time_point*) BU_SystemClock_Now();
+DLL_FUNCTION(void) BU_SystemClock_Destroy(std::chrono::system_clock::time_point* pThis);
+DLL_FUNCTION(std::chrono::system_clock::time_point*) BU_SystemClock_FromTime(time_t* pTime);
+DLL_FUNCTION(time_t*) BU_SystemClock_AsTime(std::chrono::system_clock::time_point* pThis);
@@ -0,0 +1,61 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "Time.h"
+
+DLL_FUNCTION(time_t*) BU_Time_Now() {
+#pragma comment(linker, "/EXPORT:BU_Time_Now=_BU_Time_Now@0")
+	time_t* pTime = new time_t();
+	time(pTime);
+	return pTime;
+}
+
+DLL_FUNCTION(time_t*) BU_Time_Create(uint32_t seconds, uint32_t minutes, uint32_t hours, uint32_t days, uint32_t months, uint32_t years, uint32_t isDaylightSavings) {
+#pragma comment(linker, "/EXPORT:BU_Time_Create=_BU_Time_Create@28")
+	tm* pTM = new tm();
+	pTM->tm_sec = seconds;
+	pTM->tm_min = minutes;
+	pTM->tm_hour = hours;
+	pTM->tm_mday = days;
+	pTM->tm_mon = months;
+	pTM->tm_year = years;
+	pTM->tm_isdst = isDaylightSavings;
+
+	time_t* pTime = new time_t(mktime(pTM));
+	delete pTM;
+	return pTime;
+}
+
+DLL_FUNCTION(void) BU_Time_Destroy(time_t* pTime) {
+#pragma comment(linker, "/EXPORT:BU_Time_Destroy=_BU_Time_Destroy@4")
+	delete pTime;
+}
+
+DLL_FUNCTION(const char*) BU_Time_Format(time_t* pTime, const char* pchFormatString) {
+#pragma comment(linker, "/EXPORT:BU_Time_Format=_BU_Time_Format@8")
+	std::string buffer;
+	tm* pTM = new tm;
+	localtime_s(pTM, pTime);
+	
+	uint32_t length = strlen(pchFormatString);
+	buffer.resize(length);
+	while (strftime(&buffer[0], buffer.size(), pchFormatString, pTM) == 0) {
+		buffer.resize(buffer.size() * 2);
+	}
+
+	delete pTM;
+	return buffer.c_str();
+}
@@ -0,0 +1,25 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <chrono>
+#include <time.h>
+
+DLL_FUNCTION(time_t*) BU_Time_Now();
+DLL_FUNCTION(time_t*) BU_Time_Create(uint32_t seconds, uint32_t minutes, uint32_t hours, uint32_t days, uint32_t months, uint32_t years, uint32_t isDaylightSavings);
+DLL_FUNCTION(void) BU_Time_Destroy(time_t* pTime);
+DLL_FUNCTION(const char*) BU_Time_Format(time_t* pTime, const char* pchFormatString);
@@ -1,5 +1,5 @@
 //	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -17,43 +17,68 @@
 #include "Double.h"
 #include <list>

+// Templates
+template< typename T >
+std::string int_to_hex(T i) {
+	std::stringstream stream;
+	stream
+		<< std::setfill('0')
+		<< std::setw(sizeof(T) * 2)
+		<< std::hex
+		<< i;
+	return stream.str();
+}
+
+template< typename T >
+T hex_to_int(std::string t) {
+	T x;
+	std::stringstream stream;
+	stream
+		<< std::hex
+		<< t;
+	stream
+		>> x;
+	return x;
+}
+
+
 std::list<double_t*> BU_DoubleTemporary;

-DLL_METHOD double_t* DLL_CALL BU_Double_Create() {
+DLL_FUNCTION(double_t*) BU_Double_Create() {
 	return new double_t;
 }

-DLL_METHOD void DLL_CALL BU_Double_Destroy(double_t* pthis) {
+DLL_FUNCTION(void) BU_Double_Destroy(double_t* pthis) {
 	delete pthis;
 }

-DLL_METHOD double_t* DLL_CALL BU_Double_Copy(double_t* other) {
+DLL_FUNCTION(double_t*) BU_Double_Copy(double_t* other) {
 	double_t* pthis = new double_t;
 	*pthis = *other;
 	return pthis;
 }

-DLL_METHOD double_t* DLL_CALL BU_Double_TempCreate() {
+DLL_FUNCTION(double_t*) BU_Double_TempCreate() {
 	double_t* val = new double_t;
 	BU_DoubleTemporary.push_back(val);
 	return val;
 }

-DLL_METHOD double_t* DLL_CALL BU_Double_TempCopy(double_t* other) {
+DLL_FUNCTION(double_t*) BU_Double_TempCopy(double_t* other) {
 	double_t* val = new double_t(*other);
 	BU_DoubleTemporary.push_back(val);
 	return val;
 }

-DLL_METHOD void DLL_CALL BU_Double_SetTemp(double_t* pthis) {
+DLL_FUNCTION(void) BU_Double_SetTemp(double_t* pthis) {
 	BU_DoubleTemporary.push_back(pthis);
 }

-DLL_METHOD void DLL_CALL BU_Double_UnsetTemp(double_t* pthis) {
+DLL_FUNCTION(void) BU_Double_UnsetTemp(double_t* pthis) {
 	BU_DoubleTemporary.remove(pthis);
 }

-DLL_METHOD void DLL_CALL BU_Double_TempCleanup() {
+DLL_FUNCTION(void) BU_Double_TempCleanup() {
 	auto iterEnd = BU_DoubleTemporary.end();
 	for (auto iter = BU_DoubleTemporary.begin(); iter != iterEnd; ++iter) {
 		delete *iter;
@@ -61,90 +86,90 @@ DLL_METHOD void DLL_CALL BU_Double_TempCleanup() {
 	BU_DoubleTemporary.clear();
 }

-DLL_METHOD void DLL_CALL BU_Double_Set(double_t* pthis, double_t* other) {
+DLL_FUNCTION(void) BU_Double_Set(double_t* pthis, double_t* other) {
 	*pthis = *other;
 }

-DLL_METHOD void DLL_CALL BU_Double_SetF(double_t* pthis, float_t other) {
+DLL_FUNCTION(void) BU_Double_SetF(double_t* pthis, float_t other) {
 	*pthis = other;
 }

-DLL_METHOD void DLL_CALL BU_Double_Add(double_t* pthis, double_t* other) {
+DLL_FUNCTION(void) BU_Double_Add(double_t* pthis, double_t* other) {
 	*pthis += *other;
 }

-DLL_METHOD void DLL_CALL BU_Double_AddF(double_t* pthis, float_t other) {
+DLL_FUNCTION(void) BU_Double_AddF(double_t* pthis, float_t other) {
 	*pthis += other;
 }

-DLL_METHOD void DLL_CALL BU_Double_Sub(double_t* pthis, double_t* other) {
+DLL_FUNCTION(void) BU_Double_Sub(double_t* pthis, double_t* other) {
 	*pthis -= *other;
 }

-DLL_METHOD void DLL_CALL BU_Double_SubF(double_t* pthis, float_t other) {
+DLL_FUNCTION(void) BU_Double_SubF(double_t* pthis, float_t other) {
 	*pthis -= other;
 }

-DLL_METHOD void DLL_CALL BU_Double_Mul(double_t* pthis, double_t* other) {
+DLL_FUNCTION(void) BU_Double_Mul(double_t* pthis, double_t* other) {
 	*pthis *= *other;
 }

-DLL_METHOD void DLL_CALL BU_Double_MulF(double_t* pthis, float_t other) {
+DLL_FUNCTION(void) BU_Double_MulF(double_t* pthis, float_t other) {
 	*pthis *= other;
 }

-DLL_METHOD void DLL_CALL BU_Double_Div(double_t* pthis, double_t* other) {
+DLL_FUNCTION(void) BU_Double_Div(double_t* pthis, double_t* other) {
 	*pthis /= *other;
 }

-DLL_METHOD void DLL_CALL BU_Double_DivF(double_t* pthis, float_t other) {
+DLL_FUNCTION(void) BU_Double_DivF(double_t* pthis, float_t other) {
 	*pthis /= other;
 }

-DLL_METHOD uint32_t DLL_CALL BU_Double_Compare(double_t* pthis, double_t* other) {
+DLL_FUNCTION(uint32_t) BU_Double_Compare(double_t* pthis, double_t* other) {
 	return (*pthis == *other ? 1 : 0) + (*pthis < *other ? 2 : 0) + (*pthis > *other ? 4 : 0);
 }

-DLL_METHOD uint32_t DLL_CALL BU_Double_CompareF(double_t* pthis, float_t other) {
+DLL_FUNCTION(uint32_t) BU_Double_CompareF(double_t* pthis, float_t other) {
 	return ((float_t)*pthis == other ? 1 : 0) + ((float_t)*pthis < other ? 2 : 0) + ((float_t)*pthis > other ? 4 : 0);
 }

-DLL_METHOD const char* DLL_CALL BU_Double_ToString(double_t* pthis) {
+DLL_FUNCTION(const char*) BU_Double_ToString(double_t* pthis) {
 	std::stringstream stream;
 	stream << *pthis;
 	return stream.str().c_str();
 }

-DLL_METHOD double_t* DLL_CALL BU_Double_FromString(const char* text) {
+DLL_FUNCTION(double_t*) BU_Double_FromString(const char* text) {
 	std::stringstream stream = std::stringstream(text);
 	double_t* doublePtr = new double_t;
 	stream >> *doublePtr;
 	return doublePtr;
 }

-DLL_METHOD float_t DLL_CALL BU_Double_ToFloat(double_t* pthis) {
+DLL_FUNCTION(float_t) BU_Double_ToFloat(double_t* pthis) {
 	return (float_t)*pthis;
 }

-DLL_METHOD double_t* DLL_CALL BU_Double_FromFloat(float_t other) {
+DLL_FUNCTION(double_t*) BU_Double_FromFloat(float_t other) {
 	double_t* val = new double_t;
 	*val = (double_t)other;
 	return val;
 }

-DLL_METHOD int64_t* DLL_CALL BU_Double_ToLongLong(double_t* pthis) {
+DLL_FUNCTION(int64_t*) BU_Double_ToLongLong(double_t* pthis) {
 	int64_t* val = new int64_t;
 	*val = (int64_t)*pthis;
 	return val;
 }

-DLL_METHOD double_t* DLL_CALL BU_Double_FromLongLong(int64_t* other) {
+DLL_FUNCTION(double_t*) BU_Double_FromLongLong(int64_t* other) {
 	double_t* val = new double_t;
 	*val = (double_t)*other;
 	return val;
 }

-DLL_METHOD const char* DLL_CALL BU_Double_Serialize(double_t* pthis) {
+DLL_FUNCTION(const char*) BU_Double_Serialize(double_t* pthis) {
 	union {
 		double_t real;
 		int64_t integer;
@@ -153,7 +178,7 @@ DLL_METHOD const char* DLL_CALL BU_Double_Serialize(double_t* pthis) {
 	return int_to_hex<int64_t>(myval.integer).c_str();
 }

-DLL_METHOD double_t* DLL_CALL BU_Double_Deserialize(const char* text) {
+DLL_FUNCTION(double_t*) BU_Double_Deserialize(const char* text) {
 	union {
 		double_t real;
 		int64_t integer;
@@ -1,5 +1,5 @@
 //	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -15,24 +15,25 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #pragma once
-#include "dllmain.h"
+#include "BlitzUtility.h"
 #include "LongLong.h"
+#include <iomanip>

 #pragma region Constructor & Destructor
-DLL_METHOD double_t* DLL_CALL BU_Double_Create();
-DLL_METHOD void DLL_CALL BU_Double_Destroy(double_t* pthis);
-DLL_METHOD double_t* DLL_CALL BU_Double_Copy(double_t* other);
+DLL_FUNCTION(double_t*) BU_Double_Create();
+DLL_FUNCTION(void) BU_Double_Destroy(double_t* pthis);
+DLL_FUNCTION(double_t*) BU_Double_Copy(double_t* other);
 #pragma comment(linker, "/EXPORT:BU_Double_Create=_BU_Double_Create@0")
 #pragma comment(linker, "/EXPORT:BU_Double_Destroy=_BU_Double_Destroy@4")
 #pragma comment(linker, "/EXPORT:BU_Double_Copy=_BU_Double_Copy@4")
 #pragma endregion Constructor & Destructor

 #pragma region Temporary Objects
-DLL_METHOD double_t* DLL_CALL BU_Double_TempCreate();
-DLL_METHOD double_t* DLL_CALL BU_Double_TempCopy(double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_SetTemp(double_t* pthis);
-DLL_METHOD void DLL_CALL BU_Double_UnsetTemp(double_t* pthis);
-DLL_METHOD void DLL_CALL BU_Double_TempCleanup();
+DLL_FUNCTION(double_t*) BU_Double_TempCreate();
+DLL_FUNCTION(double_t*) BU_Double_TempCopy(double_t* other);
+DLL_FUNCTION(void) BU_Double_SetTemp(double_t* pthis);
+DLL_FUNCTION(void) BU_Double_UnsetTemp(double_t* pthis);
+DLL_FUNCTION(void) BU_Double_TempCleanup();
 #pragma comment(linker, "/EXPORT:BU_Double_TempCreate=_BU_Double_TempCreate@0")
 #pragma comment(linker, "/EXPORT:BU_Double_TempCopy=_BU_Double_TempCopy@4")
 #pragma comment(linker, "/EXPORT:BU_Double_SetTemp=_BU_Double_SetTemp@4")
@@ -41,56 +42,56 @@ DLL_METHOD void DLL_CALL BU_Double_TempCleanup();
 #pragma endregion Temporary Objects

 #pragma region Math
-DLL_METHOD void DLL_CALL BU_Double_Set(double_t* pthis, double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_SetF(double_t* pthis, float_t other);
+DLL_FUNCTION(void) BU_Double_Set(double_t* pthis, double_t* other);
+DLL_FUNCTION(void) BU_Double_SetF(double_t* pthis, float_t other);
 #pragma comment(linker, "/EXPORT:BU_Double_Set=_BU_Double_Set@8")
 #pragma comment(linker, "/EXPORT:BU_Double_SetF=_BU_Double_SetF@8")
-DLL_METHOD void DLL_CALL BU_Double_Add(double_t* pthis, double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_AddF(double_t* pthis, float_t other);
+DLL_FUNCTION(void) BU_Double_Add(double_t* pthis, double_t* other);
+DLL_FUNCTION(void) BU_Double_AddF(double_t* pthis, float_t other);
 #pragma comment(linker, "/EXPORT:BU_Double_Add=_BU_Double_Add@8")
 #pragma comment(linker, "/EXPORT:BU_Double_AddF=_BU_Double_AddF@8")
-DLL_METHOD void DLL_CALL BU_Double_Sub(double_t* pthis, double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_SubF(double_t* pthis, float_t other);
+DLL_FUNCTION(void) BU_Double_Sub(double_t* pthis, double_t* other);
+DLL_FUNCTION(void) BU_Double_SubF(double_t* pthis, float_t other);
 #pragma comment(linker, "/EXPORT:BU_Double_Sub=_BU_Double_Sub@8")
 #pragma comment(linker, "/EXPORT:BU_Double_SubF=_BU_Double_SubF@8")
-DLL_METHOD void DLL_CALL BU_Double_Mul(double_t* pthis, double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_MulF(double_t* pthis, float_t other);
+DLL_FUNCTION(void) BU_Double_Mul(double_t* pthis, double_t* other);
+DLL_FUNCTION(void) BU_Double_MulF(double_t* pthis, float_t other);
 #pragma comment(linker, "/EXPORT:BU_Double_Mul=_BU_Double_Mul@8")
 #pragma comment(linker, "/EXPORT:BU_Double_MulF=_BU_Double_MulF@8")
-DLL_METHOD void DLL_CALL BU_Double_Div(double_t* pthis, double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_DivF(double_t* pthis, float_t other);
+DLL_FUNCTION(void) BU_Double_Div(double_t* pthis, double_t* other);
+DLL_FUNCTION(void) BU_Double_DivF(double_t* pthis, float_t other);
 #pragma comment(linker, "/EXPORT:BU_Double_Div=_BU_Double_Div@8")
 #pragma comment(linker, "/EXPORT:BU_Double_DivF=_BU_Double_DivF@8")
 #pragma endregion Math

 #pragma region Comparision
-DLL_METHOD uint32_t DLL_CALL BU_Double_Compare(double_t* pthis, double_t* other);
-DLL_METHOD uint32_t DLL_CALL BU_Double_CompareF(double_t* pthis, float_t other);
+DLL_FUNCTION(uint32_t) BU_Double_Compare(double_t* pthis, double_t* other);
+DLL_FUNCTION(uint32_t) BU_Double_CompareF(double_t* pthis, float_t other);
 #pragma comment(linker, "/EXPORT:BU_Double_Compare=_BU_Double_Compare@8")
 #pragma comment(linker, "/EXPORT:BU_Double_CompareF=_BU_Double_CompareF@8")
 #pragma endregion Comparision

 #pragma region Conversion
 // String conversion
-DLL_METHOD const char* DLL_CALL BU_Double_ToString(double_t* pthis);
-DLL_METHOD double_t* DLL_CALL BU_Double_FromString(const char* text);
+DLL_FUNCTION(const char*) BU_Double_ToString(double_t* pthis);
+DLL_FUNCTION(double_t*) BU_Double_FromString(const char* text);
 #pragma comment(linker, "/EXPORT:BU_Double_ToString=_BU_Double_ToString@4")
 #pragma comment(linker, "/EXPORT:BU_Double_FromString=_BU_Double_FromString@4")
 // 32-Bit Floating Point
-DLL_METHOD float_t DLL_CALL BU_Double_ToFloat(double_t* pthis);
-DLL_METHOD double_t* DLL_CALL BU_Double_FromFloat(float_t other);
+DLL_FUNCTION(float_t) BU_Double_ToFloat(double_t* pthis);
+DLL_FUNCTION(double_t*) BU_Double_FromFloat(float_t other);
 #pragma comment(linker, "/EXPORT:BU_Double_ToFloat=_BU_Double_ToFloat@4")
 #pragma comment(linker, "/EXPORT:BU_Double_FromFloat=_BU_Double_FromFloat@4")
 // 64-Bit Integer
-DLL_METHOD int64_t* DLL_CALL BU_Double_ToLongLong(double_t* pthis);
-DLL_METHOD double_t* DLL_CALL BU_Double_FromLongLong(int64_t* other);
+DLL_FUNCTION(int64_t*) BU_Double_ToLongLong(double_t* pthis);
+DLL_FUNCTION(double_t*) BU_Double_FromLongLong(int64_t* other);
 #pragma comment(linker, "/EXPORT:BU_Double_ToLongLong=_BU_Double_ToLongLong@4")
 #pragma comment(linker, "/EXPORT:BU_Double_FromLongLong=_BU_Double_FromLongLong@4")
 #pragma endregion Conversion

 #pragma region Serialization
-DLL_METHOD const char* DLL_CALL BU_Double_Serialize(double_t* pthis);
-DLL_METHOD double_t* DLL_CALL BU_Double_Deserialize(const char* text);
+DLL_FUNCTION(const char*) BU_Double_Serialize(double_t* pthis);
+DLL_FUNCTION(double_t*) BU_Double_Deserialize(const char* text);
 #pragma comment(linker, "/EXPORT:BU_Double_Serialize=_BU_Double_Serialize@4")
 #pragma comment(linker, "/EXPORT:BU_Double_Deserialize=_BU_Double_Deserialize@4")
 #pragma endregion Serialization
@@ -1,5 +1,5 @@
 //	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -18,43 +18,75 @@
 #include "LongLong.h"
 #include <list>

+// Templates
+template< typename T >
+std::string int_to_hex(T i) {
+	std::stringstream stream;
+	stream
+		<< std::setfill('0')
+		<< std::setw(sizeof(T) * 2)
+		<< std::hex
+		<< i;
+	return stream.str();
+}
+
+template< typename T >
+T hex_to_int(std::string t) {
+	T x;
+	std::stringstream stream;
+	stream
+		<< std::hex
+		<< t;
+	stream
+		>> x;
+	return x;
+}
+
+
 std::list<int64_t*> blitzLLTemporary;

-int64_t* DLL_CALL BU_LongLong_Create() {
+DLL_FUNCTION(int64_t*) BU_LongLong_Create() {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Create=_BU_LongLong_Create@0")
 	return new int64_t;
 }

-void DLL_CALL BU_LongLong_Destroy(int64_t* pthis) {
+DLL_FUNCTION(void) BU_LongLong_Destroy(int64_t* pthis) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Destroy=_BU_LongLong_Destroy@4")
 	delete pthis;
 }

-int64_t* DLL_CALL BU_LongLong_Copy(int64_t* other) {
-	int64_t* pthis = new int64_t;
-	*pthis = *other;
-	return pthis;
+DLL_FUNCTION(int64_t*) BU_LongLong_Copy(int64_t* other) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Copy=_BU_LongLong_Copy@4")
+	return new int64_t(*other);
 }

-DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCreate() {
+
+DLL_FUNCTION(int64_t*) BU_LongLong_TempCreate() {
+#pragma comment(linker, "/EXPORT:BU_LongLong_TempCreate=_BU_LongLong_TempCreate@0")
 	int64_t* val = new int64_t;
 	blitzLLTemporary.push_back(val);
 	return val;
 }

-DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCopy(int64_t* other) {
+DLL_FUNCTION(int64_t*) BU_LongLong_TempCopy(int64_t* other) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_TempCopy=_BU_LongLong_TempCopy@4")
 	int64_t* val = new int64_t(*other);
 	blitzLLTemporary.push_back(val);
 	return val;
 }

-DLL_METHOD void DLL_CALL BU_LongLong_SetTemp(int64_t* pthis) {
+DLL_FUNCTION(void) BU_LongLong_SetTemp(int64_t* pthis) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_SetTemp=_BU_LongLong_SetTemp@4")
 	blitzLLTemporary.push_back(pthis);
 }

-DLL_METHOD void DLL_CALL BU_LongLong_UnsetTemp(int64_t* pthis) {
+DLL_FUNCTION(void) BU_LongLong_UnsetTemp(int64_t* pthis) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_UnsetTemp=_BU_LongLong_UnsetTemp@4")
 	blitzLLTemporary.remove(pthis);
 }

-DLL_METHOD void DLL_CALL BU_LongLong_TempCleanup() {
+DLL_FUNCTION(void) BU_LongLong_TempCleanup() {
+#pragma comment(linker, "/EXPORT:BU_LongLong_TempCleanup=_BU_LongLong_TempCleanup@0")
 	auto iterEnd = blitzLLTemporary.end();
 	for (auto iter = blitzLLTemporary.begin(); iter != iterEnd; ++iter) {
 		delete *iter;
@@ -62,113 +94,163 @@ DLL_METHOD void DLL_CALL BU_LongLong_TempCleanup() {
 	blitzLLTemporary.clear();
 }

-
-void DLL_CALL BU_LongLong_Set(int64_t* pthis, int64_t* other) {
+DLL_FUNCTION(void) BU_LongLong_Set(int64_t* pthis, int64_t* other) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Set=_BU_LongLong_Set@8")
 	*pthis = *other;
 }

-void DLL_CALL BU_LongLong_SetV(int64_t* pthis, uint32_t left, uint32_t right) {
+DLL_FUNCTION(void) BU_LongLong_SetV(int64_t* pthis, int32_t left, int32_t right) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_SetV=_BU_LongLong_SetV@12")
 	*pthis = ((int64_t)left << 32) + right;
 }

-void DLL_CALL BU_LongLong_Add(int64_t* pthis, int64_t* other) {
+
+DLL_FUNCTION(void) BU_LongLong_Add(int64_t* pthis, int64_t* other) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Add=_BU_LongLong_Add@8")
 	*pthis += *other;
 }

-void DLL_CALL BU_LongLong_AddV(int64_t* pthis, uint32_t left, uint32_t right) {
+DLL_FUNCTION(void) BU_LongLong_AddV(int64_t* pthis, int32_t left, int32_t right) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_AddV=_BU_LongLong_AddV@12")
 	*pthis += ((int64_t)left << 32) + right;
 }

-void DLL_CALL BU_LongLong_Sub(int64_t* pthis, int64_t* other) {
+
+DLL_FUNCTION(void) BU_LongLong_Sub(int64_t* pthis, int64_t* other) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Sub=_BU_LongLong_Sub@8")
 	*pthis -= *other;
 }

-void DLL_CALL BU_LongLong_SubV(int64_t* pthis, uint32_t left, uint32_t right) {
+DLL_FUNCTION(void) BU_LongLong_SubV(int64_t* pthis, int32_t left, int32_t right) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_SubV=_BU_LongLong_SubV@12")
 	*pthis -= ((int64_t)left << 32) + right;
 }

-void DLL_CALL BU_LongLong_Mul(int64_t* pthis, int64_t* other) {
+
+DLL_FUNCTION(void) BU_LongLong_Mul(int64_t* pthis, int64_t* other) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Mul=_BU_LongLong_Mul@8")
 	*pthis *= *other;
 }

-void DLL_CALL BU_LongLong_MulV(int64_t* pthis, uint32_t left, uint32_t right) {
+DLL_FUNCTION(void) BU_LongLong_MulV(int64_t* pthis, int32_t left, int32_t right) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_MulV=_BU_LongLong_MulV@12")
 	*pthis *= ((int64_t)left << 32) + right;
 }

-void DLL_CALL BU_LongLong_Div(int64_t* pthis, int64_t* other) {
-	*pthis *= *other;
+
+DLL_FUNCTION(void) BU_LongLong_Div(int64_t* pthis, int64_t* other) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Div=_BU_LongLong_Div@8")
+	*pthis /= *other;
 }

-void DLL_CALL BU_LongLong_DivV(int64_t* pthis, uint32_t left, uint32_t right) {
-	*pthis *= ((int64_t)left << 32) + right;
+DLL_FUNCTION(void) BU_LongLong_DivV(int64_t* pthis, int32_t left, int32_t right) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_DivV=_BU_LongLong_DivV@12")
+	*pthis /= ((int64_t)left << 32) + right;
 }

-uint32_t DLL_CALL BU_LongLong_Compare(int64_t* pthis, int64_t* other) {
+
+DLL_FUNCTION(void) BU_LongLong_Modulo(int64_t* pThis, int64_t* pOther) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Modulo=_BU_LongLong_Modulo@8")
+	*pThis %= *pOther;
+}
+
+DLL_FUNCTION(void) BU_LongLong_ModuloV(int64_t* pThis, int32_t left, int32_t right) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_ModuloV=_BU_LongLong_ModuloV@12")
+	*pThis %= (((uint64_t)left << 32) + (uint64_t)right);
+}
+
+
+DLL_FUNCTION(void) BU_LongLong_ShiftLeft(int64_t* pThis, int32_t left) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_ShiftLeft=_BU_LongLong_ShiftLeft@8")
+	*pThis <<= left;
+}
+
+DLL_FUNCTION(void) BU_LongLong_ShiftRight(int64_t* pThis, int32_t right) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_ShiftRight=_BU_LongLong_ShiftRight@8")
+	*pThis >>= right;
+}
+
+
+DLL_FUNCTION(int32_t) BU_LongLong_Compare(int64_t* pthis, int64_t* other) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Compare=_BU_LongLong_Compare@8")
 	return (*pthis == *other ? 1 : 0) + (*pthis < *other ? 2 : 0) + (*pthis > *other ? 4 : 0);
 }

-uint32_t DLL_CALL BU_LongLong_CompareV(int64_t* pthis, uint32_t left, uint32_t right) {
+DLL_FUNCTION(int32_t) BU_LongLong_CompareV(int64_t* pthis, int32_t left, int32_t right) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_CompareV=_BU_LongLong_CompareV@12")
 	int64_t other = ((int64_t)left << 32) + right;
 	return (*pthis == other ? 1 : 0) + (*pthis < other ? 2 : 0) + (*pthis > other ? 4 : 0);
 }

-const char* DLL_CALL BU_LongLong_ToString(int64_t* pthis) {
+DLL_FUNCTION(const char*) BU_LongLong_ToString(int64_t* pthis) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_ToString=_BU_LongLong_ToString@4")
 	std::stringstream stream;
-	stream << *pthis;
+	stream << (*pthis);
 	return stream.str().c_str();
 }

-int64_t* DLL_CALL BU_LongLong_FromString(const char* text) {
+DLL_FUNCTION(int64_t*) BU_LongLong_FromString(const char* text) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_FromString=_BU_LongLong_FromString@4")
 	std::stringstream stream = std::stringstream(text);
 	int64_t* val = new int64_t;
-	stream >> *val;
+	stream >> (*val);
 	return val;
 }

-int32_t DLL_CALL BU_LongLong_ToLong(int64_t* pthis, int32_t _modulus) {
+DLL_FUNCTION(int32_t) BU_LongLong_ToLong(int64_t* pthis, int32_t _modulus) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_ToLong=_BU_LongLong_ToLong@8")
 	return *pthis % _modulus;
 }

-int64_t* DLL_CALL BU_LongLong_FromLong(int32_t left, int32_t right) {
+DLL_FUNCTION(int64_t*) BU_LongLong_FromLong(int32_t left, int32_t right) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_FromLong=_BU_LongLong_FromLong@8")
 	int64_t* val = new int64_t;
 	*val = ((int64_t)left << 32) + right;
 	return val;
 }

-int32_t DLL_CALL BU_LongLong_ToLongHigh(int64_t* pthis) {
+DLL_FUNCTION(int32_t) BU_LongLong_ToLongHigh(int64_t* pthis) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_ToLongHigh=_BU_LongLong_ToLongHigh@4")
 	return (int32_t)((*pthis) >> 32);
 }

-int32_t DLL_CALL BU_LongLong_ToLongLow(int64_t* pthis) {
+DLL_FUNCTION(int32_t) BU_LongLong_ToLongLow(int64_t* pthis) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_ToLongLow=_BU_LongLong_ToLongLow@4")
 	return (int32_t)((*pthis) && 0xFFFFFFFF);
 }

-float_t DLL_CALL BU_LongLong_ToFloat(int64_t* pthis) {
+DLL_FUNCTION(float_t) BU_LongLong_ToFloat(int64_t* pthis) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_ToFloat=_BU_LongLong_ToFloat@4")
 	return (float)*pthis;
 }

-int64_t* DLL_CALL BU_LongLong_FromFloat(float_t other) {
+DLL_FUNCTION(int64_t*) BU_LongLong_FromFloat(float_t other) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_FromFloat=_BU_LongLong_FromFloat@4")
 	int64_t val = (int64_t)other;
 	return BU_LongLong_Copy(&val);
 }

-double_t* DLL_CALL BU_LongLong_ToDouble(int64_t* pthis) {
+DLL_FUNCTION(double_t*) BU_LongLong_ToDouble(int64_t* pthis) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_ToDouble=_BU_LongLong_ToDouble@4")
 	double_t* val = new double_t;
 	*val = (double_t)*pthis;
 	return val;
 }

-int64_t* DLL_CALL BU_LongLong_FromDouble(double_t* other) {
+DLL_FUNCTION(int64_t*) BU_LongLong_FromDouble(double_t* other) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_FromDouble=_BU_LongLong_FromDouble@4")
 	int64_t* val = new int64_t;
 	*val = (int64_t)*other;
 	return val;
 }

-const char* DLL_CALL BU_LongLong_Serialize(int64_t* pthis) {
+DLL_FUNCTION(const char*) BU_LongLong_Serialize(int64_t* pthis) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Serialize=_BU_LongLong_Serialize@4")
 	return int_to_hex<int64_t>(*pthis).c_str();
 }

-int64_t* DLL_CALL BU_LongLong_Deserialize(const char* text) {
+DLL_FUNCTION(int64_t*) BU_LongLong_Deserialize(const char* text) {
+#pragma comment(linker, "/EXPORT:BU_LongLong_Deserialize=_BU_LongLong_Deserialize@4")
 	int64_t val = hex_to_int<int64_t>(std::string(text));
-	return BU_LongLong_Copy(&val);
+	return new int64_t(val);
 }
@@ -1,5 +1,5 @@
 //	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -15,90 +15,73 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #pragma once
-#include "dllmain.h"
+#include "BlitzUtility.h"
 #include "Double.h"
 #include <string>
 #include <sstream>
+#include <iomanip>

 #pragma region Constructor & Destructor
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_Create();
-DLL_METHOD void DLL_CALL BU_LongLong_Destroy(int64_t* pthis);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_Copy(int64_t* other);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Create=_BU_LongLong_Create@0")
-#pragma comment(linker, "/EXPORT:BU_LongLong_Destroy=_BU_LongLong_Destroy@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_Copy=_BU_LongLong_Copy@4")
+DLL_FUNCTION(int64_t*) BU_LongLong_Create();
+DLL_FUNCTION(void) BU_LongLong_Destroy(int64_t* pthis);
+DLL_FUNCTION(int64_t*) BU_LongLong_Copy(int64_t* other);
 #pragma endregion Constructor & Destructor

 #pragma region Temporary Objects
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCreate();
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCopy(int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_SetTemp(int64_t* pthis);
-DLL_METHOD void DLL_CALL BU_LongLong_UnsetTemp(int64_t* pthis);
-DLL_METHOD void DLL_CALL BU_LongLong_TempCleanup();
-#pragma comment(linker, "/EXPORT:BU_LongLong_TempCreate=_BU_LongLong_TempCreate@0")
-#pragma comment(linker, "/EXPORT:BU_LongLong_TempCopy=_BU_LongLong_TempCopy@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_SetTemp=_BU_LongLong_SetTemp@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_UnsetTemp=_BU_LongLong_UnsetTemp@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_TempCleanup=_BU_LongLong_TempCleanup@0")
+DLL_FUNCTION(int64_t*) BU_LongLong_TempCreate();
+DLL_FUNCTION(int64_t*) BU_LongLong_TempCopy(int64_t* other);
+DLL_FUNCTION(void) BU_LongLong_SetTemp(int64_t* pthis);
+DLL_FUNCTION(void) BU_LongLong_UnsetTemp(int64_t* pthis);
+DLL_FUNCTION(void) BU_LongLong_TempCleanup();
 #pragma endregion Temporary Objects

 #pragma region Math
-DLL_METHOD void DLL_CALL BU_LongLong_Set(int64_t* pthis, int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_SetV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Set=_BU_LongLong_Set@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_SetV=_BU_LongLong_SetV@12")
-DLL_METHOD void DLL_CALL BU_LongLong_Add(int64_t* pthis, int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_AddV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Add=_BU_LongLong_Add@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_AddV=_BU_LongLong_AddV@12")
-DLL_METHOD void DLL_CALL BU_LongLong_Sub(int64_t* pthis, int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_SubV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Sub=_BU_LongLong_Sub@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_SubV=_BU_LongLong_SubV@12")
-DLL_METHOD void DLL_CALL BU_LongLong_Mul(int64_t* pthis, int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_MulV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Mul=_BU_LongLong_Mul@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_MulV=_BU_LongLong_MulV@12")
-DLL_METHOD void DLL_CALL BU_LongLong_Div(int64_t* pthis, int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_DivV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Div=_BU_LongLong_Div@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_DivV=_BU_LongLong_DivV@12")
+DLL_FUNCTION(void) BU_LongLong_Set(int64_t* pthis, int64_t* other);
+DLL_FUNCTION(void) BU_LongLong_SetV(int64_t* pthis, int32_t left, int32_t right);
+
+DLL_FUNCTION(void) BU_LongLong_Add(int64_t* pthis, int64_t* other);
+DLL_FUNCTION(void) BU_LongLong_AddV(int64_t* pthis, int32_t left, int32_t right);
+
+DLL_FUNCTION(void) BU_LongLong_Sub(int64_t* pthis, int64_t* other);
+DLL_FUNCTION(void) BU_LongLong_SubV(int64_t* pthis, int32_t left, int32_t right);
+
+DLL_FUNCTION(void) BU_LongLong_Mul(int64_t* pthis, int64_t* other);
+DLL_FUNCTION(void) BU_LongLong_MulV(int64_t* pthis, int32_t left, int32_t right);
+
+DLL_FUNCTION(void) BU_LongLong_Div(int64_t* pthis, int64_t* other);
+DLL_FUNCTION(void) BU_LongLong_DivV(int64_t* pthis, int32_t left, int32_t right);
 #pragma endregion Math

+#pragma region Advanced Math
+DLL_FUNCTION(void) BU_LongLong_Modulo(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(void) BU_LongLong_ModuloV(int64_t* pThis, int32_t left, int32_t right);
+
+DLL_FUNCTION(void) BU_LongLong_ShiftLeft(int64_t* pThis, int32_t left);
+DLL_FUNCTION(void) BU_LongLong_ShiftRight(int64_t* pThis, int32_t right);
+#pragma endregion Advanced Math
+
 #pragma region Comparison
-DLL_METHOD uint32_t DLL_CALL BU_LongLong_Compare(int64_t* pthis, int64_t* other);
-DLL_METHOD uint32_t DLL_CALL BU_LongLong_CompareV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Compare=_BU_LongLong_Compare@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_CompareV=_BU_LongLong_CompareV@12")
+DLL_FUNCTION(int32_t) BU_LongLong_Compare(int64_t* pthis, int64_t* other);
+DLL_FUNCTION(int32_t) BU_LongLong_CompareV(int64_t* pthis, int32_t left, int32_t right);
 #pragma endregion Comparison

-
 #pragma region Conversion
-DLL_METHOD const char* DLL_CALL BU_LongLong_ToString(int64_t* pthis);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromString(const char* text);
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToString=_BU_LongLong_ToString@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_FromString=_BU_LongLong_FromString@4")
-DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLong(int64_t* pthis, int32_t _modulus);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromLong(int32_t left, int32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToLong=_BU_LongLong_ToLong@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_FromLong=_BU_LongLong_FromLong@8")
-DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLongHigh(int64_t* pthis);
-DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLongLow(int64_t* pthis);
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToLongHigh=_BU_LongLong_ToLongHigh@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToLongLow=_BU_LongLong_ToLongLow@4")
-DLL_METHOD float_t DLL_CALL BU_LongLong_ToFloat(int64_t* pthis);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromFloat(float_t other);
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToFloat=_BU_LongLong_ToFloat@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_FromFloat=_BU_LongLong_FromFloat@4")
-DLL_METHOD double_t* DLL_CALL BU_LongLong_ToDouble(int64_t* pthis);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromDouble(double_t* pthis);
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToDouble=_BU_LongLong_ToDouble@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_FromDouble=_BU_LongLong_FromDouble@4")
+DLL_FUNCTION(const char*) BU_LongLong_ToString(int64_t* pthis);
+DLL_FUNCTION(int64_t*) BU_LongLong_FromString(const char* text);
+
+DLL_FUNCTION(int32_t) BU_LongLong_ToLong(int64_t* pthis, int32_t _modulus);
+DLL_FUNCTION(int64_t*) BU_LongLong_FromLong(int32_t left, int32_t right);
+DLL_FUNCTION(int32_t) BU_LongLong_ToLongHigh(int64_t* pthis);
+DLL_FUNCTION(int32_t) BU_LongLong_ToLongLow(int64_t* pthis);
+
+DLL_FUNCTION(float_t) BU_LongLong_ToFloat(int64_t* pthis);
+DLL_FUNCTION(int64_t*) BU_LongLong_FromFloat(float_t other);
+
+DLL_FUNCTION(double_t*) BU_LongLong_ToDouble(int64_t* pthis);
+DLL_FUNCTION(int64_t*) BU_LongLong_FromDouble(double_t* pthis);
 #pragma endregion Conversion

 #pragma region Serialization
-DLL_METHOD const char* DLL_CALL BU_LongLong_Serialize(int64_t* pthis);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_Deserialize(const char* text);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Serialize=_BU_LongLong_Serialize@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_Deserialize=_BU_LongLong_Deserialize@4")
+DLL_FUNCTION(const char*) BU_LongLong_Serialize(int64_t* pthis);
+DLL_FUNCTION(int64_t*) BU_LongLong_Deserialize(const char* text);
 #pragma endregion Serialization
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -23,26 +23,26 @@ BOOL CALLBACK BU_DisplayEnumerator_Callback(HMONITOR hMonitor, HDC hdcMonitor, L
 	return TRUE;
 }

-DLL_METHOD DisplayEnumerator* DLL_CALL BU_DisplayEnumerator_Create() {
+DLL_FUNCTION(DisplayEnumerator*) BU_DisplayEnumerator_Create() {
 	DisplayEnumerator* displayEnumerator = new DisplayEnumerator();
 	return displayEnumerator;
 }

-DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator) {
+DLL_FUNCTION(void) BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator) {
 	delete displayEnumerator;
 }

-DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator) {
+DLL_FUNCTION(uint32_t) BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator) {
 	EnumDisplayMonitors(NULL, NULL, BU_DisplayEnumerator_Callback, (LPARAM)displayEnumerator);

 	return displayEnumerator->displays.size();
 }

-DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator) {
+DLL_FUNCTION(uint32_t) BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator) {
 	return displayEnumerator->displays.size();
 }

-DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, PRECT display) {
+DLL_FUNCTION(void) BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, PRECT display) {
 	// Retrieve the requested index.
 	auto iterator = displayEnumerator->displays.begin();
 	std::advance(iterator, index);
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -15,7 +15,7 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #pragma once
-#include "dllmain.h"
+#include "BlitzUtility.h"
 #include <list>

 struct DisplayEnumerator {
@@ -26,13 +26,13 @@ struct DisplayEnumerator {
 BOOL CALLBACK BU_DisplayEnumerator_Callback(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData);

 // Exported functions.
-DLL_METHOD DisplayEnumerator* DLL_CALL BU_DisplayEnumerator_Create();
+DLL_FUNCTION(DisplayEnumerator*) BU_DisplayEnumerator_Create();
 #pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Create=_BU_DisplayEnumerator_Create@0")
-DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator);
+DLL_FUNCTION(void) BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator);
 #pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Destroy=_BU_DisplayEnumerator_Destroy@4")
-DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator);
+DLL_FUNCTION(uint32_t) BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator);
 #pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Enumerate=_BU_DisplayEnumerator_Enumerate@4")
-DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator);
+DLL_FUNCTION(uint32_t) BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator);
 #pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Count=_BU_DisplayEnumerator_Count@4")
-DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, LPRECT display);
+DLL_FUNCTION(void) BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, LPRECT display);
 #pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Retrieve=_BU_DisplayEnumerator_Retrieve@12")
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -77,50 +77,50 @@ uint32_t IndexerV1::count(bool used) {
 	return amount;
 }

-DLL_METHOD IndexerV1* DLL_CALL BU_IndexerV1_Create() {
+DLL_FUNCTION(IndexerV1*) BU_IndexerV1_Create() {
 	return new IndexerV1();
 }

-DLL_METHOD void DLL_CALL BU_IndexerV1_Destroy(IndexerV1* indexer) {
+DLL_FUNCTION(void) BU_IndexerV1_Destroy(IndexerV1* indexer) {
 	delete indexer;
 }

-DLL_METHOD void DLL_CALL BU_IndexerV1_Mark(IndexerV1* indexer, uint32_t index, uint32_t used) {
+DLL_FUNCTION(void) BU_IndexerV1_Mark(IndexerV1* indexer, uint32_t index, uint32_t used) {
 	indexer->mark(index, used != 0);
 }

-DLL_METHOD void DLL_CALL BU_IndexerV1_MarkFree(IndexerV1* indexer, uint32_t index) {
+DLL_FUNCTION(void) BU_IndexerV1_MarkFree(IndexerV1* indexer, uint32_t index) {
 	indexer->mark(index, false);
 }

-DLL_METHOD void DLL_CALL BU_IndexerV1_MarkUsed(IndexerV1* indexer, uint32_t index) {
+DLL_FUNCTION(void) BU_IndexerV1_MarkUsed(IndexerV1* indexer, uint32_t index) {
 	indexer->mark(index, true);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Is(IndexerV1* indexer, uint32_t index, uint32_t used) {
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Is(IndexerV1* indexer, uint32_t index, uint32_t used) {
 	return indexer->is(index, used != 0);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_IsFree(IndexerV1* indexer, uint32_t index) {
+DLL_FUNCTION(uint32_t) BU_IndexerV1_IsFree(IndexerV1* indexer, uint32_t index) {
 	return indexer->is(index, false);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_IsUsed(IndexerV1* indexer, uint32_t index) {
+DLL_FUNCTION(uint32_t) BU_IndexerV1_IsUsed(IndexerV1* indexer, uint32_t index) {
 	return indexer->is(index, true);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Get(IndexerV1* indexer) {
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Get(IndexerV1* indexer) {
 	return indexer->get();
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Count(IndexerV1* indexer, uint32_t used) {
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Count(IndexerV1* indexer, uint32_t used) {
 	return indexer->count(used != 0);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_CountFree(IndexerV1* indexer) {
+DLL_FUNCTION(uint32_t) BU_IndexerV1_CountFree(IndexerV1* indexer) {
 	return indexer->count(false);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_CountUsed(IndexerV1* indexer) {
+DLL_FUNCTION(uint32_t) BU_IndexerV1_CountUsed(IndexerV1* indexer) {
 	return indexer->count(true);
 }
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -17,7 +17,7 @@
 #pragma once
 #include <cstdlib>
 #include <list>
-#include "dllmain.h"
+#include "BlitzUtility.h"

 // 67108864 = 2 ^ 32 / 64
 #define INDEXER_INDEXES 67108864 //pow(2,32) / 64 
@@ -35,27 +35,27 @@ struct IndexerV1 {
 	uint32_t count(bool used);
 };

-DLL_METHOD IndexerV1* DLL_CALL BU_IndexerV1_Create();
+DLL_FUNCTION(IndexerV1*) BU_IndexerV1_Create();
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_Create=_BU_IndexerV1_Create@0")
-DLL_METHOD void DLL_CALL BU_IndexerV1_Destroy(IndexerV1* indexer);
+DLL_FUNCTION(void) BU_IndexerV1_Destroy(IndexerV1* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_Destroy=_BU_IndexerV1_Destroy@4")
-DLL_METHOD void DLL_CALL BU_IndexerV1_Mark(IndexerV1* indexer, uint32_t used, uint32_t index);
+DLL_FUNCTION(void) BU_IndexerV1_Mark(IndexerV1* indexer, uint32_t used, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_Mark=_BU_IndexerV1_Mark@12")
-DLL_METHOD void DLL_CALL BU_IndexerV1_MarkFree(IndexerV1* indexer, uint32_t index);
+DLL_FUNCTION(void) BU_IndexerV1_MarkFree(IndexerV1* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_MarkFree=_BU_IndexerV1_MarkFree@8")
-DLL_METHOD void DLL_CALL BU_IndexerV1_MarkUsed(IndexerV1* indexer, uint32_t index);
+DLL_FUNCTION(void) BU_IndexerV1_MarkUsed(IndexerV1* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_MarkUsed=_BU_IndexerV1_MarkUsed@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Is(IndexerV1* indexer, uint32_t index, uint32_t used);
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Is(IndexerV1* indexer, uint32_t index, uint32_t used);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_Is=_BU_IndexerV1_Is@12")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_IsFree(IndexerV1* indexer, uint32_t index);
+DLL_FUNCTION(uint32_t) BU_IndexerV1_IsFree(IndexerV1* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_IsFree=_BU_IndexerV1_IsFree@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_IsUsed(IndexerV1* indexer, uint32_t index);
+DLL_FUNCTION(uint32_t) BU_IndexerV1_IsUsed(IndexerV1* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_IsUsed=_BU_IndexerV1_IsUsed@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Get(IndexerV1* indexer);
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Get(IndexerV1* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_Get=_BU_IndexerV1_Get@4")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Count(IndexerV1* indexer, uint32_t used);
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Count(IndexerV1* indexer, uint32_t used);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_Count=_BU_IndexerV1_Count@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_CountFree(IndexerV1* indexer);
+DLL_FUNCTION(uint32_t) BU_IndexerV1_CountFree(IndexerV1* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_CountFree=_BU_IndexerV1_CountFree@4")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_CountUsed(IndexerV1* indexer);
+DLL_FUNCTION(uint32_t) BU_IndexerV1_CountUsed(IndexerV1* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV1_CountUsed=_BU_IndexerV1_CountUsed@4")
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -122,50 +122,50 @@ IndexerV2::IndexerV2Range::IndexerV2Range(uint32_t min, uint32_t max) {
 }


-DLL_METHOD IndexerV2* DLL_CALL BU_IndexerV2_Create() {
+DLL_FUNCTION(IndexerV2*) BU_IndexerV2_Create() {
 	return new IndexerV2();
 }

-DLL_METHOD void DLL_CALL BU_IndexerV2_Destroy(IndexerV2* indexer) {
+DLL_FUNCTION(void) BU_IndexerV2_Destroy(IndexerV2* indexer) {
 	delete indexer;
 }

-DLL_METHOD void DLL_CALL BU_IndexerV2_Mark(IndexerV2* indexer, uint32_t used, uint32_t index) {
+DLL_FUNCTION(void) BU_IndexerV2_Mark(IndexerV2* indexer, uint32_t used, uint32_t index) {
 	indexer->mark(index, used != 0);
 }

-DLL_METHOD void DLL_CALL BU_IndexerV2_MarkFree(IndexerV2* indexer, uint32_t index) {
+DLL_FUNCTION(void) BU_IndexerV2_MarkFree(IndexerV2* indexer, uint32_t index) {
 	indexer->mark(index, false);
 }

-DLL_METHOD void DLL_CALL BU_IndexerV2_MarkUsed(IndexerV2* indexer, uint32_t index) {
+DLL_FUNCTION(void) BU_IndexerV2_MarkUsed(IndexerV2* indexer, uint32_t index) {
 	indexer->mark(index, true);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Is(IndexerV2* indexer, uint32_t index, uint32_t used) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Is(IndexerV2* indexer, uint32_t index, uint32_t used) {
 	return indexer->is(index, used != 0);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_IsFree(IndexerV2* indexer, uint32_t index) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_IsFree(IndexerV2* indexer, uint32_t index) {
 	return indexer->is(index, false);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_IsUsed(IndexerV2* indexer, uint32_t index) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_IsUsed(IndexerV2* indexer, uint32_t index) {
 	return indexer->is(index, true);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Get(IndexerV2* indexer) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Get(IndexerV2* indexer) {
 	return indexer->get();
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Count(IndexerV2* indexer, uint32_t used) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Count(IndexerV2* indexer, uint32_t used) {
 	return indexer->count(used != 0);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountFree(IndexerV2* indexer) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_CountFree(IndexerV2* indexer) {
 	return indexer->count(false);
 }

-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountUsed(IndexerV2* indexer) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_CountUsed(IndexerV2* indexer) {
 	return indexer->count(true);
 }
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -15,7 +15,7 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #pragma once
-#include "dllmain.h"
+#include "BlitzUtility.h"
 #include <vector>

 class IndexerV2 {
@@ -38,28 +38,28 @@ class IndexerV2 {
 		std::vector<IndexerV2Range> range;
 };

-DLL_METHOD IndexerV2* DLL_CALL BU_IndexerV2_Create();
+DLL_FUNCTION(IndexerV2*) BU_IndexerV2_Create();
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Create=_BU_IndexerV2_Create@0")
-DLL_METHOD void DLL_CALL BU_IndexerV2_Destroy(IndexerV2* indexer);
+DLL_FUNCTION(void) BU_IndexerV2_Destroy(IndexerV2* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Destroy=_BU_IndexerV2_Destroy@4")
-DLL_METHOD void DLL_CALL BU_IndexerV2_Mark(IndexerV2* indexer, uint32_t used, uint32_t index);
+DLL_FUNCTION(void) BU_IndexerV2_Mark(IndexerV2* indexer, uint32_t used, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Mark=_BU_IndexerV2_Mark@12")
-DLL_METHOD void DLL_CALL BU_IndexerV2_MarkFree(IndexerV2* indexer, uint32_t index);
+DLL_FUNCTION(void) BU_IndexerV2_MarkFree(IndexerV2* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_MarkFree=_BU_IndexerV2_MarkFree@8")
-DLL_METHOD void DLL_CALL BU_IndexerV2_MarkUsed(IndexerV2* indexer, uint32_t index);
+DLL_FUNCTION(void) BU_IndexerV2_MarkUsed(IndexerV2* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_MarkUsed=_BU_IndexerV2_MarkUsed@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Is(IndexerV2* indexer, uint32_t index, uint32_t used);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Is(IndexerV2* indexer, uint32_t index, uint32_t used);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Is=_BU_IndexerV2_Is@12")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_IsFree(IndexerV2* indexer, uint32_t index);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_IsFree(IndexerV2* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_IsFree=_BU_IndexerV2_IsFree@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_IsUsed(IndexerV2* indexer, uint32_t index);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_IsUsed(IndexerV2* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_IsUsed=_BU_IndexerV2_IsUsed@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Get(IndexerV2* indexer);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Get(IndexerV2* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Get=_BU_IndexerV2_Get@4")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Count(IndexerV2* indexer, uint32_t used);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Count(IndexerV2* indexer, uint32_t used);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Count=_BU_IndexerV2_Count@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountFree(IndexerV2* indexer);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_CountFree(IndexerV2* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_CountFree=_BU_IndexerV2_CountFree@4")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountUsed(IndexerV2* indexer);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_CountUsed(IndexerV2* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_CountUsed=_BU_IndexerV2_CountUsed@4")

@@ -1,5 +1,5 @@
 //	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -15,7 +15,7 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #pragma once
-#include "dllmain.h"
+#include "BlitzUtility.h"
 #include "MassOp.h"

 MassOp::MassOp(uint32_t length) : length(length) {
@@ -26,16 +26,16 @@ MassOp::~MassOp() {
 	delete this->instructions;
 }

-DLL_METHOD MassOp* DLL_CALL BU_MassOp_Create(uint32_t length) {
+DLL_FUNCTION(MassOp*) BU_MassOp_Create(uint32_t length) {
 	MassOp* myMassOp = new MassOp(length);
 	return myMassOp;
 }

-DLL_METHOD void DLL_CALL BU_MassOp_Destroy(MassOp* massop) {
+DLL_FUNCTION(void) BU_MassOp_Destroy(MassOp* massop) {
 	delete massop;
 }

-DLL_METHOD void DLL_CALL BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result) {
+DLL_FUNCTION(void) BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result) {
 	massop->instructions[index].type = type;
 	massop->instructions[index].code = code;
 	massop->instructions[index].leftOperand = leftOperand;
@@ -43,7 +43,7 @@ DLL_METHOD void DLL_CALL BU_MassOp_Instruction(MassOp* massop, uint32_t index, M
 	massop->instructions[index].result = result;
 }

-DLL_METHOD void DLL_CALL BU_MassOp_Run(MassOp* massop) {
+DLL_FUNCTION(void) BU_MassOp_Run(MassOp* massop) {
 	for (uint32_t index = 0; index < massop->length; index++) {
 		MassOpInstruction* instr = &massop->instructions[index];
 		switch (instr->code) {
@@ -1,5 +1,5 @@
 //	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -15,7 +15,7 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #pragma once
-#include "dllmain.h"
+#include "BlitzUtility.h"
 #include "Type\Double.h"
 #include "Type\LongLong.h"

@@ -98,11 +98,11 @@ struct MassOp {
 	MassOpInstruction* instructions;
 };

-DLL_METHOD MassOp* DLL_CALL BU_MassOp_Create(uint32_t length);
+DLL_FUNCTION(MassOp*) BU_MassOp_Create(uint32_t length);
 #pragma comment(linker, "/EXPORT:BU_MassOp_Create=_BU_MassOp_Create@4")
-DLL_METHOD void DLL_CALL BU_MassOp_Destroy(MassOp* massop);
+DLL_FUNCTION(void) BU_MassOp_Destroy(MassOp* massop);
 #pragma comment(linker, "/EXPORT:BU_MassOp_Destroy=_BU_MassOp_Destroy@4")
-DLL_METHOD void DLL_CALL BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result);
+DLL_FUNCTION(void) BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result);
 #pragma comment(linker, "/EXPORT:BU_MassOp_Instruction=_BU_MassOp_Instruction@28")
-DLL_METHOD void DLL_CALL BU_MassOp_Run(MassOp* massop);
+DLL_FUNCTION(void) BU_MassOp_Run(MassOp* massop);
 #pragma comment(linker, "/EXPORT:BU_MassOp_Run=_BU_MassOp_Run@4")
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -60,7 +60,7 @@ LRESULT CALLBACK BU_WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM
 	}
 }

-DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Install(HWND hwnd)
+DLL_FUNCTION(void) BU_WindowMessageHandler_Install(HWND hwnd)
 {
 	WindowUserData* UserData = new WindowUserData;
 	ZeroMemory(UserData, sizeof(UserData));
@@ -68,7 +68,7 @@ DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Install(HWND hwnd)
 	UserData->oUserData = SetWindowLong(hwnd, GWL_USERDATA, (LONG)UserData);
 }

-DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Uninstall(HWND hwnd)
+DLL_FUNCTION(void) BU_WindowMessageHandler_Uninstall(HWND hwnd)
 {
 	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
 	if (UserData) {
@@ -78,7 +78,7 @@ DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Uninstall(HWND hwnd)
 	}
 }

-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point)
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point)
 {
 	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
 	if (UserData) {
@@ -91,7 +91,7 @@ DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Resize(HWND hwnd, L
 	return FALSE;
 }

-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Destroy(HWND hwnd)
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Destroy(HWND hwnd)
 {
 	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
 	if (UserData) {
@@ -102,7 +102,7 @@ DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Destroy(HWND hwnd)
 	return 0;
 }

-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Close(HWND hwnd)
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Close(HWND hwnd)
 {
 	if (hwnd) {
 		WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -15,7 +15,7 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 #pragma once
-#include "dllmain.h"
+#include "BlitzUtility.h"
 #include <list>

 struct WindowUserData {
@@ -37,13 +37,13 @@ void BU_WindowMessageHandler_OnProcessAttach();
 void BU_WindowMessageHandler_OnProcessDetach();
 LRESULT CALLBACK BU_WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

-DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Install(HWND hwnd);
+DLL_FUNCTION(void) BU_WindowMessageHandler_Install(HWND hwnd);
 #pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Install=_BU_WindowMessageHandler_Install@4")
-DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Uninstall(HWND hwnd);
+DLL_FUNCTION(void) BU_WindowMessageHandler_Uninstall(HWND hwnd);
 #pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Uninstall=_BU_WindowMessageHandler_Uninstall@4")
-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point);
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point);
 #pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Resize=_BU_WindowMessageHandler_Message_Resize@8")
-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Destroy(HWND hwnd);
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Destroy(HWND hwnd);
 #pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Destroy=_BU_WindowMessageHandler_Message_Destroy@4")
-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Close(HWND hwnd);
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Close(HWND hwnd);
 #pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Close=_BU_WindowMessageHandler_Message_Close@4")