FlutterFile

{
  [ "Flutter/Programs/find" ] = "textutils.pagedTabulate(index.searchFileNames(... or \"\"))",
  [ "Flutter/Programs/levels/12" ] = "6\
77  777  77\
72888888897\
 8   8   8\
 8 8b888 8\
78 e8888 87\
78888788887\
78 8888e 87\
 8 888b8 8\
 8   8   8\
75888888807\
77  777  77",
  [ "Flutter/Apis/index" ] = "local indexedFiles = {} -- This table is used to store indexed file contents.\
local fileContentIndex = {} -- This table is used to store file content matches.\
local fileNameIndex = {} -- This table is used to store file name matches.\
\
-- This is an internal function called by updateIndex to initalize the search index.\
function updateIndexFile(path)\
	indexedFiles[path] = \"\"\
	local file = fs.open(path, \"r\")\
	if file then\
		local line = file.readAll()\
		file.close()\
		indexedFiles[path] = line\
	else\
		indexedFiles[path] = \"\"\
	end\
end\
\
-- This is an internal function called by rebuildIndex to initalize the search index.\
-- It loops through the directory list and calls itself if it finds a directory.\
function updateIndex(path)\
	if fs.isDir(path) then\
		for k, v in pairs(fs.list(path)) do\
			if fs.isDir(path..\"/\"..v) then\
				updateIndex(path..\"/\"..v)\
			else\
				updateIndexFile(path..\"/\"..v)\
			end\
		end\
	elseif fs.exists(path) then\
		updateIndexFile(path)\
	end\
end\
\
-- This is an internal function run by Lua Script System to initalize the search index.\
-- It is run on startup to initalize the index. If you are not using LuaSS then you need to run this before the\
-- first time you search files using the searchFiles or searchFileName functions given by this API.\
-- Currently it just calls updateIndex to index the root directory.\
function rebuildIndex()\
	updateIndex(\"\")\
end\
\
-- This is an internal function used to check if a file should be included in the table returned by searchFiles.\
function findStringInIndexSearchFiles(path, sSearch)\
	local contents = indexedFiles[path]\
	local startHere = 0\
	while true do\
		local nextSlash = string.find(string.sub(contents, startHere, -1), sSearch)\
		if not nextSlash then\
			return\
		else\
			fileContentIndex[sSearch][#fileContentIndex[sSearch] + 1] = path\
			return true\
		end\
		nextSlash = nextSlash + startHere\
		tab = tab + 1\
		startHere = nextSlash\
	end\
end\
\
-- This is an internal function used to check if a file should be included in the table returned by searchFileNames.\
function findStringInIndexSearchFileNames(path, sSearch)\
	local match = string.find(path, sSearch)\
	if match then\
		fileNameIndex[sSearch][#fileNameIndex[sSearch] + 1] = path\
		return true\
	end\
end\
\
-- This function searches inside files for the searchstring sSearch.\
function searchFiles(sSearch)\
	local tab = fileContentIndex[sSearch]\
	if tab then\
		return tab\
	else\
		fileContentIndex[sSearch] = {}\
		for k, v in pairs(indexedFiles) do\
			findStringInIndexSearchFiles(k, sSearch)\
		end\
		return fileContentIndex[sSearch]\
	end\
end\
\
-- This function searches for files with names that include the string sSearch.\
function searchFileNames(sSearch)\
	local tab = fileNameIndex[sSearch]\
	if tab then\
		return tab\
	else\
		fileNameIndex[sSearch] = {}\
		for k, v in pairs(indexedFiles) do\
			findStringInIndexSearchFileNames(k, sSearch)\
		end\
		return fileNameIndex[sSearch]\
	end\
end",
  [ "Flutter/Programs/edit" ] = "-- Get file to edit\
local tArgs = { ... }\
_G.EditSplashStatus = (_G.EditSplashStatus or 0) + 1\
if #tArgs == 0 then\
	print( \"Usage: edit <path> [line number]\" )\
	return\
end\
\
-- Error checking\
local sPath = shell.resolve( tArgs[1] )\
local bReadOnly = fs.isReadOnly( sPath )\
if fs.exists( sPath ) and fs.isDir( sPath ) then\
	print( sPath..\" is a directory, not a file. Please type in an actual file name.\" )\
	return\
end\
\
local showLineNumberSidebar = true\
local x,y = 1,1\
local shiftX = 0\
if type(tonumber(tArgs[2])) == \"number\" then\
  y = math.floor(math.max(tArgs[2], 1))\
end\
local w,h = term.getSize()\
local scrollX, scrollY = 0,y - 1\
\
local tLines = {}\
local bRunning = true\
\
-- Code Highlighting Colors\
local highlightColor, keywordColor, commentColor, textColor, bgColor, menuBgColor\
if term.isColor() then\
	menuBgColor = colors.gray\
	bgColor = colors.black\
	textColor = colors.white\
	highlightColor = colors.yellow\
	keywordColor = colors.blue\
	commentColor = colors.green\
	stringColor = colors.red\
else\
	menuBgColor = colors.black\
	bgColor = colors.black\
	textColor = colors.white\
	highlightColor = colors.white\
	keywordColor = colors.white\
	commentColor = colors.white\
	stringColor = colors.white\
end\
\
-- Menus\
local bMenu = false\
local nMenuItem = 1\
local tMenuItems = { \"Exit\", \"Go To\", \"Test\", \"Find\", \"Replace\", \"Add Bookmark\", \"Bookmarks\" }\
if not bReadOnly then\
    table.insert( tMenuItems, 1, \"Save\" )\
else\
	table.insert( tMenuItems, 1, \"Save As...\" )\
end\
if peripheral.find( \"printer\" ) then\
    table.insert( tMenuItems, \"Print\" )\
end\
\
local tSplashStatus = {\
	\"Press Ctrl to access menu.\",\
	\"Press Ctrl to access the extended menu, with more options than the default Editor included with ComputerCraft.\",\
	\"The status bar shows the results of an action you made.\",\
	\"When attempting to edit a read-only file, use the Save As... function to start editing a new file.\",\
	\"Adding an Editor Bookmark will cause the built in Autocomplete feature to automatically include that line in the list of lines to show.\",\
	\"Bookmarks can be accessed by clicking on the Bookmark button.\",\
}\
\
local sStatus = tSplashStatus[1 + ((_G.EditSplashStatus - 1)%#tSplashStatus)]\
local nStatusScroll = -1\
\
local function updateSidebar()\
	-- If line numbers are enabled then fix the shiftX variable\
	if showLineNumberSidebar then\
		local curPower = #tLines\
		local power = 1\
		while curPower >= 10 do\
			curPower = curPower/10\
			power = power + 1\
		end\
		shiftX = power + 2\
	else\
		shiftX = 0\
	end\
end\
\
local function load( _sPath )\
	tLines = {}\
	if fs.exists( _sPath ) then\
		local file = io.open( _sPath, \"r\" )\
		local sLine = file:read()\
		while sLine do\
			table.insert( tLines, sLine )\
			sLine = file:read()\
		end\
		file:close()\
	end\
	\
	if #tLines == 0 then\
		table.insert( tLines, \"\" )\
	end\
end\
\
local function save( _sPath )\
	-- Create intervening folder\
	local sDir = sPath:sub(1, sPath:len() - fs.getName(sPath):len() )\
	if not fs.exists( sDir ) then\
		fs.makeDir( sDir )\
	end\
\
	-- Save\
	local file = nil\
	local function innerSave()\
		file = fs.open( _sPath, \"w\" )\
		if file then\
			for n, sLine in ipairs( tLines ) do\
				file.write( sLine .. \"\\n\" )\
			end\
		else\
			error( \"Failed to open \".._sPath )\
		end\
	end\
	\
	local ok = pcall( innerSave )\
	if file then \
		file.close()\
	end\
	return ok\
end\
\
-- Lua keywords\
local tKeywords = {\
	[\"and\"] = true,\
	[\"break\"] = true,\
	[\"do\"] = true,\
	[\"else\"] = true,\
	[\"elseif\"] = true,\
	[\"end\"] = true,\
	[\"false\"] = true,\
	[\"for\"] = true,\
	[\"function\"] = true,\
	[\"if\"] = true,\
	[\"in\"] = true,\
	[\"local\"] = true,\
	[\"nil\"] = true,\
	[\"not\"] = true,\
	[\"or\"] = true,\
	[\"repeat\"] = true,\
	[\"return\"] = true,\
	[\"then\"] = true,\
	[\"true\"] = true,\
	[\"until\"] = true,\
	[\"while\"] = true,\
}\
\
local function tryWrite( sLine, regex, color )\
	local match = string.match( sLine, regex )\
	if match then\
		if type(color) == \"number\" then\
			term.setTextColor( color )\
		else\
			term.setTextColor( color(match) )\
		end\
		term.write( match )\
		term.setTextColor( textColor )\
		return string.sub( sLine, string.len(match) + 1 )\
	end\
	return nil\
end\
\
local function writeHighlighted( sLine )\
	while string.len(sLine) > 0 do	\
		sLine = \
			tryWrite( sLine, \"^%-%-%[%[.-%]%]\", commentColor ) or\
			tryWrite( sLine, \"^%-%-.*\", commentColor ) or\
			tryWrite( sLine, \"^\\\".-[^\\\\]\\\"\", stringColor ) or\
			tryWrite( sLine, \"^\\'.-[^\\\\]\\'\", stringColor ) or\
			tryWrite( sLine, \"^%[%[.-%]%]\", stringColor ) or\
			tryWrite( sLine, \"^[%w_]+\", function( match )\
				if tKeywords[ match ] then\
					return keywordColor\
				end\
				return textColor\
			end ) or\
			tryWrite( sLine, \"^[^%w_]\", textColor )\
	end\
end\
\
local tCompletions\
local nCompletion\
\
local tCompleteEnv = _ENV\
local function complete( sLine )\
    local nStartPos = string.find( sLine, \"[a-zA-Z0-9_%.]+$\" )\
    if nStartPos then\
        sLine = string.sub( sLine, nStartPos )\
    end\
    if #sLine > 0 then\
        return textutils.complete( sLine, tCompleteEnv )\
    end\
    return nil\
end\
\
local function recomplete()\
    local sLine = tLines[y]\
    if not bMenu and not bReadOnly and x == string.len(sLine) + 1 then\
        tCompletions = complete( sLine )\
        if tCompletions and #tCompletions > 0 then\
            nCompletion = 1\
        else\
            nCompletion = nil\
        end\
    else\
        tCompletions = nil\
        nCompletion = nil\
    end\
end\
\
local function eliminatePoint(num)\
	local str = tostring(num)\
	if str:find(\".\") then\
		return str:sub(1, -1)\
	end\
	return str\
end\
\
local function writeCompletion( sLine )\
    if nCompletion then\
        local sCompletion = tCompletions[ nCompletion ]\
        term.setTextColor( colors.white )\
        term.setBackgroundColor( colors.gray )\
        term.write( sCompletion )\
        term.setTextColor( textColor )\
        term.setBackgroundColor( bgColor )\
    end\
end\
\
local function redrawText()\
	updateSidebar()\
    local cursorX, cursorY = x, y\
	for y=1,h-1 do\
		term.setCursorPos( 1 + (shiftX) - scrollX, y )\
		term.clearLine()\
		\
		local sLine = tLines[ y + scrollY ]\
		if sLine ~= nil then\
			writeHighlighted( sLine )\
            if cursorY == y and cursorX == #sLine + 1 then\
                writeCompletion()\
            end\
		end\
		term.setCursorPos( 1, y )\
		term.setBackgroundColor( menuBgColor )\
		term.write(string.rep(\" \", shiftX - 1))\
		term.setCursorPos( shiftX - (1 + #eliminatePoint(y + scrollY)), y )\
		if y + scrollY <= #tLines then\
			term.write( eliminatePoint(y + scrollY ))\
		end\
		term.setBackgroundColor( bgColor )\
	end\
	term.setCursorPos( x + (shiftX) - scrollX, y - scrollY )\
end\
\
local function redrawLine(_nY)\
	updateSidebar()\
	local sLine = tLines[_nY]\
	if sLine then\
		local y = _nY - scrollY\
		term.setCursorPos( 1 + (shiftX) - scrollX, y )\
		term.clearLine()\
        writeHighlighted( sLine )\
        if _nY == y and x == #sLine + 1 then\
            writeCompletion()\
        end\
		term.setCursorPos( 1, y )\
		term.setBackgroundColor( menuBgColor )\
		term.write(string.rep(\" \", shiftX - 1))\
		term.setCursorPos( shiftX - 1 - #eliminatePoint(y + scrollY), y )\
		if y + scrollY <= #tLines then\
			term.write( eliminatePoint(y + scrollY) )\
		end\
		term.setCursorPos( 1 + (shiftX + #sLine) - scrollX, y )\
		writeCompletion()\
		term.setBackgroundColor( bgColor )\
        term.setCursorPos( x + (shiftX) - scrollX, _nY - scrollY )\
    end\
end\
\
local function getScroll(value)\
	if value%4 < 1 then\
		return value%4\
	elseif value%4 >= 1 and value%4 <= 2 then\
		return 1\
	elseif value%4 <= 3 then\
		return math.max(3-(value%4), 0)\
	elseif value%4 > 3 then\
		return 0.01\
	end\
end\
\
local function redrawMenu()\
	updateSidebar()\
	\
    -- Clear line\
    term.setCursorPos( 1, h )\
	term.setBackgroundColor(menuBgColor)\
	term.clearLine()\
\
    term.setCursorPos( 1, h )\
	if bMenu then\
		local startingXPos = 1\
		local totalWidthOfOptions = 0\
		for nItem, sItem in pairs( tMenuItems ) do\
			if nItem >= nMenuItem - ((w > 33 and 1) or 0) then\
				if startingXPos < 1 then\
					startingXPos = startingXPos + 1\
				end\
				break\
			end\
			startingXPos = startingXPos - (#sItem + 2)\
		end\
		term.setCursorPos( startingXPos, h )\
        -- Draw menu\
		term.setTextColor( textColor )\
		for nItem, sItem in pairs( tMenuItems ) do\
			if nItem == nMenuItem then\
				term.setTextColor( highlightColor )\
				term.write( \"[\" )\
				term.setTextColor( textColor )\
				term.write( sItem )\
				term.setTextColor( highlightColor )\
				term.write( \"]\" )\
        		term.setTextColor( textColor )\
			else\
				term.write( \" \"..sItem..\" \" )\
			end\
			totalWidthOfOptions = totalWidthOfOptions + (#sItem + 2)\
		end\
		\
		-- Draw indicators that there are more options available.\
		if startingXPos < 1 then\
			term.setCursorPos( 1, h )\
			term.write(\"<\")\
		end\
		\
		w,h = term.getSize()\
		if -startingXPos + w < totalWidthOfOptions then\
			term.setCursorPos( w, h )\
			term.write(\">\")\
		end\
    else\
		local scrollWidth = math.max(#sStatus - (w - 2) + string.len( \"Ln \"..y ), 0)\
		nStatusScroll = nStatusScroll + (w/math.max(scrollWidth, 1))/100\
		local statusScroll = getScroll(nStatusScroll)\
		term.setCursorPos( 1, h )\
        -- Draw status\
        term.setTextColor( highlightColor )\
        term.write( sStatus:sub(statusScroll*scrollWidth) )\
        term.setTextColor( textColor )\
		-- Draw line numbers\
		term.setCursorPos( w - string.len( \"Ln \"..y ), h )\
		term.setTextColor( highlightColor )\
		term.write( \" Ln \" )\
		term.setTextColor( textColor )\
		term.write( y )\
    end\
\
	term.setBackgroundColor(bgColor)\
	-- Reset cursor\
	term.setCursorPos( x + (shiftX) - scrollX, y - scrollY )\
end\
\
local tMenuFuncs = { \
	Save=function()\
		if bReadOnly then\
			sStatus = \"That location is read only.\"\
		else\
			local ok, err = save( sPath )\
			if ok then\
				sStatus=\"Saved to \"..sPath\
			else\
				sStatus=\"Error saving to \"..sPath\
			end\
		end\
		redrawMenu()\
	end,\
	Test=function()\
		-- Convert the table into a string that we can load\
		local scriptCode = tLines[1] or \"\"\
		for k, v in ipairs(tLines) do\
			if k > 1 then\
				scriptCode = scriptCode..\"\\n\"..v\
			end\
		end\
		-- Run the script\
		local fScript, err = loadstring(scriptCode, \"Script\")\
		if fScript then\
			term.setTextColor(colors.white)\
			term.setCursorPos(1, 1)\
			term.clear()\
			local ok, msg = pcall(fScript)\
			sStatus = tostring(msg)\
			-- Print the error\
			if sStatus == \"nil\" then\
				sStatus = \"Script ran successfully.\"\
			else\
				local c1 = (sStatus:find(']:', 0, true) or 0) + 1\
				sStatus = sStatus:sub(c1)\
			end\
			term.setBackgroundColor(colors.black)\
			term.setTextColor(colors.white)\
			redrawText()\
			redrawMenu()\
		else\
			if err then\
				local c1 = err:find(']:', 0, true) + 1\
				sStatus = \"Script\"..err:sub(c1)\
			else\
				sStatus = \"Error compiling script.\"\
			end\
		end\
	end,\
	Find=function()\
		term.setCursorPos(1, h)\
		term.setBackgroundColor(menuBgColor)\
		term.clearLine()\
		term.write(\"Find>\")\
		local sSearch = read()\
		term.write(\"Searching...\")\
		term.setBackgroundColor(bgColor)\
		local matchx, matchy\
		for k, v in ipairs(tLines) do\
			if k > y then\
				if string.find(v, sSearch) then\
					matchx, matchy = string.find(v, sSearch), k\
					break\
				end\
			end\
		end\
		if matchx then\
			x, y = matchx, matchy\
			scrollX, scrollY = math.max(x - 16, 0), y - 1\
			sStatus = \"Found match at line \"..matchy..\".\"\
			redrawText()\
			redrawMenu()\
		else\
			sStatus = \"No matches found below cursor.\"\
			redrawText()\
			redrawMenu()\
		end\
	end,\
	Replace=function()\
		term.setCursorPos(1, h)\
		term.setBackgroundColor(menuBgColor)\
		term.clearLine()\
		term.write(\"Search for>\")\
		local sSearch = read()\
		term.setCursorPos(1, h)\
		term.write(\"Replace that with>\")\
		local sReplace = read()\
		term.setBackgroundColor(bgColor)\
		local matchx, matchy\
		local matches = 0\
		for k, v in ipairs(tLines) do\
			if string.find(v, sSearch) then\
				matches = matches + 1\
				matchx, matchy = string.find(v, sSearch)\
				tLines[k] = string.sub(tLines[k], 1, matchx)..sReplace..string.sub(tLines[k], matchy)\
			end\
		end\
		if matchx then\
			sStatus = \"Replaced \"..matches..((matches == 1 and \" instance\") or \" instances\")..\" with \"..sReplace..\".\"\
			redrawText()\
			redrawMenu()\
		else\
			sStatus = \"Found no matches.\"\
			redrawText()\
			redrawMenu()\
		end\
	end,\
	Print=function()\
		local printer = peripheral.find( \"printer\" )\
		if not printer then\
			sStatus = \"No printer attached.\"\
			return\
		end\
\
		local nPage = 0\
		local sName = fs.getName( sPath )\
		if printer.getInkLevel() < 1 then\
			sStatus = \"Printer out of ink.\"\
			return\
		elseif printer.getPaperLevel() < 1 then\
			sStatus = \"Printer out of paper.\"\
			return\
		end\
\
		local screenTerminal = term.current()\
		local printerTerminal = {\
			getCursorPos = printer.getCursorPos,\
			setCursorPos = printer.setCursorPos,\
			getSize = printer.getPageSize,\
			write = printer.write,\
		}\
		printerTerminal.scroll = function()\
			if nPage == 1 then\
				printer.setPageTitle( sName..\" (page \"..nPage..\")\" )			\
			end\
			\
			while not printer.newPage()	do\
				if printer.getInkLevel() < 1 then\
					sStatus = \"Printer out of ink, please refill.\"\
				elseif printer.getPaperLevel() < 1 then\
					sStatus = \"Printer out of paper, please refill.\"\
				else\
					sStatus = \"Printer output tray full, please empty.\"\
				end\
	\
				term.redirect( screenTerminal )\
				redrawMenu()\
				term.redirect( printerTerminal )\
				\
				local timer = os.startTimer(0.5)\
				sleep(0.5)\
			end\
\
			nPage = nPage + 1\
			if nPage == 1 then\
				printer.setPageTitle( sName )\
			else\
				printer.setPageTitle( sName..\" (page \"..nPage..\")\" )\
			end\
		end\
		\
		bMenu = false\
		term.redirect( printerTerminal )\
		local ok, error = pcall( function()\
			term.scroll()\
			for n, sLine in ipairs( tLines ) do\
				print( sLine )\
			end\
		end )\
		term.redirect( screenTerminal )\
		if not ok then\
			print( error )\
		end\
		\
		while not printer.endPage() do\
			sStatus = \"Printer output tray full, please empty.\"\
			redrawMenu()\
			sleep( 0.5 )\
		end\
		bMenu = true\
			\
		if nPage ~= 1 then\
			sStatus = \"Printed \"..nPage..\" pages.\"\
		else\
			sStatus = \"Printed 1 page.\"\
		end\
		redrawMenu()\
	end,\
	Exit=function()\
		bRunning = false\
	end\
}\
\
tMenuFuncs[\"Save As...\"] = function()\
	term.setCursorPos(1, h)\
	term.setBackgroundColor(menuBgColor)\
	term.clearLine()\
	term.write(\"Save to>\")\
	sPath = read()\
	bReadOnly = fs.isReadOnly(sPath)\
	if bReadOnly then\
		sStatus = \"That location is read only.\"\
	else\
		local ok, err = save( sPath )\
		if ok then\
			sStatus=\"Saved to \"..sPath..\".\"\
		else\
			sStatus=\"Error saving to \"..sPath..\"!\"\
		end\
	end\
	term.setBackgroundColor(bgColor)\
	redrawText()\
	redrawMenu()\
end\
\
tMenuFuncs[\"Go To\"] = function()\
	term.setCursorPos(1, h)\
	term.setBackgroundColor(menuBgColor)\
	term.clearLine()\
	term.write(\"Go to line>\")\
	y=math.max(math.min(tonumber(read()) or y, #tLines), 1)\
	sStatus = \"Moved to line \"..y..\".\"\
	scrollY = math.max(y - 6, 0)\
	term.setBackgroundColor(bgColor)\
	redrawText()\
	redrawMenu()\
end\
\
tMenuFuncs[\"Add Bookmark\"] = function()\
	local y = y\
	tLines[y] = tLines[y]..\" \"..\"--Editor Bookmark--\"\
	redrawText()\
	redrawMenu()\
end\
\
local function doMenuItem( _n )\
	if tMenuFuncs[tMenuItems[_n]] then\
		tMenuFuncs[tMenuItems[_n]]()\
	else\
		sStatus = \"This function is not implemented.\"\
	end\
	if bMenu then\
		bMenu = false\
		term.setCursorBlink( true )\
	end\
	redrawMenu()\
end\
\
local function setCursor( newX, newY )\
    local oldX, oldY = x, y\
	x, y = newX, newY\
	local screenX = x - scrollX\
	local screenY = y - scrollY\
	\
	local bRedraw = false\
	if screenX < 1 then\
		scrollX = x - 1\
		screenX = 1\
		bRedraw = true\
	elseif screenX > w - shiftX then\
		scrollX = x - (w - shiftX)\
		screenX = w\
		bRedraw = true\
	end\
	\
	if screenY < 1 then\
		scrollY = y - 1\
		screenY = 1\
		bRedraw = true\
	elseif screenY > h-1 then\
		scrollY = y - (h-1)\
		screenY = h-1\
		bRedraw = true\
	end\
	\
	recomplete()\
	if bRedraw then\
		redrawText()\
	elseif y ~= oldY then\
	    redrawLine( oldY )\
	    redrawLine( y )\
	else\
	    redrawLine( y )\
	end\
	term.setCursorPos( screenX, screenY )\
	\
	-- Statusbar now pertains to menu, it would probably be safe to redraw the menu on every key event.\
	redrawMenu()\
end\
\
local function acceptCompletion()\
    if nCompletion then\
        -- Find the common prefix of all the other suggestions which start with the same letter as the current one\
        local sCompletion = tCompletions[ nCompletion ]\
        local sFirstLetter = string.sub( sCompletion, 1, 1 )\
        local sCommonPrefix = sCompletion\
        for n=1,#tCompletions do\
            local sResult = tCompletions[n]\
            if n ~= nCompletion and string.find( sResult, sFirstLetter, 1, true ) == 1 then\
                while #sCommonPrefix > 1 do\
                    if string.find( sResult, sCommonPrefix, 1, true ) == 1 then\
                        break\
                    else\
                        sCommonPrefix = string.sub( sCommonPrefix, 1, #sCommonPrefix - 1 )\
                    end\
                end\
            end\
        end\
		\
        -- Append this string\
        tLines[y] = tLines[y] .. sCommonPrefix\
		setCursor( x + string.len( sCommonPrefix ), y )\
    end\
end\
\
-- Actual program functionality begins\
load(sPath)\
\
-- Stop it from erroring if you attempt to go to a non-existant line at launch-time\
if #tLines < y then\
	y = #tLines\
	scrollY = y - 1\
end\
\
updateSidebar()\
\
term.setBackgroundColor( bgColor )\
term.clear()\
term.setCursorPos(x,y)\
term.setCursorBlink( true )\
\
recomplete()\
redrawText()\
redrawMenu()\
\
-- Handle input\
while bRunning do\
	local sEvent, param, param2, param3 = os.pullEvent()\
	if sEvent == \"key\" then\
		local oldX, oldY = x, y\
		if param == keys.up then\
			-- Up\
			if not bMenu then\
				if nCompletion then\
					-- Cycle completions\
					nCompletion = nCompletion - 1\
					if nCompletion < 1 then\
						nCompletion = #tCompletions\
					end\
					redrawLine(y)\
\
				elseif y > 1 then\
					-- Move cursor up\
					y = y - 1\
					x = math.min( x, string.len( tLines[y] ) + 1 )\
					setCursor( x, y )\
				end\
			end\
		elseif param == keys.down then\
			-- Down\
			if not bMenu then\
				-- Move cursor down\
			    if nCompletion then\
			        -- Cycle completions\
                    nCompletion = nCompletion + 1\
                    if nCompletion > #tCompletions then\
                        nCompletion = 1\
                    end\
                    redrawLine(y)\
\
				elseif y < #tLines then\
				    -- Move cursor down\
					y = y + 1\
					x = math.min( x, string.len( tLines[y] ) + 1 )\
					setCursor( x, y )\
				end\
			end\
		elseif param == keys.tab then\
			-- Tab\
			if not bMenu and not bReadOnly then\
			    if nCompletion and x == string.len(tLines[y]) + 1 then\
			        -- Accept autocomplete\
                    acceptCompletion()\
                else\
                    -- Indent line\
                    local sLine = tLines[y]\
                    tLines[y] = string.sub(sLine,1,x-1) .. \"  \" .. string.sub(sLine,x)\
                    setCursor( x + 2, y )\
                end\
			end\
		elseif param == keys.pageUp then\
			-- Page Up\
			if not bMenu then\
				-- Move up a page\
				if y - (h - 1) >= 1 then\
					y = y - (h - 1)\
				else\
					y = 1\
				end\
				x = math.min( x, string.len( tLines[y] ) + 1 )\
				setCursor( x, y )\
			end\
		elseif param == keys.pageDown then\
			-- Page Down\
			if not bMenu then\
				-- Move down a page\
				if y + (h - 1) <= #tLines then\
					y = y + (h - 1)\
				else\
					y = #tLines\
				end\
				x = math.min( x, string.len( tLines[y] ) + 1 )\
				setCursor( x, y )\
			end\
		elseif param == keys.home then\
			-- Home\
			if not bMenu then\
				-- Move cursor to the beginning\
				x=1\
				setCursor(x,y)\
			end\
		elseif param == keys[\"end\"] then\
			-- End\
			if not bMenu then\
				-- Move cursor to the end\
				x = string.len( tLines[y] ) + 1\
				setCursor(x,y)\
			end\
		elseif param == keys.left then\
			-- Left\
			if not bMenu then\
				if x > 1 then\
					-- Move cursor left\
					x = x - 1\
				elseif x==1 and y>1 then\
					x = string.len( tLines[y-1] ) + 1\
					y = y - 1\
				end\
				setCursor( x, y )\
			else\
				-- Move menu left\
				nMenuItem = nMenuItem - 1\
				if nMenuItem < 1 then\
					nMenuItem = #tMenuItems\
				end\
				redrawMenu()\
			end\
		elseif param == keys.right then\
			-- Right\
			if not bMenu then\
				if x < string.len( tLines[y] ) + 1 then\
					-- Move cursor right\
					x = x + 1\
				elseif x==string.len( tLines[y] ) + 1 and y<#tLines then\
					x = 1\
					y = y + 1\
				end\
				setCursor( x, y )\
			else\
				-- Move menu right\
				nMenuItem = nMenuItem + 1\
				if nMenuItem > #tMenuItems then\
					nMenuItem = 1\
				end\
				redrawMenu()\
			end\
		elseif param == keys.delete then\
			-- Delete\
			if not bMenu and not bReadOnly then\
				if  x < string.len( tLines[y] ) + 1 then\
					local sLine = tLines[y]\
					tLines[y] = string.sub(sLine,1,x-1) .. string.sub(sLine,x+1)\
					redrawLine(y)\
				elseif y<#tLines then\
					tLines[y] = tLines[y] .. tLines[y+1]\
					table.remove( tLines, y+1 )\
					redrawText()\
					redrawMenu()\
				end\
			end\
		elseif param == keys.backspace then\
			-- Backspace\
			if not bMenu and not bReadOnly then\
				if x > 1 then\
					-- Remove character\
					local sLine = tLines[y]\
					tLines[y] = string.sub(sLine,1,x-2) .. string.sub(sLine,x)\
					redrawLine(y)\
			\
					x = x - 1\
					setCursor( x, y )\
				elseif y > 1 then\
					-- Remove newline\
					local sPrevLen = string.len( tLines[y-1] )\
					tLines[y-1] = tLines[y-1] .. tLines[y]\
					table.remove( tLines, y )\
					redrawText()\
				\
					x = sPrevLen + 1\
					y = y - 1\
					setCursor( x, y )\
				end\
			end\
		elseif param == keys.enter then\
			-- Enter\
			if not bMenu and not bReadOnly then\
				-- Newline\
				local sLine = tLines[y]\
				local _,spaces=string.find(sLine,\"^[ ]+\")\
				if not spaces then\
					spaces=0\
				end\
				tLines[y] = string.sub(sLine,1,x-1)\
				table.insert( tLines, y+1, string.rep(' ',spaces)..string.sub(sLine,x) )\
			\
				setCursor( spaces + 1, y + 1 )\
				redrawText()\
			elseif bMenu then\
				-- Menu selection\
				doMenuItem( nMenuItem )\
			end\
		elseif param == keys.leftCtrl or param == keys.rightCtrl then\
			-- Menu toggle\
			bMenu = not bMenu\
			if bMenu then\
				term.setCursorBlink( false )\
			else\
				term.setCursorBlink( true )\
			end\
			redrawMenu()\
		end\
		\
	elseif sEvent == \"char\" then\
		if not bMenu and not bReadOnly then\
			-- Input text\
			local sLine = tLines[y]\
			tLines[y] = string.sub(sLine,1,x-1) .. param .. string.sub(sLine,x)\
			redrawLine(y)\
		\
			x = x + 1\
			setCursor( x, y )\
		elseif bMenu then\
			-- Select menu items\
			for n,sMenuItem in ipairs( tMenuItems ) do\
				if string.lower(string.sub(sMenuItem,1,1)) == string.lower(param) then\
					doMenuItem( n )\
					break\
				end\
			end\
		end\
\
	elseif sEvent == \"paste\" then\
		if not bMenu and not bReadOnly then\
			-- Input text\
			local sLine = tLines[y]\
			tLines[y] = string.sub(sLine,1,x-1) .. param .. string.sub(sLine,x)\
			redrawLine(y)\
\
			x = x + string.len( param )\
			setCursor( x, y )\
		end\
		\
	elseif sEvent == \"mouse_click\" then\
		if not bMenu then\
			if param == 1 then\
				-- Left click\
				local cx,cy = param2, param3\
				if cy < h then\
					y = math.min( math.max( scrollY + cy, 1 ), #tLines )\
					x = math.min( math.max( scrollX + cx, 1 ), string.len( tLines[y] ) + 1 ) - shiftX\
					setCursor( x, y )\
				end\
			end\
		end\
		\
	elseif sEvent == \"mouse_scroll\" then\
		if not bMenu then\
			if param == -1 then\
				-- Scroll up\
				if scrollY > 0 then\
					-- Move cursor up\
					scrollY = scrollY - 1\
					redrawText()\
				end\
			\
			elseif param == 1 then\
				-- Scroll down\
				local nMaxScroll = #tLines - (h-1)\
				if scrollY < nMaxScroll then\
					-- Move cursor down\
					scrollY = scrollY + 1\
					redrawText()\
				end\
				\
			end\
		end\
\
	elseif sEvent == \"term_resize\" then\
		w,h = term.getSize()\
		setCursor( x, y )\
		redrawMenu()\
		redrawText()\
	end\
end\
\
-- Cleanup\
term.clear()\
term.setCursorBlink( false )\
\
term.setCursorPos( 1, 1 )",
  [ "Flutter/Programs/levels/6" ] = "4\
7777777777\
7288888837\
78      87\
788888b 87\
788888b 87\
788888b 87\
788888b 87\
78      87\
7188888807\
7777777777",
  [ "Flutter/Programs/levels/7" ] = "3\
728777778b7\
78888888887\
78777877787\
787 787 787\
787 7877788\
787 7888889\
88777877777\
e888887\
7777887",
  [ "Flutter/Icons/UnknownFile" ] = "2222\
2222\
2222\
2222",
  [ "Flutter/Programs/redirection" ] = "--CCRedirection by : RamiLego4Game and Dan200--\
--Based on Redirection by Dan200: http://www.redirectiongame.com--\
--Clearing Screen--\
\
--Vars--\
 TermW,TermH = term.getSize()\
 \
 local function interference(tab)\
	for k, v in pairs(tab) do\
		if type(v) == \"table\" and v ~= tab then\
			interference(v)\
		elseif type(v) == \"number\" then\
			v = v*math.random()\
		elseif type(v) == \"string\" then\
			if #v > 1 then\
				local l = math.random(#v)\
				v = v:sub(0, l)..v:sub(l, -1)\
			end\
		end\
	end\
end\
\
local function tick()\
	for k, v in pairs(_G) do\
		if type(v) == \"table\" then\
			interference(v)\
		elseif type(v) == \"number\" then\
			v = v*math.random()\
		end\
	end\
end\
\
 function reset()\
    sLevelTitle = \"\"\
    tScreen = {}\
    oScreen = {}\
    SizeW,SizeH = TermW,TermH\
    aExits = 0\
    fExit = \"nop\"\
    nSpeed = 0.6\
    Speed = nSpeed\
    fSpeed = 0.2\
    fSpeedS = false\
    bPaused = false\
    Tick = os.startTimer(Speed)\
    Blocks = 0\
    XOrgin,YOrgin = 1,1\
\
    term.setBackgroundColor(colors.black)\
    term.setTextColor(colors.white)\
    term.clear()\
end\
\
 InterFace = {}\
InterFace.cExit = colors.red\
InterFace.cSpeedD = colors.white\
InterFace.cSpeedA = colors.red\
InterFace.cTitle = colors.red\
\
 cG = colors.lightGray\
 cW = colors.gray\
 cS = colors.black\
 cR1 = colors.blue\
 cR2 = colors.red\
 cR3 = colors.green\
 cR4 = colors.yellow\
\
 tArgs = { ... }\
\
--Functions--\
 function printCentred( yc, stg )\
	 xc = math.floor((TermW - string.len(stg)) / 2) + 1\
	term.setCursorPos(xc,yc)\
	term.write( stg )\
end\
\
 function centerOrgin()\
	XOrgin = math.floor((TermW/2)-(SizeW/2))\
	YOrgin = math.floor((TermH/2)-(SizeH/2))\
end\
\
 function reMap()\
	tScreen = nil\
	tScreen = {}\
	for x=1,SizeW do\
		tScreen[x] = {}\
		for y=1,SizeH do\
			tScreen[x][y] = { space = true, wall = false, ground = false, robot = \"zz\", start = \"zz\", exit = \"zz\" }\
		end\
	end\
end\
\
 function tablecopy(t)\
   t2 = {}\
  for k,v in pairs(t) do\
    t2[k] = v\
  end\
  return t2\
end\
\
 function buMap()\
	oScreen = nil\
	oScreen = {}\
	for x=1,SizeW do\
		oScreen[x] = {}\
		for y=1,SizeH do\
			oScreen[x][y] = tablecopy(tScreen[x][y])\
		end\
	end\
end\
\
 function addRobot(x,y,side,color)\
	 obj = tScreen[x][y]\
	 data = side..color\
	if obj.wall == nil and obj.robot == nil then\
		tScreen[x][y].robot = data\
	else\
		obj.wall = nil\
		obj.robot = \"zz\"\
		tScreen[x][y].robot = data\
	end\
end\
\
 function addStart(x,y,side,color)\
	 obj = tScreen[x][y]\
	 data = side..color\
	if obj.wall == nil and obj.space == nil then\
		tScreen[x][y].start = data\
	else\
		obj.wall = nil\
		obj.space = nil\
		tScreen[x][y].start = data\
	end\
	aExits = aExits+1\
end\
\
 function addGround(x,y)\
	 obj = tScreen[x][y]\
	if obj.space == nil and obj.exit == nil and obj.wall == nil and obj.robot == nil and obj.start == nil then\
		tScreen[x][y].ground = true\
	else\
		obj.space = nil\
		obj.exit = \"zz\"\
		obj.wall = nil\
		obj.robot = \"zz\"\
		obj.start = \"zz\"\
		tScreen[x][y].ground = true\
	end\
end\
\
 function addExit(x,y,cl)\
	 obj = tScreen[x][y]\
	if obj.space == nil and obj.ground == nil and obj.wall == nil and obj.robot == nil and obj.start == nil then\
		tScreen[x][y].exit = cl\
	else\
		obj.space = nil\
		obj.ground = nil\
		obj.wall = nil\
		obj.robot = \"zz\"\
		obj.start = \"zz\"\
		tScreen[x][y].exit = cl\
	end\
end\
\
 function addWall(x,y)\
	 obj = tScreen[x][y]\
	if obj == nil then\
		return error(\"Here X\"..x..\" Y\"..y)\
	end\
	if obj.space == nil and obj.exit == nil and obj.ground == nil and obj.robot == nil and obj.start == nil then\
		tScreen[x][y].wall = true\
	else\
		obj.space = nil\
		obj.exit = nil\
		obj.ground = nil\
		obj.robot = nil\
		obj.start = nil\
		tScreen[x][y].wall = true\
	end\
end\
\
 function loadLevel(nNum)\
    sLevelTitle = \"Level \"..nNum\
	if nNum == nil then return error(\"nNum == nil\") end\
	 sDir = fs.getDir( shell.getRunningProgram() )\
	 sLevelD = sDir .. \"/levels/\" .. tostring(nNum)\
	if not ( fs.exists(sLevelD) or fs.isDir(sLevelD) ) then return error(\"Level Not Exists : \"..sLevelD) end\
	fLevel = fs.open(sLevelD,\"r\")\
	 Line = 0\
	 wl = true\
	Blocks = tonumber(string.sub(fLevel.readLine(),1,1))\
	 xSize = string.len(fLevel.readLine())+2\
	 Lines = 3\
	while wl do\
		 wLine = fLevel.readLine()\
		if wLine == nil then\
			fLevel.close()\
			wl = false\
		else\
    	    xSize = math.max(string.len(wLine)+2,xSize)\
			Lines = Lines + 1\
		end\
	end\
	SizeW,SizeH = xSize,Lines\
	reMap()\
	fLevel = fs.open(sLevelD,\"r\")\
	fLevel.readLine()\
	for Line=2,Lines-1 do\
		sLine = fLevel.readLine()\
		 chars = string.len(sLine)\
		for char = 1, chars do\
			 el = string.sub(sLine,char,char)\
			if el == \"8\" then\
				addGround(char+1,Line)\
			elseif el == \"0\" then\
				addStart(char+1,Line,\"a\",\"a\")\
			elseif el == \"1\" then\
				addStart(char+1,Line,\"b\",\"a\")\
			elseif el == \"2\" then\
				addStart(char+1,Line,\"c\",\"a\")\
			elseif el == \"3\" then\
				addStart(char+1,Line,\"d\",\"a\")\
			elseif el == \"4\" then\
				addStart(char+1,Line,\"a\",\"b\")\
			elseif el == \"5\" then\
				addStart(char+1,Line,\"b\",\"b\")\
			elseif el == \"6\" then\
				addStart(char+1,Line,\"c\",\"b\")\
			elseif el == \"9\" then\
				addStart(char+1,Line,\"d\",\"b\")\
			elseif el == \"b\" then\
				addExit(char+1,Line,\"a\")\
			elseif el == \"e\" then\
				addExit(char+1,Line,\"b\")\
			elseif el == \"7\" then\
				addWall(char+1,Line)\
			end\
		end\
	end\
	fLevel.close()\
end\
\
 function drawStars()\
	--CCR Background By : RamiLego--\
	 cStar,cStarG,crStar,crStarB = colors.lightGray,colors.gray,\".\",\"*\"\
	 DStar,BStar,nStar,gStar = 14,10,16,3\
	 TermW,TermH = term.getSize()\
\
    term.clear()\
    term.setCursorPos(1,1)\
	for x=1,TermW do\
		for y=1,TermH do\
			 StarT = math.random(1,30)\
			if StarT == DStar then\
				term.setCursorPos(x,y)\
				term.setTextColor(cStar)\
				write(crStar)\
			elseif StarT == BStar then\
				term.setCursorPos(x,y)\
				term.setTextColor(cStar)\
				write(crStarB)\
			elseif StarT == nStar then\
				term.setCursorPos(x,y)\
				term.setTextColor(cStarG)\
				write(crStar)\
			elseif StarT == gStar then\
				term.setCursorPos(x,y)\
				term.setTextColor(cStarG)\
				write(crStarB)\
			end\
		end\
	end\
end\
\
 function drawMap()\
	for x=1,SizeW do\
		for y=1,SizeH do\
		  \
			 obj = tScreen[x][y]\
			if obj.ground == true then\
				paintutils.drawPixel(XOrgin+x,YOrgin+y+1,cG)\
			end\
			if obj.wall == true then\
				paintutils.drawPixel(XOrgin+x,YOrgin+y+1,cW)\
			end\
		 \
		  ex = tostring(tScreen[x][y].exit)\
			if not(ex == \"zz\" or ex == \"nil\") then\
				if ex == \"a\" then\
					ex = cR1\
				elseif ex == \"b\" then\
					ex = cR2\
				elseif ex == \"c\" then\
					ex = cR3\
				elseif ex == \"d\" then\
					ex = cR4\
				else\
					return error(\"Exit Color Out\")\
				end\
				term.setBackgroundColor(cG)\
				term.setTextColor(ex)\
				term.setCursorPos(XOrgin+x,YOrgin+y+1)\
				print(\"X\")\
			end\
		 \
		  st = tostring(tScreen[x][y].start)\
			if not(st == \"zz\" or st == \"nil\") then\
				 Cr = string.sub(st,2,2)\
				if Cr == \"a\" then\
					Cr = cR1\
				elseif Cr == \"b\" then\
					Cr = cR2\
				elseif Cr == \"c\" then\
					Cr = cR3\
				elseif Cr == \"d\" then\
					Cr = cR4\
				else\
					return error(\"Start Color Out\")\
				end\
			\
				term.setTextColor(Cr)\
			term.setBackgroundColor(cG)\
				term.setCursorPos(XOrgin+x,YOrgin+y+1)\
			\
				sSide = string.sub(st,1,1)\
				if sSide == \"a\" then\
					print(\"^\")\
				elseif sSide == \"b\" then\
					print(\">\")\
				elseif sSide == \"c\" then\
					print(\"v\")\
				elseif sSide == \"d\" then\
					print(\"<\")\
				else\
					print(\"@\")\
				end\
			end\
			\
			if obj.space == true then\
				paintutils.drawPixel(XOrgin+x,YOrgin+y+1,cS)\
			end\
			\
			 rb = tostring(tScreen[x][y].robot)\
			if not(rb == \"zz\" or rb == \"nil\") then\
				 Cr = string.sub(rb,2,2)\
				if Cr == \"a\" then\
					Cr = cR1\
				elseif Cr == \"b\" then\
					Cr = cR2\
				elseif Cr == \"c\" then\
					Cr = cR3\
				elseif Cr == \"d\" then\
					Cr = cR4\
				else\
					Cr = colors.white\
				end\
				term.setBackgroundColor(Cr)\
				term.setTextColor(colors.white)\
				term.setCursorPos(XOrgin+x,YOrgin+y+1)\
				sSide = string.sub(rb,1,1)\
				if sSide == \"a\" then\
					print(\"^\")\
				elseif sSide == \"b\" then\
					print(\">\")\
				elseif sSide == \"c\" then\
					print(\"v\")\
				elseif sSide == \"d\" then\
					print(\"<\")\
				else\
					print(\"@\")\
				end\
			end\
		end\
	end\
end\
\
 function isBrick(x,y)\
	 brb = tostring(tScreen[x][y].robot)\
	 bobj = oScreen[x][y]\
	if (brb == \"zz\" or brb == \"nil\") and not bobj.wall == true then\
		return false\
	else\
		return true\
	end\
end\
\
 function gRender(sContext)\
	tick()\
	if sContext == \"start\" then\
		for x=1,SizeW do\
			for y=1,SizeH do\
				 st = tostring(tScreen[x][y].start)\
				if not(st == \"zz\" or st == \"nil\") then\
					 Cr = string.sub(st,2,2)\
					 sSide = string.sub(st,1,1)\
					addRobot(x,y,sSide,Cr)\
				end\
			end\
		end\
	elseif sContext == \"tick\" then\
		buMap()\
        for x=1,SizeW do\
            for y=1,SizeH do\
                 rb = tostring(oScreen[x][y].robot)\
                if not(rb == \"zz\" or rb == \"nil\") then\
                     Cr = string.sub(rb,2,2)\
                     sSide = string.sub(rb,1,1)\
                     sobj = oScreen[x][y]\
                    if sobj.space == true then\
                        tScreen[x][y].robot = \"zz\"\
                        if not sSide == \"g\" then\
                            addRobot(x,y,\"g\",Cr)\
                        end\
                    elseif sobj.exit == Cr then\
                        if sSide == \"a\" or sSide == \"b\" or sSide == \"c\" or sSide == \"d\" then\
                        tScreen[x][y].robot = \"zz\"\
                        addRobot(x,y,\"g\",Cr)\
                        aExits = aExits-1\
                        end\
                    elseif sSide == \"a\" then\
                         obj = isBrick(x,y-1)\
                        tScreen[x][y].robot = \"zz\"\
                        if not obj == true then\
                            addRobot(x,y-1,sSide,Cr)\
                        else\
                             obj2 = isBrick(x-1,y)\
                             obj3 = isBrick(x+1,y)\
                            if not obj2 == true and not obj3 == true then\
                                if Cr == \"a\" then\
                                    addRobot(x,y,\"d\",Cr)\
                                elseif Cr == \"b\" then\
                                    addRobot(x,y,\"b\",Cr)\
                                end\
                            elseif obj == true and obj2 == true and obj3 == true then\
                                addRobot(x,y,\"c\",Cr)\
                            else\
                                if obj3 == true then\
                                    addRobot(x,y,\"d\",Cr)\
                                elseif obj2 == true then\
                                    addRobot(x,y,\"b\",Cr)\
                                end\
                            end\
                        end\
                    elseif sSide == \"b\" then\
                         obj = isBrick(x+1,y)\
                        tScreen[x][y].robot = \"zz\"\
                        if not obj == true then\
                            addRobot(x+1,y,sSide,Cr)\
                        else\
                             obj2 = isBrick(x,y-1)\
                             obj3 = isBrick(x,y+1)\
                            if not obj2 == true and not obj3 == true then\
                                if Cr == \"a\" then\
                                    addRobot(x,y,\"a\",Cr)\
                                elseif Cr == \"b\" then\
                                    addRobot(x,y,\"c\",Cr)\
                                end\
                            elseif obj == true and obj2 == true and obj3 == true then\
                                addRobot(x,y,\"d\",Cr)\
                            else\
                                if obj3 == true then\
                                    addRobot(x,y,\"a\",Cr)\
                                elseif obj2 == true then\
                                    addRobot(x,y,\"c\",Cr)\
                                end\
                            end\
                        end\
                    elseif sSide == \"c\" then\
                         obj = isBrick(x,y+1)\
                        tScreen[x][y].robot = \"zz\"\
                        if not obj == true then\
                            addRobot(x,y+1,sSide,Cr)\
                        else\
                             obj2 = isBrick(x-1,y)\
                             obj3 = isBrick(x+1,y)\
                            if not obj2 == true and not obj3 == true then\
                                if Cr == \"a\" then\
                                    addRobot(x,y,\"b\",Cr)\
                                elseif Cr == \"b\" then\
                                    addRobot(x,y,\"d\",Cr)\
                                end\
                            elseif obj == true and obj2 == true and obj3 == true then\
                                addRobot(x,y,\"a\",Cr)\
                            else\
                                if obj3 == true then\
                                    addRobot(x,y,\"d\",Cr)\
                                elseif obj2 == true then\
                                    addRobot(x,y,\"b\",Cr)\
                                end\
                            end\
                        end\
                    elseif sSide == \"d\" then\
                         obj = isBrick(x-1,y)\
                        tScreen[x][y].robot = \"zz\"\
                        if not obj == true then\
                            addRobot(x-1,y,sSide,Cr)\
                        else\
                             obj2 = isBrick(x,y-1)\
                             obj3 = isBrick(x,y+1)\
                            if not obj2 == true and not obj3 == true then\
                                if Cr == \"a\" then\
                                    addRobot(x,y,\"c\",Cr)\
                                elseif Cr == \"b\" then\
                                    addRobot(x,y,\"a\",Cr)\
                                end\
                            elseif obj == true and obj2 == true and obj3 == true then\
                                addRobot(x,y,\"b\",Cr)\
                            else\
                                if obj3 == true then\
                                    addRobot(x,y,\"a\",Cr)\
                                elseif obj2 == true then\
                                    addRobot(x,y,\"c\",Cr)\
                                end\
                            end\
                        end\
                    else\
                        addRobot(x,y,sSide,\"g\")\
                    end\
                end\
            end\
        end\
    end\
end\
\
function InterFace.drawBar()\
	term.setBackgroundColor( colors.black )\
	term.setTextColor( InterFace.cTitle )\
	printCentred( 1, \"  \"..sLevelTitle..\"  \" )\
	\
	term.setCursorPos(1,1)\
	term.setBackgroundColor( cW )\
	write( \" \" )\
	term.setBackgroundColor( colors.black )\
	write( \" x \"..tostring(Blocks)..\" \" )\
	\
	term.setCursorPos( TermW-8,TermH )\
	term.setBackgroundColor( colors.black )\
    term.setTextColour(InterFace.cSpeedD)\
	write(\" <<\" )\
	if bPaused then\
		term.setTextColour(InterFace.cSpeedA)\
	else\
		term.setTextColour(InterFace.cSpeedD)\
	end\
	write(\" ||\")\
	if fSpeedS then\
		term.setTextColour(InterFace.cSpeedA)\
	else\
		term.setTextColour(InterFace.cSpeedD)\
	end\
	write(\" >>\")\
\
	term.setCursorPos( TermW-1, 1 )\
	term.setBackgroundColor( colors.black )\
	term.setTextColour( InterFace.cExit )\
	write(\" X\")\
	term.setBackgroundColor(colors.black)\
end\
\
function InterFace.render()\
	tick()\
	 id,p1,p2,p3 = os.pullEvent()\
	if id == \"mouse_click\" then\
		if p3 == 1 and p2 == TermW then\
            return \"end\"\
        elseif p3 == TermH and p2 >= TermW-7 and p2 <= TermW-6 then\
            return \"retry\"\
        elseif p3 == TermH and p2 >= TermW-4 and p2 <= TermW-3 then\
            bPaused = not bPaused\
            fSpeedS = false\
            Speed = (bPaused and 0) or nSpeed\
            if Speed > 0 then\
                Tick = os.startTimer(Speed)\
            else\
                Tick = nil\
            end\
            InterFace.drawBar()\
        elseif p3 == TermH and p2 >= TermW-1 then\
            bPaused = false\
            fSpeedS = not fSpeedS\
            Speed = (fSpeedS and fSpeed) or nSpeed\
            Tick = os.startTimer(Speed)\
            InterFace.drawBar()\
		elseif p3-1 < YOrgin+SizeH+1 and p3-1 > YOrgin and\
               p2 < XOrgin+SizeW+1 and p2 > XOrgin then\
             eobj = tScreen[p2-XOrgin][p3-YOrgin-1]\
             erobj = tostring(tScreen[p2-XOrgin][p3-YOrgin-1].robot)\
            if (erobj == \"zz\" or erobj == \"nil\") and not eobj.wall == true and not eobj.space == true and Blocks > 0 then\
                addWall(p2-XOrgin,p3-YOrgin-1)\
                Blocks = Blocks-1\
                InterFace.drawBar()\
                drawMap()\
            end\
		end\
	elseif id == \"timer\" and p1 == Tick then\
		gRender(\"tick\")\
        drawMap()\
        if Speed > 0 then\
            Tick = os.startTimer(Speed)\
        else\
            Tick = nil\
        end\
	end\
end\
\
 function startG(LevelN)\
	drawStars()\
	loadLevel(LevelN)\
	centerOrgin()\
	 create = true\
	drawMap()\
	InterFace.drawBar()\
	gRender(\"start\")\
	drawMap()\
	\
	 NExit = true\
	if aExits == 0 then\
		NExit = false\
	end\
	\
	while true do\
		tick()\
		 isExit = InterFace.render()\
		if isExit == \"end\" then\
		    return nil\
		elseif isExit == \"retry\" then\
		    return LevelN\
		elseif fExit == \"yes\" then\
			if fs.exists( fs.getDir( shell.getRunningProgram() ) .. \"/levels/\" .. tostring(LevelN + 1) ) then\
			    return LevelN + 1\
			else\
			    return nil\
			end\
		end\
		if aExits == 0 and NExit == true then\
			fExit = \"yes\"\
		end\
	end\
end\
\
 ok, err = true, nil\
\
--Menu--\
 sStartLevel = tArgs[1]\
if ok and not sStartLevel then\
    ok, err = pcall( function()\
        term.setTextColor(colors.white)\
        term.setBackgroundColor( colors.black )\
        term.clear()\
        drawStars()\
        term.setTextColor( colors.red )\
        printCentred( TermH/2 - 1, \"  REDIRECTION  \" )\
        printCentred( TermH/2 - 0, \"  ComputerCraft Edition  \" )\
        term.setTextColor( colors.yellow )\
        printCentred( TermH/2 + 2, \"  Click to Begin  \" )\
        os.pullEvent( \"mouse_click\" )\
    end )\
end\
\
\
\
--Game--\
if ok then\
    ok,err = pcall( function()\
        if sStartLevel then\
            nLevel = tonumber( sStartLevel )\
        else\
            nLevel = 1\
        end\
        while nLevel do\
            reset()\
            nLevel = startG(nLevel)\
        end\
    end )\
end\
\
--Upsell screen--\
if ok then\
    ok, err = pcall( function()\
        term.setTextColor(colors.white)\
        term.setBackgroundColor( colors.black )\
        term.clear()\
        drawStars()\
        term.setTextColor( colors.red )\
        if TermW >= 40 then\
            printCentred( TermH/2 - 1, \"  Thank you for playing Redirection  \" )\
            printCentred( TermH/2 - 0, \"  ComputerCraft Edition  \" )\
            printCentred( TermH/2 + 2, \"  Check out the full game:  \" )\
            term.setTextColor( colors.yellow )\
            printCentred( TermH/2 + 3, \"  http://www.redirectiongame.com  \" )\
        else\
            printCentred( TermH/2 - 2, \"  Thank you for  \" )\
            printCentred( TermH/2 - 1, \"  playing Redirection  \" )\
            printCentred( TermH/2 - 0, \"  ComputerCraft Edition  \" )\
            printCentred( TermH/2 + 2, \"  Check out the full game:  \" )\
            term.setTextColor( colors.yellow )\
            printCentred( TermH/2 + 3, \"  www.redirectiongame.com  \" )\
        end\
        parallel.waitForAll(\
            function() sleep(2) end,\
            function() os.pullEvent( \"mouse_click\" ) end\
        )\
    end )\
end\
\
--Clear and exit--\
term.setCursorPos(1,1)\
term.setTextColor(colors.white)\
term.setBackgroundColor(colors.black)\
term.clear()\
if not ok then\
    if err == \"Terminated\" then\
        print( \"Check out the full version of Redirection:\" )\
        print( \"http://www.redirectiongame.com\" )\
    else\
        printError( err )\
    end\
end",
  [ "Flutter/Programs/levels/3" ] = "2\
  77777777\
777888188777\
7b78777787b7\
78787  78787\
78787  78787\
78887  78887\
777877778777\
  78838887\
  77777777",
  [ "Flutter/Programs/tag" ] = "",
  [ "Flutter/publish" ] = "print(\"Please wait!\")\
local savetable = {}\
function compact(path)\
	local file\
	for k, v in ipairs(fs.list(path)) do\
		if fs.isDir(path..\"/\"..v) then\
			compact(path..\"/\"..v)\
		elseif fs.exists(path..\"/\"..v) then\
			file = fs.open(path..\"/\"..v, \"r\")\
			if file then\
				savetable[path..\"/\"..v] = file.readAll()\
				file.close()\
			end\
		end\
	end\
end\
\
compact(\"Flutter\")\
local file = fs.open(\"FlutterFile\", \"w\")\
file.write(textutils.serialize(savetable))\
file.close()\
print(\"Done serializing!\")",
  [ "Flutter/Programs/levels/5" ] = "3\
777777777\
788888887\
787787787\
787787787\
788888887\
787787787\
787787787\
78e748887\
777777777",
  [ "Flutter/Programs/levels/0" ] = "0\
77     77\
718888887\
 8     8\
 8     8\
 8     8\
788888897\
77     77",
  [ "Flutter/Apis/flu" ] = "local mood = nil\
local name = \"Flutter\"\
local unknownQuestionReply = \"I don't know the answer to that question.\"\
local runningCoroutines = {}\
local memorizedReplies = {}\
local defaultReplies = {}\
local menuOptions = {}\
\
-- Returns the name of the assistant.\
function getName()\
	return name\
end\
\
function getQuestion(question)\
	question = string.lower(question)\
	if defaultReplies[question] then\
		return defaultReplies[question][1]\
	elseif memorizedReplies[question] then\
		return memorizedReplies[question][1]\
	else\
		for key, value in pairs(defaultReplies) do\
			if string.find(key, \"repLACE\", 1, true) then\
				local wordNum, chars = 0, 0\
				local lastWord = \"\"\
				local continue = true\
				for word in string.gmatch(key, \"%a+\") do\
					if continue then\
						wordNum = wordNum + 1\
						--print(word)\
						if string.find(word, \"repLACE\", 1, true) then\
							local pos1, pos2 = string.find(string.lower(question), string.lower(lastWord))\
							local str, str2 = key, string.sub(question, pos2 + 2)\
							--print(str..\", \"..str2)\
							return defaultReplies[str][str2]\
						end\
						chars = chars + #word + 1\
						lastWord = tostring(word)\
						if not string.find(string.lower(question), string.lower(lastWord)) then\
							-- This isn't the same question as the key we looked at, cancel the operation\
							continue = false\
						end\
					end\
				end\
			else\
				if string.find(question, key, 1, true) then\
					return defaultReplies[key][1]\
				end\
			end\
		end\
	end\
end\
\
-- Asks the assistant to reply to this question.\
function getReply(question)\
	question = string.lower(question)\
	local questionTag = getQuestion(question)\
	if type(questionTag) == \"function\" then\
		return questionTag()\
	elseif type(questionTag) == \"string\" then\
		return questionTag\
	else\
		return unknownQuestionReply\
	end\
end\
\
-- \
function getOptions(menu)\
	\
end\
\
function cloneQuestion(question, question2)\
	defaultReplies[question2] = setmetatable({}, {__index = defaultReplies[question]})\
end\
\
-- Default questions and answers --\
local function tellName(tab, path)\
	return \"My name is \"..getName()..\". I am a personal assistant and I am here to help you.\"\
end\
\
local function runApplication(tab, path)\
	local ok, err = pcall(shell.openTab, tostring(path))\
	if ok then\
		return \"I opened \"..path..\" for you.\"\
	else\
		return \"I could not run that program successfuly.\"..err\
	end\
end\
\
defaultReplies[\"please open repLACE\"] = setmetatable({}, {__index = runApplication})\
cloneQuestion(\"please open repLACE\", \"please run repLACE\")\
cloneQuestion(\"please open repLACE\", \"open repLACE\")\
cloneQuestion(\"please open repLACE\", \"run repLACE\")\
defaultReplies[\"what is your name\"] = setmetatable({}, {__index = tellName})\
cloneQuestion(\"what is your name\", \"who are you\")\
cloneQuestion(\"what is your name\", \"what is this\")\
cloneQuestion(\"what is your name\", \"what do you do\")\
defaultReplies[\"starttext\"] = {\"Ask me anything. Type in the given box below.\"}",
  [ "Flutter/background" ] = "",
  [ "Flutter/Autocomplete/edit" ] = "completeEdit",
  [ "Flutter/Programs/levels/8" ] = "4\
777777 7777\
7287b7 7867\
788787 7887\
77878777877\
 7888eb8887\
 77877787877\
 7887 787887\
 7487 7e7807\
 7777 777777",
  [ "Flutter/startup" ] = "-- Set the label if one does not exist --\
local computerLabel = os.getComputerLabel()\
if not computerLabel then\
	os.setComputerLabel(\"Computer #\" .. os.getComputerID())\
end\
\
-- Set up Flutter API --\
multishell = nil\
local Flutter = {}\
Flutter.Dir = string.sub(shell.getRunningProgram(), 1, -(#fs.getName(shell.getRunningProgram())) - 1)\
Flutter.Dir = \"Flutter/\"\
_G.Flutter = Flutter\
\
local function overrideFile(path, str)\
	local file = fs.open(path, \"w\")\
	if file then\
		file.write(str)\
		file.close()\
		return true\
	end\
	return false\
end\
\
local function readFile(path)\
	local file = fs.open(path, \"r\")\
	if file then\
		local str = file.readAll()\
		file.close()\
		return str\
	end\
	return false\
end\
\
local function loadTable(path)\
	local str = readFile(path)\
	if str then\
		return textutils.unserialize(str)\
	end\
	return false\
end\
\
local function saveTable(path, tab)\
	local ok, str = pcall(textutils.serialize, tab)\
	if ok then\
		return overrideFile(path, str)\
	end\
	return false, str\
end\
\
Flutter.overrideFile = overrideFile\
Flutter.readFile = readFile\
Flutter.loadTable = loadTable\
Flutter.saveTable = saveTable\
Flutter.startInWindowShellMode = (readFile(Flutter.Dir..\"Configuration/MultishellMode\") or \"\") ~= \"true\"\
\
_G.Clipboard = \"\"\
_G.ReadColors = {}\
_G.ReadHistory = loadTable(Flutter.Dir..\"Configuration/ReadHistory\") or {}\
\
local rawPullEvent = os.pullEventRaw\
local rawOsRun = os.run\
local rawSetTextColor = term.setTextColor\
local rawSetBgColor = term.setBackgroundColor\
local lastKeyPressed\
\
-- Set up test quick menu\
Flutter.QuickMenu = {}\
Flutter.QuickMenu.ProgramsList = loadTable(Flutter.Dir..\"Configuration/ProgramsList\") or {}\
\
-- Override default ComputerCraft functions --\
\
-- Override term.setTextColor\
function term.setTextColor(color)\
	rawSetTextColor(color)\
	Flutter.currentTextColor = color\
end\
\
-- Override term.setBackgroundColor\
function term.setBackgroundColor(color)\
	rawSetBgColor(color)\
	Flutter.currentBgColor = color\
end\
\
-- Override os.run\
function rawOsRun( _tEnv, _sPath, ... )\
	local tArgs = { ... }\
	local fnFile, err = loadfile( _sPath )\
	if fnFile then\
		local tEnv = _tEnv\
		--setmetatable( tEnv, { __index = function(t,k) return _G[k] end } )\
		setmetatable( tEnv, { __index = _G } )\
		setfenv( fnFile, tEnv )\
		local ok, err = pcall( function()\
			fnFile( unpack( tArgs ) )\
		end )\
		if not ok then\
			if err and err ~= \"\" then\
				printError( err )\
			end\
			return false\
		end\
		return true\
	end\
	if err and err ~= \"\" then\
		if err == \"File not found\" then\
			printError( \"File \".._sPath..\" could not be found. It most likely does not exist.\" )\
		else\
			printError( err )\
		end\
	end\
	return false\
end\
\
function _G.os.run(envVars, path, ...)\
	if fs.exists(path) then\
		local matched = path:find(\"setupAutocomplete\")\
		local name = string.sub(path, -(#fs.getName(path)), -1)\
		name = string.upper(string.sub(name, 0, 1))..string.sub(name, 2)\
		for k, v in ipairs(Flutter.QuickMenu.ProgramsList) do\
			if v[2] == path then\
				matched = k\
				break\
			end\
		end\
		if not matched then\
			if #Flutter.QuickMenu.ProgramsList > 14 then\
				table.remove(Flutter.QuickMenu.ProgramsList, 2)\
			end\
			table.insert(Flutter.QuickMenu.ProgramsList, {name, path, false})\
			saveTable(Flutter.Dir..\"Configuration/ProgramsList\", Flutter.QuickMenu.ProgramsList)\
		end\
	end\
	return rawOsRun(envVars, path, ...)\
end\
\
-- Override os.pullEventRaw\
function _G.os.pullEventRaw( sFilter )\
	local eventData = { rawPullEvent( sFilter ) }\
	if eventData[1] == \"key\" then\
		if lastKeyPressed == keys.leftCtrl then\
			if eventData[2] == keys.p then\
				skipCharInput = true\
				pasteMode = true\
				for k=1, #_G.Clipboard do\
					os.queueEvent(\"char\", string.sub(_G.Clipboard, k, k))\
				end\
				os.queueEvent(\"clipboard_paste_done\", #_G.Clipboard)\
			end\
		end\
		lastKeyPressed = eventData[2]\
	end\
	return unpack( eventData )\
end\
\
-- Override os.pullEvent\
function _G.os.pullEvent( sFilter )\
	local eventData = { rawPullEvent( sFilter ) }\
	if eventData[1] == \"terminate\" then\
		error( \"Terminated by user\", 0 )\
	elseif eventData[1] == \"key\" then\
		if lastKeyPressed == keys.leftCtrl then\
			if eventData[2] == keys.p then\
				skipCharInput = true\
				pasteMode = true\
				for k=1, #_G.Clipboard do\
					os.queueEvent(\"char\", string.sub(_G.Clipboard, k, k))\
				end\
				os.queueEvent(\"clipboard_paste_done\", #_G.Clipboard)\
			end\
		end\
		lastKeyPressed = eventData[2]\
	end\
	return unpack( eventData )\
end\
\
function showTextBox(x, y, width, height, text, history, color, backcolor, _fnComplete )\
	local cursorpos, scrollx = math.min(x or 0, #text), 0\
	scrollx = cursorpos\
	local strClr = string.rep(\" \", width + 1)\
	if #text == 0 then	\
		term.write(strClr)\
	end\
	local selectColor, ctrlColor = colors.blue, colors.red\
	local currentEntryInHistory = #history + 1\
	local toggleSelect = false\
	local selectLeft, selectRight, selectStart = nil, nil, nil\
	local lastKeyPressed\
	\
	local tCompletions\
	local nCompletion\
	local function recomplete()\
		if _fnComplete and cursorpos == string.len(text) then\
			tCompletions = _fnComplete( text )\
			if tCompletions and #tCompletions > 0 then\
				nCompletion = 1\
			else\
				nCompletion = nil\
			end\
		else\
			tCompletions = nil\
			nCompletion = nil\
		end\
	end\
\
	local function uncomplete()\
		tCompletions = nil\
		nCompletion = nil\
	end\
	\
	recomplete()\
\
	local function acceptCompletion()\
		if nCompletion then\
			-- Find the common prefix of all the other suggestions which start with the same letter as the current one\
			local sCompletion = tCompletions[ nCompletion ]\
			local sFirstLetter = string.sub( sCompletion, 1, 1 )\
			local sCommonPrefix = sCompletion\
			for n=1,#tCompletions do\
				local sResult = tCompletions[n]\
				if n ~= nCompletion and string.find( sResult, sFirstLetter, 1, true ) == 1 then\
					while #sCommonPrefix > 1 do\
						if string.find( sResult, sCommonPrefix, 1, true ) == 1 then\
							break\
						else\
							sCommonPrefix = string.sub( sCommonPrefix, 1, #sCommonPrefix - 1 )\
						end\
					end\
				end\
			end\
\
			-- Append this string\
			text = text .. sCommonPrefix\
			cursorpos = string.len( text )\
		end\
\
		recomplete()\
		--redraw()\
	end\
	\
	term.setCursorBlink(true)\
	while true do\
		if #text > width then\
			scrollx = math.min(math.max(cursorpos - width*.5, 0), #text - width)\
		else\
			scrollx = 0\
		end\
		term.setCursorPos(x + cursorpos - scrollx, y)\
		skipCharInput = false\
		local event, p1, p2, p3, p4 = os.pullEvent()\
		if(event == \"key\") then\
			if(p1 == keys.left) then\
				cursorpos = math.max(cursorpos - 1, 0)\
				if toggleSelect and selectLeft then\
					if cursorpos + 1 < selectStart then\
						selectLeft = cursorpos + 1\
					else\
						selectLeft = math.min(selectLeft, cursorpos + 1)\
						selectRight = math.min(selectRight, selectStart)\
					end\
				else\
					selectLeft, selectRight = nil, nil\
				end\
			elseif(p1 == keys.right) then\
				if cursorpos < string.len(text) then\
					-- Move right\
					cursorpos = math.min(cursorpos + 1, #text)\
				else\
					-- Accept autocomplete\
					acceptCompletion()\
				end\
				if toggleSelect and selectLeft then\
					if cursorpos + 1 > selectStart then\
						selectRight = math.max(selectRight, selectStart, cursorpos + 1)\
					else\
						selectLeft = math.max(selectLeft, cursorpos + 1)\
					end\
				else\
					selectLeft, selectRight = nil, nil\
				end\
			elseif(p1 == keys.up or p1 == keys.down) then\
				-- Cycle completions\
				if p1 == keys.up then\
					if nCompletion then\
						nCompletion = nCompletion - 1\
						if nCompletion < 1 then\
							nCompletion = #tCompletions\
						end\
					elseif #history > 0 then\
						currentEntryInHistory = math.max(1, currentEntryInHistory - 1)\
						text = history[currentEntryInHistory] or \"\"\
						cursorpos = #text\
					end\
				elseif p1 == keys.down then\
					if nCompletion then\
						nCompletion = nCompletion + 1\
						if nCompletion > #tCompletions then\
							nCompletion = 1\
						end\
					elseif #history > 0 then\
						currentEntryInHistory = math.min(#history + 1, currentEntryInHistory + 1)\
						text = history[currentEntryInHistory] or \"\"\
						cursorpos = #text\
					end\
				end\
			elseif(p1 == keys.enter) then\
				term.setCursorPos(x + cursorpos - scrollx, y)\
				term.setCursorPos(x, y)\
				term.setTextColor(color)\
				term.write(strClr)\
				term.setCursorPos(x, y)\
				term.write(string.sub(text, scrollx, scrollx + width))\
				term.setTextColor(color)\
				term.setBackgroundColor(backcolor)\
				term.setCursorBlink(false)\
				return text\
			elseif(p1 == keys.rightShift) then\
				toggleSelect = not toggleSelect\
				if toggleSelect and not selectLeft then\
					selectStart = cursorpos + 1\
					selectLeft, selectRight = cursorpos + 1, cursorpos + 1\
				end\
			elseif(p1 == keys.backspace) then\
				if cursorpos > 0 or selectLeft then\
					text = string.sub(text, 1, (selectLeft) or cursorpos - 1) .. string.sub(text, (selectRight) or cursorpos + 1, -1)\
					cursorpos = math.max(cursorpos - 1, 0)\
				end\
			elseif(p1 == keys.delete) then\
				if cursorpos < #text then\
					text = string.sub(text, 1, cursorpos) .. string.sub(text, cursorpos + 2, -1)\
				end\
			elseif(p1 == keys.home) then\
				cursorpos = 0\
			elseif(keys.getName(p1) == \"end\") then\
				cursorpos = #text\
			elseif(p1 == keys.tab) then\
				-- Tab (accept autocomplete)\
				acceptCompletion()\
			elseif(lastKeyPressed == keys.leftCtrl) and (p1 == keys.c) and selectLeft then\
				local clipboardText = string.sub(text, selectLeft, selectRight)\
				_G.Clipboard = clipboardText\
				os.queueEvent(\"clipboard_copy\", string.sub(text, selectLeft, selectRight))\
				skipCharInput = true\
			elseif(lastKeyPressed == keys.leftCtrl) and (p1 == keys.a) then\
				selectLeft, selectRight = 1, #text\
				skipCharInput = true\
			end\
			lastKeyPressed = p1\
		end\
		if(event == \"char\") and ((not skipCharInput and not (lastKeyPressed == keys.leftCtrl)) or pasteMode) then\
			text = string.sub(text, 1, cursorpos) .. p1 .. string.sub(text, cursorpos + 1, -1)\
			cursorpos = cursorpos + 1\
		end\
		if(event == \"clipboard_paste_done\") then\
			skipCharInput = false\
			pasteMode = false\
		end\
		if(event == \"mouse_click\") then\
			cursorpos = math.min(p2 - (x) + scrollx, #text)\
		end\
		if(event == \"paste\") then\
			text = string.sub(text, 1, cursorpos) .. p1 .. string.sub(text, cursorpos + 1, -1)\
			cursorpos = cursorpos + #p1\
		end\
		if #text > width then\
			scrollx = math.min(math.max(cursorpos - width*.5, 0), #text - width)\
		else\
			scrollx = 0\
		end\
		if p1 ~= keys.up and p1 ~= keys.down then\
			recomplete()\
		end\
		-- Redraw window\
		term.setCursorPos(x + cursorpos - scrollx, y)\
		term.setCursorPos(x, y)\
		term.setTextColor(color)\
		term.write(strClr)\
		term.setCursorPos(x, y)\
		term.write(string.sub(text, scrollx, scrollx + width))\
		if selectLeft then\
			term.setBackgroundColor(selectColor)\
			term.setTextColor(color)\
			term.setCursorPos((x + selectLeft - scrollx) - 1, y)\
			term.write(string.sub(text, selectLeft, selectRight))\
			term.setTextColor(selectColor)\
		end\
		if lastKeyPressed == keys.leftCtrl then\
			term.setTextColor(ctrlColor)\
		elseif not toggleSelect then\
			term.setTextColor(color)\
		else\
			term.setTextColor(selectColor)\
		end\
		if nCompletion then\
			local sCompletion = tCompletions[ nCompletion ]\
			local oldText, oldBg\
			if not _bClear then\
				oldText = term.getTextColor()\
				oldBg = term.getBackgroundColor()\
				term.setTextColor( colors.white )\
				term.setBackgroundColor( colors.gray )\
			end\
			local curX, curY = term.getCursorPos()\
			if sReplace then\
				term.write( string.rep( sReplace, string.len( sCompletion ) ) )\
			else\
				term.write( sCompletion )\
			end\
			if not _bClear then\
				term.setTextColor( oldText )\
				term.setBackgroundColor( oldBg )\
			end\
		end\
		term.setBackgroundColor(backcolor)\
	end\
end\
\
\
-- Override global read\
function _G.read( _sReplaceChar, _tHistory, _fnComplete )\
	local bgColor, textColor = colors.black, colors.white\
	local x, y = term.getCursorPos()\
	local width, height = term.getSize()\
	local isUsingGlobalHistory = type(_tHistory) ~= \"table\"\
	width = width - x, 0\
	if type(_tHistory) == \"table\" then\
		if #_tHistory < 1 then\
			isUsingGlobalHistory = true\
		end\
	end\
	if isUsingGlobalHistory then\
		_tHistory = _G.ReadHistory\
	end\
	local text = showTextBox(x, y, width, height, \"\", _tHistory, Flutter.currentTextColor, Flutter.currentBgColor, _fnComplete )\
	if isUsingGlobalHistory then\
		if text ~= \"\" then\
			table.insert(_G.ReadHistory, text)\
			saveTable(Flutter.Dir..\"Configuration/ReadHistory\", _G.ReadHistory)\
		end\
	end\
	print(\"\")\
	return text\
end\
\
-- Load the default programs list\
for k, v in ipairs(fs.list(Flutter.Dir..\"Programs\")) do\
	shell.clearAlias(v)\
	shell.setAlias(v, Flutter.Dir..\"Programs/\"..v)\
end\
\
-- Load the default APIs\
for k, v in ipairs(fs.list(Flutter.Dir..\"APIs\")) do\
	os.unloadAPI(Flutter.Dir..\"APIs/\"..v)\
	os.loadAPI(Flutter.Dir..\"APIs/\"..v)\
end\
\
index.rebuildIndex()\
\
shell.run(Flutter.Dir..\"setupAutocomplete\")\
local errorMessage\
while true do\
	if Flutter.startInWindowShellMode then\
		--term.redirect(term.native())\
		local ok, err = pcall(shell.run, Flutter.Dir..\"windowshell\")\
		if not ok then\
			errorMessage = err\
		end\
	else -- The windowshell crashed and we opened the regular multishell\
		_G.windowShell = nil\
		shell.setAlias(\"windowshell\", Flutter.Dir..\"windowshell\")\
		local oldOsRun = os.run\
		function os.run(...)\
			local args = {...}\
			if args[2] == \"/rom/programs/shell\" then\
				args[2] = Flutter.Dir..\"Programs/shell\"\
			end\
			oldOsRun(unpack(args))\
		end\
		multishell = nil\
		_G.multishell = nil\
		term.redirect(term.native())\
		term.setBackgroundColor(colors.black)\
		term.setTextColor(colors.white)\
		term.setCursorPos(1, 1)\
		term.setCursorBlink(false)\
		term.clear()\
		local ok, err = pcall(shell.run, \"rom/programs/advanced/multishell\")\
		if not ok then\
			errorMessage = err\
		end\
		os.run = oldOsRun\
	end\
\
	-- An error occured --\
	term.redirect(term.native())\
	if term.isColor() then\
		term.setTextColor(colors.red)\
	else\
		term.setTextColor(colors.white)\
	end\
	term.setBackgroundColor(colors.black)\
	term.clear()\
	term.setCursorPos(1, 1)\
	term.write(errorMessage or \"You terminated the shell.\")\
\
	term.setCursorPos(1, 2)\
	term.setTextColor(colors.white)\
	print(\"Press Enter to continue.\")\
	print(\"Press Shift to reboot.\")\
	print(\"Press Space to shut down.\")\
	local e, key = os.pullEvent(\"key\")\
	if key == keys.leftShift or key == keys.rightShift then\
		os.reboot()\
	elseif key == keys.space then\
		os.shutdown()\
	end\
	Flutter.startInWindowShellMode = false\
end",
  [ "Flutter/Programs/levels/1" ] = "1\
     777\
     7b7\
     787\
7777778777\
7188888887\
7777777777",
  [ "Flutter/tabshell" ] = "",
  [ "Flutter/Programs/levels/9" ] = "2\
    777  777\
  777877778777\
  788838888887\
7778bbbbbbbb8777\
7888b888888b8897\
7878be8888eb8787\
7588b888888b8887\
7778bbbbbbbb8777\
  788888818887\
  777877778777\
    777  777",
  [ "Flutter/Programs/adventure" ] = "local tCommandHistory = {}\
local tBiomes = {\
	\"in a forest\",\
	\"in a pine forest\",\
	\"knee deep in a swamp\",\
	\"in a mountain range\",\
	\"in a desert\",\
	\"in a grassy plain\",\
	\"in frozen tundra\",\
	\"in a jungle\",\
}\
\
local function hasTrees( _nBiome )\
	return _nBiome <= 3 or _nBiome == 8\
end\
\
local function hasStone( _nBiome )\
	return _nBiome == 4\
end\
\
local function hasRivers( _nBiome )\
	return _nBiome ~= 3 and _nBiome ~= 5\
end\
\
local items = {\
	[\"no tea\"] = {\
		droppable = false,\
		desc = \"Pull yourself together man.\",\
	},\
	[\"a pig\"] = {\
		heavy = true,\
		creature = true,\
		drops = { \"some pork\" },\
		aliases = { \"pig\" },\
		desc = \"The pig has a square nose.\",\
	},\
	[\"a cow\"] = {\
		heavy = true,\
		creature = true,\
		aliases = { \"cow\" },\
		desc = \"The cow stares at you blankly.\",\
	},\
	[\"a sheep\"] = {\
		heavy = true,\
		creature = true,\
		hitDrops = { \"some wool\" },\
		aliases = { \"sheep\" },\
		desc = \"The sheep is fluffy.\",\
	},\
	[\"a chicken\"] = {\
		heavy = true,\
		creature = true,\
		drops = { \"some chicken\" },\
		aliases = { \"chicken\" },\
		desc = \"The chicken looks delicious.\",\
	},\
	[\"a creeper\"] = {\
		heavy = true,\
		creature = true,\
		monster = true,\
		aliases = { \"creeper\" },\
		desc = \"The creeper needs a hug.\",\
	},\
	[\"a skeleton\"] = {\
		heavy = true,\
		creature = true,\
		monster = true,\
		aliases = { \"skeleton\" },\
		nocturnal = true,\
		desc = \"The head bone's connected to the neck bone, the neck bone's connected to the chest bone, the chest bone's connected to the arm bone, the arm bone's connected to the bow, and the bow is pointed at you.\",\
	},\
	[\"a zombie\"] = {\
		heavy = true,\
		creature = true,\
		monster = true,\
		aliases = { \"zombie\" },\
		nocturnal = true,\
		desc = \"All he wants to do is eat your brains.\",\
	},\
	[\"a spider\"] = {\
		heavy = true,\
		creature = true,\
		monster = true,\
		aliases = { \"spider\" },\
		desc = \"Dozens of eyes stare back at you.\",\
	},\
	[\"a cave entrance\"] = {\
		heavy = true,\
		aliases = { \"cave entance\", \"cave\", \"entrance\" },\
		desc = \"The entrance to the cave is dark, but it looks like you can climb down.\",\
	},\
	[\"an exit to the surface\"] = {\
		heavy = true,\
		aliases = { \"exit to the surface\", \"exit\", \"opening\" },\
		desc = \"You can just see the sky through the opening.\",\
	},\
	[\"a river\"] = {\
		heavy = true,\
		aliases = { \"river\" },\
		desc = \"The river flows majestically towards the horizon. It doesn't do anything else.\",\
	},\
	[\"some sunflowers\"] = {\
		aliases = { \"sunflower\", \"a sunflower\", \"sunflowers\" },\
		desc = \"The sunflower is pointing towards the sun. It of course doesn't do anything, but it is pretty.\",\
	},\
	[\"some wood\"] = {\
		aliases = { \"wood\" },\
		material = true,\
		desc = \"You could easilly craft this wood into planks.\",\
	},\
	[\"some planks\"] = {\
		aliases = { \"planks\", \"wooden planks\", \"wood planks\" },\
		desc = \"You could easilly craft these planks into sticks.\",\
	},\
	[\"some sticks\"] = {\
		aliases = { \"sticks\", \"wooden sticks\", \"wood sticks\" },\
		desc = \"A perfect handle for torches or a pickaxe.\",\
	},\
	[\"a crafting table\"] = {\
		aliases = { \"crafting table\", \"craft table\", \"work bench\", \"workbench\", \"crafting bench\", \"table\", },\
		desc = \"It's a crafting table. I shouldn't tell you this, but these don't actually do anything in this game, you can craft tools whenever you like.\",\
	},\
	[\"a furnace\"] = {\
		aliases = { \"furnace\" },\
		desc = \"It's a furnace. Between you and me, these don't actually do anything in this game.\",\
	},\
	[\"a wooden pickaxe\"] = {\
		aliases = { \"pickaxe\", \"pick\", \"wooden pick\", \"wooden pickaxe\", \"wood pick\", \"wood pickaxe\" },\
		tool = true,\
		toolLevel = 1,\
		toolType = \"pick\",\
		desc = \"The pickaxe looks good for breaking stone and coal.\",\
	},\
	[\"a stone pickaxe\"] = {\
		aliases = { \"pickaxe\", \"pick\", \"stone pick\", \"stone pickaxe\" },\
		tool = true,\
		toolLevel = 2,\
		toolType = \"pick\",\
		desc = \"The pickaxe looks good for breaking iron.\",\
	},\
	[\"an iron pickaxe\"] = {\
		aliases = { \"pickaxe\", \"pick\", \"iron pick\", \"iron pickaxe\" },\
		tool = true,\
		toolLevel = 3,\
		toolType = \"pick\",\
		desc = \"The pickaxe looks strong enough to break diamond.\",\
	},\
	[\"a diamond pickaxe\"] = {\
		aliases = { \"pickaxe\", \"pick\", \"diamond pick\", \"diamond pickaxe\" },\
		tool = true,\
		toolLevel = 4,\
		toolType = \"pick\",\
		desc = \"Best. Pickaxe. Ever.\",\
	},\
	[\"a wooden sword\"] = {\
		aliases = { \"sword\", \"wooden sword\", \"wood sword\" },\
		tool = true,\
		toolLevel = 1,\
		toolType = \"sword\",\
		desc = \"Flimsy, but better than nothing.\",\
	},\
	[\"a stone sword\"] = {\
		aliases = { \"sword\", \"stone sword\" },\
		tool = true,\
		toolLevel = 2,\
		toolType = \"sword\",\
		desc = \"A pretty good sword.\",\
	},\
	[\"an iron sword\"] = {\
		aliases = { \"sword\", \"iron sword\" },\
		tool = true,\
		toolLevel = 3,\
		toolType = \"sword\",\
		desc = \"This sword can slay any enemy.\",\
	},\
	[\"a diamond sword\"] = {\
		aliases = { \"sword\", \"diamond sword\" },\
		tool = true,\
		toolLevel = 4,\
		toolType = \"sword\",\
		desc = \"Best. Sword. Ever.\",\
	},\
	[\"a wooden shovel\"] = {\
		aliases = { \"shovel\", \"wooden shovel\", \"wood shovel\" },\
		tool = true,\
		toolLevel = 1,\
		toolType = \"shovel\",\
		desc = \"Good for digging holes.\",\
	},\
	[\"a stone shovel\"] = {\
		aliases = { \"shovel\", \"stone shovel\" },\
		tool = true,\
		toolLevel = 2,\
		toolType = \"shovel\",\
		desc = \"Good for digging holes.\",\
	},\
	[\"an iron shovel\"] = {\
		aliases = { \"shovel\", \"iron shovel\" },\
		tool = true,\
		toolLevel = 3,\
		toolType = \"shovel\",\
		desc = \"Good for digging holes.\",\
	},\
	[\"a diamond shovel\"] = {\
		aliases = { \"shovel\", \"diamond shovel\" },\
		tool = true,\
		toolLevel = 4,\
		toolType = \"shovel\",\
		desc = \"Good for digging holes.\",\
	},\
	[\"some coal\"] = {\
		aliases = { \"coal\" },\
		ore = true,\
		toolLevel = 1,\
		toolType = \"pick\",\
		desc = \"That coal looks useful for building torches, if only you had a pickaxe to mine it.\",\
	},\
	[\"some dirt\"] = {\
		aliases = { \"dirt\" },\
		material = true,\
		desc = \"Why not build a mud hut?\",\
	},\
	[\"some stone\"] = {\
		aliases = { \"stone\", \"cobblestone\" },\
		material = true,\
		ore = true,\
		infinite = true,\
		toolLevel = 1,\
		toolType = \"pick\",\
		desc = \"Stone is useful for building things, and making stone pickaxes.\",\
	},\
	[\"some iron\"] = {\
		aliases = { \"iron\" },\
		material = true,\
		ore = true,\
		toolLevel = 2,\
		toolType = \"pick\",\
		desc = \"That iron looks mighty strong, you'll need a stone pickaxe to mine it.\",\
	},\
	[\"some diamond\"] = {\
		aliases = { \"diamond\", \"diamonds\" },\
		material = true,\
		ore = true,\
		toolLevel = 3,\
		toolType = \"pick\",\
		desc = \"Sparkly, rare, and impossible to mine without an iron pickaxe.\",\
	},\
	[\"some torches\"] = {\
		aliases = { \"torches\", \"torch\" },\
		desc = \"These won't run out for a while.\",\
	},\
	[\"a torch\"] = {\
		aliases = { \"torch\" },\
		desc = \"Fire, fire, burn so bright, won't you light my cave tonight?\",\
	},\
	[\"some wool\"] = {\
		aliases = { \"wool\" },\
		material = true,\
		desc = \"Soft and good for building.\",\
	},\
	[\"some pork\"] = {\
		aliases = { \"pork\", \"porkchops\" },\
		food = true,\
		desc = \"Delicious and nutricious.\",\
	},\
	[\"some chicken\"] = {\
		aliases = { \"chicken\" },\
		food = true,\
		desc = \"Finger licking good.\",\
	},\
}\
\
local tAnimals = {\
	\"a pig\", \"a cow\", \"a sheep\", \"a chicken\",\
}\
\
local tMonsters = {\
	\"a creeper\", \"a skeleton\", \"a zombie\", \"a spider\"\
}\
\
local tRecipes = {\
	[\"some planks\"] = { \"some wood\" },\
	[\"some sticks\"] = { \"some planks\" },\
	[\"some sticks\"] = { \"some planks\" },\
	[\"a crafting table\"] = { \"some planks\" },\
	[\"a furnace\"] = { \"some stone\" },\
	[\"some torches\"] = { \"some sticks\", \"some coal\" },\
	\
	[\"a wooden pickaxe\"] = { \"some planks\", \"some sticks\" },\
	[\"a stone pickaxe\"] = { \"some stone\", \"some sticks\" },\
	[\"an iron pickaxe\"] = { \"some iron\", \"some sticks\" },\
	[\"a diamond pickaxe\"] = { \"some diamond\", \"some sticks\" },\
\
	[\"a wooden sword\"] = { \"some planks\", \"some sticks\" },\
	[\"a stone sword\"] = { \"some stone\", \"some sticks\" },\
	[\"an iron sword\"] = { \"some iron\", \"some sticks\" },\
	[\"a diamond sword\"] = { \"some diamond\", \"some sticks\" },\
\
	[\"a wooden shovel\"] = { \"some planks\", \"some sticks\" },\
	[\"a stone shovel\"] = { \"some stone\", \"some sticks\" },\
	[\"an iron shovel\"] = { \"some iron\", \"some sticks\" },\
	[\"a diamond shovel\"] = { \"some diamond\", \"some sticks\" },\
}\
\
local tGoWest = {\
	\"(life is peaceful there)\",\
	\"(lots of open air)\",\
	\"(to begin life anew)\",\
	\"(this is what we'll do)\",\
	\"(sun in winter time)\",\
	\"(we will do just fine)\",\
	\"(where the skies are blue)\",\
	\"(this and more we'll do)\",\
}\
local nGoWest = 0\
\
local bRunning = true\
local tMap = { { {}, }, }\
local x,y,z = 0,0,0\
local inventory = {\
	[\"no tea\"] = items[\"no tea\"],\
}\
\
local nTurn = 0\
local nTimeInRoom = 0\
local nRandomSeed = 2000\
local nMapSeed = math.random()*900000\
local bHardcore = true\
local bInjured = false\
local bJustLoaded = true\
\
local tDayCycle = {\
	\"It is daytime.\",\
	\"It is daytime.\",\
	\"It is daytime.\",\
	\"It is daytime.\",\
	\"It is daytime.\",\
	\"It is daytime.\",\
	\"It is daytime.\",\
	\"It is daytime.\",\
	\"The sun is setting.\",\
	\"It is night.\",\
	\"It is night.\",\
	\"It is night.\",\
	\"It is night.\",\
	\"It is night.\",\
	\"The sun is rising.\",\
}\
\
local function getTimeOfDay()\
	return math.fmod( math.floor(nTurn/3), #tDayCycle ) + 1\
end\
\
local function isSunny()\
	return (getTimeOfDay() < 10)\
end\
\
local resetGame\
\
local function getRoom( x, y, z, dontCreate )\
	tMap[x] = tMap[x] or {}\
	tMap[x][y] = tMap[x][y] or {}\
	if not tMap[x][y][z] and dontCreate ~= true then\
		math.randomseed(nMapSeed + (x*12) + (y*13) + (z*91))\
 		local room = {\
 			items = {},\
 			exits = {},\
 			nMonsters = 0,\
 		}\
		tMap[x][y][z] = room\
		\
		if y == 0 then\
			-- Room is above ground\
\
			-- Pick biome\
			room.nBiome = math.random( 1, #tBiomes )\
			room.trees = hasTrees( room.nBiome )\
		\
			-- Add animals\
			if math.random(1,3) == 1 then\
				for n = 1,math.random(1,2) do\
					local sAnimal = tAnimals[ math.random( 1, #tAnimals ) ]\
					room.items[ sAnimal ] = items[ sAnimal ]\
				end\
			end\
			\
			-- Add surface ore\
			if math.random(1,5) == 1 or hasStone( room.nBiome ) then\
				room.items[ \"some stone\" ] = items[ \"some stone\" ]\
			end\
			if math.random(1,8) == 1 then\
				room.items[ \"some coal\" ] = items[ \"some coal\" ]\
			end\
			if math.random(1,8) == 1 and hasRivers( room.nBiome ) then\
				room.items[ \"a river\" ] = items[ \"a river\" ]\
			end\
\
			-- Add exits\
			room.exits = {\
				[\"north\"] = true,\
				[\"south\"] = true,\
				[\"east\"] = true,\
				[\"west\"] = true,\
			}\
			if math.random(1,8) == 1 then\
				room.exits[\"down\"] = true\
				room.items[\"a cave entrance\"] = items[\"a cave entrance\"]\
			end\
						\
		else\
			-- Room is underground\
			-- Add exits\
			local function tryExit( sDir, sOpp, x, y, z )\
				local adj = getRoom( x, y, z, true )\
				if adj then\
					if adj.exits[sOpp] then\
						room.exits[sDir] = true\
					end\
				else\
					if math.random(1,3) == 1 then\
						room.exits[sDir] = true\
					end\
				end\
			end\
			\
			if y == -1 then\
				local above = getRoom( x, y + 1, z )\
				if above.exits[\"down\"] then\
					room.exits[\"up\"] = true\
					room.items[\"an exit to the surface\"] = items[\"an exit to the surface\"]\
				end\
			else\
				tryExit( \"up\", \"down\", x, y + 1, z )\
			end\
			\
			if y > -3 then\
				tryExit( \"down\", \"up\", x, y - 1, z )\
			end			\
			tryExit( \"east\", \"west\", x - 1, y, z )\
			tryExit( \"west\", \"east\", x + 1, y, z )\
			tryExit( \"north\", \"south\", x, y, z + 1 )\
			tryExit( \"south\", \"north\", x, y, z - 1 )	\
			\
			-- Add ores\
			room.items[ \"some stone\" ] = items[ \"some stone\" ]\
			if math.random(1,3) == 1 then\
				room.items[ \"some coal\" ] = items[ \"some coal\" ]\
			end\
			if math.random(1,8) == 1 then\
				room.items[ \"some iron\" ] = items[ \"some iron\" ]\
			end\
			if y == -3 and math.random(1,15) == 1 then\
				room.items[ \"some diamond\" ] = items[ \"some diamond\" ]\
			end\
			\
			-- Turn out the lights\
			room.dark = true\
		end\
	end\
	math.randomseed(nRandomSeed)\
	return tMap[x][y][z]\
end\
\
local function itemize( t )\
	local item = next( t )\
	if item == nil then\
		return \"nothing\"\
	end\
	\
	local text = \"\"\
	while item do\
		text = text .. item\
		\
		local nextItem = next( t, item )\
		if nextItem ~= nil then\
			local nextNextItem = next( t, nextItem )\
			if nextNextItem == nil then\
				text = text .. \" and \"\
			else\
				text = text .. \", \"\
			end\
		end\
		item = nextItem\
	end\
	return text\
end\
\
function findItem( _tList, _sQuery )\
	for sItem, tItem in pairs( _tList ) do\
		if sItem == _sQuery then\
			return sItem\
		end\
		if tItem.aliases ~= nil then\
			for n, sAlias in pairs( tItem.aliases ) do\
				if sAlias == _sQuery then\
					return sItem\
				end\
			end\
		end\
	end\
	return nil\
end\
\
local tMatches = {\
	[\"wait\"] = {\
		\"wait\",\
	},\
	[\"look\"] = {\
		\"look at the ([%a ]+)\",\
		\"look at ([%a ]+)\",\
		\"look\",\
		\"inspect ([%a ]+)\",\
		\"inspect the ([%a ]+)\",\
		\"inspect\",\
	},\
	[\"inventory\"] = {\
		\"check self\",\
		\"check inventory\",\
		\"inventory\",\
		\"i\",\
	},\
	[\"go\"] = {\
		\"go (%a+)\",\
		\"travel (%a+)\",\
		\"walk (%a+)\",\
		\"run (%a+)\",\
		\"move (%a+)\",\
		\"go\",\
	},\
	[\"dig\"] = {\
		\"dig (%a+) using ([%a ]+)\",\
		\"dig (%a+) with ([%a ]+)\",\
		\"dig (%a+)\",\
		\"dig\",\
	},\
	[\"take\"] = {\
		\"pick up the ([%a ]+)\",\
		\"pick up ([%a ]+)\",\
		\"pickup ([%a ]+)\",\
		\"take the ([%a ]+)\",\
		\"take ([%a ]+)\",\
		\"take\",\
	},\
	[\"drop\"] = {\
		\"put down the ([%a ]+)\",\
		\"put down ([%a ]+)\",\
		\"drop the ([%a ]+)\",\
		\"drop ([%a ]+)\",\
		\"drop\",\
	},\
	[\"place\"] = {\
		\"place the ([%a ]+)\",\
		\"place ([%a ]+)\",\
		\"place\",\
	},\
	[\"cbreak\"] = {\
		\"punch the ([%a ]+)\",\
		\"punch ([%a ]+)\",\
		\"punch\",\
		\"break the ([%a ]+) with the ([%a ]+)\",\
		\"break ([%a ]+) with ([%a ]+) \",\
		\"break the ([%a ]+)\",\
		\"break ([%a ]+)\",\
		\"break\",\
	},\
	[\"mine\"] = {\
		\"mine the ([%a ]+) with the ([%a ]+)\",\
		\"mine ([%a ]+) with ([%a ]+)\",\
		\"mine ([%a ]+)\",\
		\"mine\",\
	},\
	[\"attack\"] = {\
		\"attack the ([%a ]+) with the ([%a ]+)\",\
		\"attack ([%a ]+) with ([%a ]+)\",\
		\"attack ([%a ]+)\",\
		\"attack\",\
		\"kill the ([%a ]+) with the ([%a ]+)\",\
		\"kill ([%a ]+) with ([%a ]+)\",\
		\"kill ([%a ]+)\",\
		\"kill\",\
		\"hit the ([%a ]+) with the ([%a ]+)\",\
		\"hit ([%a ]+) with ([%a ]+)\",\
		\"hit ([%a ]+)\",\
		\"hit\",\
	},\
	[\"craft\"] = {\
		\"craft a ([%a ]+)\",\
		\"craft some ([%a ]+)\",\
		\"craft ([%a ]+)\",\
		\"craft\",\
		\"make a ([%a ]+)\",\
		\"make some ([%a ]+)\",\
		\"make ([%a ]+)\",\
		\"make\",\
	},\
	[\"build\"] = {\
		\"build ([%a ]+) out of ([%a ]+)\",\
		\"build ([%a ]+) from ([%a ]+)\",\
		\"build ([%a ]+)\",\
		\"build\",\
	},\
	[\"eat\"] = {\
		\"eat a ([%a ]+)\",\
		\"eat the ([%a ]+)\",\
		\"eat ([%a ]+)\",\
		\"eat\",\
	},\
	[\"help\"] = {\
		\"help me\",\
		\"help\",\
	},\
	[\"exit\"] = {\
		\"exit\",\
		\"quit\",\
		\"goodbye\",\
		\"good bye\",\
		\"bye\",\
		\"farewell\",\
	},\
	[\"reset\"] = {\
		\"reset\",\
		\"start over\",\
		\"new game\",\
		\"start new game\",\
		\"restart\",\
	}\
}\
\
local commands = {}\
function doCommand( text )\
	if text == \"\" then\
		commands[ \"noinput\" ]()\
		return\
	end\
	\
	for sCommand, t in pairs( tMatches ) do\
		for n, sMatch in pairs( t ) do\
			local tCaptures = { string.match( text, \"^\" .. sMatch .. \"$\" ) }\
			if #tCaptures ~= 0 then\
				local fnCommand = commands[ sCommand ]\
				if #tCaptures == 1 and tCaptures[1] == sMatch then\
					fnCommand()\
				else\
					fnCommand( table.unpack( tCaptures ) )\
				end\
				return\
			end\
		end\
	end\
	commands[ \"badinput\" ]()\
end\
\
function commands.wait()\
	print( \"Time passes...\" )\
end\
\
function commands.look( _sTarget )\
	local room = getRoom( x,y,z )\
	if room.dark then\
		print( \"It is pitch dark.\" )\
		return\
	end\
\
	if _sTarget == nil then\
		-- Look at the world\
		if y == 0 then\
			io.write( \"You are standing \" .. tBiomes[room.nBiome] .. \". \" )\
			print( tDayCycle[ getTimeOfDay() ] )\
		else\
			io.write( \"You are underground. \" )\
			if next( room.exits ) ~= nil then\
				print( \"You can travel \"..itemize( room.exits )..\".\" )\
			else\
				print()\
			end\
		end\
		if next( room.items ) ~= nil then\
			print( \"There is \" .. itemize( room.items ) .. \" here.\" )\
		end\
		if room.trees then\
			print( \"There are trees here.\" )\
		end\
		\
	else\
		-- Look at stuff\
		if room.trees and (_sTarget == \"tree\" or _sTarget == \"trees\") then\
			print( \"The trees look easy to break.\" )\
		elseif _sTarget == \"self\" or _sTarget == \"myself\" then\
			print( \"Very handsome.\" )\
		else\
			local tItem = nil\
			local sItem = findItem( room.items, _sTarget )\
			if sItem then\
				tItem = room.items[sItem]\
			else\
				sItem = findItem( inventory, _sTarget )\
				if sItem then\
					tItem = inventory[sItem]\
				end\
			end\
			\
			if tItem then\
				print( tItem.desc or (\"You see nothing special about \"..sItem..\".\") )\
			else\
				print( \"You don't see any \".._sTarget..\" here.\" )\
			end\
		end\
	end\
end\
\
function commands.go( _sDir )\
	local room = getRoom( x,y,z )\
	if _sDir == nil then\
		print( \"Go where?\" )\
		return\
	end\
	\
	if nGoWest ~= nil then\
		if _sDir == \"west\" then\
			nGoWest = nGoWest + 1\
			if nGoWest > #tGoWest then\
				nGoWest = 1\
			end\
			print( tGoWest[ nGoWest ] )\
		else\
			if nGoWest > 0 or nTurn > 6 then\
				nGoWest = nil\
			end\
		end\
	end\
	\
	if room.exits[_sDir] == nil then\
		print( \"You can't go that way.\" )\
		return\
	end\
	\
	if _sDir == \"north\" then\
		z = z + 1\
	elseif _sDir == \"south\" then\
		z = z - 1\
	elseif _sDir == \"east\" then\
		x = x - 1\
	elseif _sDir == \"west\" then\
		x = x + 1\
	elseif _sDir == \"up\" then\
		y = y + 1\
	elseif _sDir == \"down\" then\
		y = y - 1\
	else\
		print( \"I don't understand that direction.\" )\
		return\
	end\
	\
	nTimeInRoom = 0\
	doCommand( \"look\" )\
end\
\
function commands.dig( _sDir, _sTool )\
	local room = getRoom( x,y,z )\
	if _sDir == nil then\
		print( \"Dig where?\" )\
		return\
	end\
	\
	local sTool = nil\
	local tTool = nil\
	if _sTool ~= nil then\
		sTool = findItem( inventory, _sTool )\
		if not sTool then\
			print( \"You're not carrying a \".._sTool..\".\" )\
			return\
		end\
		tTool = inventory[ sTool ]\
	end\
	\
	local room = getRoom( x, y, z )\
	local bActuallyDigging = (room.exits[ _sDir ] ~= true)\
	if bActuallyDigging then\
		if sTool == nil or tTool.toolType ~= \"pick\" then\
			print( \"You need to use a pickaxe to dig through stone.\" )\
			return\
		end\
	end\
	\
	if _sDir == \"north\" then\
		room.exits[\"north\"] = true\
		z = z + 1\
		getRoom( x, y, z ).exits[\"south\"] = true\
\
	elseif _sDir == \"south\" then\
		room.exits[\"south\"] = true\
		z = z - 1\
		getRoom( x, y, z ).exits[\"north\"] = true\
		\
	elseif _sDir == \"east\" then\
		room.exits[\"east\"] = true\
		x = x - 1\
		getRoom( x, y, z ).exits[\"west\"] = true\
		\
	elseif _sDir == \"west\" then\
		room.exits[\"west\"] = true\
		x = x + 1\
		getRoom( x, y, z ).exits[\"east\"] = true\
		\
	elseif _sDir == \"up\" then\
		if y == 0 then\
			print( \"You can't dig that way.\" )\
			return\
		end\
\
		room.exits[\"up\"] = true\
		if y == -1 then\
			room.items[ \"an exit to the surface\" ] = items[ \"an exit to the surface\" ]\
		end\
		y = y + 1\
		\
		room = getRoom( x, y, z )\
		room.exits[\"down\"] = true\
		if y == 0 then\
			room.items[ \"a cave entrance\" ] = items[ \"a cave entrance\" ]\
		end\
		\
	elseif _sDir == \"down\" then\
		if y <= -3 then\
			print( \"You hit bedrock.\" )\
			return\
		end\
\
		room.exits[\"down\"] = true\
		if y == 0 then\
			room.items[ \"a cave entrance\" ] = items[ \"a cave entrance\" ]\
		end\
		y = y - 1\
		\
		room = getRoom( x, y, z )\
		room.exits[\"up\"] = true\
		if y == -1 then\
			room.items[ \"an exit to the surface\" ] = items[ \"an exit to the surface\" ]\
		end\
		\
	else\
		print( \"I don't understand that direction.\" )\
		return\
	end\
	\
	--\
	if bActuallyDigging then\
		if _sDir == \"down\" and y == -1 or\
		   _sDir == \"up\" and y == 0 then\
			inventory[ \"some dirt\" ] = items[ \"some dirt\" ]\
			inventory[ \"some stone\" ] = items[ \"some stone\" ]\
			print( \"You dig \".._sDir..\" using \"..sTool..\" and collect some dirt and stone.\" )\
		else\
			inventory[ \"some stone\" ] = items[ \"some stone\" ]\
			print( \"You dig \".._sDir..\" using \"..sTool..\" and collect some stone.\" )\
		end\
	end\
	\
	nTimeInRoom = 0\
	doCommand( \"look\" )\
end\
\
function commands.inventory()\
	print( \"You are carrying \" .. itemize( inventory ) .. \".\" )\
end\
\
function commands.drop( _sItem )\
	if _sItem == nil then\
		print( \"Drop what?\" )\
		return\
	end\
	\
	local room = getRoom( x,y,z )\
	local sItem = findItem( inventory, _sItem )\
	if sItem then\
		local tItem = inventory[ sItem ]\
		if tItem.droppable == false then\
			print( \"You can't drop that.\" )\
		else\
			room.items[ sItem ] = tItem\
			inventory[ sItem ] = nil\
			print( \"Dropped.\" )\
		end\
	else\
		print( \"You don't have a \".._sItem..\".\" )\
	end\
end\
\
function commands.place( _sItem )\
	if _sItem == nil then\
		print( \"Place what?\" )\
		return\
	end\
	\
	if _sItem == \"torch\" or _sItem == \"a torch\" then\
		local room = getRoom( x,y,z )\
		if inventory[\"some torches\"] or inventory[\"a torch\"] then\
			inventory[\"a torch\"] = nil\
			room.items[\"a torch\"] = items[\"a torch\"]\
			if room.dark then\
				print( \"The cave lights up under the torchflame.\" )\
				room.dark = false\
			elseif y == 0 and not isSunny() then\
				print( \"The night gets a little brighter.\" )\
			else\
				print( \"Placed.\" )\
			end\
		else\
			print( \"You don't have torches.\" )\
		end\
		return\
	end\
	\
	commands.drop( _sItem )\
end\
\
function commands.take( _sItem )\
	if _sItem == nil then\
		print( \"Take what?\" )\
		return\
	end\
\
	local room = getRoom( x,y,z )\
	local sItem = findItem( room.items, _sItem )\
	if sItem then\
		local tItem = room.items[ sItem ]\
		if tItem.heavy == true then\
			print( \"You can't carry \"..sItem..\".\" )\
		elseif tItem.ore == true then\
			print( \"You need to mine this ore.\" )\
		else\
			if tItem.infinite ~= true then\
				room.items[ sItem ] = nil\
			end\
			inventory[ sItem ] = tItem\
			\
			if inventory[\"some torches\"] and inventory[\"a torch\"] then\
				inventory[\"a torch\"] = nil\
			end\
			if sItem == \"a torch\" and y < 0 then\
				room.dark = true\
				print( \"The cave plunges into darkness.\" )\
			else\
				print( \"Taken.\" )\
			end\
		end\
	else\
		print( \"You don't see a \".._sItem..\" here.\" )\
	end\
end\
\
function commands.mine( _sItem, _sTool )\
	if _sItem == nil then\
		print( \"Mine what?\" )\
		return\
	end\
	if _sTool == nil then\
		print( \"Mine \".._sItem..\" with what?\" )\
		return\
	end	\
	commands.cbreak( _sItem, _sTool )\
end\
\
function commands.attack( _sItem, _sTool )\
	if _sItem == nil then\
		print( \"Attack what?\" )\
		return\
	end\
	commands.cbreak( _sItem, _sTool )\
end\
\
function commands.cbreak( _sItem, _sTool )\
	if _sItem == nil then\
		print( \"Break what?\" )\
		return\
	end\
	\
	local sTool = nil\
	if _sTool ~= nil then\
		sTool = findItem( inventory, _sTool )\
		if sTool == nil then\
			print( \"You're not carrying a \".._sTool..\".\" )\
			return\
		end\
	end\
\
	local room = getRoom( x,y,z )\
	if _sItem == \"tree\" or _sItem == \"trees\" or _sItem == \"a tree\" then\
		print( \"The tree breaks into blocks of wood, which you pick up.\" )\
		inventory[ \"some wood\" ] = items[ \"some wood\" ]\
		return\
	elseif _sItem == \"self\" or _sItem == \"myself\" then\
		if term.isColour() then\
			term.setTextColour( colours.red )\
		end\
		print( \"You have died.\" )\
		print( \"Score: &e0\" )\
		term.setTextColour( colours.white )\
		bRunning = false\
		bDied = true\
		return\
	end\
	\
	local sItem = findItem( room.items, _sItem )\
	if sItem then\
		local tItem = room.items[ sItem ]\
		if tItem.ore == true then\
			-- Breaking ore\
			if not sTool then\
				print( \"You need a tool to break this ore.\" )\
				return\
			end\
			local tTool = inventory[ sTool ]\
			if tTool.tool then\
				if tTool.toolLevel < tItem.toolLevel then\
					print( sTool ..\" is not strong enough to break this ore.\" )\
				elseif tTool.toolType ~= tItem.toolType then\
					print( \"You need a different kind of tool to break this ore.\" )\
				else\
					print( \"The ore breaks, dropping \"..sItem..\", which you pick up.\" )\
					inventory[ sItem ] = items[ sItem ]\
					if tItem.infinite ~= true then\
						room.items[ sItem ] = nil\
					end\
				end\
			else\
				print( \"You can't break \"..sItem..\" with \"..sTool..\".\")\
			end\
			\
		elseif tItem.creature == true then\
			-- Fighting monsters (or pigs)\
			local toolLevel = 0\
			local tTool = nil\
			if sTool then\
				tTool = inventory[ sTool ]\
				if tTool.toolType == \"sword\" then\
					toolLevel = tTool.toolLevel\
				end\
			end\
						\
			local tChances = { 0.2, 0.4, 0.55, 0.8, 1 }\
			if math.random() <= tChances[ toolLevel + 1 ] then\
				room.items[ sItem ] = nil\
				print( \"The \"..tItem.aliases[1]..\" dies.\" )\
	\
				if tItem.drops then\
					for n, sDrop in pairs( tItem.drops ) do\
						if not room.items[sDrop] then\
							print( \"The \"..tItem.aliases[1]..\" dropped \"..sDrop..\".\" )\
							room.items[sDrop] = items[sDrop]\
						end\
					end\
				end\
				\
				if tItem.monster then\
					room.nMonsters = room.nMonsters - 1\
				end\
			else\
				print( \"The \"..tItem.aliases[1]..\" is injured by your blow.\" )\
			end\
			\
			if tItem.hitDrops then\
				for n, sDrop in pairs( tItem.hitDrops ) do\
					if not room.items[sDrop] then\
						print( \"The \"..tItem.aliases[1]..\" dropped \"..sDrop..\".\" )\
						room.items[sDrop] = items[sDrop]\
					end\
				end\
			end\
		\
		else\
			print( \"You can't break \"..sItem..\".\" )\
		end\
	else\
		print( \"You don't see a \".._sItem..\" here.\" )\
	end\
end\
\
function commands.craft( _sItem )\
	if _sItem == nil then\
		print( \"Craft what?\" )\
		return\
	end\
	\
	if _sItem == \"computer\" or _sItem == \"a computer\" then\
		print( \"By creating a computer in a computer in a computer, you tear a hole in the spacetime continuum from which no mortal being can escape.\" )\
		if term.isColour() then\
			term.setTextColour( colours.red )\
		end\
		print( \"You have died.\" )\
		print( \"Score: &e0\" )\
		term.setTextColour( colours.white )\
		bRunning = false\
		bDied = true\
		return\
	end\
	\
	local room = getRoom( x,y,z )\
	local sItem = findItem( items, _sItem )\
	local tRecipe = (sItem and tRecipes[ sItem ]) or nil\
	if tRecipe then\
		for n,sReq in ipairs( tRecipe ) do\
			if inventory[sReq] == nil then\
				print( \"You don't have the items you need to craft \"..sItem..\".\" )\
				return\
			end\
		end\
		\
		for n,sReq in ipairs( tRecipe ) do\
			inventory[sReq] = nil\
		end\
		inventory[ sItem ] = items[ sItem ]\
		if inventory[\"some torches\"] and inventory[\"a torch\"] then\
			inventory[\"a torch\"] = nil\
		end\
		print( \"Crafted.\" )\
	else\
		print( \"You don't know how to make \"..(sItem or _sItem)..\".\" )\
	end	\
end\
\
function commands.build( _sThing, _sMaterial )\
	if _sThing == nil then\
		print( \"Build what?\" )\
		return\
	end\
		\
	local sMaterial = nil\
	if _sMaterial == nil then\
		for sItem, tItem in pairs( inventory ) do\
			if tItem.material then\
				sMaterial = sItem\
				break\
			end\
		end\
		if sMaterial == nil then\
			print( \"You don't have any building materials.\" )\
			return\
		end\
	else\
		sMaterial = findItem( inventory, _sMaterial )\
		if not sMaterial then\
			print( \"You don't have any \".._sMaterial )\
			return\
		end\
		\
		if inventory[sMaterial].material ~= true then\
			print( sMaterial..\" is not a good building material.\" )\
			return\
		end\
	end\
	\
	local alias = nil\
	if string.sub(_sThing, 1, 1) == \"a\" then\
		alias = string.match( _sThing, \"a ([%a ]+)\" )\
	end\
	\
	local room = getRoom( x,y,z )\
	inventory[sMaterial] = nil\
	room.items[ _sThing ] = {\
		heavy = true,\
		aliases = { alias },\
		desc = \"As you look at your creation (made from \"..sMaterial..\"), you feel a swelling sense of pride.\",\
	}\
\
	print( \"Your construction is complete.\" )\
end\
\
function commands.help()\
	local sText = \
		\"Welcome to adventure, the greatest text adventure game on CraftOS. \" ..\
		\"To get around the world, type actions, and the adventure will \" ..\
		\"be read back to you. The actions availiable to you are go, look, inspect, inventory, \" ..\
		\"take, drop, place, punch, attack, mine, dig, craft, build, eat and exit.\"\
	print( sText )\
end\
\
function commands.eat( _sItem )\
	if _sItem == nil then\
		print( \"Eat what?\" )\
		return\
	end\
\
	local sItem = findItem( inventory, _sItem )\
	if not sItem then\
		print( \"You don't have any \".._sItem..\".\" )\
		return\
	end\
	\
	local tItem = inventory[sItem]\
	if tItem.food then\
		print( \"That was delicious!\" )\
		inventory[sItem] = nil\
		\
		if bInjured then\
			print( \"You are no longer injured.\" )\
			bInjured = false\
		end\
	else\
		print( \"You can't eat \"..sItem..\".\" )\
	end\
end\
\
function commands.exit()\
	bRunning = false\
end\
\
function commands.reset()\
	print(\"You have requested to reset your game.\")\
	if term.isColour() then\
		term.setTextColour( colours.red )\
	end\
	print(\"Are you sure you want to reset? You will lose all progress in this adventure!\")\
	print(\"Type in reset again to reset the game.\")\
	if string.lower(read()) == \"reset\" then\
		resetGame()\
	else\
		skipSimulationForThisFrame = true\
	end\
end\
\
function commands.badinput()\
	local tResponses = {\
		\"I don't understand.\",\
		\"I don't understand you.\",\
		\"You can't do that.\",\
		\"Nope.\",\
		\"Huh?\",\
		\"Say again?\",\
		\"That's crazy talk.\",\
		\"Speak clearly.\",\
		\"I'll think about it.\",\
		\"Let me get back to you on that one.\",\
		\"That doesn't make any sense.\",\
		\"What? Try again with a different phrase, or use help.\",\
	}\
	print( tResponses[ math.random(1,#tResponses) ] )\
end\
\
function commands.noinput()\
	local tResponses = {\
		\"Speak up.\",\
		\"Enunciate.\",\
		\"Project your voice.\",\
		\"Don't be shy.\",\
		\"Use your words.\",\
	}\
	print( tResponses[ math.random(1,#tResponses) ] )\
end\
\
local function simulate()\
	local bNewMonstersThisRoom = false\
	math.randomseed(nRandomSeed)\
	\
	-- Spawn monsters in nearby rooms\
	for sx = -2,2 do\
		for sy = -1,1 do\
			for sz = -2,2 do\
				local h = y + sy\
				if h >= -3 and h <= 0 then\
					local room = getRoom( x + sx, h, z + sz )\
					\
					-- Spawn monsters\
					if room.nMonsters < 2 and\
					   ((h == 0 and not isSunny() and not room.items[\"a torch\"]) or room.dark) and\
					   math.random(1,6) == 1 then\
					   \
						local sMonster = tMonsters[ math.random(1,#tMonsters) ]\
						if room.items[ sMonster ] == nil then\
					   		room.items[ sMonster ] = items[ sMonster ]\
					   		room.nMonsters = room.nMonsters + 1\
					   		\
					   		if sx == 0 and sy == 0 and sz == 0 and not room.dark then\
					   			print( \"From the shadows, \"..sMonster..\" appears.\" )\
					   			bNewMonstersThisRoom = true\
					   		end\
						end	\
					end\
					\
					-- Burn monsters\
					if h == 0 and isSunny() then\
						for n,sMonster in ipairs( tMonsters ) do\
							if room.items[sMonster] and items[sMonster].nocturnal then\
								room.items[sMonster] = nil\
						   		if sx == 0 and sy == 0 and sz == 0 and not room.dark then\
						   			print( \"With the sun high in the sky, the \"..items[sMonster].aliases[1]..\" bursts into flame and dies.\" )\
						   		end\
						   		room.nMonsters = room.nMonsters - 1\
						   	end\
						end\
					end	\
				end\
			end\
		end\
	end\
\
	-- Make monsters attack\
	local room = getRoom( x, y, z )\
	if nTimeInRoom >= 2 and not bNewMonstersThisRoom and not bJustLoaded then\
		for n,sMonster in ipairs( tMonsters ) do\
			if room.items[sMonster] then\
				if math.random(1,4) == 1 and\
				   not (y == 0 and isSunny() and (sMonster == \"a spider\")) then\
					if sMonster == \"a creeper\" then\
						if room.dark then\
							print( \"A creeper explodes.\" )\
						else\
							print( \"The creeper explodes.\" )\
						end\
						room.items[sMonster] = nil\
						room.nMonsters = room.nMonsters - 1\
					else\
						if room.dark then\
							print( \"A \"..items[sMonster].aliases[1]..\" attacks you.\" )\
						else\
							print( \"The \"..items[sMonster].aliases[1]..\" attacks you.\" )\
						end\
					end\
					\
					if bInjured then\
						if term.isColour() then\
							term.setTextColour( colours.red )\
						end\
						print( \"You have died.\" )\
						print( \"Score: &e0\" )\
						term.setTextColour( colours.white )\
						bRunning = false\
						bDied = true\
						return\
					else\
						bInjured = true\
					end\
					\
					break\
				end\
			end\
		end\
	end\
	\
	-- Always print this\
	if bInjured then\
		if term.isColour() then\
			term.setTextColour( colours.red )\
		end\
		print( \"You are injured.\" )\
		term.setTextColour( colours.white )\
	end\
	\
	-- Advance time\
	if not bJustLoaded then\
		nTurn = nTurn + 1\
		nTimeInRoom = nTimeInRoom + 1\
		nRandomSeed = math.random()*9000 + (os.clock())\
	else\
		bJustLoaded = false\
	end\
end\
\
-- Add autocompletion stuff --\
local tActions = {\
	\"go\",\
	\"craft\",\
	\"drop\",\
	\"place\",\
	\"build\",\
	\"inspect\",\
	\"inventory\",\
	\"take\",\
	\"look\",\
	\"mine\",\
	\"eat\",\
	\"attack\",\
	\"dig\",\
	\"help\",\
	\"exit\",\
}\
function autoTab(tab)\
	local ret = {}\
	for k, v in pairs(tab) do\
		if type(v) == \"string\" then\
			ret[v] = true\
		elseif type(k) == \"string\" then\
			ret[k] = true\
		end\
	end\
	return ret\
end\
local tActions2 = autoTab(tActions)\
\
local function autoComplete( sLine )\
	if string.find(sLine, \" \") == nil then\
        return textutils.complete( sLine, tActions2 )\
    end\
end\
\
-- Save game stuff --\
function resetGame()\
	nGoWest = 0\
	\
	bRunning = true\
	tMap = { { {}, }, }\
	x,y,z = 0,0,0\
	inventory = {\
		[\"no tea\"] = items[\"no tea\"],\
	}\
\
	nTurn = 0\
	nTimeInRoom = 0\
	nRandomSeed = math.random()*9000\
	nMapSeed = math.random()*900000\
	bInjured = false\
	bJustLoaded = true\
	\
	doCommand( \"look\" )\
	simulate()\
	tCommandHistory = {}\
end\
\
function saveGame()\
	local recursive = {}\
	local map = {}\
	for x, xTable in pairs(tMap) do\
		map[x] = {}\
		for y, yTable in pairs(xTable) do\
			map[x][y] = {}\
			for z, zTable in pairs(yTable) do\
				local matched = false\
				for k, v in ipairs(recursive) do\
					if v == zTable then\
						matched = true\
						break\
					end\
				end\
				if not matched then\
					local tab = {}\
					local items = {}\
					for k, v in pairs(zTable.items) do\
						items[k] = true\
					end\
					tab.dark = zTable.dark\
					tab.exits = zTable.exits\
					tab.nBiome = tonumber(zTable.nBiome)\
					tab.nMonsters = zTable.nMonsters\
					tab.items = items\
					map[x][y][z] = tab\
					table.insert(recursive, tab)\
				end\
			end\
		end\
	end\
	local file = fs.open(\"save.Adventure\", \"w\")\
	if file then\
		file.writeLine(\"Success\")\
		file.writeLine(textutils.serialize(map))\
		file.writeLine(\"--Inventory--\")\
		file.writeLine(textutils.serialize(inventory))\
		file.writeLine(\"--Other--\")\
		file.writeLine(tostring(bInjured))\
		file.writeLine(nTurn)\
		file.writeLine(nTimeInRoom)\
		file.writeLine(nRandomSeed)\
		file.writeLine(nMapSeed)\
		file.writeLine(x)\
		file.writeLine(y)\
		file.writeLine(z)\
		file.close()\
	end\
end\
\
function loadGame()\
	local file = fs.open(\"save.Adventure\", \"r\")\
	if file then\
		if file.readLine() ~= \"Success\" then\
			file.close()\
			return false\
		end\
		\
		if term.isColour() then\
			term.setTextColour( colours.yellow )\
		end\
		print(\"Your game is being loaded.\")\
		if term.isColour() then\
			term.setTextColour( colours.white )\
		end\
		\
		bJustLoaded = true\
		local mapStr = \"\"\
		local loops = 0\
		while true do\
			loops = loops + 1\
			local str = file.readLine()\
			if str == \"--Inventory--\" then\
				break\
			end\
			if loops > 1 then\
				mapStr = mapStr..\"\\n\"..str\
			else\
				mapStr = str\
			end\
		end\
		tMap = textutils.unserialize(mapStr)\
		local invStr = \"\"\
		loops = 0\
		while true do\
			loops = loops + 1\
			local str = file.readLine()\
			if str == \"--Other--\" then\
				break\
			end\
			if loops > 1 then\
				invStr = invStr..\"\\n\"..str\
			else\
				invStr = str\
			end\
		end\
		inventory = textutils.unserialize(invStr)\
		bInjured = file.readLine() == \"true\"\
		nTurn = tonumber(file.readLine()) or 0\
		nTimeInRoom = tonumber(file.readLine()) or 0\
		nRandomSeed = tonumber(file.readLine()) or 0\
		nMapSeed = tonumber(file.readLine()) or 0\
		x = tonumber(file.readLine()) or 0\
		y = tonumber(file.readLine()) or 0\
		z = tonumber(file.readLine()) or 0\
		file.close()\
	end\
	for x, xTable in pairs(tMap) do\
		for y, yTable in pairs(xTable) do\
			for z, zTable in pairs(yTable) do\
				local Myitems = {}\
				for k, v in pairs(zTable.items) do\
					Myitems[k] = items[k]\
				end\
				zTable.items = Myitems\
			end\
		end\
	end\
	return true\
end\
\
local ok = pcall(loadGame)\
if not ok then\
	if term.isColour() then\
		term.setTextColour( colours.yellow )\
	end\
	print(\"The save could not be loaded.\")\
	if term.isColour() then\
		term.setTextColour( colours.white )\
	end\
end\
\
doCommand( \"look\" )\
simulate()\
\
local bLoop = true\
\
while bLoop do\
	while bRunning do\
		if term.isColour() then\
			term.setTextColour( colours.yellow )\
		end\
		write( \"? \" )\
		term.setTextColour( colours.white )\
			\
		local sRawLine \
		if #tCommandHistory > 1 then\
			sRawLine = read( nil, tCommandHistory )\
		else\
			sRawLine = read( nil, tCommandHistory, autoComplete )\
		end\
		if #sRawLine < 1 and #tCommandHistory > 0 then\
			sRawLine = tCommandHistory[#tCommandHistory]\
		end\
		table.insert( tCommandHistory, sRawLine )\
		\
		local sLine = nil\
		for match in string.gmatch(sRawLine, \"%a+\") do\
			if sLine then\
				sLine = sLine .. \" \" .. string.lower(match)\
			else\
				sLine = string.lower(match)\
			end\
		end\
		\
		doCommand( sLine or \"\" )\
		if bRunning and not skipSimulationForThisFrame then\
			simulate()\
		end\
		if bRunning and not skipSimulationForThisFrame then\
			saveGame()\
		end\
		skipSimulationForThisFrame = false\
	end\
	if bDied then\
		if bHardcore then\
			fs.delete(\"save.Adventure\")\
		end\
		bLoop = false\
		print(\"Would you like to play again?\")\
		if term.isColour() then\
			term.setTextColour( colours.yellow )\
		end\
		write( \"? \" )\
		term.setTextColour( colours.white )\
		if string.lower(read()):find(\"y\") == 1 then\
			bLoop = true\
			resetGame()\
		end\
	else\
		break\
	end\
end",
  [ "Flutter/windowshell" ] = "local tArgs = {...}\
local tDesktop = {}\
if _G.windowShell then\
	tArgs[1] = tArgs[1] or \"shell\"\
	os.run({}, \"fg\", unpack(tArgs))\
	return\
end\
\
-- Local color setup\
local backColor, windowBorderColor, windowTitleColor, windowCloseColor\
if term.isColor() then\
	backColor, windowBorderColor = colors.gray, colors.blue\
	windowTitleColor, windowCloseColor = colors.white, colors.red\
else\
	backColor, windowBorderColor = colors.black, colors.white\
	windowTitleColor, windowCloseColor = colors.black, colors.white\
end\
term.setBackgroundColor(backColor)\
term.clear()\
term.redirect(term.native())\
\
-- Window API --\
local window = {}\
function window.create( parent, nX, nY, nWidth, nHeight, bStartVisible, sExpectedTitle )\
\
	if type( parent ) ~= \"table\" or\
		type( nX ) ~= \"number\" or\
		type( nY ) ~= \"number\" or\
		type( nWidth ) ~= \"number\" or\
		type( nHeight ) ~= \"number\" or\
		(bStartVisible ~= nil and type( bStartVisible ) ~= \"boolean\") then\
		error( \"Expected object, number, number, number, number, [boolean]\", 2 )\
	end\
\
	if parent == term then\
		error( \"term is not a recommended window parent, try term.current() instead\", 2 )\
	end\
\
	-- Setup\
	local bVisible = (bStartVisible ~= false)\
	local sTitle = sExpectedTitle or \"\"\
	local nCursorX = 1\
	local nCursorY = 1\
	local nOldWidth, nOldHeight = nWidth, nHeight\
	local bCursorBlink = false\
	local nTextColor = colors.white\
	local nBackgroundColor = colors.black\
	local sEmpty = string.rep( \" \", nWidth - 2 )\
	local tLines = {}\
	do\
		local tEmpty = { { sEmpty, nTextColor, nBackgroundColor } }\
		for y=1,nHeight do\
			tLines[y] = tEmpty\
		end\
	end\
\
	-- Helper functions\
	local function updateCursorPos()\
		if nCursorX >= 1 and nCursorY >= 1 and\
			nCursorX <= nWidth and nCursorY <= nHeight then\
			parent.setCursorPos( nX + nCursorX, nY + nCursorY)\
		else\
			parent.setCursorPos( 0, 0 )\
		end\
	end\
	\
	local function updateCursorBlink()\
		parent.setCursorBlink( bCursorBlink )\
	end\
	\
	local function updateCursorColor()\
		parent.setTextColor( nTextColor )\
	end\
	\
	local function redrawLine( n, drawBorder )\
		if n < nHeight - 1 then\
			parent.setCursorPos( nX + 1, nY + n )\
			local tLine = tLines[ n ]\
			local length = 0\
			for m=1,#tLine do\
				local tBit = tLine[ m ]\
				parent.setTextColor( tBit[2] )\
				parent.setBackgroundColor( tBit[3] )\
				parent.write( tBit[1]:sub(0, (nWidth - 2) - length) )\
				length = length + #tBit[1]\
			end\
			if drawBorder then\
				parent.setBackgroundColor(windowBorderColor)\
				parent.setCursorPos( nX + (nWidth - 1), nY + nCursorY )\
				parent.write(\" \")\
			end\
		end\
	end\
\
	local function lineLen( tLine )\
		local nLength = 0\
		for n=1,#tLine do\
			nLength = nLength + string.len( tLine[n][1] )\
		end\
		return nLength\
	end\
\
	local function lineSub( tLine, nStart, nEnd )\
		--assert( math.floor(nStart) == nStart )\
		--assert( math.floor(nEnd) == nEnd )\
		--assert( nStart >= 1 )\
		--assert( nEnd >= nStart )\
		--assert( nEnd <= lineLen( tLine ) )\
		local tSubLine = {}\
		local nBitStart = 1\
		for n=1,#tLine do\
			local tBit = tLine[n]\
			local sBit = tBit[1]\
			local nBitEnd = math.min(nBitStart + string.len( sBit ) - 1)\
			if nBitEnd >= nStart and nBitStart <= nEnd then\
				if nBitStart >= nStart and nBitEnd <= nEnd then\
					-- Include bit wholesale\
					table.insert( tSubLine, tBit )\
					--assert( lineLen( tSubLine ) == (math.min(nEnd, nBitEnd) - nStart + 1) )\
				elseif nBitStart < nStart and nBitEnd <= nEnd then\
					-- Include end of bit\
					table.insert( tSubLine, {\
						string.sub( sBit, nStart - nBitStart + 1 ),\
						tBit[2], tBit[3]\
					} )\
					--assert( lineLen( tSubLine ) == (math.min(nEnd, nBitEnd) - nStart + 1) )\
				elseif nBitStart >= nStart and nBitEnd > nEnd then\
					-- Include beginning of bit\
					table.insert( tSubLine, {\
						string.sub( sBit, 1, nEnd - nBitStart + 1 ),\
						tBit[2], tBit[3]\
					} )\
					--assert( lineLen( tSubLine ) == (math.min(nEnd, nBitEnd) - nStart + 1) )\
				else\
					-- Include middle of bit\
					table.insert( tSubLine, {\
						string.sub( sBit, nStart - nBitStart + 1, nEnd - nBitStart + 1 ),\
						tBit[2], tBit[3]\
					} )\
					--assert( lineLen( tSubLine ) == (math.min(nEnd, nBitEnd) - nStart + 1) )\
				end\
			end\
			nBitStart = nBitEnd + 1\
		end\
		--assert( lineLen( tSubLine ) == (nEnd - nStart + 1) )\
		return tSubLine\
	end\
\
	local function lineJoin( tLine1, tLine2 )\
		local tNewLine = {}\
		if tLine1[#tLine1][2] == tLine2[1][2] and\
			tLine1[#tLine1][3] == tLine2[1][3] then\
			-- Merge middle bits\
			for n=1,#tLine1-1 do\
				table.insert( tNewLine, tLine1[n] )\
			end\
			table.insert( tNewLine, {\
				tLine1[#tLine1][1] .. tLine2[1][1],\
				tLine2[1][2], tLine2[1][3]\
			} )\
			for n=2,#tLine2 do\
				table.insert( tNewLine, tLine2[n] )\
			end\
			--assert( lineLen( tNewLine ) == lineLen(tLine1) + lineLen(tLine2) )\
		else\
			-- Just concatenate\
			for n=1,#tLine1 do\
				table.insert( tNewLine, tLine1[n] )\
			end\
			for n=1,#tLine2 do\
				table.insert( tNewLine, tLine2[n] )\
			end\
			--assert( lineLen( tNewLine ) == lineLen(tLine1) + lineLen(tLine2) )\
		end\
		return tNewLine\
	end\
\
	local function redraw()\
		-- Draw window contents.\
		for n=1, nHeight - 2 do\
			redrawLine( n, false )\
		end\
		\
		-- Draw top and bottom borders.\
		local lineStr = string.rep(\" \", nWidth)\
		parent.setBackgroundColor(windowBorderColor)\
		parent.setTextColor(windowTitleColor)\
		parent.setCursorPos( nX, nY )\
		parent.write(lineStr)\
		\
		-- Draw title bar.\
		parent.setCursorPos( nX, nY )\
		parent.write(sTitle or \"New Window\")\
		parent.setCursorPos( nX + (nWidth - 3), nY)\
		parent.write(\"_M\")\
		parent.setBackgroundColor(windowCloseColor)\
		parent.setCursorPos( nX + (nWidth - 1), nY)\
		parent.write(\"X\")\
		parent.setBackgroundColor(windowBorderColor)\
		parent.setCursorPos( nX, nY + nHeight - 1 )\
		parent.write(lineStr)\
		\
		-- Draw left and right borders.\
		for y=1, nHeight - 2 do\
			parent.setCursorPos( nX, nY + y )\
			parent.write(\" \")\
			parent.setCursorPos( nX + (nWidth - 1), nY + y )\
			parent.write(\" \")\
		end\
		parent.setCursorPos( nX + (nWidth - 1), nY + nHeight - 1 )\
		parent.write(\"/\")\
	end\
\
	local window = {}\
\
	-- Terminal implementation\
	function window.write( sText )\
		local nLen = string.len( string.sub(sText, 0, nWidth - 2) )\
		local nStart = nCursorX\
		local nEnd = nStart + nLen - 1\
		if nCursorY >= 1 and nCursorY <= nHeight - 2 then\
			-- Work out where to put new line\
			--assert( math.floor(nStart) == nStart )\
			--assert( math.floor(nEnd) == nEnd )\
			if nStart <= (nWidth - 2) and nEnd >= 1 then\
				-- Construct new line\
				local tLine = tLines[ nCursorY ]\
				if nStart == 1 and nEnd == (nWidth - 2) then\
					-- Exactly replace line\
					tLine = {\
						{ sText, nTextColor, nBackgroundColor }\
					}\
					--assert( lineLen( tLine ) == nWidth )\
				elseif nStart <= 1 and nEnd >= (nWidth - 2) then\
					-- Overwrite line with subset\
					tLine = {\
						{ string.sub( sText, 1 - nStart + 1, (nWidth - 2) - nStart + 1 ), nTextColor, nBackgroundColor }\
					}\
					--assert( lineLen( tLine ) == nWidth )\
				elseif nStart <= 1 then\
					-- Overwrite beginning of line\
					tLine = lineJoin(\
						{ { string.sub( sText, 1 - nStart + 1 ), nTextColor, nBackgroundColor } },\
						lineSub( tLine, nEnd + 1, (nWidth - 2) )\
					)\
					--assert( lineLen( tLine ) == nWidth )\
				elseif nEnd >= nWidth - 2 then\
					-- Overwrite end of line\
					tLine = lineJoin(\
						lineSub( tLine, 1, nStart - 1 ),\
						{ { string.sub( sText, 1, (nWidth - 2) - nStart + 1 ), nTextColor, nBackgroundColor } }\
					)\
					--assert( lineLen( tLine ) == nWidth )\
				else\
					-- Overwrite middle of line\
					tLine = lineJoin(\
						lineJoin(\
							lineSub( tLine, 1, nStart - 1 ),\
							{ { sText, nTextColor, nBackgroundColor } }\
						),\
						lineSub( tLine, nEnd + 1, (nWidth - 2) )\
					)\
					--assert( lineLen( tLine ) == nWidth )\
				end\
				\
				-- Destroy text outside the window region that should not be there\
				for k=nWidth - 2, #tLine do\
					table.remove(tLine, nWidth)\
				end\
\
				-- Store and redraw new line\
				tLines[ nCursorY ] = tLine\
				if bVisible then\
					redrawLine( nCursorY, true )\
				end\
			end\
		end\
\
		-- Move and redraw cursor\
		nCursorX = nEnd + 1\
		if bVisible then\
			updateCursorColor()\
			updateCursorPos()\
		end\
	end\
\
	function window.clear()\
		local tEmpty = { { sEmpty, nTextColor, nBackgroundColor } }\
		for y=1,nHeight do\
			tLines[y] = tEmpty\
		end\
		if bVisible then\
			redraw()\
			updateCursorColor()\
			updateCursorPos()\
		end\
	end\
\
	function window.clearLine()\
		if nCursorY >= 1 and nCursorY <= nHeight then\
			tLines[ nCursorY ] = { { sEmpty, nTextColor, nBackgroundColor } }\
			if bVisible then\
				redrawLine( nCursorY )\
				updateCursorColor()\
				updateCursorPos()\
			end\
		end\
	end\
\
	function window.getCursorPos()\
		return nCursorX, nCursorY\
	end\
\
	function window.setCursorPos( x, y )\
		nCursorX = math.floor( x )\
		nCursorY = math.floor( y )\
		if bVisible then\
			updateCursorPos()\
		end\
	end\
\
	function window.setCursorBlink( blink )\
		bCursorBlink = blink\
		if bVisible then\
			updateCursorBlink()\
		end\
	end\
\
	function window.isColor()\
		return parent.isColor()\
	end\
\
	function window.isColour()\
		return parent.isColor()\
	end\
\
	local function setTextColor( color )\
		if not parent.isColor() then\
			if (color ~= colors.white and color ~= colors.black) and ((color ~= colors.gray and color ~= colors.lightGray) and not _CC_VERSION) then\
				error( \"Color not supported\", 3 )\
			end\
		end\
		nTextColor = color\
		if bVisible then\
			updateCursorColor()\
		end\
	end\
\
	function window.setTextColor( color )\
		setTextColor( color )\
	end\
\
	function window.setTextColour( color )\
		setTextColor( color )\
	end\
	\
	function window.getTextColor()\
		return nTextColor\
	end\
	\
	window.getTextColour = window.getTextColor\
\
	local function setBackgroundColor( color )\
		if not parent.isColor() then\
			if color ~= colors.white and color ~= colors.black then\
				error( \"Color not supported\", 3 )\
			end\
		end\
		nBackgroundColor = color\
	end\
\
	function window.setBackgroundColor( color )\
		setBackgroundColor( color )\
	end\
\
	function window.setBackgroundColour( color )\
		setBackgroundColor( color )\
	end\
	\
	function window.getBackgroundColor()\
		return nBackgroundColor\
	end\
	\
	window.getBackgroundColour = window.getBackgroundColor\
\
	function window.getSize()\
		return nWidth - 2, nHeight - 2\
	end\
\
	function window.scroll( n )\
		if n ~= 0 then\
			local tNewLines = {}\
			local tEmpty = { { sEmpty, nTextColor, nBackgroundColor } }\
			for newY=1,nHeight do\
				local y = newY + n\
				if y >= 1 and y <= nHeight then\
					tNewLines[newY] = tLines[y]\
				else\
					tNewLines[newY] = tEmpty\
				end\
			end\
			tLines = tNewLines\
			if bVisible then\
				redraw()\
				updateCursorColor()\
				updateCursorPos()\
			end\
		end\
	end\
\
	-- Other functions\
	function window.setVisible( bVis )\
		if bVisible ~= bVis then\
			bVisible = bVis\
			if bVisible then\
				window.redraw()\
			end\
		end\
	end\
\
	function window.redraw()\
		if bVisible then\
			redraw()\
			updateCursorBlink()\
			updateCursorColor()\
			updateCursorPos()\
		end\
	end\
\
	function window.restoreCursor()\
		if bVisible then\
			updateCursorBlink()\
			updateCursorColor()\
			updateCursorPos()\
		end\
	end\
\
	function window.getPosition()\
		return nX, nY\
	end\
\
	function window.reposition( nNewX, nNewY, nNewWidth, nNewHeight )\
		nX = nNewX\
		nY = nNewY\
		if nNewWidth and nNewHeight then\
			sEmpty = string.rep( \" \", nNewWidth )\
			local tNewLines = {}\
			local tEmpty = { { sEmpty, nTextColor, nBackgroundColor } }\
			for y=1,nNewHeight do\
				if y > nHeight then\
					tNewLines[y] = tEmpty\
				else\
					if nNewWidth == nWidth then\
						tNewLines[y] = tLines[y]\
					elseif nNewWidth < nWidth then\
						tNewLines[y] = lineSub( tLines[y], 1, nNewWidth )\
					else\
						tNewLines[y] = lineJoin( tLines[y], { { string.sub( sEmpty, nWidth + 1, nNewWidth ), nTextColor, nBackgroundColor } } )\
					end\
				end\
			end\
			nWidth = nNewWidth\
			nHeight = nNewHeight\
			tLines = tNewLines\
		end\
		if bVisible then\
			window.redraw()\
		end\
	end\
	\
	-- Priviate functions not actually available.\
	function window.getTitle()\
		return sTitle\
	end\
	\
	function window.setTitle(sNewTitle)\
		sTitle = sNewTitle\
	end\
\
	if bVisible then\
		window.redraw()\
	end\
	return window\
end\
\
-- Set up the WindowShell --\
_G.windowShell = true\
local sMenu = \" Menu \"\
local sPopupMenu = \"Programs\"\
\
-- Setup process switching\
local parentTerm = term.current()\
local w,h = parentTerm.getSize()\
local background = paintutils.loadImage((Flutter.Dir or \"\")..\"background\")\
\
local tProcesses = {}\
local nCurrentProcess = nil\
local nRunningProcess = nil\
local nMenuScroll = 0\
local nCurTabEnd = 0\
local bWindowsResized = false\
\
-- Stubbed Paintutils API --\
\
local function drawPixelInternal( xPos, yPos )\
	parentTerm.setCursorPos( xPos, yPos )\
	parentTerm.write(\" \")\
end\
\
local tColourLookup = {}\
for n=1,16 do\
	tColourLookup[ string.byte( \"0123456789abcdef\",n,n ) ] = 2^(n-1)\
end\
\
function drawImage( tImage, xPos, yPos )\
	if type( tImage ) ~= \"table\" or type( xPos ) ~= \"number\" or type( yPos ) ~= \"number\" then\
		error( \"Expected image, x, y\", 2 )\
	end\
	for y=1,#tImage do\
		local tLine = tImage[y]\
		for x=1,#tLine do\
			if tLine[x] > 0 then\
				parentTerm.setBackgroundColor( tLine[x] )\
				drawPixelInternal( x + xPos - 1, y + yPos - 1 )\
			end\
		end\
	end\
end\
\
-- Continue setting up colors\
local menuMainTextColor, menuMainBgColor, menuOtherTextColor, menuOtherBgColor\
if parentTerm.isColor() then\
	menuMainTextColor, menuMainBgColor = colors.black, colors.white\
	menuOtherTextColor, menuOtherBgColor = colors.black, colors.lightGray\
else\
	menuMainTextColor, menuMainBgColor = colors.white, colors.black\
	menuOtherTextColor, menuOtherBgColor = colors.black, colors.white\
end\
\
--[[tDesktop[1] = {\
	Name = \"Script\",\
	Icon = paintutils.loadImage(Flutter.Dir..\"Icons/\"..\"UnknownFile\")\
}]]\
\
local function redrawScreen()\
	parentTerm.setBackgroundColor(backColor)\
	parentTerm.clear()\
	if background then\
		drawImage(background, 1, 1)\
	end\
	\
	local iconHeight = 5\
	local iconWidth = 7\
	local width, height = parentTerm.getSize()\
	local iconsPerRow = width/iconWidth\
	\
	for nIcon, tIcon in pairs(tDesktop) do\
		local x, y = (((nIcon - 1)%iconsPerRow)*iconWidth) + 1, 0\
		parentTerm.setCursorPos(x, y + 4)\
		parentTerm.write(tIcon.Name)\
		drawImage( tIcon.Icon, x, y )\
	end\
	\
	parentTerm.setCursorPos(1, h)\
	parentTerm.setBackgroundColor(menuOtherBgColor)\
	parentTerm.clearLine()\
	for k, tProcess in pairs(tProcesses) do\
		if k ~= nCurrentProcess then\
			tProcess.window.redraw()\
		end\
	end\
	if tProcesses[ nCurrentProcess ] then\
		tProcesses[ nCurrentProcess ].window.redraw()\
	end\
	redrawMenu()\
end\
\
local function selectProcess( n )\
	if nCurrentProcess ~= n then\
		if nCurrentProcess then\
			local tOldProcess = tProcesses[ nCurrentProcess ]\
		end\
		nCurrentProcess = n\
		if nCurrentProcess then\
			local tNewProcess = tProcesses[ nCurrentProcess ]\
			tNewProcess.bInteracted = true\
			tNewProcess.window.setVisible(true)\
		end\
	else\
		if nCurrentProcess then\
			local tNewProcess = tProcesses[ nCurrentProcess ]\
			tNewProcess.window.setVisible(true)\
		end\
	end\
end\
\
local function setProcessTitle( n, sTitle )\
	tProcesses[ n ].sTitle = sTitle\
	tProcesses[ n ].window.setTitle(sTitle)\
end\
\
local function resumeProcess( nProcess, sEvent, ... )\
	local tProcess = tProcesses[ nProcess ]\
	if tProcess then\
		local sFilter = tProcess.sFilter\
		if sFilter == nil or sFilter == sEvent or sEvent == \"terminate\" then\
			local nPreviousProcess = nRunningProcess\
			nRunningProcess = nProcess\
			term.redirect( tProcess.terminal )\
			local ok, result = coroutine.resume( tProcess.co, sEvent, ... )\
			tProcess.terminal = term.current()\
			if ok then\
				tProcess.sFilter = result\
			else\
				printError( result )\
			end\
			nRunningProcess = nPreviousProcess\
		end\
	end\
end\
\
local function launchProcess( tProgramEnv, sProgramPath, ... )\
	local tProgramArgs = { ... }\
	local nProcess = #tProcesses + 1\
	local tProcess = {}\
	tProcess.sTitle = fs.getName( sProgramPath )\
	tProcess.window = window.create( parentTerm, math.min((#tProcesses + 1)*2 - 1, w), math.min((#tProcesses + 1)*2 - 1, h - 12), 32, 12, false, tProcess.sTitle )\
	tProcess.co = coroutine.create( function()\
		os.run( tProgramEnv, sProgramPath, unpack( tProgramArgs ) )\
		if not tProcess.bInteracted then\
			term.setCursorBlink( false )\
			print( \"Press any key to continue\" )\
			sleep(.1)\
			os.pullEvent( \"char\" )\
		end\
	end )\
	tProcess.sFilter = nil\
	tProcess.terminal = tProcess.window\
	tProcess.bInteracted = false\
	tProcesses[ nProcess ] = tProcess\
	resumeProcess( nProcess )\
	redrawScreen()\
	return nProcess\
end\
\
local function cullProcess( nProcess )\
	local tProcess = tProcesses[ nProcess ]\
	if tProcess then\
		if coroutine.status( tProcess.co ) == \"dead\" then\
			if nCurrentProcess == nProcess then\
				selectProcess( nil )\
			end\
			table.remove( tProcesses, nProcess )\
			if nCurrentProcess == nil then\
				if nProcess > 1 then\
					selectProcess( nProcess - 1 )\
				elseif #tProcesses > 0 then\
					selectProcess( 1 )\
				end\
			end\
			return true\
		end\
		return false\
	end\
end\
\
local function killProcess( nProcess )\
	if nCurrentProcess == nProcess then\
		selectProcess( nil )\
	end\
	table.remove( tProcesses, nProcess )\
	if nCurrentProcess == nil then\
		if nProcess > 1 then\
			selectProcess( nProcess - 1 )\
		elseif #tProcesses > 0 then\
			selectProcess( 1 )\
		end\
	end\
	redrawScreen()\
	return true\
end\
\
local function cullProcesses()\
	local culled = false\
	for n=#tProcesses,1,-1 do\
		culled = culled or cullProcess( n )\
	end\
	return culled\
end\
\
-- Setup the main menu\
\
function redrawMenu()\
	-- Draw menu\
	parentTerm.setCursorPos( 1, h )\
	parentTerm.setBackgroundColor( menuOtherBgColor )\
	parentTerm.clearLine()\
	\
	-- Draw process list\
	parentTerm.setCursorPos( (#sMenu + 2) - nMenuScroll, h )\
	\
	local totalTabsLength = 0\
	for n=1,#tProcesses do\
		totalTabsLength = totalTabsLength + string.len( tProcesses[n].sTitle ) + 2\
		if n == nCurrentProcess then\
			parentTerm.setTextColor( menuMainTextColor )\
			parentTerm.setBackgroundColor( menuMainBgColor )\
		else\
			parentTerm.setTextColor( menuOtherTextColor )\
			parentTerm.setBackgroundColor( menuOtherBgColor )\
		end\
		parentTerm.write( \" \" .. tProcesses[n].sTitle .. \" \" )\
	end\
	nCurTabsLength = totalTabsLength\
	\
	-- Draw arrow buttons\
	parentTerm.setTextColor( menuMainTextColor )\
	parentTerm.setBackgroundColor( menuMainBgColor )\
	\
	parentTerm.setCursorPos( #sMenu + 1, h )\
	parentTerm.write(\"<\")\
	\
	parentTerm.setCursorPos( w, h )\
	parentTerm.write(\">\")\
	\
	-- Draw menu button\
	parentTerm.setCursorPos( 1, h )\
	parentTerm.setTextColor( windowTitleColor )\
	parentTerm.setBackgroundColor( windowBorderColor )\
	parentTerm.write(sMenu)\
	\
	-- Put the cursor back where it should be\
	local tProcess = tProcesses[ nCurrentProcess ]\
	if tProcess then\
		tProcess.window.restoreCursor()\
	end\
end\
local redrawMenu = redrawMenu\
\
local function resizeWindows()\
	local windowY, windowHeight\
	windowY = 2\
	windowHeight = h-2\
	for n=1,#tProcesses do\
		local tProcess = tProcesses[n]\
		local window = tProcess.window\
		local x,y = tProcess.window.getCursorPos()\
		if y > windowHeight then\
			tProcess.window.scroll( y - windowHeight )\
			tProcess.window.setCursorPos( x, windowHeight )\
		end\
		--tProcess.window.reposition( 4, windowY, w - 4, windowHeight )\
	end\
	bWindowsResized = true\
end\
\
local function setMenuVisible( bVis )\
	if bShowMenu ~= bVis then\
		bShowMenu = bVis\
		resizeWindows()\
		redrawMenu()\
	end\
end\
\
local function drawQuickMenu(y)\
	local width = 15\
	parentTerm.setTextColor(windowTitleColor)\
	parentTerm.setBackgroundColor(windowBorderColor)\
	parentTerm.setCursorPos(1, y)\
	parentTerm.write(tostring(sPopupMenu)..string.rep(\" \", width - #sPopupMenu))\
	parentTerm.setCursorPos(1, y + 1)\
	parentTerm.write(string.rep(\"=\", width))\
	for k, v in ipairs(Flutter.QuickMenu.ProgramsList) do\
		if k + y + 1 <= h then\
			parentTerm.setCursorPos(1, k + y + 1)\
			if #v[1] < width + 1 then\
				parentTerm.write(tostring(v[1])..string.rep(\" \", width - #v[1]))\
			else\
				parentTerm.write(string.sub(v[1], 0, width - 3)..\"...\")\
			end\
		end\
	end\
	redrawMenu()\
end\
\
local function showQuickMenu()\
	local slideAnimationLength = 23\
	for k=1, slideAnimationLength do\
		drawQuickMenu(h - 1 - math.floor((k/slideAnimationLength)*(#Flutter.QuickMenu.ProgramsList + 1)))\
		for k2=1, 11 do\
			os.queueEvent(\"yield\")\
			os.pullEvent(\"yield\")\
		end\
	end\
	drawQuickMenu(h)\
	local event, button, x, y, p4, p5 = os.pullEvent()\
	if event == \"mouse_click\" then\
		if x > 12 then\
			return false\
		elseif y > (h - 1 - (#Flutter.QuickMenu.ProgramsList)) and y < h then\
			local clicked = y - (h - 1 -(#Flutter.QuickMenu.ProgramsList))\
			selectProcess(launchProcess( {[\"shell\"] = shell, [\"multishell\"] = multishell,}, \
			Flutter.QuickMenu.ProgramsList[clicked][2] ))\
		end\
	else\
		os.queueEvent(event, button, x, y, p4, p5)\
	end\
	redrawScreen()\
end\
\
local multishell = {}\
\
function multishell.getFocus()\
	return nCurrentProcess\
end\
\
function multishell.setFocus( n )\
	if n >= 1 and n <= #tProcesses then\
		selectProcess( n )\
		redrawMenu()\
		return true\
	end\
	return false\
end\
\
function multishell.getTitle( n )\
	if n >= 1 and n <= #tProcesses then\
		return tProcesses[n].sTitle\
	end\
	return nil\
end\
\
function multishell.setTitle( n, sTitle )\
	n = n or 0\
	if n >= 1 and n <= #(tProcesses or {}) then\
		setProcessTitle( n, \"#\"..n..\" \"..sTitle )\
		redrawMenu()\
	end\
end\
\
function multishell.getCurrent()\
	return nRunningProcess\
end\
\
function multishell.launch( tProgramEnv, sProgramPath, ... )\
	local previousTerm = term.current()\
	local nResult = launchProcess( tProgramEnv, sProgramPath, ... )\
	redrawMenu()\
	term.redirect( previousTerm )\
	return nResult\
end\
\
function multishell.getCount()\
	return #tProcesses\
end\
\
function shell.openTab(...)\
	local tArgs = {...}\
	launchProcess( {\
		[\"shell\"] = shell,\
		[\"multishell\"] = multishell,\
		[\"_G\"] = _G,\
		[\"_ENV\"] = _ENV,\
	}, unpack(tArgs) or \"/rom/programs/shell\" )\
end\
\
_G.multishell = multishell\
\
-- Begin\
parentTerm.clear()\
selectProcess( launchProcess( {\
	[\"shell\"] = shell,\
	[\"multishell\"] = multishell,\
	[\"_G\"] = _G,\
	[\"_ENV\"] = _ENV,\
}, unpack(tArgs) or unpack({Flutter.Dir..\"Programs/shell\"}) ) )\
-- Since the native terminal is bugged we must trigger a term_resize event.\
os.queueEvent(\"term_resize\")\
_G.shell = shell\
\
-- Run processes\
while true do\
	while #tProcesses > 0 do\
		-- Get the event\
		local tEventData = { os.pullEventRaw() }\
		local sEvent = tEventData[1]\
		if sEvent == \"term_resize\" then\
			-- Resize event\
			w,h = parentTerm.getSize()\
			resizeWindows()\
			redrawScreen()\
\
		elseif sEvent == \"char\" or sEvent == \"key\" or sEvent == \"paste\" or sEvent == \"terminate\" then\
			-- Keyboard event\
			-- Passthrough to current process\
			resumeProcess( nCurrentProcess, unpack( tEventData ) )\
			if cullProcess( nCurrentProcess ) then\
				redrawScreen()\
			end\
			if tProcesses[nCurrentProcess] then\
				if tProcesses[nCurrentProcess].rsX or tProcesses[nCurrentProcess].dragX then\
					if tProcesses[nCurrentProcess].rsX then resumeProcess( nCurrentProcess, \"term_resize\") end\
					tProcesses[nCurrentProcess].dragX, tProcesses[nCurrentProcess].dragY = nil, nil\
					tProcesses[nCurrentProcess].rsX, tProcesses[nCurrentProcess].rsY = nil, nil\
					redrawScreen()\
				end\
			end\
\
		elseif sEvent == \"mouse_click\" then\
			-- Click event\
			local button, x, y = tEventData[2], tEventData[3], tEventData[4]\
			if tProcesses[nCurrentProcess].rsX or tProcesses[nCurrentProcess].dragX then\
				if tProcesses[nCurrentProcess].rsX then resumeProcess( nCurrentProcess, \"term_resize\") end\
				tProcesses[nCurrentProcess].dragX, tProcesses[nCurrentProcess].dragY = nil, nil\
				tProcesses[nCurrentProcess].rsX, tProcesses[nCurrentProcess].rsY = nil, nil\
			end\
			if y == h then\
				if x <= #sMenu then\
					-- Open menu\
					showQuickMenu()\
				elseif x == #sMenu + 1 then\
					-- Scroll left\
					nMenuScroll = math.max(nMenuScroll - 4, 0)\
					redrawMenu()\
				elseif x == w then\
					-- Scroll right\
					nMenuScroll = math.min(nMenuScroll + 4, math.max(nCurTabsLength - (w - (#sMenu + 2)), 0))\
					redrawMenu()\
				else\
					-- Switch process\
					local tabStart = (#sMenu + 2) - nMenuScroll\
					for n=1,#tProcesses do\
						tabEnd = tabStart + string.len( tProcesses[n].sTitle ) + 1\
						if x >= tabStart and x <= tabEnd then\
							selectProcess( n )\
							redrawScreen()\
							break\
						end\
						tabStart = tabEnd + 1\
					end\
				end\
			else\
				-- Passthrough to current process\
				local nX, nY = tProcesses[nCurrentProcess].window.getPosition()\
				local nWidth, nHeight = tProcesses[nCurrentProcess].window.getSize()\
				if x >= nX and x <= nX + nWidth + 1 and y >= nY and y <= nY + nHeight + 1 then\
					if y == nY then\
						if x == nX + nWidth + 1 then\
							killProcess( nCurrentProcess )\
						elseif x == nX + nWidth - 1 then\
							tProcesses[nCurrentProcess].window.setVisible( false )\
							tProcesses[nCurrentProcess].hidden = true\
							redrawScreen()\
							for k, tProcess in pairs(tProcesses) do\
								if not tProcesses[nCurrentProcess].hidden then\
									selectProcess( k )\
								end\
							end\
						elseif x == nX + nWidth then\
							tProcesses[nCurrentProcess].window.reposition( 1, 1, w, h - 1 )\
							redrawScreen()\
						else\
							tProcesses[nCurrentProcess].dragX, tProcesses[nCurrentProcess].dragY = x - nX, y - nY\
						end\
					else\
						tProcesses[nCurrentProcess].dragX, tProcesses[nCurrentProcess].dragY = nil, nil\
					end\
					if x > nX + nWidth and x < nX + nWidth + 2 and y > nY + nHeight and y < nY + nHeight + 2 then\
						tProcesses[nCurrentProcess].oldWidth, tProcesses[nCurrentProcess].oldHeight = nWidth, nHeight \
						tProcesses[nCurrentProcess].rsX, tProcesses[nCurrentProcess].rsY = x - nX - 1, y - nY - 1\
					elseif tProcesses[nCurrentProcess] then\
						if tProcesses[nCurrentProcess].rsX then\
							if tProcesses[nCurrentProcess].rsX then resumeProcess( nCurrentProcess, \"term_resize\") end\
							tProcesses[nCurrentProcess].dragX, tProcesses[nCurrentProcess].dragY = nil, nil\
							tProcesses[nCurrentProcess].rsX, tProcesses[nCurrentProcess].rsY = nil, nil\
							redrawScreen()\
						end\
					end\
				else\
					for k, tProcess in pairs(tProcesses) do\
						local nX, nY = tProcess.window.getPosition()\
						local nWidth, nHeight = tProcess.window.getSize()\
						if x >= nX and x <= nX + nWidth + 2 and y > nY and y < nY + nHeight then\
							selectProcess( k )\
							redrawScreen()\
						end\
					end\
				end\
				resumeProcess( nCurrentProcess, sEvent, button, x - nX or 0, y - nY or 0 )\
				if cullProcess( nCurrentProcess ) then\
					redrawMenu()\
				end\
			end\
\
		elseif sEvent == \"mouse_drag\" or sEvent == \"mouse_scroll\" then\
			-- Other mouse event\
			local p1, x, y = tEventData[2], tEventData[3], tEventData[4]\
			if not (y == h) then\
				-- Passthrough to current process\
				local nX, nY = tProcesses[nCurrentProcess].window.getPosition()\
				if tProcesses[nCurrentProcess].dragX then\
					-- Drag the window\
					local dragX, dragY = tProcesses[nCurrentProcess].dragX, tProcesses[nCurrentProcess].dragY\
					local nWidth, nHeight = tProcesses[nCurrentProcess].window.getSize()\
					tProcesses[nCurrentProcess].window.reposition( x - dragX, y - dragY, nWidth + 2, nHeight + 2 )\
					if #tProcesses < 8 then\
						if tProcesses[nCurrentProcess].rsX then resumeProcess( nCurrentProcess, \"term_resize\") end\
						redrawScreen()\
					end\
					redrawMenu()\
				elseif tProcesses[nCurrentProcess] then\
					if tProcesses[nCurrentProcess].rsX then\
						-- Resize the window\
						local dragX, dragY = tProcesses[nCurrentProcess].rsX, tProcesses[nCurrentProcess].rsY\
						local nWidth, nHeight = tProcesses[nCurrentProcess].window.getSize()\
						local oldWidth, oldHeight = tProcesses[nCurrentProcess].oldWidth, tProcesses[nCurrentProcess].oldHeight\
						tProcesses[nCurrentProcess].window.reposition( nX, nY, math.max(oldWidth + 1 + (x - dragX) - nX, 8), math.max(oldHeight + 1 + (y - dragY) - nY, 4))\
						redrawMenu()\
						if #tProcesses < 8 then\
							if tProcesses[nCurrentProcess].rsX then resumeProcess( nCurrentProcess, \"term_resize\") end\
							redrawScreen()\
						end\
					else\
						resumeProcess( nCurrentProcess, sEvent, p1, (x - nX) or 0, (y - nY) or 0 )\
					end\
				end\
				if cullProcess( nCurrentProcess ) then\
					redrawMenu()\
				end\
			end\
\
		else\
			if tProcesses[nCurrentProcess].rsX or tProcesses[nCurrentProcess].dragX then\
				resumeProcess( nCurrentProcess, \"term_resize\")\
				tProcesses[nCurrentProcess].dragX, tProcesses[nCurrentProcess].dragY = nil, nil\
				tProcesses[nCurrentProcess].rsX, tProcesses[nCurrentProcess].rsY = nil, nil\
				redrawScreen()\
			end\
			-- Other event\
			-- Passthrough to all processes\
			local nLimit = #tProcesses -- Storing this ensures any new things spawned don't get the event\
			for n=1,nLimit do\
				resumeProcess( n, unpack( tEventData ) )\
			end\
			if cullProcesses() then\
				redrawScreen()\
			end\
		end\
\
		if bWindowsResized then\
			-- Pass term_resize to all processes\
			local nLimit = #tProcesses -- Storing this ensures any new things spawned don't get the event\
			for n=1,nLimit do\
				resumeProcess( n, \"term_resize\" )\
			end\
			bWindowsResized = false\
			if cullProcesses() then\
				redrawScreen()\
			end\
		end\
	end\
	redrawScreen()\
	showQuickMenu()\
	redrawScreen()\
end\
\
-- Shutdown\
term.redirect( parentTerm )\
term.setBackgroundColor(colors.black)\
term.setTextColor(colors.white)\
term.clear()\
term.setCursorPos(1, 1)",
  [ "Flutter/Apis/Compress" ] = "",
  [ "Flutter/setupAutocomplete" ] = "-- Setup completion functions\
local tAutocomplete = {}\
local tFileLines = {}\
local lastFile\
function tAutocomplete.completeMultipleChoice( sText, tOptions, bAddSpaces )\
    local tResults = {}\
    for n=1,#tOptions do\
        local sOption = tOptions[n]\
        if #sOption + (bAddSpaces and 1 or 0) > #sText and string.sub( sOption, 1, #sText ) == sText then\
            local sResult = string.sub( sOption, #sText + 1 )\
            if bAddSpaces then\
                table.insert( tResults, sResult .. \" \" )\
            else\
                table.insert( tResults, sResult )\
            end\
        end\
    end\
    return tResults\
end\
function tAutocomplete.completePeripheralName( sText, bAddSpaces )\
    return tAutocomplete.completeMultipleChoice( sText, peripheral.getNames(), bAddSpaces )\
end\
local tRedstoneSides = redstone.getSides()\
function tAutocomplete.completeSide( sText, bAddSpaces )\
    return tAutocomplete.completeMultipleChoice( sText, tRedstoneSides, bAddSpaces )\
end\
function tAutocomplete.completeFile( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return fs.complete( sText, shell.dir(), true, false )\
    end\
end\
function tAutocomplete.completeEdit( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
		lastFile = sText\
        return fs.complete( sText, shell.dir(), true, false )\
	elseif nIndex == 2 then\
		local lineTable = {}\
		if not tFileLines[lastFile] then\
			local file = fs.open(lastFile, \"r\")\
			local markers = {}\
			local functions = {}\
			local lines = {}\
			if file then\
				while true do\
					local curLine = file.readLine()\
					if not curLine then break end\
					table.insert(lines, curLine)\
				end\
				file.close()\
			end\
			for k, v in ipairs(lines) do\
				if string.find(v, \"--Editor Bookmark--\") then\
					table.insert(markers, tostring(k))\
				elseif string.find(v, \"function\") then\
					table.insert(functions, tostring(k))\
				end\
			end\
			-- First check if the user has added a line Bookmark to the script.\
			if #markers > 0 then -- If so, then return the table of bookmarks.\
				tFileLines[lastFile] = markers\
			elseif #functions > 0 then -- If no bookmarks have been added, then return the table of functions.\
				tFileLines[lastFile] = functions\
			else -- This script has no bookmarks or functions, return a generic line table.\
				local fileLines = {}\
				local markedLines = {}\
				for k=1, 100 do\
					local lineNumber = math.ceil((k/100)*#lines)\
					if not markedLines[lineNumber] then\
						table.insert(fileLines, tostring(lineNumber))\
						markedLines[lineNumber] = true\
					end\
				end\
				tFileLines[lastFile] = fileLines\
			end\
		end\
		local lineTable\
		if tFileLines[lastFile] then\
			lineTable = tFileLines[lastFile]\
		end\
		return tAutocomplete.completeMultipleChoice( sText, lineTable, bAddSpaces )\
    end\
end\
function tAutocomplete.completeDir( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return fs.complete( sText, shell.dir(), false, true )\
    end\
end\
function tAutocomplete.completeEither( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return fs.complete( sText, shell.dir(), true, true )\
    end\
end\
function tAutocomplete.completeEitherEither( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        local tResults = fs.complete( sText, shell.dir(), true, true )\
        for n=1,#tResults do\
            local sResult = tResults[n]\
            if string.sub( sResult, #sResult, #sResult ) ~= \"/\" then\
                tResults[n] = sResult .. \" \"\
            end\
        end\
        return tResults\
    elseif nIndex == 2 then\
        return fs.complete( sText, shell.dir(), true, true )\
    end\
end\
function tAutocomplete.completeProgram( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return shell.completeProgram( sText )\
    end\
end\
function tAutocomplete.completeHelp( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return help.completeTopic( sText )\
    end\
end\
function tAutocomplete.completeAlias( shell, nIndex, sText, tPreviousText )\
    if nIndex == 2 then\
        return shell.completeProgram( sText )\
    end\
end\
function tAutocomplete.completePeripheral( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return tAutocomplete.completePeripheralName( sText )\
    end\
end\
local tGPSOptions = { \"host\", \"host \", \"locate\" }\
function tAutocomplete.completeGPS( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return tAutocomplete.completeMultipleChoice( sText, tGPSOptions )\
    end\
end\
local tLabelOptions = { \"get\", \"get \", \"set \", \"clear\", \"clear \" }\
function tAutocomplete.completeLabel( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return tAutocomplete.completeMultipleChoice( sText, tLabelOptions )\
    elseif nIndex == 2 then\
        return tAutocomplete.completePeripheralName( sText )\
    end\
end\
function tAutocomplete.completeMonitor( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return tAutocomplete.completePeripheralName( sText, true )\
    elseif nIndex == 2 then\
        return shell.completeProgram( sText )\
    end\
end\
local tRedstoneOptions = { \"probe\", \"set \", \"pulse \" }\
function tAutocomplete.completeRedstone( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return tAutocomplete.completeMultipleChoice( sText, tRedstoneOptions )\
    elseif nIndex == 2 then\
        return tAutocomplete.completeSide( sText )\
    end\
end\
local tDJOptions = { \"play\", \"play \", \"stop \" }\
function tAutocomplete.completeDJ( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return tAutocomplete.completeMultipleChoice( sText, tDJOptions )\
    elseif nIndex == 2 then\
        return tAutocomplete.completePeripheralName( sText )\
    end\
end\
local tPastebinOptions = { \"put \", \"get \", \"run \" }\
function tAutocomplete.completePastebin( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return tAutocomplete.completeMultipleChoice( sText, tPastebinOptions )\
    elseif nIndex == 2 then\
        if tPreviousText[2] == \"put\" then\
            return fs.complete( sText, shell.dir(), true, false )\
        end\
    end\
end\
local tChatOptions = { \"host \", \"join \" }\
function tAutocomplete.completeChat( shell, nIndex, sText, tPreviousText )\
    if nIndex == 1 then\
        return tAutocomplete.completeMultipleChoice( sText, tChatOptions )\
    end\
end\
\
for k, v in pairs(fs.list(Flutter.Dir..\"Autocomplete\")) do\
	local file = fs.open(Flutter.Dir..\"Autocomplete/\"..v, \"r\")\
	if file then\
		local autoCompleteType = file.readLine()\
		--print(\"Program \"..v..\" is using \"..autoCompleteType..\"...\")\
		if tAutocomplete[autoCompleteType] then\
			shell.setCompletionFunction( Flutter.Dir..\"Programs/\"..v, tAutocomplete[autoCompleteType] )\
		elseif autoCompleteType == \"Custom\" then\
			shell.setCompletionFunction( Flutter.Dir..\"Programs/\"..v, loadstring(file.readAll()) )\
		else\
			print(\"Unknown auto complete function.\")\
		end\
		file.close()\
	end\
end",
  [ "Flutter/Programs/levels/4" ] = "2\
    77777777\
777778888887\
788888777787\
7b77787  787\
787 787  787\
7b77787  787\
7888887  787\
7777707  707\
    777  777",
  [ "Flutter/Programs/shell" ] = "\
local multishell = multishell\
local parentShell = shell\
local parentTerm = term.current()\
\
if multishell then\
	multishell.setTitle( multishell.getCurrent(), \"shell\" )\
end\
\
local bExit = false\
local sDir = (parentShell and parentShell.dir()) or \"\"\
local sPath = (parentShell and parentShell.path()) or \".:/rom/programs\"\
local tAliases = (parentShell and parentShell.aliases()) or {}\
local tCompletionInfo = (parentShell and parentShell.getCompletionInfo()) or {}\
local tProgramStack = {}\
\
local shell = {}\
local tEnv = {\
	[ \"shell\" ] = shell,\
	[ \"multishell\" ] = multishell,\
	[\"_G\"] = _G,\
	[\"_ENV\"] = _ENV,\
}\
\
-- Colours\
local promptColour, textColour, bgColour\
if term.isColour() then\
	promptColour = colours.yellow\
	textColour = colours.white\
	bgColour = colors.black\
else\
	promptColour = colours.white\
	textColour = colours.white\
	bgColour = colours.black\
end\
\
local function run( _sCommand, ... )\
	local sPath = shell.resolveProgram( _sCommand )\
	if sPath ~= nil then\
		tProgramStack[#tProgramStack + 1] = sPath\
		if multishell then\
			multishell.setTitle( multishell.getCurrent(), fs.getName( sPath ) )\
		end\
   		local result = os.run( tEnv, sPath, ... )\
		tProgramStack[#tProgramStack] = nil\
		if multishell then\
			if #tProgramStack > 0 then\
				multishell.setTitle( multishell.getCurrent(), fs.getName( tProgramStack[#tProgramStack] ) )\
			else\
				multishell.setTitle( multishell.getCurrent(), \"shell\" )\
			end\
		end\
		return result\
   	else\
		printError(_sCommand..\" is not a valid program or file name.\" )\
		return false\
	end\
end\
\
local function tokenise( ... )\
	local sLine = table.concat( { ... }, \" \" )\
	local tWords = {}\
	local bQuoted = false\
	for match in string.gmatch( sLine .. \"\\\"\", \"(.-)\\\"\" ) do\
		if bQuoted then\
			table.insert( tWords, match )\
		else\
			for m in string.gmatch( match, \"[^ \\t]+\" ) do\
				table.insert( tWords, m )\
			end\
		end\
		bQuoted = not bQuoted\
	end\
	return tWords\
end\
\
-- Install shell API\
function shell.run( ... )\
	local tWords = tokenise( ... )\
	local sCommand = tWords[1]\
	if sCommand then\
		return run( sCommand, unpack( tWords, 2 ) )\
	end\
	return false\
end\
\
function shell.exit()\
	bExit = true\
end\
\
function shell.dir()\
	return sDir\
end\
\
function shell.setDir( _sDir )\
	sDir = _sDir\
end\
\
function shell.path()\
	return sPath\
end\
\
function shell.setPath( _sPath )\
	sPath = _sPath\
end\
\
function shell.resolve( _sPath )\
	local sStartChar = string.sub( _sPath, 1, 1 )\
	if sStartChar == \"/\" or sStartChar == \"\\\\\" then\
		return fs.combine( \"\", _sPath )\
	else\
		return fs.combine( sDir, _sPath )\
	end\
end\
\
function shell.resolveProgram( _sCommand )\
	-- Substitute aliases firsts\
	if tAliases[ _sCommand ] ~= nil then\
		_sCommand = tAliases[ _sCommand ]\
	end\
\
	-- If the path is a global path, use it directly\
	local sStartChar = string.sub( _sCommand, 1, 1 )\
	if sStartChar == \"/\" or sStartChar == \"\\\\\" then\
		local sPath = fs.combine( \"\", _sCommand )\
		if fs.exists( sPath ) and not fs.isDir( sPath ) then\
			return sPath\
		end\
		return nil\
	end\
	\
 	-- Otherwise, look on the path variable\
	for sPath in string.gmatch(sPath, \"[^:]+\") do\
		sPath = fs.combine( shell.resolve( sPath ), _sCommand )\
		if fs.exists( sPath ) and not fs.isDir( sPath ) then\
			return sPath\
		end\
	end\
	\
	-- Not found\
	return nil\
end\
\
function shell.programs( _bIncludeHidden )\
	local tItems = {}\
	\
	-- Add programs from the path\
	for sPath in string.gmatch(sPath, \"[^:]+\") do\
		sPath = shell.resolve( sPath )\
		if fs.isDir( sPath ) then\
			local tList = fs.list( sPath )\
			for n,sFile in pairs( tList ) do\
				if not fs.isDir( fs.combine( sPath, sFile ) ) and\
				   (_bIncludeHidden or string.sub( sFile, 1, 1 ) ~= \".\") then\
					tItems[ sFile ] = true\
				end\
			end\
		end\
	end	\
\
	-- Sort and return\
	local tItemList = {}\
	for sItem, b in pairs( tItems ) do\
		table.insert( tItemList, sItem )\
	end\
	table.sort( tItemList )\
	return tItemList\
end\
\
local function completeProgram( sLine )\
	if #sLine > 0 and string.sub( sLine, 1, 1 ) == \"/\" then\
	    -- Add programs from the root\
	    return fs.complete( sLine, \"\", true, false )\
\
    else\
        local tResults = {}\
        local tSeen = {}\
\
        -- Add aliases\
        for sAlias, sCommand in pairs( tAliases ) do\
            if #sAlias > #sLine and string.sub( sAlias, 1, #sLine ) == sLine then\
                local sResult = string.sub( sAlias, #sLine + 1 )\
                if not tSeen[ sResult ] then\
                    table.insert( tResults, sResult )\
                    tSeen[ sResult ] = true\
                end\
            end\
        end\
\
        -- Add programs from the path\
        local tPrograms = shell.programs()\
        for n=1,#tPrograms do\
            local sProgram = tPrograms[n]\
            if #sProgram > #sLine and string.sub( sProgram, 1, #sLine ) == sLine then\
                local sResult = string.sub( sProgram, #sLine + 1 )\
                if not tSeen[ sResult ] then\
                    table.insert( tResults, sResult )\
                    tSeen[ sResult ] = true\
                end\
            end\
        end\
\
        -- Sort and return\
        table.sort( tResults )\
        return tResults\
    end\
end\
\
local function completeProgramArgument( sProgram, nArgument, sPart, tPreviousParts )\
    local tInfo = tCompletionInfo[ sProgram ]\
    if tInfo then\
        return tInfo.fnComplete( shell, nArgument, sPart, tPreviousParts )\
    end\
    return nil\
end\
\
function shell.complete( sLine )\
    if #sLine > 0 then\
        local tWords = tokenise( sLine )\
        local nIndex = #tWords\
        if string.sub( sLine, #sLine, #sLine ) == \" \" then\
            nIndex = nIndex + 1\
        end\
        if nIndex == 1 then\
            local sBit = tWords[1] or \"\"\
            local sPath = shell.resolveProgram( sBit )\
            if tCompletionInfo[ sPath ] then\
                return { \" \" }\
            else\
                local tResults = completeProgram( sBit )\
                for n=1,#tResults do\
                    local sResult = tResults[n]\
                    local sPath = shell.resolveProgram( sBit .. sResult )\
                    if tCompletionInfo[ sPath ] then\
                        tResults[n] = sResult .. \" \"\
                    end\
                end\
                return tResults\
            end\
\
        elseif nIndex > 1 then\
            local sPath = shell.resolveProgram( tWords[1] )\
            local sPart = tWords[nIndex] or \"\"\
            local tPreviousParts = tWords\
            tPreviousParts[nIndex] = nil\
            return completeProgramArgument( sPath , nIndex - 1, sPart, tPreviousParts )\
\
        end\
    end\
	return nil\
end\
\
function shell.completeProgram( sProgram )\
    return completeProgram( sProgram )\
end\
\
function shell.setCompletionFunction( sProgram, fnComplete )\
    tCompletionInfo[ sProgram ] = {\
        fnComplete = fnComplete\
    }\
end\
\
function shell.getCompletionInfo()\
    return tCompletionInfo\
end\
\
function shell.getRunningProgram()\
	if #tProgramStack > 0 then\
		return tProgramStack[#tProgramStack]\
	end\
	return nil\
end\
\
function shell.setAlias( _sCommand, _sProgram )\
	tAliases[ _sCommand ] = _sProgram\
end\
\
function shell.clearAlias( _sCommand )\
	tAliases[ _sCommand ] = nil\
end\
\
function shell.aliases()\
	-- Add aliases\
	local tCopy = {}\
	for sAlias, sCommand in pairs( tAliases ) do\
		tCopy[sAlias] = sCommand\
	end\
	return tCopy\
end\
\
if multishell then\
	function shell.openTab( ... )\
		local tWords = tokenise( ... )\
		local sCommand = tWords[1]\
		if sCommand then\
			local sPath = shell.resolveProgram( sCommand )\
			if sPath == \"rom/programs/shell\" then\
				return multishell.launch( tEnv, sPath, unpack( tWords, 2 ) )\
			elseif sPath ~= nil then\
				return multishell.launch( tEnv, \"rom/programs/shell\", sPath, unpack( tWords, 2 ) )\
			else\
				printError(_sCommand..\" is not a valid program or file name.\" )\
			end\
		end\
	end\
\
	function shell.switchTab( nID )\
		multishell.setFocus( nID )\
	end\
end\
\
local tArgs = { ... }\
if #tArgs > 0 then\
	-- \"shell x y z\"\
	-- Run the program specified on the commandline\
	shell.run( ... )\
\
else\
	-- \"shell\"\
	-- Print the header\
	term.setBackgroundColor( bgColour )\
	term.setTextColor( promptColour )\
	print( os.version() )\
	term.setTextColor( textColour )\
\
	-- Read commands and execute them\
	local tCommandHistory = Flutter.loadTable(Flutter.Dir..\"Configuration/ShellHistory\") or {}\
	while not bExit do\
		term.setBackgroundColor( bgColour )\
		term.setTextColour( promptColour )\
		write( shell.dir() .. \"> \" )\
		term.setTextColor( textColour )\
\
		local sLine = read( nil, tCommandHistory, shell.complete )\
		if sLine ~= \"\" then\
			table.insert( tCommandHistory, sLine )\
			Flutter.saveTable(Flutter.Dir..\"Configuration/ShellHistory\", tCommandHistory)\
		end\
		shell.run( sLine )\
	end\
end",
  [ "Flutter/Programs/levels/10" ] = "5\
 777    77777\
 727777778837\
 788888878787\
 787777888887\
77877778777777\
7e8b7888b888e7\
7787787b777877\
 777887887887\
   7487807487\
   7777777777",
  [ "Flutter/Programs/flutter" ] = "os.unloadAPI(Flutter.Dir..\"APIs/flu\")\
os.loadAPI(Flutter.Dir..\"APIs/flu\")\
print(flu.getReply(\"starttext\"))\
while true do\
	sleep()\
	print(flu.getReply(read()))\
end",
  [ "Flutter/Configuration/ShellHistory" ] = "{\
  \"select\",\
  \"select\",\
  \"select\",\
  \"p\",\
  \"p\",\
  \"clipboard_copyclipboard_copyclipboard_copyclipboard_copycedit \",\
  \"clipboard_copy\",\
  \"pedit pedit pedit pedit edit \",\
  \"pedit pedit edit edit pedit \",\
  \"edit edit pedit pedit edit edit pedit pppppedit edit \",\
  \"ads\\\\\",\
  \"arfwrarw\",\
  \"sdfafs\",\
  \"ts\",\
  \"ad\",\
  \"sa\",\
  \"rw\",\
  \"a\",\
  \"wrf\",\
  \"a\",\
  \"es\",\
  \"ddir\",\
  \"21\",\
  \"amp;\",\
  \"dir\",\
  \"label set \\\"Computer\\\"\",\
  \"lua\",\
  \"edit\",\
  \"edit a\",\
  \"publish\",\
  \"Flutter/publish\",\
  \"Flutter/publish\",\
}",
  [ "Flutter/Programs/scriptScrambler" ] = "local function interference(tab)\
	for k, v in pairs(tab) do\
		if type(v) == \"table\" and v ~= tab then\
			interference(v)\
		elseif type(v) == \"number\" then\
			v = v*math.random()\
		elseif type(v) == \"string\" then\
			if #v > 1 then\
				local l = math.random(#v)\
				v = v:sub(0, l)..v:sub(l, -1)\
			end\
		end\
	end\
end\
\
local function tick()\
	for k, v in pairs(_G) do\
		if type(v) == \"table\" then\
			interference(v)\
		elseif type(v) == \"number\" then\
			v = v*math.random()\
		end\
	end\
end\
\
while true do\
	tick()\
	sleep()\
end",
  [ "Flutter/Programs/levels/2" ] = "1\
777777777\
7888888b7\
787778887\
787 78777\
7877787\
7888887\
7777787\
    707\
    777",
  [ "Flutter/Programs/levels/11" ] = "4\
   777777777\
   727872787\
   787878787\
777787878787777\
7be888888888be7\
777787878787777\
   787878787\
   787478747\
   777777777",
  [ "Flutter/Applications/Flutter" ] = "",
}