if (!documentation)
	var documentation = {
		start: {
			id: "start",
			name: "Welcome!",
			content: ""
		},
		files: []
	}
documentation.files[documentation.files.length] = {
	file: "AHKA.ahk",
	items: [
		{
			name: "Tutorials",
			id: "tutorials",
			items: [
				{
					id: "tutorial1",
					name: "First Steps",
					content: "<p>"
							+"Sorry, this tutorial is under construction.<br /><br />"
							+"Well, let's start!<br />"
							+"First of all, let's create an array! We do this with the <b>NewArray</b> function:"
							+"<pre><code>myArray := AHKA_NewArray()</code></pre>"
							+"Simple, right?<br />"
							+"An empty array is no use to anyone though, so let's fill it up with something! "
							+"For this, the <b>Add</b> function is used:"
							+"<pre><code>myArray := AHKA_Add(myArray, \"Hello\")"
							+"\nmyArray := AHKA_Add(myArray, \"World\")</code></pre>"
							+"Notice that the result of the function is assigned to the array, "
							+"this is because the function makes no change to the original array, "
							+"rather, it just returns the resultant new array.<br />"
							+"By default, the <b>Add</b> function needs the array you want to add something "
							+"to, and the value of what you want to add. You can also optionally specify an "
							+"index as the third parameter which would tell the function where you want it "
							+"to add the new value. If the index is left out, the function will add the value "
							+"to the end of the array."
							+"</p>",
					history: [
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* Tutorial 1			*/
				{
					id: "tutorial2",
					name: "Going In Depth",
					content: "<p>Sorry, this tutorial is under construction.</p>",
					history: [
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* Tutorial 2			*/
				{
					id: "tutorial3",
					name: "Doing It All",
					content: "<p>Sorry, this tutorial is under construction.</p>",
					history: [
						{version: "6.00",
							update: "History Record Begins"}
					]
				} /* Tutorial 3			*/
			]
		},
		{
			name: "User Functions API",
			id: "userapi",
			items: [
				{
					id: "newarray",
					name: "NewArray",
					content: "Creates a new AHKArray.<br />"
							+"If parameter String is omitted, an empty AHKArray is generated.<br />"
							+"Otherwise, this function converts a non-HEXed AHKArray into a HEXed one if HEXing is enabled.<br />"
							+"Or simply returns the String it is given if HEXing is disabled.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"newArray1 := AHKA_NewArray()"
							+"\n<span class=\"comment\">; newArray1->[]</span>"
							+"\nnewArray2 := AHKA_NewArray(\"[1,2,3]\")"
							+"\n<span class=\"comment\">; newArray2->[1, 2, 3]</span>"
							+"\nnewArray3 := AHKA_NewArray(\"[1,2,[31,32],4]\")"
							+"\n<span class=\"comment\">; newArray3->[1, 2, [31, 32], 4]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "0.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "String=\"\"",
							type: "String",
							info: "The String to convert to an AHKArray."
						},
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The generated AHKArray."
					}
				}, /* NewArray				*/
				{
					id: "size",
					name: "Size",
					content: "Measures the length of a given AHKArray.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"newArray := AHKA_NewArray()"
							+"\n<span class=\"comment\">; newArray->[]</span>"
							+"\nnewArray := AHKA_Add(newArray, \"Hello\")"
							+"\n<span class=\"comment\">; newArray->[\"Hello\"]</span>"
							+"\nnewArray := AHKA_Add(newArray, \"!\", 2)"
							+"\n<span class=\"comment\">; newArray->[\"Hello\", \"!\"]</span>"
							+"\nnewArray := AHKA_Add(newArray, \"World\", -1)"
							+"\n<span class=\"comment\">; newArray->[\"Hello\", \"World\", \"!\"]</span>"
							+"\nnewArrayLength := AHKA_Size(newArray)"
							+"\n<span class=\"comment\">; newArrayLength->3</span>"
							+"\n\n"
							+"subArray := AHKA_NewArray()"
							+"\n<span class=\"comment\">; subArray->[]</span>"
							+"\nsubArray := AHKA_Add(subArray, \"SubValue1\", 2)"
							+"\n<span class=\"comment\">; subArray->[\"SubValue1\"]</span>"
							+"\nsubArray := AHKA_Add(subArray, \"SubValue2\", 2)"
							+"\n<span class=\"comment\">; subArray->[\"SubValue1\", \"SubValue2\"]</span>"
							+"\nnewArray := AHKA_Add(newArray, subArray)"
							+"\n<span class=\"comment\">; newArray->[\"Hello\", \"World\", \"!\", [\"SubValue1\", \"SubValue2\"]]</span>"
							+"\nnewArrayLength := AHKA_Size(newArray)"
							+"\n<span class=\"comment\">; newArrayLength->4</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "1"},
						{version: "0.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray whose length should be measured."
						}
					],
					returns: {
						name: "arrayLength",
						type: "Integer",
						info: "The number of elements within the AHKArray.<br />Note: All Sub-AHKArrays count as single elements."
					}
				}, /* Size					*/
				{
					id: "add",
					name: "Add",
					content: "Adds a value to an existing AHKArray.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"newArray := AHKA_NewArray()"
							+"\n<span class=\"comment\">; newArray->[]</span>"
							+"\nnewArray := AHKA_Add(newArray, \"Hello\")"
							+"\n<span class=\"comment\">; newArray->[\"Hello\"]</span>"
							+"\nnewArray := AHKA_Add(newArray, \"!\", 2)"
							+"\n<span class=\"comment\">; newArray->[\"Hello\", \"!\"]</span>"
							+"\nnewArray := AHKA_Add(newArray, \"World\", -1)"
							+"\n<span class=\"comment\">; newArray->[\"Hello\", \"World\", \"!\"]</span>"
							+"\nnewArray := AHKA_Add(newArray, AHKA_NewArray())"
							+"\n<span class=\"comment\">; newArray->[\"Hello\", \"World\", \"!\", []]</span>"
							+"\nnewArray := AHKA_Add(newArray, \"2-D\", 4, 0)"
							+"\n<span class=\"comment\">; newArray->[\"Hello\", \"World\", \"!\", [\"2-D\"]]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "6"},
						{version: "0.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray to which the value should be added."
						},
						{
							name: "Value",
							type: "String",
							info: "The value to add."
						},
						{
							name: "Index1=0",
							type: "Integer",
							info: "Where to add the value within the AHKArray.<br />Index of <b>0</b> will add the value at the end of the AHKArray.<br />Index of <b>&gt;0</b> will add the value at the proper index (AHKArrays start at 1, not 0).<br />Value of <b>&lt;0</b> will add the value at the abs(Index) from the back of the AHKArray."
						},
						{
							name: "Index2=\"\" ... Index10=\"\"",
							type: "Integer",
							info: "There may be up to 10 Index values for use with multi-dimensional arrays."
						}
					],
					returns: {
						name: "finalArray",
						type: "String",
						info: "The new AHKArray with the added value.<br />Note: The original AHKArray variable is not modified."
					}
				}, /* Add					*/
				{
					id: "get",
					name: "Get",
					content: "Retrieves a value from an existing AHKArray.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"<span class=\"comment\">; Assume myArray->[\"A\", \"B\", [\"C1\", \"C2\"], \"D\"]</span>"
							+"\nmyValue := AHKA_Get(myArray)"
							+"\n<span class=\"comment\">; myValue->\"D\"</span>"
							+"\nmyValue := AHKA_Get(myArray, 1)"
							+"\n<span class=\"comment\">; myValue->\"A\"</span>"
							+"\nmyValue := AHKA_Get(myArray, -1)"
							+"\n<span class=\"comment\">; myValue->[\"C1\", \"C2\"]</span>"
							+"\nmyValue := AHKA_Get(myArray, -1, 2)"
							+"\n<span class=\"comment\">; myValue->\"C2\"</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "1"},
						{version: "0.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray from which the value should be retrieved."
						},
						{
							name: "Index1=0",
							type: "Integer",
							info: "Where to add the value within the AHKArray.<br />Index of <b>0</b> will get the value at the end of the AHKArray.<br />Index of <b>&gt;0</b> will get the value at the proper index (AHKArrays start at 1, not 0).<br />Value of <b>&lt;0</b> will get the value at the abs(Index) from the back of the AHKArray."
						},
						{
							name: "Index2=\"\" ... Index10=\"\"",
							type: "Integer",
							info: "There may be up to 10 Index values for use with multi-dimensional arrays."
						}
					],
					returns: {
						name: "Value",
						type: "String",
						info: "The value retrieved from the AHKArray.<br />Note: May be an AHKArray in case of multi-dimensional AHKArrays."
					}
				}, /* Get					*/
				{
					id: "remove",
					name: "Remove",
					content: "Removes a value from an existing AHKArray.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"<span class=\"comment\">; Assume myArray->[\"A\", \"B\", [\"C1\", \"C2\"], \"D\"]</span>"
							+"\nmyArray := AHKA_Remove(myArray)"
							+"\n<span class=\"comment\">; myArray->[\"A\", \"B\", [\"C1\", \"C2\"]]</span>"
							+"\nmyArray := AHKA_Remove(myArray, 1)"
							+"\n<span class=\"comment\">; myArray->[\"B\", [\"C1\", \"C2\"]]</span>"
							+"\nmyArray := AHKA_Remove(myArray, -1)"
							+"\n<span class=\"comment\">; myArray->[[\"C1\", \"C2\"]]</span>"
							+"\nmyArray := AHKA_Remove(myArray, 1, 2)"
							+"\n<span class=\"comment\">; myArray->[[\"C1\"]]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "2"},
						{version: "0.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray from which the value should be removed."
						},
						{
							name: "Index1=0",
							type: "Integer",
							info: "Where to add the value within the AHKArray.<br />Index of <b>0</b> will remove the value at the end of the AHKArray.<br />Index of <b>&gt;0</b> will remove the value at the proper index (AHKArrays start at 1, not 0).<br />Value of <b>&lt;0</b> will remove the value at the abs(Index) from the back of the AHKArray."
						},
						{
							name: "Index2=\"\" ... Index10=\"\"",
							type: "Integer",
							info: "There may be up to 10 Index values for use with multi-dimensional arrays."
						}
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The new AHKArray without the removed value.<br />Note: The original AHKArray variable is not modified."
					}
				}, /* Remove				*/
				{
					id: "set",
					name: "Set",
					content: "Modifies a value in an existing AHKArray.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"<span class=\"comment\">; Assume myArray->[\"A\", \"B\", [\"C1\", \"C2\"], \"D\"]</span>"
							+"\nmyArray := AHKA_Set(myArray, \"mD\")"
							+"\n<span class=\"comment\">; myArray->[\"A\", \"B\", [\"C1\", \"C2\"], \"mD\"]</span>"
							+"\nmyArray := AHKA_Set(myArray, \"mA\", 1)"
							+"\n<span class=\"comment\">; myArray->[\"mA\", \"B\", [\"C1\", \"C2\"], \"mD\"]</span>"
							+"\nmyArray := AHKA_Set(myArray, \"mC2\", -1, 2)"
							+"\n<span class=\"comment\">; myArray->[\"mA\", \"B\", [\"C1\", \"mC2\"], \"mD\"]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "0.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray whose value should be modified."
						},
						{
							name: "Index1=0",
							type: "Integer",
							info: "Where to add the value within the AHKArray.<br />Index of <b>0</b> will modify the value at the end of the AHKArray.<br />Index of <b>&gt;0</b> will modify the value at the proper index (AHKArrays start at 1, not 0).<br />Value of <b>&lt;0</b> will modify the value at the abs(Index) from the back of the AHKArray."
						},
						{
							name: "Index2=\"\" ... Index10=\"\"",
							type: "Integer",
							info: "There may be up to 10 Index values for use with multi-dimensional arrays."
						}
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The new AHKArray with the modified value.<br />Note: The original AHKArray variable is not modified."
					}
				}, /* Set					*/
				{
					id: "split",
					name: "Split",
					content: "Creates a new AHKArray from a string.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"newArray1 := AHKA_NewArray()"
							+"\n<span class=\"comment\">; newArray1->[]</span>"
							+"\nnewArray2 := AHKA_Split(\"Testing\")"
							+"\n<span class=\"comment\">; newArray2->[\"T\", \"e\", \"s\", \"t\", \"i\", \"n\", \"g\"]</span>"
							+"\nnewArray3 := AHKA_Split(\"I Am Jolly!\", \" \")"
							+"\n<span class=\"comment\">; newArray3->[\"I\", \"Am\", \"Jolly!\"]</span>"
							+"\nnewArray4 := AHKA_Split(\"The Hay Had A Ham!\", \"H\", true)"
							+"\n<span class=\"comment\">; newArray4->[\"The \", \"ay \", \"ad A \", \"am!\"]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "2"},
						{version: "4.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "String",
							type: "String",
							info: "The String to split."
						},
						{
							name: "Delimeter=\"\"",
							type: "String",
							info: "The delimeter by which to split String."
						},
						{
							name: "CaseSensitive=false",
							type: "Boolean",
							info: "Wheather to treat the delimeter as case-sensitive, or not."
						}
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The generated AHKArray."
					}
				}, /* Split					*/
				{
					id: "convert",
					name: "Convert",
					content: "Creates a new AHKArray from a standard AutoHotKey array.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myString := \"This is a test string.\""
							+"\nStringSplit, myString, myArray, myString, %A_Space%"
							+"\nnewArray := AHKA_Convert(\"myArray\")"
							+"\n<span class=\"comment\">; newArray->[\"This\", \"is\", \"a\", \"test\", \"string.\"]</span>"
							+"\n<span class=\"comment\">"
							+"\n; Technical Note:"
							+"\n; This method tries to get the length of the array primarily by %myArray%, and if that does not work, by %myArray%0."
							+"\n; Meaning, if using a function like StringSplit which returns length in %myArray%0, make sure myArray doesn't have a value,"
							+"\n; otherwise, an empty array will be returned."
							+"\n; Example of bad usage:"
							+"<span style=\"color:#FF0000;\">"
							+"\nmyString := \"This is a test string.\""
							+"\nStringSplit, myArray, myString, %A_Space%"
							+"\nmyArray := \"Nothing Here\""
							+"\nnewArray := AHKA_Convert(\"myArray\")"
							+"</span>"
							+"\n; newArray will then contain \"[]\""
							+"</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "1"},
						{version: "1.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The name of the AutoHotkey array to convert."
						}
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The generated AHKArray."
					}
				}, /* Convert				*/
				{
					id: "sort",
					name: "Sort",
					content: "Sorts an AHKArray using 1 dimension.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myArray := AHKA_NewArray(\"[5,2,7,3,9,1,4,6,8]\")"
							+"\nmySortedArray1 := AHKA_Sort(myArray)"
							+"\n<span class=\"comment\">; mySortedArray1->[1, 2, 3, 4, 5, 6, 7, 8, 9]</span>"
							+"\nmySortedArray2 := AHKA_Sort(myArray, 2)"
							+"\n<span class=\"comment\">; mySortedArray2->[9, 8, 7, 6, 5, 4, 3, 2, 1]</span>"
							+"\nmySortedArray3 := AHKA_Sort(myArray, 1, 2)"
							+"\n<span class=\"comment\">; mySortedArray3->[5, 1, 2, 3, 4, 6, 7, 8, 9]</span>"
							+"\nmySortedArray4 := AHKA_Sort(myArray, 2, 3, 7)"
							+"\n<span class=\"comment\">; mySortedArray4->[5, 2, 9, 7, 4, 3, 1, 6, 8]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "6"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The name of the AHKArray to sort."
						},
						{
							name: "Type=1",
							type: "Integer",
							info: "Determines which way to sort the AHKArray."
									+"<br />If =1 AHKArray is sorted from smallest to largest."
									+"<br />If =2 AHKArray is sorted from largest to smallest."
						},
						{
							name: "Start=0",
							type: "Integer",
							info: "Determines at which index to start sorting."
									+"<br />Values 0 and 1 both represent the first index of the AHKArray."
									+"<br />Values are on a start=1 based order."
									+"<br />Note: This is NOT an advanced index."
						},
						{
							name: "End=-1",
							type: "Integer",
							info: "Determines at which index to end sorting."
									+"<br />Value -1 represents the last index of the AHKArray."
									+"<br />Values are on a start=1 based order."
									+"<br />Note: This is NOT an advanced index."
						}
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The sorted AHKArray."
					}
				}, /* Sort					*/
				{
					id: "swap",
					name: "Swap",
					content: "Swaps 2 indexes within an AHKArray.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myArray1 := AHKA_NewArray(\"[a,b,c,d,e,f]\")"
							+"\nmyArray2 := AHKA_Swap(myArray1, 2, 4)"
							+"\n<span class=\"comment\">; myArray2->[\"a\", \"d\", \"c\", \"b\", \"e\", \"f\"]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray to swap values within."
						},
						{
							name: "IndexA=0",
							type: "Integer",
							info: "The first value to swap within the AHKArray.<br />Index of <b>0</b> will get the value at the end of the AHKArray.<br />Index of <b>&gt;0</b> will get the value at the proper index (AHKArrays start at 1, not 0).<br />Value of <b>&lt;0</b> will get the value at the abs(Index) from the back of the AHKArray."
						},
						{
							name: "IndexB=0",
							type: "Integer",
							info: "The second value to swap within the AHKArray.<br />Index of <b>0</b> will get the value at the end of the AHKArray.<br />Index of <b>&gt;0</b> will get the value at the proper index (AHKArrays start at 1, not 0).<br />Value of <b>&lt;0</b> will get the value at the abs(Index) from the back of the AHKArray."
						}
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The resultant AHKArray."
					}
				}, /* Swap					*/
				{
					id: "find",
					name: "Find",
					content: "Finds a specified value within an AHKArray.<br />"
							+"If value isn't found, returns 0.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myArray := AHKA_NewArray(\"[a,b,c,d,a,b,c,d,a,b,c,d]\")"
							+"\nmyIndex1 := AHKA_Search(myArray, \"a\")"
							+"\n<span class=\"comment\">; myIndex1->1</span>"
							+"\nmyIndex2 := AHKA_Search(myArray, \"a\", 2)"
							+"\n<span class=\"comment\">; myIndex2->5</span>"
							+"\nmyIndex3 := AHKA_Search(myArray, \"a\", -1)"
							+"\n<span class=\"comment\">; myIndex3->5</span>"
							+"\nmyIndex4 := AHKA_Search(myArray, \"a\", 0)"
							+"\n<span class=\"comment\">; myIndex4->9</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray to search within."
						},
						{
							name: "Value",
							type: "String",
							info: "The value to search for."
						},
						{
							name: "Number=1",
							type: "Integer",
							info: "If Number=0 Returns the index of last occurance of value in the AHKArray.<br />"
									+"If Number>0 Returns the index of the Number'th occurance of value in the AHKArray.<br />"
									+"If Number<0 Returns the index of (abs(Index)+1)'th occurance of value in array starting from the end of the AHKArray."
						}
					],
					returns: {
						name: "newIndex",
						type: "Integer",
						info: "The index of the found Value."
					}
				}, /* Find					*/
				{
					id: "minimum",
					name: "Minimum",
					content: "Finds the smallest value within an AHKArray.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myArray := AHKA_NewArray(\"[5,4,6,9,1,3,7,8,2]\")"
							+"\nmyIndex := AHKA_Minimum(myArray)"
							+"\n<span class=\"comment\">; myIndex->5</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray to search within."
						}
					],
					returns: {
						name: "newIndex",
						type: "Integer",
						info: "The index of the found Value."
					}
				}, /* Minimum				*/
				{
					id: "maximum",
					name: "Maximum",
					content: "Finds the largest value within an AHKArray.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myArray := AHKA_NewArray(\"[5,4,6,9,1,3,7,8,2]\")"
							+"\nmyIndex := AHKA_Maximum(myArray)"
							+"\n<span class=\"comment\">; myIndex->4</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray to search within."
						}
					],
					returns: {
						name: "newIndex",
						type: "Integer",
						info: "The index of the found Value."
					}
				}, /* Maximum				*/
				{
					id: "reverse",
					name: "Reverse",
					content: "Reverses the order of an AHKArray.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myArray1 := AHKA_NewArray(\"[5,4,6,9,1,3,7,8,2]\")"
							+"\nmyArray2 := AHKA_Reverse(myArray1)"
							+"\n<span class=\"comment\">; myArray2->[2, 8, 7, 3, 1, 9, 6, 4, 5]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "1"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray to reverse."
						}
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The reversed AHKArray."
					}
				}, /* Reverse				*/
				{
					id: "trim",
					name: "Trim",
					content: "Trims an AHKArray by cutting off a specified number of indexes from beginning and end of the AHKArray.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myArray := AHKA_NewArray(\"[5,4,6,9,1,3,7,8,2]\")"
							+"\nmyArray1 := AHKA_Trim(myArray, 1)"
							+"\n<span class=\"comment\">; myArray1->[4, 6, 9, 1, 3, 7, 8, 2]</span>"
							+"\nmyArray2 := AHKA_Trim(myArray, 0, 2)"
							+"\n<span class=\"comment\">; myArray2->[5, 4, 6, 9, 1, 3, 7]</span>"
							+"\nmyArray3 := AHKA_Trim(myArray, 2, 3)"
							+"\n<span class=\"comment\">; myArray3->[6, 9, 1, 3]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray to reverse."
						},
						{
							name: "Starting=0",
							type: "Integer",
							info: "Number of indexes to cut off from the beginning of the AHKArray."
						},
						{
							name: "Ending=0",
							type: "Integer",
							info: "Number of indexes to cut off from the end of the AHKArray."
						}
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The trimmed AHKArray."
					}
				}, /* Trim					*/
				{
					id: "merge",
					name: "Merge",
					content: "Merges a number of AHKArrays together by appending the values of one to the end of another.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myArray1 := AHKA_NewArray(\"[a,b]\")"
							+"myArray2 := AHKA_NewArray(\"[c,d]\")"
							+"myArray3 := AHKA_NewArray(\"[e,f]\")"
							+"myArray4 := AHKA_NewArray(\"[g,h]\")"
							+"\nmyArray5 := AHKA_Merge(myArray1, myArray2)"
							+"\n<span class=\"comment\">; myArray5->[\"a\", \"b\", \"c\", \"d\"]</span>"
							+"\nmyArray6 := AHKA_Merge(myArray1, myArray2, myArray4, myArray3)"
							+"\n<span class=\"comment\">; myArray6->[\"a\", \"b\", \"c\", \"d\", \"g\", \"h\", \"e\", \"f\"]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "1"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array1",
							type: "String",
							info: "An AHKArray to merge.<br />Note: earlier indexes are merged to the beginning, later indexes are meged to the end."
						},
						{
							name: "Array2",
							type: "String",
							info: "An AHKArray to merge."
						},
						{
							name: "Array3=\"\" ... Array10=\"\"",
							type: "Integer",
							info: "There may be up to 10 AHKArrays specified to merge."
						}
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The merged AHKArray."
					}
				}, /* Megre					*/
				{
					id: "string",
					name: "String",
					content: "Converts an AHKArray into a simple string with no delimeters.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myArray := AHKA_NewArray(\"[1,2,3,4,5,6]\")"
							+"\nmyString := AHKA_String(myArray)"
							+"\n<span class=\"comment\">; myString->\"123456\"</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "1"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray to convert."
						}
					],
					returns: {
						name: "newString",
						type: "String",
						info: "The String representing the converted AHKArray."
					}
				}, /* String				*/
				{
					id: "move",
					name: "Move",
					content: "Moves a value at a specified index to another specified index.<br />"
							+"Sample Usage:<br /><pre><code>"
							+"myArray1 := AHKA_NewArray(\"[1,2,3,4,5,6]\")"
							+"\nmyArray2 := AHKA_Move(myArray1, 2, 3)"
							+"\n<span class=\"comment\">; myArray2->[1, 3, 2, 4, 5, 6]</span>"
							+"\nmyArray3 := AHKA_Move(myArray1, 3, 0)"
							+"\n<span class=\"comment\">; myArray3->[1, 2, 4, 5, 6, 3]</span>"
							+"\nmyArray4 := AHKA_Move(myArray1, 1, -1)"
							+"\n<span class=\"comment\">; myArray4->[2, 3, 4, 5, 1, 6]</span>"
							+"</code></pre>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "6.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					],
					parameters: [
						{
							name: "Array",
							type: "String",
							info: "The AHKArray to move the value within."
						},
						{
							name: "IndexA=0",
							type: "Integer",
							info: "Which value to move within the AHKArray.<br />Index of <b>0</b> will get the value at the end of the AHKArray.<br />Index of <b>&gt;0</b> will get the value at the proper index (AHKArrays start at 1, not 0).<br />Value of <b>&lt;0</b> will get the value at the abs(Index) from the back of the AHKArray."
						},
						{
							name: "IndexB=0",
							type: "Integer",
							info: "Where to move the value within the AHKArray.<br />Index of <b>0</b> will get the value at the end of the AHKArray.<br />Index of <b>&gt;0</b> will get the value at the proper index (AHKArrays start at 1, not 0).<br />Value of <b>&lt;0</b> will get the value at the abs(Index) from the back of the AHKArray."
						}
					],
					returns: {
						name: "newArray",
						type: "String",
						info: "The AHKArray resulting from the value being moved."
					}
				} /* Move					*/
			]
		},
		{
			name: "Utility Functions API",
			id: "utilityapi",
			items: [
				{
					id: "isarray",
					name: "IsArray",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "0.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* IsArray				*/
				{
					id: "error",
					name: "Error",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* Error					*/
				{
					id: "open",
					name: "Open",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* Open					*/
				{
					id: "close",
					name: "Close",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* Close					*/
				{
					id: "getfirstdimenstion",
					name: "GetFirstDimension",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "4"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* GetFirstDimensions	*/
				{
					id: "getdimension",
					name: "GetDimension",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "2"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* GetDimension			*/
				{
					id: "parsefirst",
					name: "ParseFirst",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "4"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* ParseFirst			*/
				{
					id: "parse",
					name: "Parse",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* Parse					*/
				{
					id: "unparse",
					name: "Unparse",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "2"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* Unparse				*/
				{
					id: "floor",
					name: "Floor",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* Floor					*/
				{
					id: "abs",
					name: "Abs",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* Abs					*/
				{
					id: "chartohex",
					name: "CharToHex",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* CharToHex				*/
				{
					id: "charfromhex",
					name: "CharFromHex",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* CharFromHex			*/
				{
					id: "hex",
					name: "Hex",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "2"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* Hex					*/
				{
					id: "hexarray",
					name: "HexArray",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "6.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* HexArray				*/
				{
					id: "checkdebug",
					name: "CheckDebug",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "6.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* CheckDebug			*/
				{
					id: "setdebug",
					name: "SetDebug",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "6.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* SetDebug				*/
				{
					id: "getsimple",
					name: "GetSimple",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "2"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* GetSimple				*/
				{
					id: "setsimple",
					name: "SetSimple",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "0"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* SetSimple				*/
				{
					id: "mergesimple",
					name: "MergeSimple",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "1"},
						{version: "5.xx",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* MergeSimple			*/
				{
					id: "addsimple",
					name: "AddSimple",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "6"},
						{version: "6.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				}, /* AddSimple				*/
				{
					id: "removesimple",
					name: "RemoveSimple",
					content: "<p>"
							+"Sorry, this function's documentation is under construction."
							+"</p>",
					history: [
						{version: "Bugs Known",
							update: "0"},
						{version: "Bugs Fixed",
							update: "2"},
						{version: "6.00",
							update: "Function Created"},
						{version: "6.00",
							update: "History Record Begins"}
					]
				} /* RemoveSimple			*/
			]
		}
	]
};