--[====================================================================================================================[

	I2 Cheat Engine Teleporter


	Version: 1.0.12
		1.0.1:
			* Initial setup.
		1.0.2:
			* Fixed saves memory record creation error.
			* Fixed memory record append on existing memory records.
			* Added "delete" and "rename" functions.
		1.0.3:
			* Added Teleport Back Feature. Back values are saved in "writeToCoords".
			* Added optional camera rotation angle (Pitch, Yaw).
				Not used; if "ptrI2CETeleporterCamRotationAngle" is "nil" or 0 (zero), 
				Not used; if "Pitch" and "Yaw" are not found in save, 
			* Fixed default line end, changed to '\n'.
		1.0.4:
			* Added optional player rotation angle (set from camera rotation angle).
				Not used; if "ptrI2CETeleporterPlayerRotationAngle" is "nil" or 0 (zero).
					Not used; if "ptrI2CETeleporterCamRotationAngle" is "nil" or 0 (zero), 
					Not used; if "Pitch" and "Yaw" are not found in save, 
			* Added "Debug" section to main memory records.
			* Added "WarnForNoSavesTableFile" setting.
			* Added "FlagPointerSymbol" to work with injected writes for the teleporter.
		1.0.5:
			* First release.
		1.0.6:
			* Fixed Auto Load to check for an attached process.
		1.0.7:
			* Fixed bug in delete save function, where save name was being cleared on the request (first call).
		1.0.8:
			* Fixed save name and new save name memory not getting allocated if auto allocate was false.
		1.0.9:
			* Fixed error with "getAddress" needing to be "getAddressSafe".
		1.0.10:
			* Now uses logger module. "I2CETLogger" (v1.0.1)
		1.0.11:
			* Setup to handle multi-threading or aysnc(ed) scripts.
		1.0.12:
			* Added settable read and write functions to allow reading and writing with any data type.


	Author: Matt - TheyCallMeTim13 - MattI2.com



	Features:
		- Set an auto allocated pointer "ptrI2CETeleporterCoord" (user symbol), 
			or "CoordPointerSymbol" (setting) can be set to a string used to get the address.

		- A timer is used for writing to coordinates and rotation angle, just writes multiple times for a second.

		- Writes to coordinates using a saved file with names for lookup.
			- Optionally writes to camera pitch and yaw, and player yaw.
				Note: Only camera pitch and yaw, is read and saved.

		- When writing to the coordinates a flag is set "flgI2CETeleporter" (user symbol), 
			or "FlagPointerSymbol" (setting) can be set to a byte flag address/symbol string.

			This allows for injection based teleport writes, just set "CoordPointerSymbol" 
			to allocated memory (i.e.: X @+0, Y @+4, Z @+8) to read from after byte flag is set to 1.
			- Same for camera rotation angle, but byte flag is offset by +1.
			
		- Includes a function ("generateMemoryRecords") to generate "Teleport to: ??" scripts, 
			that are added to a "Saves" grouped section (memory record).
			Note: Memory records are looked up using the description, so duplicates aren't made, 
				but if the description is changed then a new one will be generated.

		- I got these, Cheese Buggers Man!
			
		- Includes a "Helpers" and "Debug" sections in the default memory records that are generated.

			- A generate memory records script is included in the helpers section. 
			
			- A rename save section is included in the helpers section.
				Note: Only renames the save; new "teleport to" scripts will need to be generated, 
					and old "teleport to" scripts removed (manually).
			
			- A delete save script is included in the helpers section. 
				- the script first requests a save (save name) to be deleted 
					and is only deleted the second time it is enabled.
		
		- Delete function first requests a save to be deleted and is only deleted on second call, 
			unless force equates to true.


	Getting Started:

		Symbols: Must be set:
			"ptrI2CETeleporterCoord" (with a base address), 
				i.e.: "mov [ptrI2CETeleporterCoord],***" (ASM)
			or I2CETeleporter.CoordPointerSymbol (with a symbol/address string).
				i.e.: "I2CETeleporter.CoordPointerSymbol = 'ptrCoordHook'" (Lua)

		Symbols: [Optional]
			"ptrI2CETeleporterCamRotationAngle" (with a base address), 
			or "I2CETeleporter.CamRotationAnglePointerSymbol" (with a symbol/address string).

			"ptrI2CETeleporterPlayerRotationAngle" (with a base address), 
			or "I2CETeleporter.PlayerRotationAnglePointerSymbol" (with a symbol/address string).
				Note: Only "Yaw" is set using camera yaw.

			"ptrI2CETeleporterWaypoint" (with a base address), 
			or "I2CETeleporter.WaypointPointerSymbol" (with a symbol/address string).

		Offsets: [Optional]
			"I2CETeleporter.Xoffset" (default: 0)
			"I2CETeleporter.Yoffset" (default: 4)
			"I2CETeleporter.Zoffset" (default: 8)

			"I2CETeleporter.WayXoffset" (default: 0)
			"I2CETeleporter.WayYoffset" (default: 4)
			"I2CETeleporter.WayZoffset" (default: 8)

			"I2CETeleporter.PlayerYawOffset" (default: 0)
			"I2CETeleporter.CamPitchOffset" (default: 0)
			"I2CETeleporter.CamYawOffset" (default: 4)

		Adjusters: [Optional]
			"I2CETeleporter.XaddOnWrite" (default: 0)
			"I2CETeleporter.YaddOnWrite" (default: 0)
			"I2CETeleporter.ZaddOnWrite" (default: 0)

			"I2CETeleporter.XaddOnRead" (default: 0)
			"I2CETeleporter.YaddOnRead" (default: 0)
			"I2CETeleporter.ZaddOnRead" (default: 0)

			"I2CETeleporter.WayXaddOnRead" (default: 0)
			"I2CETeleporter.WayYaddOnRead" (default: 0)
			"I2CETeleporter.WayZaddOnRead" (default: 0)

		Data Write Functions: [Optional]
				CoordWrite (default: writeFloat)
				CoordWriteString, for use in templates. (default: "writeFloat")
					key: "CoordWrite")
				PlayerRotationAngleWrite (default: writeFloat)
				PlayerRotationAngleWriteString, for use in templates. (default: "writeFloat")
					key: "PlayerRotationAngleWrite")
				CamRotationAngleWrite (default: writeFloat)
				CamRotationAngleWriteString, for use in templates. (default: "writeFloat")
					key: "CamRotationAngleWrite")

		Data Read Functions: [Optional]
				CoordRead (default: readFloat)
				CoordReadString, for use in templates. (default: "readFloat")
					key: "CoordRead"
				PlayerRotationAngleRead (default: readFloat)
				PlayerRotationAngleReadString, for use in templates. (default: "readFloat")
					key: "PlayerRotationAngleRead"
				CamRotationAngleRead (default: readFloat)
				CamRotationAngleReadString, for use in templates. (default: "readFloat")
					key: "CamRotationAngleRead"
				WaypointRead (default: readFloat)
				WaypointReadString, for use in templates. (default: "readFloat")
					key: "WaypointRead"


		Examples:
			Starter Example:
				Code (Lua):
					dofile([[E:\Where\Ever\The\Module\Is\I2CETeleporter.Lua]])
					I2CETeleporter.CoordPointerSymbol = '"Game.exe"+123ABC0'
					I2CETeleporter.Xoffset = 0x60
					I2CETeleporter.Yoffset = 0x64
					I2CETeleporter.Zoffset = 0x68
					---- Comment out or remove after starter memory records are generated.
					I2CETeleporter.generateMemoryRecords()
					---- END: Comment out or remove after starter memory records are generated.

			Example:
				Code (Lua):
					require 'I2CETeleporter'
					I2CETeleporter.AutoAllocate = false
					I2CETeleporter.CoordPointerSymbol = '[["Game.exe"+123ABC0]+10]+5D0'
					I2CETeleporter.CoordWrite = writeDouble
					I2CETeleporter.CoordWriteString = 'writeDouble'

			Example:
				Code (Lua):
					require 'I2CETeleporter'
					I2CETeleporter.AutoAllocate = false
					I2CETeleporter.CoordPointerSymbol = 'ptrCoordHook'
					I2CETeleporter.CoordWrite = writeDouble
					I2CETeleporter.CoordWriteString = 'writeDouble'

			Example:
				Code (Lua):
					require 'I2CETeleporter'
					I2CETeleporter.Xoffset = 0x60
					I2CETeleporter.Yoffset = 0x64
					I2CETeleporter.Zoffset = 0x68
				Code (ASM):
					...
					mov [ptrI2CETeleporterCoord],rax
					...
			Example:
				Code (Lua):
					require 'I2CETeleporter'
				Code (ASM):
					...
					mov [ptrI2CETeleporterCoord],rax
					add [ptrI2CETeleporterCoord],60
					...


		Call to generate starter memory records:
			
			"I2CETeleporter.generateMemoryRecords()"

			Note: Form then on you can use the "Generate Memory Records" in the "Helpers" section.



	Settings:
		Symbol Names:
			FlagPointerSymbol (default: 'flgI2CETeleporter')
			CoordPointerSymbol (default: 'ptrI2CETeleporterCoord')
			PlayerRotationAnglePointerSymbol (default: 'ptrI2CETeleporterPlayerRotationAngle')
			CamRotationAnglePointerSymbol (default: 'ptrI2CETeleporterCamRotationAngle')
			WaypointPointerSymbol (default: 'ptrI2CETeleporterWaypoint')
			SaveNameStringSymbol (default: 'strI2CETeleporterSaveName')
			NewSaveNameStringSymbol (default: 'strI2CETeleporterSaveNameNew')
		----
		MainMemoryRecordDescription (default: '_[  I2CETeleporter  ]_')
		SavesMemoryRecordDescription (default: '_[  Saves  ]_' [translated])
		----
		AutoLoad (default: true)
		AutoAllocate (default: true)
		AutoLoadAndSave (default: true)
		SavesFileName (default: 'I2CETeleporterSaves.txt')
		SavesFileAsTableFile (default: false)
		OverRideSaveMemoryRecords (default: false)
		AutoSaveSavesFile (default: true)
		WarnIfSavesTableFileNotFound (default: false)
		----
		WriteToCoordsTimerInterval (default: 100)
		WriteToCoordsTimerTicksMax (default: 100)
		SetCamRotationAngleTimerInterval (default: 100)
		SetCamRotationAngleTimerTicksMax (default: 100)
		----
		Xoffset (default: 0)
		Yoffset (default: 4)
		Zoffset (default: 8)
		XaddOnWrite (default: 0)
		YaddOnWrite (default: 0)
		ZaddOnWrite (default: 0)
		XaddOnRead (default: 0)
		YaddOnRead (default: 0)
		ZaddOnRead (default: 0)
		WayXoffset (default: 0)
		WayYoffset (default: 4)
		WayZoffset (default: 8)
		WayXaddOnRead (default: 0)
		WayYaddOnRead (default: 0)
		WayZaddOnRead (default: 0)
		PlayerYawOffset (default: 0)
		CamPitchOffset (default: 0)
		CamYawOffset (default: 4)
		----
		SaveMemoryRecord (table)
		MainMemoryRecords (table)
		----
		CoordWrite (default: writeFloat)
		CoordWriteString (default: "writeFloat")
		PlayerRotationAngleWrite (default: writeFloat)
		PlayerRotationAngleWriteString (default: "writeFloat")
		CamRotationAngleWrite (default: writeFloat)
		CamRotationAngleWriteString (default: "writeFloat")
		----
		CoordRead (default: readFloat)
		CoordReadString (default: "readFloat")
		PlayerRotationAngleRead (default: readFloat)
		PlayerRotationAngleReadString (default: "readFloat")
		CamRotationAngleRead (default: readFloat)
		CamRotationAngleReadString (default: "readFloat")
		WaypointRead (default: readFloat)
		WaypointReadString (default: "readFloat")

	Symbol Addresses:
		FlagPointerAddress
		CoordPointerAddress
		PlayerRotationAnglePointerAddress
		CamRotationAnglePointerAddress
		WaypointPointerAddress
		SaveNameStringAddress
		NewSaveNameStringAddress

	Template Keys:
			- Keys to be used in script templates and memory record strings.
				format:
					${TemplateKey}

		SaveName
		----
		FlagPointerSymbol
		FlagPointerAddress
		CoordPointerSymbol
		CoordPointerAddress
		PlayerRotationAnglePointerSymbol
		PlayerRotationAnglePointerAddress
		CamRotationAnglePointerSymbol
		CamRotationAnglePointerAddress
		WaypointPointerSymbol
		WaypointPointerAddress
		SaveNameStringSymbol
		SaveNameStringAddress
		NewSaveNameStringSymbol
		NewSaveNameStringAddress
		----
		Xoffset
		Yoffset
		Zoffset
		WayXoffset
		WayYoffset
		WayZoffset
		PlayerYawOffset
		CamPitchOffset 
		CamYawOffset
		----
		X
		Y
		Z
		WayX
		WayY
		WayZ
		CamPitch
		CamYaw
		----
		CoordWrite
		CoordWriteString
		PlayerRotationAngleWrite
		PlayerRotationAngleWriteString
		CamRotationAngleWrite
		CamRotationAngleWriteString
		----
		CoordRead
		CoordReadString
		PlayerRotationAngleRead
		PlayerRotationAngleReadString
		CamRotationAngleRead
		CamRotationAngleReadString
		WaypointRead
		WaypointReadString


--------------
I2CETeleporter.CoordWrite = writeDouble
I2CETeleporter.CoordWriteString = 'writeDouble'
I2CETeleporter.PlayerRotationAngleWrite = writeDouble
I2CETeleporter.PlayerRotationAngleWriteString = 'writeDouble'
I2CETeleporter.CamRotationAngleWrite = writeDouble
I2CETeleporter.CamRotationAngleWriteString = 'writeDouble'
--
I2CETeleporter.CoordRead = readDouble
I2CETeleporter.CoordReadString = 'readDouble'
I2CETeleporter.PlayerRotationAngleRead = readDouble
I2CETeleporter.PlayerRotationAngleReadString = 'readDouble'
I2CETeleporter.CamRotationAngleRead = readDouble
I2CETeleporter.CamRotationAngleReadString = 'readDouble'
I2CETeleporter.WaypointRead = readDouble
I2CETeleporter.WaypointReadString = 'readDouble'
----
{$lua}
I2CETeleporter.CoordPointerSymbol = '[[ptrPlayerHook]+30]+48'
I2CETeleporter.Xoffset = 0x20
I2CETeleporter.Yoffset = 0x24
I2CETeleporter.Zoffset = 0x28
I2CETeleporter.PlayerRotationAnglePointerSymbol = '[[ptrPlayerHook]+30]+48'
I2CETeleporter.PlayerYawOffset = 0x84
I2CETeleporter.CamRotationAnglePointerSymbol = '[[ptrPlayerHook]+38]+B8'
I2CETeleporter.CamPitchOffset = 0x270
I2CETeleporter.CamYawOffset = 0x274
I2CETeleporter.CamYawToPlayerYaw = function(cY) return (cY / 3) end
I2CETeleporter.WaypointPointerSymbol = 'ptrWaypointHook'
I2CETeleporter.WayXoffset = 0x10
I2CETeleporter.WayYoffset = 0x14
I2CETeleporter.WayZoffset = 0x18
I2CETeleporter.WayYaddOnRead = 3
{$asm}
----
{$lua}
I2CETeleporter.CoordPointerSymbol = ''
I2CETeleporter.Xoffset = 0x
I2CETeleporter.Yoffset = 0x
I2CETeleporter.Zoffset = 0x
I2CETeleporter.PlayerRotationAnglePointerSymbol = ''
I2CETeleporter.PlayerYawOffset = 0x
-- I2CETeleporter.CamYawToPlayerYaw = function(cY) return cY end
I2CETeleporter.CamRotationAnglePointerSymbol = ''
I2CETeleporter.CamPitchOffset = 0x
I2CETeleporter.CamYawOffset = 0x
I2CETeleporter.WaypointPointerSymbol = ''
I2CETeleporter.WayXoffset = 0x
I2CETeleporter.WayYoffset = 0x
I2CETeleporter.WayZoffset = 0x
I2CETeleporter.WayYaddOnRead = 0
{$asm}
----
I2CETeleporter.initMemory()

]====================================================================================================================]--

local NAME = 'I2 Cheat Engine Teleporter'
local CLASS_NAME = 'I2CETeleporter'
local VERSION = '1.0.11'
local AUTHOR = 'Matt Irwin; Matt.Irwin.US@Gmail.com'
local LICENSE = [=[MIT License

Copyright (c) 2018 Matt Irwin

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sub-license, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
]=]


local format = string.format
local strE = string.empty or STRING_EMPTY or ''
local t = translate

if MainForm == nil then
	MainForm = getMainForm()
end
if AddressList == nil then
	AddressList = getAddressList()
end


local DEBUG = DEBUG or false

local LineEnd = '\n'


local AutoLoad = true
local AutoAllocate = AutoLoad
local AutoLoadAndSave = true
local SavesFileName = 'I2CETeleporterSaves.txt'
local SavesFileAsTableFile = false
local OverRideSaveMemoryRecords = false
local AutoSaveSavesFile = true
local WarnIfSavesTableFileNotFound = DEBUG
local LogSavesRead = DEBUG

local CoordWrite = writeFloat
local CoordWriteString = 'writeFloat'
local PlayerRotationAngleWrite = writeFloat
local PlayerRotationAngleWriteString = 'writeFloat'
local CamRotationAngleWrite = writeFloat
local CamRotationAngleWriteString = 'writeFloat'

local CoordRead = readFloat
local CoordReadString = 'readFloat'
local PlayerRotationAngleRead = readFloat
local PlayerRotationAngleReadString = 'readFloat'
local CamRotationAngleRead = readFloat
local CamRotationAngleReadString = 'readFloat'

local WaypointRead = readFloat
local WaypointReadString = 'readFloat'

local WriteToCoordsTimerInterval = 100
local WriteToCoordsTimerTicksMax = 5
local SetCamRotationAngleTimerInterval = 100
local SetCamRotationAngleTimerTicksMax = 5

local MainMemoryRecordDescription = '_[  I2CETeleporter  ]_'
local SavesMemoryRecordDescription = '_[  ' .. t('Saves') .. '  ]_'
local FlagPointerSymbol = 'flgI2CETeleporter'
local CoordPointerSymbol = 'ptrI2CETeleporterCoord'
local PlayerRotationAnglePointerSymbol = 'ptrI2CETeleporterPlayerRotationAngle'
local CamRotationAnglePointerSymbol = 'ptrI2CETeleporterCamRotationAngle'
local WaypointPointerSymbol = 'ptrI2CETeleporterWaypoint'
local SaveNameStringSymbol = 'strI2CETeleporterSaveName'
local NewSaveNameStringSymbol = 'strI2CETeleporterSaveNameNew'
local DataDelimiter = '<sep>'

local SaveNameStringMax = 60



local Colors = {
	Black = 0x000000, 
	White = 0xFFFFFF, 
	Silver = 0xC0C0C0, 
	Grey = 0x808080, 
	Red = 0x0000FF, -- 0xFF0000
	Maroon = 0x000080, -- 0x800000
	Yellow = 0x00FFFF, -- 0xFFFF00
	Olive = 0x008080, -- 0x808000
	Lime = 0x00FF00, 
	Green = 0x008000, 
	Aqua = 0xFFFF00, -- 0x00FFFF
	Teal = 0x808000, -- 0x008080
	Blue = 0xFF0000, -- 0x0000FF
	Navy = 0x800000, -- 0x000080
	Fuchsia = 0xFF00FF, 
	Purple = 0x800080,
}


-- local Logger = {
-- 	LEVELS = {
-- 		OFF = 0, 
-- 		FATAL = 1, 
-- 		ERROR = 2, 
-- 		WARN = 3, 
-- 		INFO = 4, 
-- 		DEBUG = 5, 
-- 		TRACE = 6
-- 	}, 
-- }
-- for k, v in pairs(Logger.LEVELS) do
-- 	-- Logger[k:lower()] = function( ... ) return end
-- 	-- Logger[k:lower() .. 'f'] = function( ... ) return end
-- 	Logger[k:lower()] = function(msg, ex) return print(msg, ex) end
-- 	Logger[k:lower() .. 'f'] = function(msg, ... ) return print(string.format(msg, ... )) end
-- end
local Logger = Logger
if Logger == nil then
	if type(CETrequire) == 'function' then
		Logger = CETrequire('I2CETLogger')
	else
		Logger = require('I2CETLogger')
	end
	Logger.LogName = 'CETtele'
end


if type(CETrequire) == 'function' then
	I2CEHelpers = CETrequire('I2CEHelpers')
else
	I2CEHelpers = require('I2CEHelpers')
end

local function split(s, delimiter)
	return I2CEHelpers.split(s, delimiter)
end

local function interp(s, tbl)
	return I2CEHelpers.interp(s, tbl)
end

local function padR(str, len, char)
	return I2CEHelpers.padR(s, len, char)
end

local function titleCase(s, s_char)
	return I2CEHelpers.titleCase(s, s_char)
end

local function getPointerSize()
	return I2CEHelpers.getPointerSize()
end

local function getPointerSizeStrs()
	return I2CEHelpers.getPointerSizeStrs()
end


--[====[
Keys:
	SaveName
	----
	FlagPointerSymbol
	FlagPointerAddress
	CoordPointerSymbol
	CoordPointerAddress
	PlayerRotationAnglePointerSymbol
	PlayerRotationAnglePointerAddress
	CamRotationAnglePointerSymbol
	CamRotationAnglePointerAddress
	WaypointPointerSymbol
	WaypointPointerAddress
	----
	SaveNameStringSymbol
	SaveNameStringAddress
	NewSaveNameStringSymbol
	NewSaveNameStringAddress
	----
	Xoffset
	Yoffset
	Zoffset
	PlayerYawOffset
	CamPitchOffset 
	CamYawOffset
	WayXoffset
	WayYoffset
	WayZoffset
	----
	X
	Y
	Z
	CamPitch
	CamYaw
	WayX
	WayY
	WayZ
	----
	CoordWrite
	CoordWriteString
	PlayerRotationAngleWrite
	PlayerRotationAngleWriteString
	CamRotationAngleWrite
	CamRotationAngleWriteString
	----
	CoordRead
	CoordReadString
	PlayerRotationAngleRead
	PlayerRotationAngleReadString
	CamRotationAngleRead
	CamRotationAngleReadString
	WaypointRead
	WaypointReadString
]====]--

local DEFAULT_SCRIPT_COLOR = Colors.Green
local DEFAULT_SAVE_MR_DESCRIPTION = t('Teleport to') .. ':  ${SaveName}  ()->'
local DEFAULT_SAVE_MR_SCRIPT = [==============================[
{$lua}
---- ${SaveName}
---- ${CoordPointerSymbol}: ${CoordPointerAddress}
---- ${X}, ${Y}, ${Z}
[Enable]
if syntaxcheck then return end
I2CETeleporter.teleport("${SaveName}")
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local SaveLocationScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.save()
I2CETeleporter.generateMemoryRecords()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local TeleportToSaveScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.teleport()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local TeleportBackScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.teleportBack()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local TeleportToWaypointScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.teleportToWaypoint()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local WriteSavesToFileScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.writeSavesToFile()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local ReadFromFileScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.readSavesFromFile()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local PrintSavesScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.printSaves()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local generateMemoryRecordsScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.generateMemoryRecords()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local DeleteSaveScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.delete()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local RenameSaveScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.rename()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local ZeroCamRotationAngleScript = [==============================[
{$lua}
[Enable]
if syntaxcheck then return end
I2CETeleporter.zeroCamRotationAngle()
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]
local SetLoggerLevelScript = [==============================[
{$lua}
[Enable]
-- OFF
-- FATAL
-- ERROR
-- WARN
-- INFO
-- DEBUG
-- TRACE
if syntaxcheck then return end
I2CETeleporter.Logger.Level = I2CETeleporter.Logger.LEVELS.INFO
if type(mrAutoDisable) == 'function' then
	mrAutoDisable(memrec.ID)
end
[Disable]
]==============================]


I2CETeleporter = {
	Name = NAME, 
	ClassName = CLASS_NAME, 
	Version = VERSION, 
	Author = AUTHOR, 
	License = LICENSE, 
	MainMemoryRecordDescription = MainMemoryRecordDescription, 
	SavesMemoryRecordDescription = SavesMemoryRecordDescription, 
	FlagPointerSymbol = FlagPointerSymbol, 
	-- FlagPointerAddress = 0, 
	CoordPointerSymbol = CoordPointerSymbol, 
	-- CoordPointerAddress = 0, 
	PlayerRotationAnglePointerSymbol = PlayerRotationAnglePointerSymbol,
	-- PlayerRotationAnglePointerAddress = 0,
	CamRotationAnglePointerSymbol = CamRotationAnglePointerSymbol,
	-- CamRotationAnglePointerAddress = 0,
	WaypointPointerSymbol = WaypointPointerSymbol, 
	-- WaypointPointerAddress = 0, 
	SaveNameStringSymbol = SaveNameStringSymbol, 
	-- SaveNameStringAddress = 0, 
	NewSaveNameStringSymbol = NewSaveNameStringSymbol,
	-- NewSaveNameStringAddress = 0, 
	AutoLoad = AutoLoad, 
	AutoAllocate = AutoAllocate, 
	AutoLoadAndSave = AutoLoadAndSave, 
	SavesFileName = SavesFileName, 
	SavesFileAsTableFile = SavesFileAsTableFile, 
	OverRideSaveMemoryRecords = OverRideSaveMemoryRecords, 
	AutoSaveSavesFile = AutoSaveSavesFile, 
	WriteToCoordsTimerInterval = WriteToCoordsTimerInterval, 
	WriteToCoordsTimerTicksMax = WriteToCoordsTimerTicksMax,
	SetCamRotationAngleTimerInterval = SetCamRotationAngleTimerInterval, 
	SetCamRotationAngleTimerTicksMax = SetCamRotationAngleTimerTicksMax, 
	WarnIfSavesTableFileNotFound = WarnIfSavesTableFileNotFound, 
	LogSavesRead = LogSavesRead, 
	----
	CoordWrite = CoordWrite,
	CoordWriteString = CoordWriteString,
	PlayerRotationAngleWrite = PlayerRotationAngleWrite,
	PlayerRotationAngleWriteString = PlayerRotationAngleWriteString,
	CamRotationAngleWrite = CamRotationAngleWrite,
	CamRotationAngleWriteString = CamRotationAngleWriteString,
	----
	CoordRead = CoordRead, 
	CoordReadString = CoordReadString, 
	PlayerRotationAngleRead = PlayerRotationAngleRead, 
	PlayerRotationAngleReadString = PlayerRotationAngleReadString, 
	CamRotationAngleRead = CamRotationAngleRead, 
	CamRotationAngleReadString = CamRotationAngleReadString, 
	WaypointRead = WaypointRead, 
	WaypointReadString = WaypointReadString, 
	----
	Xoffset = 0, 
	Yoffset = 4, 
	Zoffset = 8, 
	----
	PlayerYawOffset = 4, 
	----
	CamPitchOffset = 0, 
	CamYawOffset = 4, 
	----
	XaddOnWrite = 0, 
	YaddOnWrite = 0, 
	ZaddOnWrite = 0, 
	----
	XaddOnRead = 0, 
	YaddOnRead = 0, 
	ZaddOnRead = 0, 
	----
	WayXoffset = 0, 
	WayYoffset = 4, 
	WayZoffset = 8, 
	----
	WayXaddOnRead = 0, 
	WayYaddOnRead = 0, 
	WayZaddOnRead = 0, 
	----
	SaveMemoryRecord = {
		Description = DEFAULT_SAVE_MR_DESCRIPTION, 
		Type = vtAutoAssembler, 
		Script = DEFAULT_SAVE_MR_SCRIPT, 
		Color = DEFAULT_SCRIPT_COLOR, 
	},
	----
	MainMemoryRecords = {
		Description = MainMemoryRecordDescription, 
		IsGroupHeader = true, 
		options = "[moHideChildren]", 
		MemoryRecords = {
			{
				Description = '**  ' .. t('See "Saves" section for stored saves.') .. '  **', 
				IsGroupHeader = true, 
				Color = Colors.Maroon, 
			}, 
			{
				Description = t('Save Name'), 
				Type = vtString, 
				Address = '${SaveNameStringSymbol}', 
				Color = Colors.Blue, 
				String = {
					Size = SaveNameStringMax, 
				}, 
			}, 
			{
				Description = t('Save Location') .. '  ()->', 
				Type = vtAutoAssembler, 
				Color = DEFAULT_SCRIPT_COLOR, 
				Script = SaveLocationScript, 
			}, 
			{
				Description = t('Teleport To: Save (Save Name)') .. '  ()->', 
				Type = vtAutoAssembler, 
				Color = DEFAULT_SCRIPT_COLOR, 
				Script = TeleportToSaveScript, 
			}, 
			{
				Description = t('Teleport To: Waypoint') .. '  ()->', 
				Type = vtAutoAssembler, 
				Color = DEFAULT_SCRIPT_COLOR, 
				Script = TeleportToWaypointScript, 
			}, 
			{
				Description = t('Teleport: Back') .. '  ()->', 
				Type = vtAutoAssembler, 
				Color = DEFAULT_SCRIPT_COLOR, 
				Script = TeleportBackScript, 
			}, 
			{
				Description = SavesMemoryRecordDescription, 
				IsGroupHeader = true, 
				options = "[moHideChildren]", 
				AppendSaves = true, 
			}, 
			{
				Description = '_[  Helpers - I2CETeleporter  ]_', 
				IsGroupHeader = true, 
				options = "[moHideChildren]", 
				Color = Colors.Grey, 
				MemoryRecords = {
					{
						Description = t('Generate Memory Records') .. '  ()->', 
						Type = vtAutoAssembler, 
						Color = DEFAULT_SCRIPT_COLOR, 
						Script = generateMemoryRecordsScript, 
					}, 
					{
						Description = t('Zero Camera Rotation Angle') .. '  ()->', 
						Type = vtAutoAssembler, 
						Color = DEFAULT_SCRIPT_COLOR, 
						Script = ZeroCamRotationAngleScript, 
					}, 
					{
						Description = t('Write Saves To File') .. '  ()->', 
						Type = vtAutoAssembler, 
						Color = DEFAULT_SCRIPT_COLOR, 
						Script = WriteSavesToFileScript, 
					}, 
					{
						Description = t('Print Saves') .. '  ()->', 
						Type = vtAutoAssembler, 
						Color = DEFAULT_SCRIPT_COLOR, 
						Script = PrintSavesScript, 
					}, 
					{
						Description = '_[  Rename Save  ]_', 
						IsGroupHeader = true, 
						options = "[moHideChildren]", 
						MemoryRecords = {
							{
								Description = t('Save Name (to rename)'), 
								Type = vtString, 
								Address = '${SaveNameStringSymbol}', 
								Color = Colors.Blue, 
								String = {
									Size = SaveNameStringMax, 
								}, 
							}, 
							{
								Description = t('New Save Name'), 
								Type = vtString, 
								Address = '${NewSaveNameStringSymbol}', 
								Color = Colors.Blue, 
								String = {
									Size = SaveNameStringMax, 
								}, 
							}, 
							{
								Description = t('Rename Save') .. '  ()->', 
								Type = vtAutoAssembler, 
								Color = DEFAULT_SCRIPT_COLOR, 
								Script = RenameSaveScript, 
							}, 
						}, 
					},
					{
						Description = t('Read From File') .. '  ()->', 
						Type = vtAutoAssembler, 
						Color = DEFAULT_SCRIPT_COLOR, 
						Script = ReadFromFileScript, 
					}, 
					{
						Description = t('Delete Save ** Must Enable 2 Times **') .. '  ()->', 
						Type = vtAutoAssembler, 
						Color = DEFAULT_SCRIPT_COLOR, 
						Script = DeleteSaveScript, 
					}, 
					{
						Description = t('Set Logger Level - I2CETeleporter') .. '  ()->', 
						Type = vtAutoAssembler, 
						Color = DEFAULT_SCRIPT_COLOR, 
						Script = SetLoggerLevelScript, 
					}, 
				}, 
			},
			{
				Description = '_[  Debug - I2CETeleporter  ]_', 
				IsGroupHeader = true, 
				options = "[moHideChildren]", 
				Color = Colors.Grey, 
				MemoryRecords = {
					{
						Description = '${SaveNameStringSymbol}', 
						Type = vtString, 
						Address = '${SaveNameStringSymbol}', 
						Color = Colors.Fuchsia, 
						String = {
							Size = SaveNameStringMax, 
						}, 
					}, 
					{
						Description = '${NewSaveNameStringSymbol}', 
						Type = vtString, 
						Address = '${NewSaveNameStringSymbol}', 
						Color = Colors.Fuchsia, 
						String = {
							Size = SaveNameStringMax, 
						}, 
					}, 
					{
						Description = '${FlagPointerSymbol}', 
						Address = '${FlagPointerSymbol}', 
						Color = Colors.Fuchsia, 
						Type = vtByte, 
						ShowAsHex = true, 
						DropDownList = {
							Text = '00:' .. t('Disabled') .. '\n01:' .. t('Enabled') .. '\n', 
						}, 
						DropDownReadOnly = true, ---- Disallow manual user input
						DropDownDescriptionOnly = true, ---- Only show the description part
						DisplayAsDropDownListItem = true, ---- Make the record display values like the dropdownlist
					}, 
					{
						Description = '${FlagPointerSymbol}+1', 
						Address = '${FlagPointerSymbol}+1', 
						Color = Colors.Fuchsia, 
						Type = vtByte, 
						ShowAsHex = true, 
						DropDownList = {
							Text = '00:' .. t('Disabled') .. '\n01:' .. t('Enabled') .. '\n', 
						}, 
						DropDownReadOnly = true, ---- Disallow manual user input
						DropDownDescriptionOnly = true, ---- Only show the description part
						DisplayAsDropDownListItem = true, ---- Make the record display values like the dropdownlist
					}, 
					{
						Description = '${CoordPointerSymbol}', 
						Type = 'Pointer', 
						Address = '${CoordPointerSymbol}', 
						Color = Colors.Grey, 
						ShowAsHex = true, 
					}, 
					{
						Description = '${PlayerRotationAnglePointerSymbol}', 
						Type = 'Pointer', 
						Address = '${PlayerRotationAnglePointerSymbol}', 
						Color = Colors.Grey, 
						ShowAsHex = true, 
					}, 
					{
						Description = '${CamRotationAnglePointerSymbol}', 
						Type = 'Pointer', 
						Address = '${CamRotationAnglePointerSymbol}', 
						Color = Colors.Grey, 
						ShowAsHex = true, 
					}, 
					{
						Description = '${WaypointPointerSymbol}', 
						Type = 'Pointer', 
						Address = '${WaypointPointerSymbol}', 
						Color = Colors.Grey, 
						ShowAsHex = true, 
					}, 
				}, 
			},
		}, 
	},
	----
	DataDelimiter = DataDelimiter, 
	LineEnd = LineEnd, 
	----
	-- Finalized = false, 
	----
	-- Saves = {
	-- 	['Save Name'] = {
	-- 		X = #f.9, 
	-- 		Y = #f.9, 
	-- 		Z = #f.9, 
	-- 		CamPitch = #f.9, 
	-- 		CamYaw = #f.9, 
	-- 	}, 
	-- }, 
	Logger = Logger,
}
function I2CETeleporter.CamYawToPlayerYaw(cY) -- Set for conversions.
	return cY
end


function I2CETeleporter.initialize()
	Logger.trace()
	Logger.debug('Initializing')
	local function I2CETeleporterInitMemoryTimer_tick(timer)
		if process ~= nil then
			Logger.debugf('Killing timer: %s', timer)
			timer.destroy()
			if I2CETeleporter.AutoLoad then
				Logger.info('Auto loading')
				I2CETeleporter.initMemory()
				if I2CETeleporter.AutoLoadAndSave then
					Logger.debugf('Hooking main form "OnClose": "%s"', MainForm.OnClose)
					I2CETeleporter.readSavesFromFile()
					I2CETeleporter.MainFormOnClose = MainForm.OnClose
					MainForm.OnClose = I2CETeleporter.OnClose
				end
			end
			Logger.infof('Initialized')
		end
	end
	local intervals = 1000
	local timer = createTimer(MainForm)
	timer.Interval = intervals
	timer.OnTimer = I2CETeleporterInitMemoryTimer_tick
	Logger.info('Timer started')
end

function I2CETeleporter.finalize()
	Logger.trace()
	Logger.debug('Finalizing')
	if I2CETeleporter.AutoLoadAndSave then --- Can't save table file on close with out forcing table save.
		I2CETeleporter.writeSavesToFile()
	end
	I2CETeleporter.finaMemory()
end

function I2CETeleporter.OnClose(sender)
	Logger.trace()
	if not I2CETeleporter.Finalized then
		Logger.infof('Calling main form "OnClose"')
		MainForm.OnClose = I2CETeleporter.MainFormOnClose
		I2CETeleporter.Finalized = true
		closeCE()
	end
end

function I2CETeleporter.initMemory()
	Logger.trace()
	Logger.debug('Initializing memory')
	local pointerSize, pointerSizeStr, pointerFtmStr, pointerWordSize, pointerDefaultStr = getPointerSizeStrs()

	if I2CETeleporter.AutoAllocate then
		if getAddressSafe(I2CETeleporter.FlagPointerSymbol) then
			deAlloc(I2CETeleporter.FlagPointerSymbol)
			unregisterSymbol(I2CETeleporter.FlagPointerSymbol)
		end
		I2CETeleporter.FlagPointerAddress = allocateSharedMemory(I2CETeleporter.FlagPointerSymbol, getPointerSize() or 0x8)
		if I2CETeleporter.FlagPointerAddress then
			Logger.debugf('Memory allocated: %s, ' .. pointerFtmStr, I2CETeleporter.FlagPointerSymbol, 
																		I2CETeleporter.FlagPointerAddress)
			registerSymbol(I2CETeleporter.FlagPointerSymbol, I2CETeleporter.FlagPointerAddress, true)
		else
			Logger.warnf('Memory allocation failed: %s', I2CETeleporter.FlagPointerSymbol)
		end
		local addrF = getAddressSafe(I2CETeleporter.FlagPointerSymbol)
		if addrF ~= nil and addrF ~= 0 then
			writeBytes(addrF, 0, 0)
		end

		if getAddressSafe(I2CETeleporter.CoordPointerSymbol) then
			deAlloc(I2CETeleporter.CoordPointerSymbol)
			unregisterSymbol(I2CETeleporter.CoordPointerSymbol)
		end
		I2CETeleporter.CoordPointerAddress = allocateSharedMemory(I2CETeleporter.CoordPointerSymbol, getPointerSize() or 0x8)
		if I2CETeleporter.CoordPointerAddress then
			Logger.debugf('Memory allocated: %s, ' .. pointerFtmStr, I2CETeleporter.CoordPointerSymbol, 
																		I2CETeleporter.CoordPointerAddress)
			registerSymbol(I2CETeleporter.CoordPointerSymbol, I2CETeleporter.CoordPointerAddress, true)
		else
			Logger.warnf('Memory allocation failed: %s', I2CETeleporter.CoordPointerSymbol)
		end

		if getAddressSafe(I2CETeleporter.PlayerRotationAnglePointerSymbol) then
			deAlloc(I2CETeleporter.PlayerRotationAnglePointerSymbol)
			unregisterSymbol(I2CETeleporter.PlayerRotationAnglePointerSymbol)
		end
		I2CETeleporter.PlayerRotationAnglePointerAddress = allocateSharedMemory(I2CETeleporter.PlayerRotationAnglePointerSymbol, getPointerSize() or 0x8)
		if I2CETeleporter.PlayerRotationAnglePointerAddress then
			Logger.debugf('Memory allocated: %s, ' .. pointerFtmStr, I2CETeleporter.PlayerRotationAnglePointerSymbol, 
																		I2CETeleporter.PlayerRotationAnglePointerAddress)
			registerSymbol(I2CETeleporter.PlayerRotationAnglePointerSymbol, I2CETeleporter.PlayerRotationAnglePointerAddress, true)
		else
			Logger.warnf('Memory allocation failed: %s', I2CETeleporter.PlayerRotationAnglePointerSymbol)
		end

		if getAddressSafe(I2CETeleporter.CamRotationAnglePointerSymbol) then
			deAlloc(I2CETeleporter.CamRotationAnglePointerSymbol)
			unregisterSymbol(I2CETeleporter.CamRotationAnglePointerSymbol)
		end
		I2CETeleporter.CamRotationAnglePointerAddress = allocateSharedMemory(I2CETeleporter.CamRotationAnglePointerSymbol, getPointerSize() or 0x8)
		if I2CETeleporter.CamRotationAnglePointerAddress then
			Logger.debugf('Memory allocated: %s, ' .. pointerFtmStr, I2CETeleporter.CamRotationAnglePointerSymbol, 
																		I2CETeleporter.CamRotationAnglePointerAddress)
			registerSymbol(I2CETeleporter.CamRotationAnglePointerSymbol, I2CETeleporter.CamRotationAnglePointerAddress, true)
		else
			Logger.warnf('Memory allocation failed: %s', I2CETeleporter.CamRotationAnglePointerSymbol)
		end

		if getAddressSafe(I2CETeleporter.WaypointPointerSymbol) then
			deAlloc(I2CETeleporter.WaypointPointerSymbol)
			unregisterSymbol(I2CETeleporter.WaypointPointerSymbol)
		end
		I2CETeleporter.WaypointPointerAddress = allocateSharedMemory(I2CETeleporter.WaypointPointerSymbol, getPointerSize() or 0x8)
		if I2CETeleporter.WaypointPointerAddress then
			Logger.debugf('Memory allocated: %s, ' .. pointerFtmStr, I2CETeleporter.WaypointPointerSymbol, 
																		I2CETeleporter.WaypointPointerAddress)
			registerSymbol(I2CETeleporter.WaypointPointerSymbol, I2CETeleporter.WaypointPointerAddress, true)
		else
			Logger.warnf('Memory allocation failed: %s', I2CETeleporter.WaypointPointerSymbol)
		end
	end

	if getAddressSafe(I2CETeleporter.SaveNameStringSymbol) then
		deAlloc(I2CETeleporter.SaveNameStringSymbol)
		unregisterSymbol(I2CETeleporter.SaveNameStringSymbol)
	end
	local size = SaveNameStringMax * 2
	if size < 0x100 then
		size = 0x100
	end
	I2CETeleporter.SaveNameStringAddress = allocateSharedMemory(I2CETeleporter.SaveNameStringSymbol, size or 0x100)
	if I2CETeleporter.SaveNameStringAddress then
		Logger.debugf('Memory allocated: %s, ' .. pointerFtmStr, I2CETeleporter.SaveNameStringSymbol, 
																	I2CETeleporter.SaveNameStringAddress)
		registerSymbol(I2CETeleporter.SaveNameStringSymbol, I2CETeleporter.SaveNameStringAddress, true)
		local bytes = { string.byte(t('Starting location'), 1, -1) }
		bytes[#bytes + 1] = 0x00
		writeBytes(I2CETeleporter.SaveNameStringSymbol, bytes)
	else
		Logger.warnf('Memory allocation failed: %s', I2CETeleporter.SaveNameStringSymbol)
	end

	if getAddressSafe(I2CETeleporter.NewSaveNameStringSymbol) then
		deAlloc(I2CETeleporter.NewSaveNameStringSymbol)
		unregisterSymbol(I2CETeleporter.NewSaveNameStringSymbol)
	end
	local size = SaveNameStringMax * 2
	if size < 0x100 then
		size = 0x100
	end
	I2CETeleporter.NewSaveNameStringAddress = allocateSharedMemory(I2CETeleporter.NewSaveNameStringSymbol, size or 0x100)
	if I2CETeleporter.NewSaveNameStringAddress then
		Logger.debugf('Memory allocated: %s, ' .. pointerFtmStr, I2CETeleporter.NewSaveNameStringSymbol, 
																	I2CETeleporter.NewSaveNameStringAddress)
		registerSymbol(I2CETeleporter.NewSaveNameStringSymbol, I2CETeleporter.NewSaveNameStringAddress, true)
		writeBytes(I2CETeleporter.NewSaveNameStringSymbol, 0)
	else
		Logger.warnf('Memory allocation failed: %s', I2CETeleporter.NewSaveNameStringSymbol)
	end
	Logger.infof('Memory initialized')
end

function I2CETeleporter.finaMemory()
	Logger.trace()
	Logger.debug('Finalizing')
	if I2CETeleporter.AutoAllocate then
		deAlloc(I2CETeleporter.FlagPointerSymbol)
		Logger.debugf('Memory deallocated: %s', I2CETeleporter.FlagPointerSymbol)
		deAlloc(I2CETeleporter.CoordPointerSymbol)
		Logger.debugf('Memory deallocated: %s', I2CETeleporter.CoordPointerSymbol)
		deAlloc(I2CETeleporter.PlayerRotationAnglePointerSymbol)
		Logger.debugf('Memory deallocated: %s', I2CETeleporter.PlayerRotationAnglePointerSymbol)
		deAlloc(I2CETeleporter.CamRotationAnglePointerSymbol)
		Logger.debugf('Memory deallocated: %s', I2CETeleporter.CamRotationAnglePointerSymbol)
		deAlloc(I2CETeleporter.WaypointPointerSymbol)
		Logger.debugf('Memory deallocated: %s', I2CETeleporter.WaypointPointerSymbol)
		unregisterSymbol(I2CETeleporter.FlagPointerSymbol)
		unregisterSymbol(I2CETeleporter.CoordPointerSymbol)
		unregisterSymbol(I2CETeleporter.PlayerRotationAnglePointerSymbol)
		unregisterSymbol(I2CETeleporter.CamRotationAnglePointerSymbol)
		unregisterSymbol(I2CETeleporter.WaypointPointerSymbol)
	end
	deAlloc(I2CETeleporter.SaveNameStringSymbol)
	Logger.debugf('Memory deallocated: %s', I2CETeleporter.SaveNameStringSymbol)
	deAlloc(I2CETeleporter.NewSaveNameStringSymbol)
	Logger.debugf('Memory deallocated: %s', I2CETeleporter.NewSaveNameStringSymbol)
	unregisterSymbol(I2CETeleporter.SaveNameStringSymbol)
	unregisterSymbol(I2CETeleporter.NewSaveNameStringSymbol)
end



function I2CETeleporter.writeSavesToFile(fileName)
	Logger.trace()
	local del = I2CETeleporter.DataDelimiter
	local le = I2CETeleporter.LineEnd
	if type(fileName) ~= 'string' then
		fileName =  I2CETeleporter.SavesFileName or 'I2CETeleporterSaves.txt'
	end
	if I2CETeleporter.Saves == nil then
		local msg = 'No saves to write'
		Logger.error(msg)
		return 
	end
	local fileStr = strE
	for k, v in pairs(I2CETeleporter.Saves) do
		fileStr = fileStr .. k:gsub('\r', strE):gsub('\n', strE) .. del .. v.X .. del .. v.Y .. del .. v.Z
		if v.CamPitch ~= nil and v.CamYaw ~= nil then
			fileStr = fileStr .. del .. v.CamPitch .. del .. v.CamYaw
		end
		fileStr = fileStr .. le
	end
	if I2CETeleporter.SavesFileAsTableFile then
		local tableFile = findTableFile(fileName)
		if tableFile == nil then
			tableFile = createTableFile(fileName)
		end
		if tableFile == nil then
			local msg = format('Error opening table file, "%s"', fileName)
			Logger.error(msg)
			return
		end
		local stream = tableFile.getData()
		local bytes = { string.byte(fileStr, 1, -1) }
		stream.write(bytes)
		Logger.infof('table file saved, "%s"', fileName)
	else
		local f, err = io.open(I2CETeleporter.SavesFileName, 'w')
		if err then
			Logger.errorf('The local file could not be opened, "%s"', fileName)
		elseif f and not err then
			f:write(fileStr)
			f:close()
		end
	end
	return fileName
end


function I2CETeleporter.readSavesFromFile(fileName)
	Logger.trace()
	local del = I2CETeleporter.DataDelimiter
	if type(fileName) ~= 'string' then
		fileName =  I2CETeleporter.SavesFileName or 'I2CETeleporterSaves.txt'
	end
	local fileStr = nil
	local f, err = io.open(I2CETeleporter.SavesFileName, 'r')
	if err then
		--Logger.debugf('The local file could not be opened, "%s"', fileName)
		local tableFile = findTableFile(fileName)
		if tableFile == nil then
			local msg = format('Table file not found, "%s"', fileName)
			if I2CETeleporter.WarnIfSavesTableFileNotFound then
				Logger.warn(msg)
			else
				Logger.info(Logger.LEVELS.WARN, msg)
			end
			return
		end
		local stream = tableFile.getData()
		local bytes = stream.read(stream.Size)
		for i = 1, #bytes do
			if fileStr == nil then
				fileStr = strE
			end
			fileStr = fileStr .. string.char(bytes[i])
		end
	elseif f and not err then
		fileStr = f:read('*all')
		f:close()
	end
	if fileStr == nil then
		return
	end
	if I2CETeleporter.Saves == nil then
		I2CETeleporter.Saves = {}
	end
	fileStr = fileStr:gsub('\r\n', '\n'):gsub('\r', '\n')
	local lines = split(fileStr, '\n')
	local lastSave = nil
	for i, line in ipairs(lines) do
		if line ~= nil then
			local save = split(line, del)
			if save ~= nil and save[1] ~= nil and save[2] ~= nil and save[3] ~= nil and save[4] ~= nil then
				I2CETeleporter.Saves[save[1]] = {
					Name = save[1], 
					X = tonumber(save[2]), 
					Y = tonumber(save[3]), 
					Z = tonumber(save[4]), 
				}
				if save[5] ~= nil and save[6] ~= nil then
					I2CETeleporter.Saves[save[1]].CamPitch = tonumber(save[5])
					I2CETeleporter.Saves[save[1]].CamYaw = tonumber(save[6])
				end
				lastSave = save[1]
				if I2CETeleporter.LogSavesRead then
					if save[5] ~= nil and save[6] ~= nil then
						Logger.debugf('Loading save: %s, %s, %s, %s; %s, %s', 
											save[1], save[2], save[3], save[4], save[5], save[6])
					else
						Logger.debugf('Loading save: %s, %s, %s, %s', save[1], save[2], save[3], save[4])
					end
				end
			end
		end
	end
	if lastSave ~= nil then
		local bytes = { string.byte(lastSave, 1, -1) }
		bytes[#bytes + 1] = 0x00
		writeBytes(I2CETeleporter.SaveNameStringSymbol, bytes)
	end
	Logger.infof('Table file loaded, "%s"', fileName)
	return I2CETeleporter.Saves
end


function I2CETeleporter.printSaves()
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.printSaves()
		end)
		return
	end
	Logger.trace()
	if I2CETeleporter.Saves == nil then
		local msg = 'No saves to write'
		Logger.error(msg)
		return 
	end
	for k, v in pairs(I2CETeleporter.Saves) do
		if v.CamPitch ~= nil and v.CamYaw ~= nil then
			print(format('%s : %f9, %f9, %f9; %f9, %f9', padR(k, 25), v.X, v.Y, v.Z, v.CamPitch, v.CamYaw))
		else
			print(format('%s : %f9, %f9, %f9', padR(k, 25), v.X, v.Y, v.Z))
		end
	end
	Logger.debug('Saves printed')
end



function I2CETeleporter.writeToCoords(x, y, z, cP, cY)
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.writeToCoords(x, y, z, cP, cY)
		end)
		return
	end
	Logger.trace()
	local pointerSize, pointerSizeStr, pointerFtmStr, pointerWordSize, pointerDefaultStr = getPointerSizeStrs()

	if type(x) ~= 'number' or type(y) ~= 'number' or type(z) ~= 'number' then
		local msg = format('Write canceled, coordinate must be a number: %s, %s, %s', 
							type(x), type(y), type(z))
		Logger.error(msg)
		error(msg)
		return
	end
	if (math.type(x) == 'integer' and x == 0) 
	or (math.type(y) == 'integer' and y == 0) 
	or (math.type(z) == 'integer' and z == 0) then
		local msg = format('Write canceled, coordinate zero: %f9, %f9, %f9', x, y, z)
		Logger.error(msg)
		error(msg)
		return
	end

	local base = getAddressSafe('[' .. I2CETeleporter.CoordPointerSymbol .. ']')
	if base == nil or base == 0 then
		local msg = format('Write canceled, no address at base: %s', I2CETeleporter.CoordPointerSymbol)
		Logger.error(msg)
		error(msg)
		return
	end
	
	local addrF = getAddressSafe(I2CETeleporter.FlagPointerSymbol)
	local baseCra = getAddressSafe('[' .. I2CETeleporter.CamRotationAnglePointerSymbol .. ']')
	local basePra = getAddressSafe('[' .. I2CETeleporter.PlayerRotationAnglePointerSymbol .. ']')

	local function writeToCoordsTimer_tick(timer)
		Logger.trace()
		if I2CETeleporter.WriteToCoordsTimerTicks == nil then
			I2CETeleporter.WriteToCoordsTimerTicks = 0
		elseif I2CETeleporter.WriteToCoordsTimerTicks > I2CETeleporter.WriteToCoordsTimerTicksMax then
			timer.destroy()
			I2CETeleporter.WriteToCoordsTimerTicks = 0
		else
			I2CETeleporter.WriteToCoordsTimerTicks = I2CETeleporter.WriteToCoordsTimerTicks + 1
		end
		Logger.debugf('Writing:  ' .. pointerFtmStr .. ' :  %f9', base + I2CETeleporter.Xoffset, x)
		Logger.debugf('Writing:  ' .. pointerFtmStr .. ' :  %f9', base + I2CETeleporter.Yoffset, y)
		Logger.debugf('Writing:  ' .. pointerFtmStr .. ' :  %f9', base + I2CETeleporter.Zoffset, z)
		I2CETeleporter.CoordWrite(base + I2CETeleporter.Xoffset, x + I2CETeleporter.XaddOnWrite)
		I2CETeleporter.CoordWrite(base + I2CETeleporter.Yoffset, y + I2CETeleporter.YaddOnWrite)
		I2CETeleporter.CoordWrite(base + I2CETeleporter.Zoffset, z + I2CETeleporter.ZaddOnWrite)
		if cP ~= nil and cY ~= nil then
			if baseCra ~= nil and baseCra ~= 0 then
				I2CETeleporter.CamRotationAngleWrite(baseCra + I2CETeleporter.CamPitchOffset, cP)
				I2CETeleporter.CamRotationAngleWrite(baseCra + I2CETeleporter.CamYawOffset, cY)
			end
			if basePra ~= nil and basePra ~= 0 then
				I2CETeleporter.PlayerRotationAngleWrite(basePra + I2CETeleporter.PlayerYawOffset, I2CETeleporter.CamYawToPlayerYaw(cY))
			end
		end
		if addrF ~= nil and addrF ~= 0 then
			writeBytes(addrF, 1)
		end
	end
	local bX = I2CETeleporter.CoordRead(base + I2CETeleporter.Xoffset) + I2CETeleporter.XaddOnRead
	local bY = I2CETeleporter.CoordRead(base + I2CETeleporter.Yoffset) + I2CETeleporter.YaddOnRead
	local bZ = I2CETeleporter.CoordRead(base + I2CETeleporter.Zoffset) + I2CETeleporter.ZaddOnRead
	local bcP = nil
	local bcY = nil
	if baseCra ~= nil and baseCra ~= 0 then
		bcP = I2CETeleporter.CamRotationAngleRead(baseCra + I2CETeleporter.CamPitchOffset)
		bcY = I2CETeleporter.CamRotationAngleRead(baseCra + I2CETeleporter.CamYawOffset)
	end
	I2CETeleporter.Back = { X = bX, Y = bY, Z = bZ, CamPitch = bcP, CamYaw = bcY }
	local intervals = I2CETeleporter.WriteToCoordsTimerInterval
	local timer = createTimer(MainForm, true)
	timer.Interval = intervals
	timer.OnTimer = writeToCoordsTimer_tick
	return x, y, z, cP, cY
end


function I2CETeleporter.setCamRotationAngle(cP, cY)
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.setCamRotationAngle(cP, cY)
		end)
		return
	end
	Logger.trace()
	local pointerSize, pointerSizeStr, pointerFtmStr, pointerWordSize, pointerDefaultStr = getPointerSizeStrs()

	local baseCra = getAddressSafe('[' .. I2CETeleporter.CamRotationAnglePointerSymbol .. ']')
	if baseCra == nil or baseCra == 0 then
		local msg = format('Write canceled, no address at base: %s', I2CETeleporter.CamRotationAnglePointerSymbol)
		Logger.error(msg)
		error(msg)
		return
	end

	local addrF = getAddressSafe(I2CETeleporter.FlagPointerSymbol)
	local basePra = getAddressSafe('[' .. I2CETeleporter.PlayerRotationAnglePointerSymbol .. ']')

	local function setCamRotationAngleTimer_tick(timer)
		Logger.trace()
		if I2CETeleporter.SetCamRotationAngleTimerTicks == nil then
			I2CETeleporter.SetCamRotationAngleTimerTicks = 0
		elseif I2CETeleporter.SetCamRotationAngleTimerTicks > I2CETeleporter.SetCamRotationAngleTimerTicksMax then
			timer.destroy()
			I2CETeleporter.SetCamRotationAngleTimerTicks = 0
		else
			I2CETeleporter.SetCamRotationAngleTimerTicks = I2CETeleporter.SetCamRotationAngleTimerTicks + 1
		end
		if cP ~= nil and cY ~= nil and baseCra ~= nil and baseCra ~= 0 then
			I2CETeleporter.CamRotationAngleWrite(baseCra + I2CETeleporter.CamPitchOffset, cP)
			I2CETeleporter.CamRotationAngleWrite(baseCra + I2CETeleporter.CamYawOffset, cY)
		end
		if cP ~= nil and cY ~= nil and basePra ~= nil and basePra ~= 0 then
			I2CETeleporter.PlayerRotationAngleWrite(basePra + I2CETeleporter.PlayerYawOffset, I2CETeleporter.CamYawToPlayerYaw(cY))
		end
		if addrF ~= nil and addrF ~= 0 then
			writeBytes(addrF + 1, 1)
		end
	end
	local intervals = I2CETeleporter.SetCamRotationAngleTimerInterval
	local timer = createTimer(MainForm, true)
	timer.Interval = intervals
	timer.OnTimer = setCamRotationAngleTimer_tick
	return cP, cY
end


function I2CETeleporter.zeroCamRotationAngle()
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.zeroCamRotationAngle()
		end)
		return
	end
	Logger.trace()
	return I2CETeleporter.setCamRotationAngle(0, 0)
end


function I2CETeleporter.readFromCoords()
	if not inMainThread() then
		synchronize(function(thread)
			local msg = 'Read canceled, code must be executed in main thread'
			Logger.error(msg)
			error(msg)
		end)
		return
	end
	Logger.trace()
	local pointerSize, pointerSizeStr, pointerFtmStr, pointerWordSize, pointerDefaultStr = getPointerSizeStrs()
	local base = getAddressSafe('[' .. I2CETeleporter.CoordPointerSymbol .. ']')
	if base == nil or base == 0 then
		local msg = format('Read canceled, no address at base: %s', I2CETeleporter.CoordPointerSymbol)
		Logger.error(msg)
		error(msg)
		return
	end
	local baseCra = getAddressSafe('[' .. I2CETeleporter.CamRotationAnglePointerSymbol .. ']')

	local x = I2CETeleporter.CoordRead(base + I2CETeleporter.Xoffset) + I2CETeleporter.XaddOnRead
	local y = I2CETeleporter.CoordRead(base + I2CETeleporter.Yoffset) + I2CETeleporter.YaddOnRead
	local z = I2CETeleporter.CoordRead(base + I2CETeleporter.Zoffset) + I2CETeleporter.ZaddOnRead
	local cP = nil
	local cY = nil
	if baseCra ~= nil and baseCra ~= 0 then
		cP = I2CETeleporter.CamRotationAngleRead(baseCra + I2CETeleporter.CamPitchOffset)
		cY = I2CETeleporter.CamRotationAngleRead(baseCra + I2CETeleporter.CamYawOffset)
	end
	Logger.debugf('Read:  ' .. pointerFtmStr .. ' :  %f9', base + I2CETeleporter.Xoffset, x)
	Logger.debugf('Read:  ' .. pointerFtmStr .. ' :  %f9', base + I2CETeleporter.Yoffset, y)
	Logger.debugf('Read:  ' .. pointerFtmStr .. ' :  %f9', base + I2CETeleporter.Zoffset, z)
	if cP ~= nil and cY ~= nil then
		Logger.debugf('Read:  ' .. pointerFtmStr .. ' :  %f9', baseCra + I2CETeleporter.CamPitchOffset, cP)
		Logger.debugf('Read:  ' .. pointerFtmStr .. ' :  %f9', baseCra + I2CETeleporter.CamYawOffset, cY)
	end
	return x, y, z, cP, cY
end


function I2CETeleporter.readFromWaypoint()
	if not inMainThread() then
		synchronize(function(thread)
			local msg = 'Read canceled, code must be executed in main thread'
			Logger.error(msg)
			error(msg)
		end)
		return
	end
	Logger.trace()
	local pointerSize, pointerSizeStr, pointerFtmStr, pointerWordSize, pointerDefaultStr = getPointerSizeStrs()
	local base = getAddressSafe('[' .. I2CETeleporter.WaypointPointerSymbol .. ']')
	if base == nil or base == 0 then
		local msg = format('Read canceled, no address at base: %s', I2CETeleporter.WaypointPointerSymbol)
		Logger.error(msg)
		error(msg)
		return
	end
	x = I2CETeleporter.WaypointRead(base + I2CETeleporter.WayXoffset) + I2CETeleporter.WayXaddOnRead
	y = I2CETeleporter.WaypointRead(base + I2CETeleporter.WayYoffset) + I2CETeleporter.WayYaddOnRead
	z = I2CETeleporter.WaypointRead(base + I2CETeleporter.WayZoffset) + I2CETeleporter.WayZaddOnRead
	Logger.debugf('Read:  ' .. pointerFtmStr .. ' :  %f9', base + I2CETeleporter.WayXoffset, x)
	Logger.debugf('Read:  ' .. pointerFtmStr .. ' :  %f9', base + I2CETeleporter.WayYoffset, y)
	Logger.debugf('Read:  ' .. pointerFtmStr .. ' :  %f9', base + I2CETeleporter.WayZoffset, z)
	return x, y, z
end


function I2CETeleporter.teleport(name)
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.teleport(name)
		end)
		return
	end
	Logger.trace()
	if name == nil then
		name = readString(I2CETeleporter.SaveNameStringSymbol, SaveNameStringMax)
	end
	if type(name) ~= 'string' then
		local msg = format('Teleport canceled, "name" must be a string: %s', type(name))
		Logger.error(msg)
		error(msg)
		return
	end
	local save = I2CETeleporter.Saves[name]
	if save == nil then
		local msg = format('Teleport canceled, save not found: %s', name)
		Logger.error(msg)
		error(msg)
		return
	end
	Logger.debugf('Teleporting to save: %s', name)
	local bytes = { string.byte(name, 1, -1) }
	bytes[#bytes + 1] = 0x00
	writeBytes(I2CETeleporter.SaveNameStringSymbol, bytes)
	return I2CETeleporter.writeToCoords(save.X, save.Y, save.Z, save.CamPitch, save.CamYaw)
end


function I2CETeleporter.save(name)
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.save(name)
		end)
		return
	end
	Logger.trace()
	if name == nil then
		name = readString('strI2CETeleporterSaveName', SaveNameStringMax)
	end
	if type(name) ~= 'string' then
		local msg = format('Save canceled, "name" must be a string: %s', type(name))
		Logger.error(msg)
		error(msg)
		return
	end
	local x, y, z, cP, cY = I2CETeleporter.readFromCoords()
	if type(x) ~= 'number' or type(y) ~= 'number' or type(z) ~= 'number' then
		local msg = format('Save canceled, coordinate must be a number: %s, %s, %s', type(x), type(y), type(z))
		Logger.error(msg)
		error(msg)
		return
	end
	if (math.type(x) == 'integer' and x == 0) 
	or (math.type(y) == 'integer' and y == 0) 
	or (math.type(z) == 'integer' and z == 0) then
		local msg = format('Save canceled, coordinate zero: %f9, %f9, %f9', x, y, z)
		Logger.error(msg)
		error(msg)
		return
	end
	if I2CETeleporter.Saves == nil then
		I2CETeleporter.Saves = {}
	end
	if cP ~= nil and cY ~= nil then
		Logger.debugf('Saving: %s, %f9, %f9, %f9, %f9, %f9', name, x, y, z, cP, cY)
	else
		Logger.debugf('Saving: %s, %f9, %f9, %f9', name, x, y, z)
	end
	I2CETeleporter.Saves[name] = { Name = name, X = x, Y = y, Z = z, CamPitch = cP, CamYaw = cY }
	if I2CETeleporter.AutoSaveSavesFile then
		I2CETeleporter.writeSavesToFile()
	end
	return I2CETeleporter.Saves[name]
end


function I2CETeleporter.teleportBack()
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.teleportBack()
		end)
		return
	end
	Logger.trace()
	if I2CETeleporter.Back ~= nil then
		return I2CETeleporter.writeToCoords(I2CETeleporter.Back.X, I2CETeleporter.Back.Y, I2CETeleporter.Back.Z, 
											I2CETeleporter.Back.CamPitch, I2CETeleporter.Back.CamYaw)
	end
end


function I2CETeleporter.delete(name, force)
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.delete(name, force)
		end)
		return
	end
	Logger.trace()
	if name == nil then
		name = readString('strI2CETeleporterSaveName', SaveNameStringMax)
	end
	if type(name) ~= 'string' then
		local msg = format('Delete canceled, "name" must be a string: %s', type(name))
		Logger.error(msg)
		error(msg)
		return
	end
	if I2CETeleporter.Saves == nil then
		local msg = 'No saves to delete'
		Logger.error(msg)
		return 
	end
	if force or I2CETeleporter.DeleteRequest == I2CETeleporter.Saves[name] then
		I2CETeleporter.Saves[name] = nil
		Logger.infof('Save deleted: %s', name)
		writeBytes(I2CETeleporter.SaveNameStringSymbol, 0)
	else
		I2CETeleporter.DeleteRequest = I2CETeleporter.Saves[name]
		Logger.debugf('Delete request set for: %s', name)
	end
	if I2CETeleporter.AutoSaveSavesFile then
		I2CETeleporter.writeSavesToFile()
	end
end

function I2CETeleporter.rename(name, newName)
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.rename(name, newName)
		end)
		return
	end
	Logger.trace()
	if name == nil then
		name = readString('strI2CETeleporterSaveName', SaveNameStringMax)
	end
	if type(name) ~= 'string' then
		local msg = format('Rename canceled, "name" must be a string: %s', type(name))
		Logger.error(msg)
		error(msg)
		return
	end
	if newName == nil then
		newName = readString('strI2CETeleporterSaveNameNew', SaveNameStringMax)
	end
	if type(newName) ~= 'string' then
		local msg = format('Rename canceled, "newName" must be a string: %s', type(newName))
		Logger.error(msg)
		error(msg)
		return
	end
	if I2CETeleporter.Saves == nil then
		local msg = 'No saves to rename'
		Logger.error(msg)
		return 
	end
	I2CETeleporter.Saves[newName] = I2CETeleporter.Saves[name]
	I2CETeleporter.Saves[name] = nil
	local bytes = { string.byte(newName, 1, -1) }
	bytes[#bytes + 1] = 0x00
	writeBytes(I2CETeleporter.SaveNameStringSymbol, bytes)
	writeBytes(I2CETeleporter.NewSaveNameStringSymbol, 0)
	if I2CETeleporter.AutoSaveSavesFile then
		I2CETeleporter.writeSavesToFile()
	end
	return I2CETeleporter.Saves[newName]
end


function I2CETeleporter.teleportToWaypoint()
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.teleportToWaypoint()
		end)
		return
	end
	Logger.trace()
	local x, y, z = I2CETeleporter.readFromWaypoint()
	Logger.debugf('Teleporting to waypoint: %f9, %f9, %f9', x, y, z)
	return I2CETeleporter.writeToCoords(x, y, z)
end


function I2CETeleporter.createMR(mrTbl, interpTbl, appendMr)
	if not inMainThread() then
		synchronize(function(thread)
			local msg = 'Memory record creation canceled, code must be executed in main thread'
			Logger.error(msg)
			error(msg)
		end)
		return
	end
	Logger.trace()
	if mrTbl == nil then return end
	local memoryRecord = nil
	local memoryRecordCreated = false
	if mrTbl.Description ~= nil then
		memoryRecord = AddressList.getMemoryRecordByDescription(interp(mrTbl.Description, interpTbl))
	end
	if memoryRecord == nil then
		memoryRecord = AddressList.createMemoryRecord()
		memoryRecord.Description = interp(mrTbl.Description, interpTbl)
		memoryRecordCreated = true
		Logger.debug('Creating new memory record.')
	else
		Logger.debug('Memory record found.')
	end
	local isScript = false
	local scriptStr = nil
	for k, v in pairs(mrTbl) do
		if k == 'MemoryRecords' and type(v) == 'table' then
			Logger.debug('Generating child memory records.')
			for i = 1, #v do
				if not I2CETeleporter.OverRideSaveMemoryRecords and v[i].Description ~= nil 
				and v[i].Description ~= I2CETeleporter.SavesMemoryRecordDescription 
				and AddressList.getMemoryRecordByDescription(interp(v[i].Description, interpTbl)) ~= nil then
					Logger.debugf('Child memory record found: %s', interp(v[i].Description, interpTbl))
					--break
				else
					I2CETeleporter.createMR(v[i], interpTbl, memoryRecord)
				end 
			end
		else
			if type(v) == 'table' and memoryRecord[k] ~= nil then
				if k == 'Hotkey' then
					for v_k, v_v in pairs(v) do
						if v_v ~= nil then
							memoryRecord[k][v_k] = v_v
						end
					end
				elseif (k == 'Offset' or k == 'OffsetText') then
					for v_k, v_v in ipairs(v) do
						memoryRecord.setOffsetCount(#v)
						if v_v ~= nil then
							memoryRecord.setOffset(v_k - 1, tonumber(interp(v_v, interpTbl), 16))
							Logger.debugf('MemoryRecord Offset set: %d, %X', 
											v_k - 1, tonumber(interp(v_v, interpTbl), 16))
						end
					end
				else
					for v_k, v_v in pairs(v) do
						if v_v ~= nil then
							memoryRecord[k][v_k] = v_v
						end
					end
				end
			else
				if k == 'AppendSaves' then
					Logger.debug('Found "AppendSaves"')
					if I2CETeleporter.Saves ~= nil then
						local tbl = {}
						for k, v in pairs(interpTbl) do
							tbl[k] = v
						end
						for k, v in pairs(I2CETeleporter.Saves) do
							Logger.debugf('Creating child memory record: %s', k)
							tbl.SaveName = k
							tbl.X = format('%f9', v.X)
							tbl.Y = format('%f9', v.Y)
							tbl.Z = format('%f9', v.Z)
							I2CETeleporter.createMR(I2CETeleporter.SaveMemoryRecord, tbl, memoryRecord)
						end
					end
				else
					if k == 'Type' and v == vtAutoAssembler then
						isScript = true
					elseif k == 'Script' and type(v) == 'string' then
						scriptStr = interp(v, interpTbl)
					end
					if k == 'Type' and type(v) == 'string' 
					and (v:lower() == 'pointer' or v:lower() == 'ptr' or v:lower() == 'p') then
						if interpTbl.PointerSize == '0x4' then
							memoryRecord[k] = vtDword
						else
							memoryRecord[k] = vtQword
						end
					else
						if type(v) == 'string' then
							v = interp(v, interpTbl)
						end
						memoryRecord[k] = v
					end
				end
			end
		end
	end
	if appendMr ~= nil and memoryRecordCreated then
		memoryRecord.appendToEntry(appendMr)
	end
	if isScript and scriptStr == nil then
		memoryRecord.Script = interpTbl.Script
	elseif scriptStr ~= nil then
		memoryRecord.Script = scriptStr
	end
	local lDStr = memoryRecord.Description:sub(1, 40)
	Logger.debugf('Done: memory record: ID: % 3d, Type: % 2d, "%s".', 
						memoryRecord.ID, memoryRecord.Type, lDStr)
	return memoryRecord
end


function I2CETeleporter.generateMemoryRecords(mainMemoryRecordsTbl)
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.generateMemoryRecords(mainMemoryRecordsTbl)
		end)
		return
	end
	Logger.trace()
	local selMR = AddressList.getSelectedRecord()
	local pointerSize, pointerSizeStr, pointerFtmStr, pointerWordSize, pointerDefaultStr = getPointerSizeStrs()
	Logger.info('Generating memory records.')
	local mrTbl = mainMemoryRecordsTbl or I2CETeleporter.MainMemoryRecords
	local createdMemoryRecordsTbl = { }
	local saveName = readString(I2CETeleporter.SaveNameStringSymbol, SaveNameStringMax)
	local interpTbl = {
		SaveName = saveName, 
		FlagPointerSymbol = I2CETeleporter.FlagPointerSymbol, 
		FlagPointerAddress = format(pointerFtmStr, I2CETeleporter.FlagPointerAddress or 0), 
		CoordPointerSymbol = I2CETeleporter.CoordPointerSymbol, 
		CoordPointerAddress = format(pointerFtmStr, I2CETeleporter.CoordPointerAddress or 0), 
		PlayerRotationAnglePointerSymbol = I2CETeleporter.PlayerRotationAnglePointerSymbol, 
		PlayerRotationAnglePointerAddress = format(pointerFtmStr, I2CETeleporter.PlayerRotationAnglePointerAddress or 0), 
		CamRotationAnglePointerSymbol = I2CETeleporter.CamRotationAnglePointerSymbol, 
		CamRotationAnglePointerAddress = format(pointerFtmStr, I2CETeleporter.CamRotationAnglePointerAddress or 0), 
		WaypointPointerSymbol = I2CETeleporter.WaypointPointerSymbol, 
		WaypointPointerAddress = format(pointerFtmStr, I2CETeleporter.WaypointPointerAddress or 0), 
		SaveNameStringSymbol = I2CETeleporter.SaveNameStringSymbol, 
		SaveNameStringAddress = format(pointerFtmStr, I2CETeleporter.SaveNameStringAddress or 0), 
		NewSaveNameStringSymbol = I2CETeleporter.NewSaveNameStringSymbol, 
		NewSaveNameStringAddress = format(pointerFtmStr, I2CETeleporter.NewSaveNameStringAddress or 0), 
		Xoffset = format('%X', I2CETeleporter.Xoffset or 0), 
		Yoffset = format('%X', I2CETeleporter.Yoffset or 0), 
		Zoffset = format('%X', I2CETeleporter.Zoffset or 0), 
		WayXoffset = format('%X', I2CETeleporter.WayXoffset or 0), 
		WayYoffset = format('%X', I2CETeleporter.WayYoffset or 0), 
		WayZoffset = format('%X', I2CETeleporter.WayZoffset or 0), 
		X = strE, 
		Y = strE, 
		Z = strE, 
		CamPitch = strE, 
		CamYaw = strE, 
		CoordWrite = I2CETeleporter.CoordWriteString, 
		PlayerRotationAngleWrite = I2CETeleporter.PlayerRotationAngleWriteString, 
		CamRotationAngleWrite = I2CETeleporter.CamRotationAngleWriteString, 
		CoordRead = I2CETeleporter.CoordReadString, 
		PlayerRotationAngleRead = I2CETeleporter.PlayerRotationAngleReadString, 
		CamRotationAngleRead = I2CETeleporter.CamRotationAngleReadString, 
		WaypointRead = I2CETeleporter.WaypointReadString, 
	}
	if I2CETeleporter.Saves ~= nil and I2CETeleporter.Saves[saveName] ~= nil then
		interpTbl.X = format('%f9', I2CETeleporter.Saves[saveName].X or 0)
		interpTbl.Y = format('%f9', I2CETeleporter.Saves[saveName].Y or 0)
		interpTbl.Z = format('%f9', I2CETeleporter.Saves[saveName].Z or 0)
		if I2CETeleporter.Saves[saveName].CamPitch ~= nil and I2CETeleporter.Saves[saveName].CamYaw ~= nil then
			interpTbl.CamPitch = format('%f9', I2CETeleporter.Saves[saveName].CamPitch)
			interpTbl.CamYaw = format('%f9', I2CETeleporter.Saves[saveName].CamYaw)
		end
	end
	if mrTbl.Description ~= nil then
		createdMemoryRecordsTbl[1] = I2CETeleporter.createMR(mrTbl, interpTbl)
	else
		for i = 1, #mrTbl do
			createdMemoryRecordsTbl[i] = I2CETeleporter.createMR(mrTbl[i], interpTbl)
		end
	end
	if selMR ~= nil then
		AddressList.setSelectedRecord(selMR)
	end
	return createdMemoryRecordsTbl
end


function I2CETeleporter.autoLoad()
	if not inMainThread() then
		synchronize(function(thread)
			I2CETeleporter.autoLoad()
		end)
		return
	end
	Logger.trace()
	local function I2CETeleporterAutoLoadTimer_tick(timer)
		Logger.trace()
		if I2CETeleporter.AutoLoad then
			if process ~= nil and getAddressSafe(process) ~= 0 then
				Logger.info('Auto loading')
				Logger.debugf('Killing timer: %s', timer)
				timer.destroy()
				I2CETeleporter.initialize()
			end
		else
			Logger.debugf('Killing timer: %s', timer)
			timer.destroy()
		end
	end
	local intervals = 100
	local timer = createTimer(MainForm)
	timer.Interval = intervals
	timer.OnTimer = I2CETeleporterAutoLoadTimer_tick
	Logger.info('Timer started')
end

I2CETeleporter.autoLoad()


local function setCoordSymbol(parameters, syntaxcheck)
	---- setCoordSymbol([ptrSymbol]+123ABC)
	I2CETeleporter.CoordPointerSymbol = parameters
	return strE
end
local function setCoordOffsets(parameters, syntaxcheck)
	---- setCoordOffsets(0, 4, 8)
	local tbl = split(parameters, ',')
	I2CETeleporter.Xoffset = tonumber(tbl[1], 16)
	I2CETeleporter.Yoffset = tonumber(tbl[2], 16)
	I2CETeleporter.Zoffset = tonumber(tbl[3], 16)
	return strE
end
registerAutoAssemblerCommand('setCoordSymbol', setCoordSymbol)
registerAutoAssemblerCommand('setCoordOffsets', setCoordOffsets)

local function setPlayerRotationAnglePointerSymbol(parameters, syntaxcheck)
	---- setPlayerRotationAnglePointerSymbol([ptrSymbol]+123ABC)
	I2CETeleporter.PlayerRotationAnglePointerSymbol = parameters
	return strE
end
local function setPlayerYawOffset(parameters, syntaxcheck)
	---- setPlayerYawOffset(0)
	I2CETeleporter.PlayerYawOffset = tonumber(parameters, 16)
	return strE
end
registerAutoAssemblerCommand('setPlayerRotationAnglePointerSymbol', setPlayerRotationAnglePointerSymbol)
registerAutoAssemblerCommand('setPlayerYawOffset', setPlayerYawOffset)

local function setCamRotationAnglePointerSymbol(parameters, syntaxcheck)
	---- setCamRotationAnglePointerSymbol([ptrSymbol]+123ABC)
	I2CETeleporter.CamRotationAnglePointerSymbol = parameters
	return strE
end
local function setCamRotationAngleOffsets(parameters, syntaxcheck)
	---- setCamRotationAngleOffsets(0, 4)
	local tbl = split(parameters, ',')
	I2CETeleporter.CamPitchOffset = tonumber(tbl[1], 16)
	I2CETeleporter.CamYawOffset = tonumber(tbl[2], 16)
	return strE
end
registerAutoAssemblerCommand('setCamRotationAnglePointerSymbol', setCamRotationAnglePointerSymbol)
registerAutoAssemblerCommand('setCamRotationAngleOffsets', setCamRotationAngleOffsets)

local function setWaypointPointerSymbol(parameters, syntaxcheck)
	---- setWaypointPointerSymbol([ptrSymbol]+123ABC)
	I2CETeleporter.WaypointPointerSymbol = parameters
	return strE
end
local function setWaypointOffsets(parameters, syntaxcheck)
	---- setWaypointOffsets(0, 4, 8)
	local tbl = split(parameters, ',')
	I2CETeleporter.WayXoffset = tonumber(tbl[1], 16)
	I2CETeleporter.WayYoffset = tonumber(tbl[2], 16)
	I2CETeleporter.WayZoffset = tonumber(tbl[3], 16)
	return strE
end
registerAutoAssemblerCommand('setWaypointPointerSymbol', setWaypointPointerSymbol)
registerAutoAssemblerCommand('setWaypointOffsets', setWaypointOffsets)


return I2CETeleporter