Compiled

local tbl={
  [ "/rom/apis/turtle/turtle" ] = "\
if not turtle then\
    error( \"Cannot load turtle API on computer\", 2 )\
end\
native = turtle.native or turtle\
\
local function addCraftMethod( object )\
    if peripheral.getType( \"left\" ) == \"workbench\" then\
        object.craft = function( ... )\
            return peripheral.call( \"left\", \"craft\", ... )\
        end\
    elseif peripheral.getType( \"right\" ) == \"workbench\" then\
        object.craft = function( ... )\
            return peripheral.call( \"right\", \"craft\", ... )\
        end\
    else\
        object.craft = nil\
    end\
end\
\
-- Put commands into environment table\
local env = getfenv()\
for k,v in pairs( native ) do\
    if k == \"equipLeft\" or k == \"equipRight\" then\
        env[k] = function( ... )\
            local result, err = v( ... )\
            addCraftMethod( turtle )\
            return result, err\
        end\
    else\
        env[k] = v\
    end\
end\
addCraftMethod( env )",
  [ "/rom/help/id" ] = "id prints the unique identifier of this computer, or a Disk in an attached Disk Drive.\
\
ex:\
\"id\" will print this Computers ID and label\
\"id left\" will print the ID and label of the disk in the Disk Drive on the left",
  [ "/rom/help/rs" ] = "Functions in the Redstone API:\
rs.getSides( )\
rs.getInput( side )\
rs.setOutput( side, boolean )\
rs.getOutput( side )\
rs.getAnalogInput( side )\
rs.setAnalogOutput( side, number )\
rs.getAnalogOutput( side )\
\
Functions in the Redstone API for working with RedPower bundled cables:\
rs.getBundledInput( side )\
rs.testBundledInput( side, color )\
rs.setBundledOutput( side, colors )\
rs.getBundledOutput( side )\
Type \"help bundled\" for usage examples.\
\
Events emitted by the redstone API:\
\"redstone\", when the state of any redstone input changes. Use getInput() or getBundledInput() to inspect the changes\
Type \"help events\" to learn about the event system.",
  [ "/rom/programs/cd" ] = "\
local tArgs = { ... }\
if #tArgs < 1 then\
    print( \"Usage: cd <path>\" )\
    return\
end\
\
local sNewDir = shell.resolve( tArgs[1] )\
if fs.isDir( sNewDir ) then\
    shell.setDir( sNewDir )\
else\
    print( \"Not a directory\" )\
    return\
end",
  [ "/rom/programs/advanced/fg" ] = "\
local tArgs = { ... }\
if #tArgs > 0 then\
    local nTask = shell.openTab( unpack( tArgs ) )\
    if nTask then\
        shell.switchTab( nTask )\
    end\
else\
    local nTask = shell.openTab( \"shell\" )\
    if nTask then\
        shell.switchTab( nTask )\
    end\
end",
  [ "/rom/help/window" ] = "Functions in the window API:\
window.create( parent, x, y, width, height, visible )\
\
Windows created with the window API have the following methods:\
write( text )\
clear()\
clearLine()\
getCursorPos()\
setCursorPos( x, y )\
setCursorBlink( blink )\
isColor()\
setTextColor( color )\
setBackgroundColor( color )\
getSize()\
scroll( n )\
setVisible( bVisible )\
redraw()\
restoreCursor()\
getPosition()\
reposition( x, y, width, height )",
  [ "/startup" ] = "shell.run('run')\
",
  [ "/rom/help/peripherals" ] = "Peripherals are external devices which CraftOS Computers and Turtles can interact with using the peripheral API.\
Type \"help peripheral\" to learn about using the peripheral API.\
Type \"help drives\" to learn about using Disk Drives.\
Type \"help modems\" to learn about using Wireless Modems.\
Type \"help monitors\" to learn about using Monitors.\
Type \"help printers\" to learn about using Printers.",
  [ "/rom/programs/delete" ] = "\
local tArgs = { ... }\
if #tArgs < 1 then\
    print( \"Usage: rm <path>\" )\
    return\
end\
\
local sPath = shell.resolve( tArgs[1] )\
local tFiles = fs.find( sPath )\
if #tFiles > 0 then\
    for n,sFile in ipairs( tFiles ) do\
        fs.delete( sFile )\
    end\
else\
    printError( \"No matching files\" )\
end",
  [ "/rom/programs/fun/advanced/levels/9" ] = "2\
    777  777\
  777877778777\
  788838888887\
7778bbbbbbbb8777\
7888b888888b8897\
7878be8888eb8787\
7588b888888b8887\
7778bbbbbbbb8777\
  788888818887\
  777877778777\
    777  777",
  [ "/Flare/version/1.2/lib/UI/draw/pixelbatch.lua" ] = "\
local function pixelbatch( buffer, pixels )\
    local bc, tc = buffer:getColours()\
    for i = 1, #pixels do\
        if pixels[i].bc ~= bc or pixels[i].tc ~= tc then\
            buffer:setColours( pixels[i].bc, pixels[i].tc )\
            bc, tc = pixels[i].bc, pixels[i].tc\
        end\
        buffer:drawPixel( pixels[i].x, pixels[i].y, pixels[i].char )\
    end\
end\
\
return pixelbatch",
  [ "/rom/apis/textutils" ] = "\
function slowWrite( sText, nRate )\
    nRate = nRate or 20\
    if nRate < 0 then\
        error( \"Rate must be positive\", 2 )\
    end\
    local nSleep = 1 / nRate\
        \
    sText = tostring( sText )\
    local x,y = term.getCursorPos(x,y)\
    local len = string.len( sText )\
    \
    for n=1,len do\
        term.setCursorPos( x, y )\
        sleep( nSleep )\
        local nLines = write( string.sub( sText, 1, n ) )\
        local newX, newY = term.getCursorPos()\
        y = newY - nLines\
    end\
end\
\
function slowPrint( sText, nRate )\
    slowWrite( sText, nRate)\
    print()\
end\
\
function formatTime( nTime, bTwentyFourHour )\
    local sTOD = nil\
    if not bTwentyFourHour then\
        if nTime >= 12 then\
            sTOD = \"PM\"\
        else\
            sTOD = \"AM\"\
        end\
        if nTime >= 13 then\
            nTime = nTime - 12\
        end\
    end\
\
    local nHour = math.floor(nTime)\
    local nMinute = math.floor((nTime - nHour)*60)\
    if sTOD then\
        return string.format( \"%d:%02d %s\", nHour, nMinute, sTOD )\
    else\
        return string.format( \"%d:%02d\", nHour, nMinute )\
    end\
end\
\
local function makePagedScroll( _term, _nFreeLines )\
    local nativeScroll = _term.scroll\
    local nFreeLines = _nFreeLines or 0\
    return function( _n )\
        for n=1,_n do\
            nativeScroll( 1 )\
            \
            if nFreeLines <= 0 then\
                local w,h = _term.getSize()\
                _term.setCursorPos( 1, h )\
                _term.write( \"Press any key to continue\" )\
                os.pullEvent( \"key\" )\
                _term.clearLine()\
                _term.setCursorPos( 1, h )\
            else\
                nFreeLines = nFreeLines - 1\
            end\
        end\
    end\
end\
\
function pagedPrint( _sText, _nFreeLines )\
    -- Setup a redirector\
    local oldTerm = term.current()\
    local newTerm = {}\
    for k,v in pairs( oldTerm ) do\
        newTerm[k] = v\
    end\
    newTerm.scroll = makePagedScroll( oldTerm, _nFreeLines )\
    term.redirect( newTerm )\
\
    -- Print the text\
    local result\
    local ok, err = pcall( function()\
        result = print( _sText )\
    end )\
\
    -- Removed the redirector\
    term.redirect( oldTerm )\
\
    -- Propogate errors\
    if not ok then\
        error( err, 0 )\
    end\
    return result\
end\
\
local function tabulateCommon( bPaged, ... )\
    local tAll = { ... }\
    \
    local w,h = term.getSize()\
    local nMaxLen = w / 8\
    for n, t in ipairs( tAll ) do\
        if type(t) == \"table\" then\
            for n, sItem in pairs(t) do\
                nMaxLen = math.max( string.len( sItem ) + 1, nMaxLen )\
            end\
        end\
    end\
    local nCols = math.floor( w / nMaxLen )\
    local nLines = 0\
    local function newLine()\
        if bPaged and nLines >= (h-3) then\
            pagedPrint()\
        else\
            print()\
        end\
        nLines = nLines + 1\
    end\
    \
    local function drawCols( _t )\
        local nCol = 1\
        for n, s in ipairs( _t ) do\
            if nCol > nCols then\
                nCol = 1\
                newLine()\
            end\
\
            local cx, cy = term.getCursorPos()\
            cx = 1 + ((nCol - 1) * nMaxLen)\
            term.setCursorPos( cx, cy )\
            term.write( s )\
\
            nCol = nCol + 1      \
        end\
        print()\
    end\
    for n, t in ipairs( tAll ) do\
        if type(t) == \"table\" then\
            if #t > 0 then\
                drawCols( t )\
            end\
        elseif type(t) == \"number\" then\
            term.setTextColor( t )\
        end\
    end    \
end\
\
function tabulate( ... )\
    tabulateCommon( false, ... )\
end\
\
function pagedTabulate( ... )\
    tabulateCommon( true, ... )\
end\
\
local function serializeImpl( t, tTracking, sIndent )\
    local sType = type(t)\
    if sType == \"table\" then\
        if tTracking[t] ~= nil then\
            error( \"Cannot serialize table with recursive entries\", 0 )\
        end\
        tTracking[t] = true\
\
        if next(t) == nil then\
            -- Empty tables are simple\
            return \"{}\"\
        else\
            -- Other tables take more work\
            local sResult = \"{\\n\"\
            local sSubIndent = sIndent .. \"  \"\
            local tSeen = {}\
            for k,v in ipairs(t) do\
                tSeen[k] = true\
                sResult = sResult .. sSubIndent .. serializeImpl( v, tTracking, sSubIndent ) .. \",\\n\"\
            end\
            for k,v in pairs(t) do\
                if not tSeen[k] then\
                    local sEntry\
                    if type(k) == \"string\" and string.match( k, \"^[%a_][%a%d_]*$\" ) then\
                        sEntry = k .. \" = \" .. serializeImpl( v, tTracking, sSubIndent ) .. \",\\n\"\
                    else\
                        sEntry = \"[ \" .. serializeImpl( k, tTracking, sSubIndent ) .. \" ] = \" .. serializeImpl( v, tTracking, sSubIndent ) .. \",\\n\"\
                    end\
                    sResult = sResult .. sSubIndent .. sEntry\
                end\
            end\
            sResult = sResult .. sIndent .. \"}\"\
            return sResult\
        end\
        \
    elseif sType == \"string\" then\
        return string.format( \"%q\", t )\
    \
    elseif sType == \"number\" or sType == \"boolean\" or sType == \"nil\" then\
        return tostring(t)\
        \
    else\
        error( \"Cannot serialize type \"..sType, 0 )\
        \
    end\
end\
\
function serialize( t )\
    local tTracking = {}\
    return serializeImpl( t, tTracking, \"\" )\
end\
\
function unserialize( s )\
    local func = loadstring( \"return \"..s, \"unserialize\" )\
    if func then\
        setfenv( func, {} )\
        local ok, result = pcall( func )\
        if ok then\
            return result\
        end\
    end\
    return nil\
end\
\
function urlEncode( str )\
    if str then\
        str = string.gsub(str, \"\\n\", \"\\r\\n\")\
        str = string.gsub(str, \"([^%w ])\", function(c)\
            return string.format(\"%%%02X\", string.byte(c))\
        end )\
        str = string.gsub(str, \" \", \"+\")\
    end\
    return str    \
end\
\
-- GB versions\
serialise = serialize\
unserialise = unserialize",
  [ "/rom/help/adventure" ] = "adventure is a text adventure game for CraftOS. To navigate around the world of adventure, type simple instructions to the interpreter, for example: \"go north\", \"punch tree\", \"craft planks\", \"mine coal with pickaxe\", \"hit creeper with sword\"",
  [ "/Flare/version/1.2/lib/UI/elements/ProgressBar.lua" ] = "\
local class = require \"lib.class\"\
local base = require \"lib.UI.base\"\
local mouse = require \"lib.UI.event.mouse\"\
local graphics = require \"lib.graphics\"\
local formatter = require \"lib.UI.text.formatter\"\
local drawtext = require \"lib.UI.draw.text\"\
\
local ProgressBar = class \"ProgressBar\"\
ProgressBar:extend( base )\
\
ProgressBar.pc = \"lightGrey\" -- progress colour\
ProgressBar.bc = \"grey\" -- background colour\
ProgressBar.tc = \"white\" -- text colour\
\
ProgressBar.direction = \"horizontal\"\
\
ProgressBar.showPercentage = false\
ProgressBar.label = nil\
\
ProgressBar.value = 9\
\
function ProgressBar:ProgressBar( x, y, w, h, value )\
    self:base( x, y, w, h )\
    self.value = value\
end\
\
function ProgressBar:draw( x, y, buffer )\
    buffer:setColours( graphics.colour( self.bc ) )\
    buffer:drawFilledRectangle( x, y, self.width, self.height )\
\
    buffer:setColours( graphics.colour( self.pc ) )\
\
    if self.direction == \"vertical\" then\
        local h = math.floor( self.height * self.value ) - .5\
        buffer:drawFilledRectangle( x, y, self.width, h )\
        if self.showPercentage then\
            local lines = formatter.renderPrep( math.floor( self.value * 100 ) .. \"%\", { width = self.width, bc = 0, tc = self.tc } )\
            formatter.fixAlignment( lines, self.width, self.height, \"centre\", \"centre\" )\
            drawtext( self, lines, x, y, buffer )\
        end\
    else\
        local w = math.floor( self.width * self.value ) - .5\
        buffer:drawFilledRectangle( x, y, w, self.height )\
        if self.showPercentage then\
            local lines = formatter.renderPrep( math.floor( self.value * 100 ) .. \"%\", { width = self.width, bc = 0, tc = self.tc } )\
            formatter.fixAlignment( lines, self.width, self.height, \"centre\", \"centre\" )\
            drawtext( self, lines, x, y, buffer )\
        elseif self.label then\
            local lines = formatter.renderPrep( self.label, { width = self.width, bc = 0, tc = self.tc } )\
            formatter.fixAlignment( lines, self.width, self.height, \"centre\", \"centre\" )\
            drawtext( self, lines, x, y, buffer )\
        end\
    end\
end\
\
function ProgressBar:handle( event )\
    if event.name == \"mouse_ping\" then\
        mouse_event.ping( self, event )\
    end\
end\
\
return ProgressBar",
  [ "/rom/help/redstone" ] = "The redstone program can be used to get, set or pulse redstone inputs and outputs from the computer.\
\
ex:\
\"redstone probe\" will list all the redstone inputs to the computer\
\"redstone set left true\" turns on the left redstone output.\
\"redstone set right blue false\" turns off the blue wire in the bundled cable on the right redstone output.\
\"redstone pulse front 10 1\" emits 10 one second redstone pulses on the front redstone output.\
\
Type \"help redstoneapi\" or \"help rs\" for information on the redstone Lua API.",
  [ "/rom/programs/fun/advanced/levels/5" ] = "3\
777777777\
788888887\
787787787\
787787787\
788888887\
787787787\
787787787\
78e748887\
777777777",
  [ "/rom/help/excavate" ] = "excavate is a program for Mining Turtles. When excavate is run, the turtle will mine a rectangular shaft into the ground, collecting blocks as it goes, and return to the surface once bedrock is hit.\
\
ex:\
\"excavate 3\" will mine a 3x3 shaft.",
  [ "/Flare/version/1.2/lib/UI/event/mouse.lua" ] = "\
local up_stops_drag = true\
if not _CC_VERSION or _CC_VERSION:match \"(1.74)pr%d+\" < 1.74 then\
    up_stops_drag = false\
end\
\
local mouse = {}\
\
function mouse.within( self, event )\
    if event.name ~= \"mouse_down\" and event.name ~= \"mouse_up\" and event.name ~= \"mouse_drag\" and event.name ~= \"mouse_scroll\" and event.name ~= \"mouse_ping\" then return false end\
    local x, y, within = event:getParam \"x\", event:getParam \"y\", event:getParam \"within\"\
    return x >= 1\
    and x <= self.width\
    and y >= 1\
    and y <= self.height\
    and within ~= false\
end\
\
function mouse.click( self, event )\
    if event.handled then\
        return\
    elseif event.name == \"mouse_drag\" then\
        self.current_mouse_event = nil\
    elseif mouse.within( self, event ) then\
        if event.name == \"mouse_down\" and event:getParam \"button\" == 1 then\
            event.handled = true\
            self.current_mouse_event = {\
                time = os.clock();\
                button = event:getParam \"button\";\
                moved = false;\
            }\
        elseif event.name == \"mouse_up\" then\
            event.handled = true\
            if self.current_mouse_event then\
                if self.current_mouse_event.button == event:getParam \"button\" then\
                    if os.clock() - self.current_mouse_event.time <= ( self.mouse_click_timeout or .4 ) then\
                        self.current_mouse_event = nil\
                        return true\
                    end\
                    self.current_mouse_event = nil\
                end\
            end\
        end\
    end\
end\
\
function mouse.drag( self, event )\
    if event.handled then\
        return\
    elseif event.name == \"mouse_drag\" and self.current_mouse_event then\
        event.handled = true\
        self.current_mouse_event.moved = true\
        if self.current_mouse_event.button == event:getParam \"button\" then\
            return \"drag\", event:getParam \"x\", event:getParam \"y\"\
        end\
    elseif mouse.within( self, event ) then\
        if event.name == \"mouse_down\" and event:getParam \"button\" == 1 then\
            event.handled = true\
            self.current_mouse_event = {\
                time = os.clock();\
                button = event:getParam \"button\";\
                moved = false;\
            }\
            return \"down\", event:getParam \"x\", event:getParam \"y\"\
        elseif event.name == \"mouse_up\" then\
            event.handled = true\
            if self.current_mouse_event then\
                if self.current_mouse_event.button == event:getParam \"button\" then\
                    if os.clock() - self.current_mouse_event.time <= ( self.mouse_click_timeout or .4 ) and not self.current_mouse_event.moved then\
                        if up_stops_drag then\
                            self.current_mouse_event = nil\
                        end\
                        return \"click\", event:getParam \"x\", event:getParam \"y\"\
                    end\
                    if up_stops_drag then\
                        self.current_mouse_event = nil\
                    end\
                end\
            end\
        end\
    end\
end\
\
function mouse.ping( self, event )\
    if mouse.within( self, event ) then\
        local elements = event:getParam \"elements\"\
        elements[#elements + 1] = self\
    end\
end\
\
function mouse.text_link_check( lines, x, y, offset )\
    if offset then\
        y = y - ( offset.y or 0 )\
    end\
    if lines[y] then\
        if offset and offset[y] then\
            x = x - offset[y]\
        end\
        if lines[y].link[x] then\
            return lines[y].link[x].protocol, lines[y].link[x].target\
        end\
    end\
end\
\
return mouse",
  [ "/rom/programs/turtle/equip" ] = "\
local tArgs = { ... }\
local function printUsage()\
    print( \"Usage: equip <slot> <side>\" )\
end\
\
if #tArgs ~= 2 then\
    printUsage()\
    return\
end\
\
local function equip( nSlot, fnEquipFunction )\
    turtle.select( nSlot )\
    local nOldCount = turtle.getItemCount( nSlot )\
    if nOldCount == 0 then\
        print( \"Nothing to equip\" )\
    elseif fnEquipFunction() then\
        local nNewCount = turtle.getItemCount( nSlot )\
        if nNewCount > 0 then\
            print( \"Items swapped\" )\
        else\
            print( \"Item equipped\" )\
        end\
    else\
        print( \"Item not equippable\" )\
    end\
end\
\
local nSlot = tonumber( tArgs[1] )\
local sSide = tArgs[2]\
if sSide == \"left\" then\
    equip( nSlot, turtle.equipLeft )\
elseif sSide == \"right\" then\
    equip( nSlot, turtle.equipRight )\
else\
    printUsage()\
    return\
end",
  [ "/Shop/run" ] = "local Dir = 'Shop'\
local FlareVersion = '1.2'\
-- Check and install Flare --\
\
if not fs.isDir( \"Flare/version/\" .. FlareVersion ) then\
    fs.delete( \"Flare/version/\" .. FlareVersion )\
    print \"Installing Flare\"\
    local h = http.get( \"https://raw.githubusercontent.com/awsumben13/Flare/master/version/\" .. FlareVersion .. \"/install.lua\" )\
    if h then\
        local content = h.readAll()\
        h.close()\
\
        local f, err = loadstring( content, \"Flare Installer\" )\
        if f then\
            f()\
        else\
            print( err )\
            return\
        end\
    else\
        print \"Failed to install Flare\"\
        return\
    end\
end\
\
if not fs.isDir( Dir ) then\
    Dir = fs.getDir( shell.getRunningProgram() )\
end\
\
local FDK = dofile( \"Flare/version/\" .. FlareVersion .. \"/FDK.lua\" )\
\
FDK.setup( Dir ) -- set up relative paths\
FDK.dofile \"main\" -- load the starting file\
FDK.begin() -- begin running Flare",
  [ "/rom/help/type" ] = "type determines the type of a file or directory. Prints \"file\", \"directory\" or \"does not exist\".",
  [ "/rom/help/list" ] = "ls will list all the directories and files in the current location. Use \"type\" to find out if an item is a file or a directory.",
  [ "/rom/help/alias" ] = "alias assigns shell commands to run other programs.\
\
ex:\
\"alias dir ls\" will make the \"dir\" command run the \"ls\" program\
\"alias dir\" will remove the alias set on \"dir\"\
\"alias\" will list all current aliases.",
  [ "/rom/help/rename" ] = "rename renames a file or directory.\
\
ex:\
\"rename foo bar\" renames the file \"foo\" to \"bar\".",
  [ "/rom/help/programs" ] = "programs lists all the programs on the rom of the computer.",
  [ "/rom/programs/gps" ] = "\
local function printUsage()\
    print( \"Usages:\" )\
    print( \"gps host\" )\
    print( \"gps host <x> <y> <z>\" )\
    print( \"gps locate\" )\
end\
\
local tArgs = { ... }\
if #tArgs < 1 then\
    printUsage()\
    return\
end\
    \
local sCommand = tArgs[1]\
if sCommand == \"locate\" then\
    -- \"gps locate\"\
    -- Just locate this computer (this will print the results)\
    gps.locate( 2, true )\
    \
elseif sCommand == \"host\" then\
    -- \"gps host\"\
    -- Act as a GPS host\
    if pocket then\
        print( \"GPS Hosts must be stationary\" )\
        return\
    end\
\
    -- Find a modem\
    local sModemSide = nil\
    for n,sSide in ipairs( rs.getSides() ) do\
        if peripheral.getType( sSide ) == \"modem\" and peripheral.call( sSide, \"isWireless\" ) then   \
            sModemSide = sSide\
            break\
        end\
    end\
\
    if sModemSide == nil then\
        print( \"No wireless modems found. 1 required.\" )\
        return\
    end\
    \
    -- Open a channel\
    local modem = peripheral.wrap( sModemSide )\
    print( \"Opening channel on modem \"..sModemSide )\
    modem.open( gps.CHANNEL_GPS )\
\
    -- Determine position\
    local x,y,z\
    if #tArgs >= 4 then\
        -- Position is manually specified\
        x = tonumber(tArgs[2])\
        y = tonumber(tArgs[3])\
        z = tonumber(tArgs[4])\
        if x == nil or y == nil or z == nil then\
            printUsage()\
            return\
        end\
        print( \"Position is \"..x..\",\"..y..\",\"..z )\
    else\
        -- Position is to be determined using locate        \
        x,y,z = gps.locate( 2, true )\
        if x == nil then\
            print( \"Run \\\"gps host <x> <y> <z>\\\" to set position manually\" )\
            if bCloseChannel then\
                print( \"Closing GPS channel\" )\
                modem.close( gps.CHANNEL_GPS )\
            end\
            return\
        end\
    end\
    \
    -- Serve requests indefinately\
    local nServed = 0\
    while true do\
        local e, p1, p2, p3, p4, p5 = os.pullEvent( \"modem_message\" )\
        if e == \"modem_message\" then\
            -- We received a message from a modem\
            local sSide, sChannel, sReplyChannel, sMessage, nDistance = p1, p2, p3, p4, p5\
            if sSide == sModemSide and sChannel == gps.CHANNEL_GPS and sMessage == \"PING\" then\
                -- We received a ping message on the GPS channel, send a response\
                modem.transmit( sReplyChannel, gps.CHANNEL_GPS, { x, y, z } )\
            \
                -- Print the number of requests handled\
                nServed = nServed + 1\
                if nServed > 1 then\
                    local x,y = term.getCursorPos()\
                    term.setCursorPos(1,y-1)\
                end\
                print( nServed..\" GPS requests served\" )\
            end\
        end\
    end\
    \
    print( \"Closing channel\" )\
    modem.close( gps.CHANNEL_GPS )\
\
else\
    -- \"gps somethingelse\"\
    -- Error\
    printUsage()\
    \
end",
  [ "/Flare/version/1.2/lib/UI/animation.lua" ] = "\
local tween = require \"lib.tween\"\
local base = require \"lib.UI.base\"\
local process = require \"lib.process\"\
\
local animation = {}\
\
animation.DEFAULT_TIME = .3\
animation.SCALE_TIME = 1\
animation.TWEEN = \"inOutSine\"\
\
function base:move( x, y, time, onFinish )\
    if x == \"centre\" and self.parent then\
        x = math.floor( self.parent.width / 2 - self.width / 2 + .5 ) + 1\
    end\
    if y == \"centre\" and self.parent then\
        y = math.floor( self.parent.height / 2 - self.height / 2 + .5 ) + 1\
    end\
    if self.move_animation_thread then\
        self.move_animation_thread:stop()\
    end\
\
    if type( time ) == \"function\" then\
        onFinish = time\
        time = nil\
    end\
\
    local t = tween.new( ( time or animation.DEFAULT_TIME ) * animation.SCALE_TIME, self, { x = x, y = y }, animation.TWEEN )\
    t.round = true\
    if process.thread.current then\
        self.move_animation_thread = process.thread.current.parent:spawnThread( function()\
            t:run()\
            if onFinish then\
                onFinish( self )\
            end\
        end )\
    else\
        t:run()\
    end\
end\
\
function base:resize( w, h, time, onFinish )\
    if self.resize_animation_thread then\
        self.resize_animation_thread:stop()\
    end\
\
    if type( time ) == \"function\" then\
        onFinish = time\
        time = nil\
    end\
\
    local t = tween.new( ( time or animation.DEFAULT_TIME ) * animation.SCALE_TIME, self, { width = w, height = h }, animation.TWEEN )\
    t.round = true\
    if process.thread.current then\
        self.resize_animation_thread = process.thread.current.parent:spawnThread( function()\
            t:run()\
            if onFinish then\
                onFinish( self )\
            end\
        end )\
    else\
        t:run()\
    end\
end\
\
function base:animateValue( index, value, time, onFinish )\
    if self[index .. \"_animation_thread\"] then\
        self[index .. \"_animation_thread\"]:stop()\
    end\
\
    if type( time ) == \"function\" then\
        onFinish = time\
        time = nil\
    end\
\
    local t = tween.new( ( time or animation.DEFAULT_TIME ) * animation.SCALE_TIME, self, { [index] = value }, animation.TWEEN )\
    t.round = true\
    if process.thread.current then\
        self[index .. \"_animation_thread\"] = process.thread.current.parent:spawnThread( function()\
            t:run()\
            if onFinish then\
                onFinish()\
            end\
        end )\
    else\
        t:run()\
    end\
end\
\
return animation",
  [ "/rom/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 tProgramStack = {}\
\
local shell = {}\
local tEnv = {\
    [ \"shell\" ] = shell,\
    [ \"multishell\" ] = multishell,\
}\
\
-- Colours\
local promptColour, textColour, bgColour\
if term.isColour() then\
    promptColour = colours.yellow\
    textColour = colours.white\
    bgColour = colours.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( \"No such program\" )\
        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\
\
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( \"No such program\" )\
            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.setTextColour( promptColour )\
    print( os.version() )\
    term.setTextColour( textColour )\
\
    -- Run the startup program\
    if parentShell == nil then\
        shell.run( \"/rom/startup\" )\
    end\
\
    -- Read commands and execute them\
    local tCommandHistory = {}\
    while not bExit do\
        term.redirect( parentTerm )\
        term.setBackgroundColor( bgColour )\
        term.setTextColour( promptColour )\
        write( shell.dir() .. \"> \" )\
        term.setTextColour( textColour )\
\
        local sLine = read( nil, tCommandHistory )\
        table.insert( tCommandHistory, sLine )\
        shell.run( sLine )\
    end\
end",
  [ "/compress" ] = "local function Decompile(CompiledTbl)\
  local Str = ''\
  for k, v in pairs(CompiledTbl) do\
    Str = Str .. string.char(v)\
  end\
  return Str\
end\
\
local function Compile(Str)\
  local Compiled = {string.byte(Str,1,#tostring(Str))}\
  return Compiled, table.concat(Compiled, ',')\
end\
\
local Args = {...}\
\
if Args[1] ~= '-String' or Args[1] ~= '-File' then\
  printError([[\
Usage:\
  -String <str> \
  -File]])\
end\
if Args[1] == '-String' then\
  String = Args[2]\
elseif Args[1] == '-File' then\
\
  local Blacklist={\
    shell.getRunningProgram(),\
    'rom',\
  }\
\
  local function Blacklisted(Path)\
    for k, v in pairs(Blacklist) do\
      if v == Path then\
        return true\
      end\
    end\
    return false\
  end\
\
  local Path = '/'\
  local Contents = {}\
\
  local function GetDir(Path)\
    if Blacklisted(Path) then\
    else\
      local List = fs.list(Path or '/')\
      for k, v in pairs(List) do\
\
        local CurrentPath = Path..fs.getName(\
          fs.combine(\
            Path,\
            v\
          )\
        )\
        if fs.isDir(CurrentPath) then\
          CurrentPath = CurrentPath .. '/'\
        end\
        print(tostring(CurrentPath))\
        if fs.isDir(CurrentPath) then\
          GetDir(CurrentPath)\
        else\
          local File = fs.open(CurrentPath, 'r')\
          if File then\
            local Data = File.readAll()\
            -- Compile data --\
            --Data = --{string.byte(Data,1,#tostring(Data))}\
            --print(table.concat(Data, ', '))\
            --os.pullEvent()\
            File.close()\
            Contents[CurrentPath] = Data\
            os.queueEvent('Ping')\
            os.pullEvent('Ping')\
          end\
        end\
      end\
    end\
  end\
\
\
  GetDir(Path)\
\
  --print('Waiting for input...')\
  --os.pullEvent('key')\
  --term.clear()\
  --term.setCursorPos(1,1)\
  local Pre = [[local tbl=]]\
  local Extra = [[\
  for k, v in pairs(tbl) do\
    local X = fs.open(k, 'w')\
    X.write(v)\
    X.close()\
  end\
  ]]\
  Compiled = fs.open('Compiled', 'w')\
  Compiled.write(Pre..textutils.serialize(Contents)..Extra)\
  Compiled.close()\
  --\
  --Decompiled = textutils.unserialize(Compiled.readAll())\
end",
  [ "/rom/programs/clear" ] = "term.clear()\
term.setCursorPos( 1, 1 )",
  [ "/rom/help/dance" ] = "dance is a program for Turtles. Turtles love to get funky.",
  [ "/Flare/version/1.2/lib/UI/elements/Input.lua" ] = "\
local class = require \"lib.class\"\
local base = require \"lib.UI.base\"\
local mouse = require \"lib.UI.event.mouse\"\
local graphics = require \"lib.graphics\"\
\
local Input = class \"Input\"\
Input:extend( base )\
\
function Input:Input( x, y, w, mask )\
    self:base( x, y, w, 1 )\
\
    self.text = \"\"\
    self.cpos = 1\
    self.selecting = false\
    self.scroll = 0\
    self.mask = mask\
    self.focussed = false\
    self.down = false\
\
    self.fc  = colours.white\
    self.bc  = colours.lightGrey\
    self.tc  = colours.grey\
    self.hc  = colours.blue\
    self.htc = colours.white\
\
    self.downRequiredToDrag = os.version() == \"CraftOS 1.7\"\
end\
\
function Input:setCursorPos( pos )\
    self.cpos = math.min( math.max( pos, 1 ), #self.text + 1 )\
    if self.cpos - self.scroll <= 0 then\
        self.scroll = self.cpos - 1\
    elseif self.cpos > self.scroll + self.width then\
        self.scroll = self.cpos - self.width\
    end\
end\
\
function Input:write( content )\
    if self.selecting then\
        self.text = self.text:sub( 1, math.min( self.cpos, self.selecting ) - 1 ) .. content .. self.text:sub( math.max( self.cpos, self.selecting ) + 1 )\
        self:setCursorPos( math.min( self.cpos, self.selecting ) + #content )\
        self.selecting = false\
    else\
        self.text = self.text:sub( 1, self.cpos - 1 ) .. content .. self.text:sub( self.cpos )\
        self:setCursorPos( self.cpos + #content )\
    end\
end\
\
function Input:getSelection()\
    if self.selecting then\
        return self.text:sub( math.min( self.cpos, self.selecting ), math.max( self.cpos, self.selecting ) )\
    end\
end\
\
function Input:focusOn()\
    self.focussed = true\
end\
\
function Input:unFocus()\
    self.focussed = false\
end\
\
function Input:draw( x, y, buffer )\
    if self.focussed then\
        buffer:setCursorBlink( x - self.scroll + self.cpos - 1, y, self.tc )\
    end\
\
    local _bc, _tc = buffer:getColours()\
    for i = 1, self.width do\
        local char = i + self.scroll\
        local bc, tc = graphics.colour( self.bc ), graphics.colour( self.tc )\
        if self.focussed then\
            bc = graphics.colour( self.fc )\
        end\
        if self.selecting and char >= math.min( self.cpos, self.selecting ) and char <= math.max( self.cpos, self.selecting ) then\
            bc, tc = graphics.colour( self.hc ), graphics.colour( self.htc )\
        end\
        local c = self.text:sub( char, char )\
        if self.mask and c ~= \"\" then\
            c = self.mask\
        end\
        if _bc ~= bc or _tc ~= tc then\
            buffer:setColours( bc, tc )\
            _bc, _tc = bc, tc\
        end\
        buffer:drawPixel( x, y, c )\
        x = x + 1\
    end\
end\
\
function Input:handle( event )\
    if type( self.onChange ) ~= \"function\" then self.onChange = nil end\
    if event.name == \"mouse_down\" and ( event.handled or not mouse.within( self, event ) ) then\
        self.focussed = false\
        self.down = false\
    elseif not event.handled and event.name == \"mouse_down\" and mouse.within( self, event ) then\
        event.handled = true\
        self.focussed = true\
        self.selecting = false\
\
        if self.down and os.clock() - self.downTime < .5 then\
            local x = math.min( event:getParam \"x\" + self.scroll, #self.text )\
            local char = self.text:sub( x, x )\
            local m = \"\"\
            if char:find \"%s\" then\
                m = \"%s\"\
            elseif char:find \"%w\" then\
                m = \"[%w_]\"\
            else\
                m = \"[^%s%w]\"\
            end\
            local min, max = x, x\
            for i = x, 1, -1 do\
                if self.text:sub( i, i ):find( m ) then\
                    min = i\
                else\
                    break\
                end\
            end\
            for i = x, #self.text do\
                if self.text:sub( i, i ):find( m ) then\
                    max = i\
                else\
                    break\
                end\
            end\
            self.cpos = min\
            self.selecting = max\
            self.down = nil\
            self.downTime = nil\
        else\
            self.down = event:getParam \"x\"\
            self.downTime = os.clock()\
            self.cpos = math.min( #self.text + 1, self.down + self.scroll )\
        end\
    elseif not event.handled and event.name == \"mouse_up\" and mouse.within( self, event ) then\
        event.handled = true\
        if self.downRequiredToDrag then\
            self.down = false\
        end\
    elseif not event.handled and event.name == \"mouse_drag\" and self.down then\
        event.handled = true\
\
        local rx = event:getParam \"x\"\
        self.selecting = math.max( math.min( #self.text + 1, rx + self.scroll ), 1 )\
    elseif not event.handled and event.name == \"key\" and self.focussed then\
        local key = event:getParam \"key\"\
\
        if key == \"left\" then\
            if self.selecting then\
                self:setCursorPos( math.min( self.cpos, self.selecting ) )\
            else\
                self:setCursorPos( self.cpos - 1 )\
            end\
            event.handled = true\
        elseif key == \"right\" then\
            if self.selecting then\
                self:setCursorPos( math.max( self.cpos, self.selecting ) )\
            else\
                self:setCursorPos( self.cpos + 1 )\
            end\
            event.handled = true\
        elseif key == \"backspace\" then\
            if self.selecting then\
                self.text = self.text:sub( 1, math.min( self.cpos, self.selecting ) - 1 ) .. self.text:sub( math.max( self.cpos, self.selecting ) + 1 )\
                self:setCursorPos( math.min( self.cpos, self.selecting ) )\
                self.selecting = false\
            elseif self.cpos > 1 then\
                self.text = self.text:sub( 1, self.cpos - 2 ) .. self.text:sub( self.cpos )\
                self:setCursorPos( self.cpos - 1 )\
            end\
            event.handled = true\
            if self.onChange then\
                self:onChange()\
            end\
        elseif key == \"delete\" then\
            if self.selecting then\
                self.text = self.text:sub( 1, math.min( self.cpos, self.selecting ) - 1 ) .. self.text:sub( math.max( self.cpos, self.selecting ) + 1 )\
                self:setCursorPos( math.min( self.cpos, self.selecting ) )\
                self.selecting = false\
            else\
                self.text = self.text:sub( 1, self.cpos - 1 ) .. self.text:sub( self.cpos + 1 )\
            end\
            event.handled = true\
            if self.onChange then\
                self:onChange()\
            end\
        elseif key == \"home\" then\
            self.selecting = false\
            self:setCursorPos( 1 )\
            event.handled = true\
        elseif key == \"end\" then\
            self.selecting = false\
            self:setCursorPos( #self.text + 1 )\
            event.handled = true\
        elseif key == \"enter\" then\
            if self.selecting then\
                self.selecting = false\
                self:write \"\"\
                if self.onChange then\
                    self:onChange()\
                end\
            end\
            if self.onEnter then\
                self:onEnter()\
            end\
            event.handled = true\
        elseif key == \"tab\" then\
            if self.onTab then\
                self:onTab()\
            else\
                self:write \" \"\
                if self.onChange then\
                    self:onChange()\
                end\
            end\
            event.handled = true\
        end\
    elseif not event.handled and event.name == \"char\" and self.focussed then\
        if self.selecting then\
            self.text = self.text:sub( 1, math.min( self.cpos, self.selecting ) - 1 ) .. event:getParam \"char\" .. self.text:sub( math.max( self.cpos, self.selecting ) + 1 )\
            self:setCursorPos( math.min( self.cpos, self.selecting ) + 1 )\
            self.selecting = false\
        else\
            self.text = self.text:sub( 1, self.cpos - 1 ) .. event:getParam \"char\" .. self.text:sub( self.cpos )\
            self:setCursorPos( self.cpos + 1 )\
        end\
        if self.onChange then\
            self:onChange()\
        end\
    elseif not event.handled and event.name == \"paste\" and self.focussed then\
        self:write( event:getParam \"data\" )\
        if self.onChange then\
            self:onChange()\
        end\
    elseif event.name == \"mouse_ping\" then\
        mouse.ping( self, event )\
    end\
end\
\
return Input",
  [ "/rom/programs/rename" ] = "local tArgs = { ... }\
if #tArgs < 2 then\
    print( \"Usage: rename <source> <destination>\" )\
    return\
end\
\
local sSource = shell.resolve( tArgs[1] )\
local sDest = shell.resolve( tArgs[2] )\
fs.move( sSource, sDest )",
  [ "/rom/programs/edit" ] = "-- Get file to edit\
local tArgs = { ... }\
if #tArgs == 0 then\
    print( \"Usage: edit <path>\" )\
    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( \"Cannot edit a directory.\" )\
    return\
end\
\
local x,y = 1,1\
local w,h = term.getSize()\
local scrollX, scrollY = 0,0\
\
local tLines = {}\
local bRunning = true\
\
-- Colours\
local highlightColour, keywordColour, commentColour, textColour, bgColour\
if term.isColour() then\
    bgColour = colours.black\
    textColour = colours.white\
    highlightColour = colours.yellow\
    keywordColour = colours.yellow\
    commentColour = colours.green\
    stringColour = colours.red\
else\
    bgColour = colours.black\
    textColour = colours.white\
    highlightColour = colours.white\
    keywordColour = colours.white\
    commentColour = colours.white\
    stringColour = colours.white\
end\
\
-- Menus\
local bMenu = false\
local nMenuItem = 1\
local tMenuItems\
if bReadOnly then\
    tMenuItems = { \"Exit\", \"Print\" }\
else\
    tMenuItems = { \"Save\", \"Exit\", \"Print\" }\
end\
    \
local sStatus = \"Press Ctrl to access menu\"\
\
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\
\
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, colour )\
    local match = string.match( sLine, regex )\
    if match then\
        if type(colour) == \"number\" then\
            term.setTextColour( colour )\
        else\
            term.setTextColour( colour(match) )\
        end\
        term.write( match )\
        term.setTextColour( textColour )\
        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, \"^%-%-%[%[.-%]%]\", commentColour ) or\
            tryWrite( sLine, \"^%-%-.*\", commentColour ) or\
            tryWrite( sLine, \"^\\\".-[^\\\\]\\\"\", stringColour ) or\
            tryWrite( sLine, \"^\\'.-[^\\\\]\\'\", stringColour ) or\
            tryWrite( sLine, \"^%[%[.-%]%]\", stringColour ) or\
            tryWrite( sLine, \"^[%w_]+\", function( match )\
                if tKeywords[ match ] then\
                    return keywordColour\
                end\
                return textColour\
            end ) or\
            tryWrite( sLine, \"^[^%w_]\", textColour )\
    end\
end\
\
local function redrawText()\
    for y=1,h-1 do\
        term.setCursorPos( 1 - scrollX, y )\
        term.clearLine()\
\
        local sLine = tLines[ y + scrollY ]\
        if sLine ~= nil then\
            writeHighlighted( sLine )\
        end\
    end\
    term.setCursorPos( x - scrollX, y - scrollY )\
end\
\
local function redrawLine(_nY)\
    local sLine = tLines[_nY]\
    term.setCursorPos( 1 - scrollX, _nY - scrollY )\
    term.clearLine()\
    writeHighlighted( sLine )\
    term.setCursorPos( x - scrollX, _nY - scrollY )\
end\
\
local function redrawMenu()\
    -- Clear line\
    term.setCursorPos( 1, h )\
    term.clearLine()\
\
    -- Draw line numbers\
    term.setCursorPos( w - string.len( \"Ln \"..y ) + 1, h )\
    term.setTextColour( highlightColour )\
    term.write( \"Ln \" )\
    term.setTextColour( textColour )\
    term.write( y )\
\
    term.setCursorPos( 1, h )\
    if bMenu then\
        -- Draw menu\
        term.setTextColour( textColour )\
        for nItem,sItem in pairs( tMenuItems ) do\
            if nItem == nMenuItem then\
                term.setTextColour( highlightColour )\
                term.write( \"[\" )\
                term.setTextColour( textColour )\
                term.write( sItem )\
                term.setTextColour( highlightColour )\
                term.write( \"]\" )\
                term.setTextColour( textColour )\
            else\
                term.write( \" \"..sItem..\" \" )\
            end\
        end\
    else\
        -- Draw status\
        term.setTextColour( highlightColour )\
        term.write( sStatus )\
        term.setTextColour( textColour )\
    end\
\
    -- Reset cursor\
    term.setCursorPos( x - scrollX, y - scrollY )\
end\
\
local tMenuFuncs = { \
    Save=function()\
        if bReadOnly then\
            sStatus = \"Access denied\"\
        else\
            local ok, err = save( sPath )\
            if ok then\
                sStatus=\"Saved to \"..sPath\
            else\
                sStatus=\"Error saving to \"..sPath\
            end\
        end\
        redrawMenu()\
    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\
}\
\
local function doMenuItem( _n )\
    tMenuFuncs[tMenuItems[_n]]()\
    if bMenu then\
        bMenu = false\
        term.setCursorBlink( true )\
    end\
    redrawMenu()\
end\
\
local function setCursor( x, y )\
    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 then\
        scrollX = x - w\
        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\
    \
    if bRedraw then\
        redrawText()\
    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\
\
-- Actual program functionality begins\
load(sPath)\
\
term.setBackgroundColour( bgColour )\
term.clear()\
term.setCursorPos(x,y)\
term.setCursorBlink( true )\
\
redrawText()\
redrawMenu()\
\
-- Handle input\
while bRunning do\
    local sEvent, param, param2, param3 = os.pullEvent()\
    if sEvent == \"key\" then\
        if param == keys.up then\
            -- Up\
            if not bMenu then\
                if 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 y < #tLines then\
                    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\
                -- Indent line\
                tLines[y]=\"  \"..tLines[y]\
                x = x + 2\
                setCursor( x, y )\
                redrawLine(y)\
            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) )\
                redrawText()\
            \
                x = spaces+1\
                y = y + 1\
                setCursor( x, y )\
            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 )\
                    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 )",
  [ "/rom/programs/fun/worm" ] = "\
-- Display the start screen\
local w,h = term.getSize()\
\
local titleColour, headingColour, textColour, wormColour, fruitColour\
if term.isColour() then\
    titleColour = colours.red\
    headingColour = colours.yellow\
    textColour = colours.white\
    wormColour = colours.green\
    fruitColour = colours.red\
else\
    titleColour = colours.white\
    headingColour = colours.white\
    textColour = colours.white\
    wormColour = colours.white\
    fruitColour = colours.white\
end\
\
function printCentred( y, s )\
    local x = math.floor((w - string.len(s)) / 2)\
    term.setCursorPos(x,y)\
    --term.clearLine()\
    term.write( s )\
end\
\
local xVel,yVel = 1,0\
local xPos, yPos = math.floor(w/2), math.floor(h/2)\
local pxVel, pyVel = nil, nil\
\
local nLength = 1\
local nExtraLength = 6\
local bRunning = true\
\
local tailX,tailY = xPos,yPos\
local nScore = 0\
local nDifficulty = 2\
local nSpeed, nInterval\
\
-- Setup the screen\
local screen = {}\
for x=1,w do\
    screen[x] = {}\
    for y=1,h do\
        screen[x][y] = {}\
    end\
end\
screen[xPos][yPos] = { snake = true }\
\
local nFruit = 1\
local tFruits = {\
    \"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\",\
    \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\",\
    \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\",\
    \"Y\", \"Z\",\
    \"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\",\
    \"i\", \"j\", \"k\", \"l\", \"m\", \"n\", \"o\", \"p\",\
    \"q\", \"r\", \"s\", \"t\", \"u\", \"v\", \"w\", \"x\",\
    \"y\", \"z\",\
    \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"0\",\
    \"@\", \"$\", \"%\", \"#\", \"&\", \"!\", \"?\", \"+\", \"*\", \"~\"\
}\
\
local function addFruit()\
    while true do\
        local x = math.random(1,w)\
        local y = math.random(2,h)\
        local fruit = screen[x][y]\
        if fruit.snake == nil and fruit.wall == nil and fruit.fruit == nil then\
            screen[x][y] = { fruit = true }\
            term.setCursorPos(x,y)\
            term.setBackgroundColour( fruitColour )\
            term.write(\" \")\
            term.setBackgroundColour( colours.black )\
            break\
        end\
    end\
    \
    nFruit = nFruit + 1\
    if nFruit > #tFruits then\
        nFruit = 1\
    end\
end\
\
local function drawMenu()\
    term.setTextColour( headingColour )\
    term.setCursorPos(1,1)\
    term.write( \"SCORE \" )\
    \
    term.setTextColour( textColour )\
    term.setCursorPos(7,1)\
    term.write( tostring(nScore) )\
\
    term.setTextColour( headingColour )\
    term.setCursorPos(w-11,1)\
    term.write( \"DIFFICULTY \")\
\
    term.setTextColour( textColour )\
    term.setCursorPos(w,1)\
    term.write( tostring(nDifficulty or \"?\") ) \
\
    term.setTextColour( colours.white )\
end\
\
local function update( )\
    local x,y = xPos,yPos\
    if pxVel and pyVel then\
        xVel, yVel = pxVel, pyVel\
        pxVel, pyVel = nil, nil\
    end\
\
    -- Remove the tail\
    if nExtraLength == 0 then\
        local tail = screen[tailX][tailY]\
        screen[tailX][tailY] = {}\
        term.setCursorPos(tailX,tailY)\
        term.write(\" \")\
        tailX = tail.nextX\
        tailY = tail.nextY\
    else\
        nExtraLength = nExtraLength - 1\
    end\
    \
    -- Update the head\
    local head = screen[xPos][yPos]\
    local newXPos = xPos + xVel\
    local newYPos = yPos + yVel\
    if newXPos < 1 then\
        newXPos = w\
    elseif newXPos > w then\
        newXPos = 1\
    end\
    if newYPos < 2 then\
        newYPos = h\
    elseif newYPos > h then\
        newYPos = 2\
    end\
    \
    local newHead = screen[newXPos][newYPos]\
    term.setCursorPos(1,1);\
    print( newHead.snake )\
    if newHead.snake == true or newHead.wall == true then\
        bRunning = false\
        \
    else\
        if newHead.fruit == true then\
            nScore = nScore + 10\
            nExtraLength = nExtraLength + 1\
            addFruit()\
        end\
        xPos = newXPos\
        yPos = newYPos\
        head.nextX = newXPos\
        head.nextY = newYPos\
        screen[newXPos][newYPos] = { snake = true }\
        \
    end\
    \
    term.setCursorPos(xPos,yPos)\
    term.setBackgroundColour( wormColour )\
    term.write(\" \")\
    term.setBackgroundColour( colours.black )\
\
    drawMenu()\
end\
\
-- Display the frontend\
term.clear()\
local function drawFrontend()\
    --term.setTextColour( titleColour )\
    --printCentred( math.floor(h/2) - 4, \" W O R M \" )\
\
    term.setTextColour( headingColour )\
    printCentred( math.floor(h/2) - 3, \"\" )\
    printCentred( math.floor(h/2) - 2, \" SELECT DIFFICULTY \" )\
    printCentred( math.floor(h/2) - 1, \"\" )\
    \
    printCentred( math.floor(h/2) + 0, \"            \" )\
    printCentred( math.floor(h/2) + 1, \"            \" )\
    printCentred( math.floor(h/2) + 2, \"            \" )\
    printCentred( math.floor(h/2) - 1 + nDifficulty, \" [        ] \" )\
\
    term.setTextColour( textColour )\
    printCentred( math.floor(h/2) + 0, \"EASY\" )\
    printCentred( math.floor(h/2) + 1, \"MEDIUM\" )\
    printCentred( math.floor(h/2) + 2, \"HARD\" )\
    printCentred( math.floor(h/2) + 3, \"\" )\
\
    term.setTextColour( colours.white )\
end\
\
drawMenu()\
drawFrontend()\
while true do\
    local e,key = os.pullEvent( \"key\" )\
    if key == keys.up or key == keys.w then\
        -- Up\
        if nDifficulty > 1 then\
            nDifficulty = nDifficulty - 1\
            drawMenu()\
            drawFrontend()\
        end\
    elseif key == keys.down or key == keys.s then\
        -- Down\
        if nDifficulty < 3 then\
            nDifficulty = nDifficulty + 1\
            drawMenu()\
            drawFrontend()\
        end\
    elseif key == keys.enter then\
        -- Enter\
        break\
    end\
end\
\
local tSpeeds = { 5, 10, 25 }\
nSpeed = tSpeeds[nDifficulty]\
nInterval = 1 / nSpeed\
\
-- Grow the snake to its intended size\
term.clear()\
drawMenu()\
screen[tailX][tailY].snake = true\
while nExtraLength > 0 do\
    update()\
end\
addFruit()\
addFruit()\
\
-- Play the game\
local timer = os.startTimer(0)\
while bRunning do\
    local event, p1, p2 = os.pullEvent()\
    if event == \"timer\" and p1 == timer then\
        timer = os.startTimer(nInterval)\
        update( false )\
    \
    elseif event == \"key\" then\
        local key = p1\
        if key == keys.up or key == keys.w then\
            -- Up\
            if yVel == 0 then\
                pxVel,pyVel = 0,-1\
            end\
        elseif key == keys.down or key == keys.s then\
            -- Down\
            if yVel == 0 then\
                pxVel,pyVel = 0,1\
            end\
        elseif key == keys.left or key == keys.a then\
            -- Left\
            if xVel == 0 then\
                pxVel,pyVel = -1,0\
            end\
        \
        elseif key == keys.right or key == keys.d then\
            -- Right\
            if xVel == 0 then\
                pxVel,pyVel = 1,0\
            end\
        \
        end \
    end\
end\
\
-- Display the gameover screen\
term.setTextColour( headingColour )\
printCentred( math.floor(h/2) - 2, \"                   \" )\
printCentred( math.floor(h/2) - 1, \" G A M E   O V E R \" )\
\
term.setTextColour( textColour )\
printCentred( math.floor(h/2) + 0, \"                 \" )\
printCentred( math.floor(h/2) + 1, \" FINAL SCORE \"..nScore..\" \" )\
printCentred( math.floor(h/2) + 2, \"                 \" )\
term.setTextColour( colours.white )\
\
local timer = os.startTimer(2.5)\
repeat\
    local e,p = os.pullEvent()\
    if e == \"timer\" and p == timer then\
        term.setTextColour( textColour )\
        printCentred( math.floor(h/2) + 2, \" PRESS ANY KEY \" )\
        printCentred( math.floor(h/2) + 3, \"               \" )\
        term.setTextColour( colours.white )\
    end\
until e == \"char\"\
\
term.clear()\
term.setCursorPos(1,1)\
\
        ",
  [ "/rom/programs/fun/advanced/levels/10" ] = "5\
 777    77777\
 727777778837\
 788888878787\
 787777888887\
77877778777777\
7e8b7888b888e7\
7787787b777877\
 777887887887\
   7487807487\
   7777777777",
  [ "/Flare/version/1.2/lib/process.lua" ] = "\
local thread = {}\
\
function thread:new( f )\
\
    local t = {}\
\
    t.state = \"running\"\
    t.environment = setmetatable( {}, { __index = getfenv( f ) } )\
\
    t.filter = nil\
\
    t.raw_environment = setmetatable( {}, {\
        __index = function( _, k )\
            if k == \"thread\" then\
                return t\
            end\
            return t.environment[k]\
        end,\
        __newindex = function( _, k, v )\
            t.environment[k] = v\
        end\
    } )\
\
    setfenv( f, t.raw_environment )\
    t.func = f\
    t.co = coroutine.create( f )\
\
    setmetatable( t, {\
        __index = self;\
        __type = \"thread\";\
        __tostring = function()\
            return \"thread\"\
        end;\
    } )\
\
    return t\
end\
\
function thread:stop()\
    if self.state ~= \"dead\" then\
        self.state = \"stopped\"\
    end\
end\
\
function thread:pause()\
    if self.state == \"running\" then\
        self.state = \"paused\"\
    end\
end\
\
function thread:resume()\
    if self.state == \"paused\" then\
        self.state = \"running\"\
    end\
end\
\
function thread:restart()\
    self.state = \"running\"\
    self.co = coroutine.create( self.func )\
end\
\
function thread:update( event, ... )\
    if self.state ~= \"running\" then return true, self.state end -- if not running, don't update\
    if self.filter ~= nil and self.filter ~= event then return true, self.filter end -- if filtering an event, don't update\
    thread.current = self\
    local ok, data = coroutine.resume( self.co, event, ... )\
    thread.current = nil\
    if not ok then\
        self.state = \"stopped\"\
        return false, data\
    end\
    if coroutine.status( self.co ) == \"dead\" then\
        self.state = \"stopped\"\
        return true, \"die\"\
    end\
    self.filter = data\
    return true, data\
end\
\
function thread:type()\
    return \"thread\"\
end\
\
local process = {}\
\
process.thread = thread\
\
function process:new( name )\
    local p = {}\
\
    p.name = name\
    p.children = {}\
\
    setmetatable( p, {\
        __index = self;\
        __type = \"process\";\
        __tostring = function()\
            return \"process\"\
        end;\
    } )\
\
    return p\
end\
\
function process:spawnThread( f )\
    local t = thread:new( f )\
    t.parent = self\
    self.children[#self.children + 1] = t\
    return t\
end\
\
function process:spawnSubProcess( name )\
    local p = process:new( name )\
    p.parent = self\
    self.children[#self.children + 1] = p\
    return p\
end\
\
function process:update( event, ... )\
    for i = #self.children, 1, -1 do\
        local ok, data = self.children[i]:update( event, ... )\
        if not ok then\
            if self.exceptionHandler then\
                self:exceptionHandler( self.children[i], data )\
            else\
                return false, data\
            end\
        end\
        if data == \"die\" or self.children[i].state == \"stopped\" then\
            self.children[i].state = \"dead\"\
            table.remove( self.children, i )\
        end\
    end\
    return true, #self.children == 0 and \"die\"\
end\
\
function process:stop()\
    for i = 1, #self.children do\
        self.children[i]:stop()\
    end\
end\
\
function process:pause()\
    for i = 1, #self.children do\
        self.children[i]:pause()\
    end\
end\
\
function process:resume()\
    for i = 1, #self.children do\
        self.children[i]:resume()\
    end\
end\
\
function process:restart()\
    for i = 1, #self.children do\
        self.children[i]:restart()\
    end\
end\
\
function process:list( deep )\
    local t = {}\
    for i = #self.children, 1, -1 do\
        if self.children[i]:type() == \"process\" then\
            if deep then\
                local c = self.children[i]:list( true )\
                c.name = self.children[i].name\
                t[#t + 1] = c\
            else\
                t[#t + 1] = self.children[i]\
            end\
        elseif self.children[i]:type() == \"thread\" then\
            t[#t + 1] = self.children[i]\
        end\
    end\
    return t\
end\
\
function process:type()\
    return \"process\"\
end\
\
process.main = process:new \"main\"\
\
return process",
  [ "/rom/help/refuel" ] = "refuel is a program for Turtles. Refuel will consume items from the inventory as fuel for turtle.\
\
ex:\
\"refuel\" will refuel with at most one fuel item\
\"refuel 10\" will refuel with at most 10 fuel items\
\"refuel all\" will refuel with as many fuel items as possible",
  [ "/rom/help/events" ] = "The function os.pullEvent() will yield the program until a system event occurs. The first return value is the event name, followed by any arguments.\
\
Some events which can occur are:\
\"char\" when text is typed on the keyboard. Argument is the letter typed.\
\"key\" when a key is pressed on the keyboard. Argument is the numerical keycode. Compare to the values in keys API to see which key was pressed.\
\"paste\" when text is pasted from the users keyboard. Argument is the line of text pasted.\
\
Events only on advanced computers:\
\"mouse_click\" when a user clicks the mouse. Arguments are button, xPos, yPos.\
\"mouse_drag\" when a user moves the mouse when held. Arguments are button, xPos, yPos.\
\"mouse_scroll\" when a user uses the scrollwheel on the mouse. Arguments are direction, xPos, yPos.\
\
Other APIs and peripherals will emit their own events. See their respective help pages for details.",
  [ "/rom/help/exit" ] = "exit will exit the current shell.",
  [ "/rom/help/string" ] = "string is a standard Lua5.1 API.\
Refer to http://www.lua.org/manual/5.1/ for more information.",
  [ "/rom/programs/label" ] = "\
local function printUsage()\
    print( \"Usages:\" )\
    print( \"label get\" )\
    print( \"label get <drive>\" )\
    print( \"label set <text>\" )\
    print( \"label set <drive> <text>\" )\
    print( \"label clear\" )\
    print( \"label clear <drive>\" )\
end\
\
local function checkDrive( sDrive )\
    if peripheral.getType( sDrive ) == \"drive\" then\
        -- Check the disk exists\
        local bData = disk.hasData( sDrive )\
        if not bData then\
            print( \"No disk in \"..sDrive..\" drive\" )\
            return false\
        end\
    else\
        print( \"No disk drive named \"..sDrive )\
        return false\
    end\
    return true\
end\
\
local function get( sDrive )\
    if sDrive ~= nil then\
        if checkDrive( sDrive ) then\
            local sLabel = disk.getLabel( sDrive )\
            if sLabel then\
                print( \"Disk label is \\\"\"..sLabel..\"\\\"\" )\
            else\
                print( \"No Disk label\" )\
            end\
        end\
    else\
        local sLabel = os.getComputerLabel()\
        if sLabel then\
            print( \"Computer label is \\\"\"..sLabel..\"\\\"\" )\
        else\
            print( \"No Computer label\" )\
        end\
    end\
end\
\
local function set( sDrive, sText )\
    if sDrive ~= nil then\
        if checkDrive( sDrive ) then\
            disk.setLabel( sDrive, sText )\
            local sLabel = disk.getLabel( sDrive )\
            if sLabel then\
                print( \"Disk label set to \\\"\"..sLabel..\"\\\"\" )\
            else\
                print( \"Disk label cleared\" )\
            end\
        end\
    else\
        os.setComputerLabel( sText )\
        local sLabel = os.getComputerLabel()\
        if sLabel then\
            print( \"Computer label set to \\\"\"..sLabel..\"\\\"\" )\
        else\
            print( \"Computer label cleared\" )\
        end\
    end\
end\
\
local tArgs = { ... }\
local sCommand = tArgs[1]\
if sCommand == \"get\" then\
    -- Get a label\
    if #tArgs == 1 then\
        get( nil )\
    elseif #tArgs == 2 then\
        get( tArgs[2] )\
    else\
        printUsage()\
    end\
elseif sCommand == \"set\" then\
    -- Set a label\
    if #tArgs == 2 then\
        set( nil, tArgs[2] )\
    elseif #tArgs == 3 then\
        set( tArgs[2], tArgs[3] )\
    else\
        printUsage()\
    end\
elseif sCommand == \"clear\" then\
    -- Clear a label\
    if #tArgs == 1 then\
        set( nil, nil )\
    elseif #tArgs == 2 then\
        set( tArgs[2], nil )\
    else\
        printUsage()\
    end\
else\
    printUsage()\
end",
  [ "/Shop/States/Main.lua" ] = "local StateLib = FDK.require('lib.state')\
local State = StateLib.names.Init\
local Main = StateLib.names.Main\
local Search = StateLib.names.Search\
local Account = StateLib.names.Account\
local Items = StateLib.names.Items\
\
local Field = FDK.require('lib.UI.elements.Field')\
local Text = FDK.require('lib.UI.elements.Text')\
local Button = FDK.require('lib.UI.elements.Button')\
\
-- Main Field\
Main.frame:newChild(Field(1, 1, Main.frame.width, Main.frame.height, colors.white))\
-- Header Field\
Main.frame:newChild(Field(1, 1, Main.frame.width, 3, colors.lightGray))\
\
local Header = Main.frame:newChild(Text(0, 0, 13, 1, '&b8&t0Menu'))\
Header.y = 2\
Header.width = #Header.text - #'&b7&t8'\
Header:alignX('centre')\
\
-- Buttons --\
local Buttons = {\
  _Search = {func=Search, Frame=Main.frame:newChild(Button(0, 5, 18, 3, '&t0Search'))},\
  _Items = {func=Items, Frame=Main.frame:newChild(Button(0, 10, 18, 3, '&t0Items'))},\
  _Account = {func=Account, Frame=Main.frame:newChild(Button(0, 15, 18, 3, '&t0Account'))},\
  --Search = Main.frame:newChild(Button(2, 5, 18, 3, '&t0Search')),\
}\
\
for k, v in pairs(Buttons) do\
  v.Frame.bc = colors.gray\
  v.Frame:alignX('centre')\
  function v.Frame:onClick()\
    v.func:show()\
  end\
end\
\
\
--Buttons.Search:align('centre', 'centre')\
\
--Main.frame:newChild( Text( 2, 5, 46, 3, '&t7What would you like to see a demonstration of?' ) )",
  [ "/rom/help/fs" ] = "Functions in the Filesystem API:\
fs.list( path )\
fs.find( wildcard )\
fs.exists( path )\
fs.isDir( path )\
fs.isReadOnly( path )\
fs.getDir( path )\
fs.getName( path )\
fs.getSize( path )\
fs.getDrive( path )\
fs.getFreeSpace( path )\
fs.makeDir( path )\
fs.move( path, path )\
fs.copy( path, path )\
fs.delete( path )\
fs.combine( path, localpath )\
fs.open( path, mode )\
Available fs.open() modes are \"r\", \"w\", \"a\", \"rb\", \"wb\" and \"ab\".\
\
Functions on files opened with mode \"r\":\
readLine()\
readAll()\
close()\
\
Functions on files opened with mode \"w\" or \"a\":\
write( string )\
writeLine( string )\
flush()\
close()\
\
Functions on files opened with mode \"rb\":\
read()\
close()\
\
Functions on files opened with mode \"wb\" or \"ab\":\
write( byte )\
flush()\
close()",
  [ "/rom/help/colours" ] = "Functions in the colours api\
(used for redstone.setBundledOutput):\
colours.combine( colour1, colour2, colour3, ...)\
colours.subtract( colours, colour1, colour2, ...)\
colours.test( colours, colour )\
\
Colour constants in the colours api, in ascending bit order:\
colours.white, colours.orange, colours.magenta, colours.lightBlue, colours.yellow, colours.lime, colours.pink, colours.grey, colours.lightGrey, colours.cyan, colours.purple, colours.blue, colours.brown, colours.green, colours.red, colours.black.",
  [ "/Flare/version/1.2/lib/UI/draw/pixel.lua" ] = "\
local function pixel( buffer, x, y, bc, tc, char )\
    buffer:setColours( bc, tc )\
    buffer:drawPixel( x, y, char )\
end\
\
return pixel",
  [ "/rom/apis/paintutils" ] = "\
local function drawPixelInternal( xPos, yPos )\
    term.setCursorPos( xPos, yPos )\
    term.write(\" \")\
end\
\
local tColourLookup = {}\
for n=1,16 do\
    tColourLookup[ string.byte( \"0123456789abcdef\",n,n ) ] = 2^(n-1)\
end\
\
function loadImage( sPath )\
    if type( sPath ) ~= \"string\" then\
        error( \"Expected path\", 2 )\
    end\
\
    local tImage = {}\
    if fs.exists( sPath ) then\
        local file = io.open(sPath, \"r\" )\
        local sLine = file:read()\
        while sLine do\
            local tLine = {}\
            for x=1,sLine:len() do\
                tLine[x] = tColourLookup[ string.byte(sLine,x,x) ] or 0\
            end\
            table.insert( tImage, tLine )\
            sLine = file:read()\
        end\
        file:close()\
        return tImage\
    end\
    return nil\
end\
\
function drawPixel( xPos, yPos, nColour )\
    if type( xPos ) ~= \"number\" or type( yPos ) ~= \"number\" or (nColour ~= nil and type( nColour ) ~= \"number\") then\
        error( \"Expected x, y, colour\", 2 )\
    end\
    if nColour then\
        term.setBackgroundColor( nColour )\
    end\
    drawPixelInternal( xPos, yPos )\
end\
\
function drawLine( startX, startY, endX, endY, nColour )\
    if type( startX ) ~= \"number\" or type( startX ) ~= \"number\" or\
       type( endX ) ~= \"number\" or type( endY ) ~= \"number\" or\
       (nColour ~= nil and type( nColour ) ~= \"number\") then\
        error( \"Expected startX, startY, endX, endY, colour\", 2 )\
    end\
    \
    startX = math.floor(startX)\
    startY = math.floor(startY)\
    endX = math.floor(endX)\
    endY = math.floor(endY)\
\
    if nColour then\
        term.setBackgroundColor( nColour )\
    end\
    if startX == endX and startY == endY then\
        drawPixelInternal( startX, startY )\
        return\
    end\
    \
    local minX = math.min( startX, endX )\
    if minX == startX then\
        minY = startY\
        maxX = endX\
        maxY = endY\
    else\
        minY = endY\
        maxX = startX\
        maxY = startY\
    end\
\
    -- TODO: clip to screen rectangle?\
        \
    local xDiff = maxX - minX\
    local yDiff = maxY - minY\
            \
    if xDiff > math.abs(yDiff) then\
        local y = minY\
        local dy = yDiff / xDiff\
        for x=minX,maxX do\
            drawPixelInternal( x, math.floor( y + 0.5 ) )\
            y = y + dy\
        end\
    else\
        local x = minX\
        local dx = xDiff / yDiff\
        if maxY >= minY then\
            for y=minY,maxY do\
                drawPixelInternal( math.floor( x + 0.5 ), y )\
                x = x + dx\
            end\
        else\
            for y=minY,maxY,-1 do\
                drawPixelInternal( math.floor( x + 0.5 ), y )\
                x = x - dx\
            end\
        end\
    end\
end\
\
function drawBox( startX, startY, endX, endY, nColour )\
    if type( startX ) ~= \"number\" or type( startX ) ~= \"number\" or\
       type( endX ) ~= \"number\" or type( endY ) ~= \"number\" or\
       (nColour ~= nil and type( nColour ) ~= \"number\") then\
        error( \"Expected startX, startY, endX, endY, colour\", 2 )\
    end\
\
    startX = math.floor(startX)\
    startY = math.floor(startY)\
    endX = math.floor(endX)\
    endY = math.floor(endY)\
\
    if nColour then\
        term.setBackgroundColor( nColour )\
    end\
    if startX == endX and startY == endY then\
        drawPixelInternal( startX, startY )\
        return\
    end\
\
    local minX = math.min( startX, endX )\
    if minX == startX then\
        minY = startY\
        maxX = endX\
        maxY = endY\
    else\
        minY = endY\
        maxX = startX\
        maxY = startY\
    end\
\
    for x=minX,maxX do\
        drawPixelInternal( x, minY )\
        drawPixelInternal( x, maxY )\
    end\
\
    if (maxY - minY) >= 2 then\
        for y=(minY+1),(maxY-1) do\
            drawPixelInternal( minX, y )\
            drawPixelInternal( maxX, y )\
        end\
    end\
end\
\
function drawFilledBox( startX, startY, endX, endY, nColour )\
    if type( startX ) ~= \"number\" or type( startX ) ~= \"number\" or\
       type( endX ) ~= \"number\" or type( endY ) ~= \"number\" or\
       (nColour ~= nil and type( nColour ) ~= \"number\") then\
        error( \"Expected startX, startY, endX, endY, colour\", 2 )\
    end\
\
    startX = math.floor(startX)\
    startY = math.floor(startY)\
    endX = math.floor(endX)\
    endY = math.floor(endY)\
\
    if nColour then\
        term.setBackgroundColor( nColour )\
    end\
    if startX == endX and startY == endY then\
        drawPixelInternal( startX, startY )\
        return\
    end\
\
    local minX = math.min( startX, endX )\
    if minX == startX then\
        minY = startY\
        maxX = endX\
        maxY = endY\
    else\
        minY = endY\
        maxX = startX\
        maxY = startY\
    end\
\
    for x=minX,maxX do\
        for y=minY,maxY do\
            drawPixelInternal( x, y )\
        end\
    end\
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\
                term.setBackgroundColor( tLine[x] )\
                drawPixelInternal( x + xPos - 1, y + yPos - 1 )\
            end\
        end\
    end\
end",
  [ "/rom/help/credits" ] = "ComputerCraft was created by Daniel \"dan200\" Ratcliffe, with additional code by Aaron \"Cloudy\" Mills.\
Thanks to nitrogenfingers, GopherATL and RamiLego for program contributions.\
Thanks to Mojang, the Forge team, and the MCP team.\
Uses LuaJ from http://luaj.sourceforge.net/\
\
Join the ComputerCraft community online at http://www.computercraft.info\
Follow @DanTwoHundred on Twitter!",
  [ "/rom/help/redstoneapi" ] = "Functions in the Redstone API:\
redstone.getSides( )\
redstone.getInput( side )\
redstone.setOutput( side, boolean )\
redstone.getOutput( side )\
redstone.getAnalogInput( side )\
redstone.setAnalogOutput( side, number )\
redstone.getAnalogOutput( side )\
\
Functions in the Redstone API for working with bundled cables:\
redstone.getBundledInput( side )\
redstone.testBundledInput( side, color )\
redstone.setBundledOutput( side, colors )\
redstone.getBundledOutput( side )\
Type \"help bundled\" for usage examples.\
\
Events emitted by the redstone API:\
\"redstone\", when the state of any redstone input changes. Use getInput() or getBundledInput() to inspect the changes\
Type \"help events\" to learn about the event system.",
  [ "/rom/help/shell" ] = "shell is the toplevel program which interprets commands and runs program.\
Type \"help shellapi\" for information about the shell lua api.",
  [ "/Flare/version/1.2/lib/UI/elements/Button.lua" ] = "\
local class = require \"lib.class\"\
local base = require \"lib.UI.base\"\
local formatter = require \"lib.UI.text.formatter\"\
local drawtext = require \"lib.UI.draw.text\"\
local mouse = require \"lib.UI.event.mouse\"\
\
local Button = class \"Button\"\
Button:extend( base )\
\
Button.bc = \"white\"\
Button.tc = \"grey\"\
\
Button.noAlign = false\
\
Button.mouse_click_timeout = .4\
\
function Button:Button( x, y, w, h, text )\
    self:base( x, y, w, h )\
\
    self.text = text or \"\"\
    self:update( 0 )\
end\
\
function Button:update( dt )\
    self.metadata = {\
        bc = self.bc;\
        tc = self.tc;\
        width = self.width;\
        height = self.height;\
    }\
    self.lines = formatter.lines( self.text, self.metadata )\
    self.fmt = formatter.renderPrep( self.lines, self.metadata )\
end\
\
function Button:draw( x, y, buffer )\
    if not self.noAlign then\
        formatter.fixAlignment( self.fmt, self.width, self.height, \"centre\", \"centre\" )\
    end\
    drawtext( self, self.fmt, x, y, buffer )\
end\
\
function Button:handle( event )\
    if mouse.click( self, event ) then\
        local protocol, target = mouse.text_link_check( self.lines, event:getParam \"x\", event:getParam \"y\", self.fmt.offset )\
        if protocol and self.onLinkOpened then\
            self:onLinkOpened( protocol, target )\
        elseif self.onClick then\
            self:onClick( protocol, target )\
        end\
    elseif event.name == \"mouse_ping\" then\
        mouse.ping( self, event )\
    end\
end\
\
return Button",
  [ "/rom/help/copy" ] = "cp copies a file or directory from one location to another.\
\
ex:\
\"cp rom myrom\" copies \"rom\" to \"myrom\".\
\"cp rom mystuff/rom\" copies \"rom\" to \"mystuff/rom\".\
\"cp disk/* disk2\" copies the contents of one disk to another",
  [ "/Flare/version/1.2/lib/UI/elements/Frame.lua" ] = "\
local class = require \"lib.class\"\
local base = require \"lib.UI.base\"\
local mouse = require \"lib.UI.event.mouse\"\
\
local Frame = class \"Frame\"\
Frame:extend( base )\
\
function Frame:Frame( x, y, w, h )\
    self:base( x, y, w, h )\
    \
    self.children = {}\
    self.ox = 0\
    self.oy = 0\
\
    self.stack = \"none\"\
    self.padding = 0\
\
    return self\
end\
\
function Frame:newChild( child )\
    if child.parent then\
        child.parent:removeChild( child )\
    end\
    self.children[#self.children + 1] = child\
    child.parent = self\
    child.root.__index = self.root\
    child.root.__newindex = self.root\
    return child\
end\
\
function Frame:removeChild( child )\
    for i = #self.children, 1, -1 do\
        if self.children[i] == child then\
            table.remove( self.children, i )\
            child.parent = nil\
            child.root.__index = nil\
            child.root.__newindex = nil\
            break\
        end\
    end\
    return self\
end\
\
function Frame:draw( x, y, buffer )\
    for i = 1, #self.children do\
        self.children[i]:draw( x + self.children[i].x - 1 + self.ox, y + self.children[i].y - 1 + self.oy, buffer )\
    end\
end\
\
function Frame:update( dt )\
    if self.stack == \"vertical\" then\
        for i = 2, #self.children do\
            self.children[i].y = self.children[i-1].y + self.children[i-1].height + self.padding\
        end\
    elseif self.stack == \"horizontal\" then\
        for i = 2, #self.children do\
            self.children[i].x = self.children[i-1].x + self.children[i-1].width + self.padding\
        end\
    end\
    local ch = self:getContentHeight()\
    if ch <= self.height then\
    elseif self.oy < self.height - ch then\
        self.oy = self.height - ch\
    elseif self.oy > 0 then\
        self.oy = 0\
    end\
    local cw = self:getContentWidth()\
    if cw <= self.width then\
    elseif self.ox < self.width - cw then\
        self.ox = self.width - cw\
    elseif self.ox > 0 then\
        self.ox = 0\
    end\
    for i = #self.children, 1, -1 do\
        self.children[i]:update( dt )\
    end\
end\
\
function Frame:handle( event )\
    if event.name == \"mouse_down\" or event.name == \"mouse_up\" or event.name == \"mouse_drag\" then\
        local within = event:getParam \"within\" ~= false and mouse.within( self, event ) or false\
        for i = #self.children, 1, -1 do\
            local child = self.children[i]\
            child:handle( event:clone {\
                x = event:getParam \"x\" - child.x + 1 - self.ox;\
                y = event:getParam \"y\" - child.y + 1 - self.oy;\
                within = within;\
            } )\
        end\
    elseif event.name == \"mouse_scroll\" then\
        local within = event:getParam \"within\" ~= false and mouse.within( self, event ) or false\
        for i = #self.children, 1, -1 do\
            local child = self.children[i]\
            child:handle( event:clone {\
                x = event:getParam \"x\" - child.x + 1 - self.ox;\
                y = event:getParam \"y\" - child.y + 1 - self.oy;\
                within = within;\
            } )\
        end\
        if not event.handled and mouse.within( self, event ) and event:getParam \"direction\" == 1 and self.height - self.oy < self:getContentHeight() then\
            event.handled = true\
            self.oy = self.oy - 1\
        elseif not event.handled and mouse.within( self, event ) and event:getParam \"direction\" == -1 and self.oy < 0 then\
            event.handled = true\
            self.oy = self.oy + 1\
        end\
    elseif event.name == \"mouse_ping\" then\
        mouse.ping( self, event )\
        for i = #self.children, 1, -1 do\
            self.children[i]:handle( event )\
        end\
    else\
        for i = #self.children, 1, -1 do\
            self.children[i]:handle( event )\
        end\
    end\
end\
\
function Frame:getContentWidth()\
    local w = 0\
    for i = 1, #self.children do\
        w = math.max( self.children[i].x + self.children[i].width - 1, w )\
    end\
    return w\
end\
\
function Frame:getContentHeight()\
    local h = 0\
    for i = 1, #self.children do\
        h = math.max( self.children[i].y + self.children[i].height - 1, h )\
    end\
    return h\
end\
\
function Frame:getContentScrollX()\
    return -self.ox\
end\
\
function Frame:setContentScrollX( scroll )\
    self.ox = math.min( math.max( -scroll, self.width - self:getContentWidth() ), 0 )\
end\
\
function Frame:getContentScrollY()\
    return -self.oy\
end\
\
function Frame:setContentScrollY( scroll )\
    self.oy = math.min( math.max( -scroll, self.height - self:getContentHeight() ), 0 )\
end\
\
return Frame",
  [ "/rom/programs/fun/adventure" ] = "\
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\",\
}\
\
local function hasTrees( _nBiome )\
    return _nBiome <= 3\
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 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 bInjured = false\
\
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 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\
        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\
    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+)\",\
        \"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\",\
    },\
}\
\
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( 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\
        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\
        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.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?\",\
    }\
    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\
    \
    -- 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 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\
                        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\
    nTurn = nTurn + 1\
    nTimeInRoom = nTimeInRoom + 1\
end\
\
doCommand( \"look\" )\
simulate()\
\
local tCommandHistory = {}\
while bRunning do\
    if term.isColour() then\
        term.setTextColour( colours.yellow )\
    end\
    write( \"? \" )\
    term.setTextColour( colours.white )\
        \
    local sRawLine = read( nil, tCommandHistory )\
    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 then\
        simulate()\
    end\
end",
  [ "/Shop/States/Search.lua" ] = "local StateLib = FDK.require('lib.state')\
local State = StateLib.names.Init\
local Main = StateLib.names.Main\
local Search = StateLib.names.Search\
local Account = StateLib.names.Account\
local Items = StateLib.names.Items\
\
local Field = FDK.require('lib.UI.elements.Field')\
local Text = FDK.require('lib.UI.elements.Text')\
local Button = FDK.require('lib.UI.elements.Button')\
local ScrollBar = FDK.require('lib.UI.elements.ScrollBar')\
local Frame = FDK.require('lib.UI.elements.ClippingFrame')\
\
-- Main Field\
Search.frame:newChild(Field(1, 1, Search.frame.width, Search.frame.height, colors.white))\
-- Header Field\
Search.frame:newChild(Field(1, 1, Search.frame.width, 3, colors.lightGray))\
\
local back = Search.frame:newChild( Button( 1, 1, 8, 3, \"< back\" ) )\
back.bc = colors.lightGray\
back.tc = colors.white\
\
function back:onClick()\
  Main:show()\
end\
\
local SearchFrame = Search.frame:newChild(Frame(1, 4,\
  Search.frame.width-2,\
  Search.frame.height-3\
))\
local SearchBar = Search.frame:newChild(ScrollBar(Search.frame.width, 4, 1, Search.frame.height-3, SearchFrame))",
  [ "/Flare/version/1.2/lib/UI/draw/draw.lua" ] = "\
local image = require \"lib.UI.draw.image\"\
local pixel = require \"lib.UI.draw.pixel\"\
local pixelbatch = require \"lib.UI.draw.pixelbatch\"\
local text = require \"lib.UI.draw.text\"\
\
return {\
    image = image;\
    pixel = pixel;\
    pixelbatch = pixelbatch;\
    text = text;\
}",
  [ "/rom/help/edit" ] = "edit is a text editor for creating or modifying programs or text files. After creating a program with edit, type its filename in the shell to run it. You can open any of the builtin programs with edit to learn how to program.\
\
ex:\
\"edit hello\" opens a file called \"hello\" for editing.",
  [ "/rom/help/clear" ] = "clear clears the screen.",
  [ "/Flare/version/1.2/lib/UI/elements/ScrollBar.lua" ] = "\
local class = require \"lib.class\"\
local base = require \"lib.UI.base\"\
local mouse = require \"lib.UI.event.mouse\"\
local graphics = require \"lib.graphics\"\
\
-- bar / tray = object / children\
-- scroll = ( height - bar ) * tscroll / ( tcontent - theight )\
\
local function scrollStats( self )\
    if not self.target then\
        return 0, self.direction == \"vertical\" and self.height or self.width\
    end\
    local objectsize = self.direction == \"vertical\" and self.target.height or self.target.width\
    local childrensize = self.direction == \"vertical\" and self.target:getContentHeight() or self.target:getContentWidth()\
    local trayheight = self.direction == \"vertical\" and self.height or self.width\
    local barheight = math.min( math.max( math.ceil( trayheight * ( objectsize / childrensize ) ), 1 ), trayheight )\
\
    local tscroll = self.direction == \"vertical\" and self.target:getContentScrollY() or self.target:getContentScrollX()\
    local scroll = math.floor( ( trayheight - barheight ) * tscroll / ( childrensize - objectsize ) )\
\
    return scroll, barheight, objectsize, childrensize, trayheight, tscroll\
end\
\
local ScrollBar = class \"ScrollBar\"\
ScrollBar:extend( base )\
\
ScrollBar.tc = \"grey\" -- tray colour\
ScrollBar.bc = \"lightGrey\" -- bar colour\
\
ScrollBar.direction = \"vertical\"\
\
function ScrollBar:ScrollBar( x, y, w, h, target )\
    self:base( x, y, w, h )\
    self.target = target\
end\
\
function ScrollBar:draw( x, y, buffer )\
    buffer:setColours( graphics.colour( self.tc ) )\
    buffer:drawFilledRectangle( x, y, self.width, self.height )\
\
    local scroll, size = scrollStats( self )\
\
    buffer:setColours( graphics.colour( self.bc ) )\
\
    if self.direction == \"vertical\" then\
        buffer:drawFilledRectangle( x, y + scroll, self.width, size )\
    else\
        buffer:drawFilledRectangle( x + scroll, y, size, self.height )\
    end\
end\
\
function ScrollBar:handle( event )\
    local mode, x, y = mouse.drag( self, event )\
    if mode == \"down\" then\
        local scroll, barheight, objectsize, childrensize, trayheight, tscroll = scrollStats( self )\
        local pos\
        if self.direction == \"vertical\" then\
            if y > scroll and y <= scroll + barheight then\
                pos = \"inside\"\
            elseif y <= scroll then\
                pos = \"below\"\
            elseif y > scroll + barheight then\
                pos = \"above\"\
            end\
        else\
            if x > scroll and x <= scroll + barheight then\
                pos = \"inside\"\
            elseif x <= scroll then\
                pos = \"below\"\
            elseif x > scroll + barheight then\
                pos = \"above\"\
            end\
        end\
\
        if pos == \"inside\" then\
            self.down = self.direction == \"vertical\" and ( y - scroll ) or ( x - scroll )\
        elseif pos == \"below\" then\
            scroll = self.direction == \"vertical\" and y - 1 or x - 1\
        elseif pos == \"above\" then\
            scroll = self.direction == \"vertical\" and y - barheight or x - barheight\
        end\
\
        if pos ~= \"inside\" then\
            self.down = false\
            local method = self.direction == \"vertical\" and \"setContentScrollY\" or \"setContentScrollX\"\
            self.target[method]( self.target, math.floor( scroll / ( trayheight - barheight ) * ( childrensize - objectsize ) + .5 ) )\
        end\
    elseif mode == \"drag\" and self.down then\
        event.handled = true\
        local x, y = event:getParam \"x\", event:getParam \"y\"\
        local scroll, barheight, objectsize, childrensize, trayheight, tscroll = scrollStats( self )\
\
        scroll = ( self.direction == \"vertical\" and ( y - self.down ) or ( x - self.down ) )\
\
        local method = self.direction == \"vertical\" and \"setContentScrollY\" or \"setContentScrollX\"\
        self.target[method]( self.target, math.floor( scroll / ( trayheight - barheight ) * ( childrensize - objectsize ) + .5 ) )\
    end\
    if event.name == \"mouse_scroll\" and not event.handled and mouse.within( self, event ) then\
        event.handled = true\
        local scroll, barheight, objectsize, childrensize, trayheight, tscroll = scrollStats( self )\
        if event:getParam \"direction\" == 1 then\
            scroll = scroll + 1\
        elseif event:getParam \"direction\" == -1 then\
            scroll = scroll - 1\
        end\
        local method = self.direction == \"vertical\" and \"setContentScrollY\" or \"setContentScrollX\"\
        self.target[method]( self.target, math.floor( scroll / ( trayheight - barheight ) * ( childrensize - objectsize ) + .5 ) )\
    elseif event.name == \"mouse_ping\" then\
        mouse_event.ping( self, event )\
    end\
end\
\
return ScrollBar",
  [ "/rom/help/label" ] = "label gets or sets the label of the Computer, or of Floppy Disks in attached disk drives.\
\
ex:\
\"label get\" prints the label of the computer.\
\"label get left\" prints the label of the disk in the left drive.\
\"label set \"My Computer\"\" set the label of the computer to \"My Computer\".\
\"label set left \"My Programs\"\" - sets the label of the disk in the left drive to \"My Programs\".\
\"label clear\" clears the label of the computer.\
\"label clear left\" clears the label of the disk in the left drive.",
  [ "/rom/programs/fun/hello" ] = "if term.isColour() then\
    term.setTextColour( 2^math.random(0,15) )\
end\
textutils.slowPrint( \"Hello World!\" )\
term.setTextColour( colours.white )",
  [ "/rom/help/colors" ] = "Functions in the colors api\
(used for redstone.setBundledOutput):\
colors.combine( color1, color2, color3, ... )\
colors.subtract( colors, color1, color2, ... )\
colors.test( colors, color )\
\
Color constants in the colors api, in ascending bit order:\
colors.white, colors.orange, colors.magenta, colors.lightBlue, colors.yellow, colors.lime, colors.pink, colors.gray, colors.lightGray, colors.cyan, colors.purple, colors.blue, colors.brown, colors.green, colors.red, colors.black.",
  [ "/rom/programs/fun/advanced/levels/3" ] = "2\
  77777777\
777888188777\
7b78777787b7\
78787  78787\
78787  78787\
78887  78887\
777877778777\
  78838887\
  77777777",
  [ "/rom/programs/advanced/bg" ] = "\
local tArgs = { ... }\
if #tArgs > 0 then\
    shell.openTab( unpack( tArgs ) )\
else\
    shell.openTab( \"shell\" )\
end",
  [ "/run" ] = "shell.run('Shop/run')",
  [ "/rom/apis/colours" ] = "-- Colours (for lovers of british spelling)\
local fnFile, err = loadfile(\"/rom/apis/colors\")\
if not fnFile then\
    error( err )\
end\
\
local tColors = {}\
setmetatable( tColors, { __index = _G } )\
setfenv( fnFile, tColors )\
fnFile( tColors )\
\
local tColours = getfenv()\
for k,v in pairs( tColors ) do\
    tColours[k] = v\
end\
\
tColours.gray = nil\
tColours.grey = tColors.gray\
\
tColours.lightGray = nil\
tColours.lightGrey = tColors.lightGray",
  [ "/rom/help/gpsapi" ] = "Functions in the GPS API:\
gps.locate( timeout )\
\
The locate function will send a signal to nearby gps servers, and wait for responses before the timeout. If it receives enough responses to determine this computers position then x, y and z co-ordinates will be returned, otherwise it will return nil. If GPS hosts do not have their positions configured correctly, results will be inaccurate.",
  [ "/rom/help/pastebin" ] = "pastebin is a program for uploading files to and downloading files from pastebin.com. This is useful for sharing programs with other players.\
The HTTP API must be enabled in ComputerCraft.cfg to use this program.\
\
ex:\
\"pastebin put foo\" will upload the file \"foo\" to pastebin.com, and print the URL.\
\"pastebin get xq5gc7LB foo\" will download the file from the URL http://pastebin.com/xq5gc7LB, and save it as \"foo\".\
\"pastebin run CxaWmPrX\" will download the file from the URL http://pastebin.com/CxaWmPrX, and immediately run it.",
  [ "/rom/autorun/.ignoreme" ] = "--[[\
Alright then, don't ignore me. This file is to ensure the existance of the \"autorun\" folder, files placed in this folder\
using resource packs will always run when computers startup.\
]]",
  [ "/rom/programs/time" ] = "local nTime = os.time()\
local nDay = os.day()\
print( \"The time is \"..textutils.formatTime( nTime, false )..\" on Day \"..nDay )",
  [ "/rom/help/monitor" ] = "monitor will connect to an attached Monitor peripheral, and run a program on its display.\
\
ex:\
\"monitor left hello\" will run the \"hello\" program on the monitor to the left of the computer.\
\"monitor top edit foo\" will run the edit program on the top monitor, editing the file \"foo\".",
  [ "/rom/help/io" ] = "io is a standard Lua5.1 API, reimplemented for CraftOS. Not all the features are availiable.\
Refer to http://www.lua.org/manual/5.1/ for more information.",
  [ "/rom/programs/http/pastebin" ] = "\
local function printUsage()\
    print( \"Usages:\" )\
    print( \"pastebin put <filename>\" )\
    print( \"pastebin get <code> <filename>\" )\
    print( \"pastebin run <code> <arguments>\" )\
end\
 \
local tArgs = { ... }\
if #tArgs < 2 then\
    printUsage()\
    return\
end\
 \
if not http then\
    printError( \"Pastebin requires http API\" )\
    printError( \"Set http_enable to true in ComputerCraft.cfg\" )\
    return\
end\
 \
local function get(paste)\
    write( \"Connecting to pastebin.com... \" )\
    local response = http.get(\
        \"http://pastebin.com/raw.php?i=\"..textutils.urlEncode( paste )\
    )\
        \
    if response then\
        print( \"Success.\" )\
        \
        local sResponse = response.readAll()\
        response.close()\
        return sResponse\
    else\
        printError( \"Failed.\" )\
    end\
end\
 \
local sCommand = tArgs[1]\
if sCommand == \"put\" then\
    -- Upload a file to pastebin.com\
    -- Determine file to upload\
    local sFile = tArgs[2]\
    local sPath = shell.resolve( sFile )\
    if not fs.exists( sPath ) or fs.isDir( sPath ) then\
        print( \"No such file\" )\
        return\
    end\
    \
    -- Read in the file\
    local sName = fs.getName( sPath )\
    local file = fs.open( sPath, \"r\" )\
    local sText = file.readAll()\
    file.close()\
    \
    -- POST the contents to pastebin\
    write( \"Connecting to pastebin.com... \" )\
    local key = \"0ec2eb25b6166c0c27a394ae118ad829\"\
    local response = http.post(\
        \"http://pastebin.com/api/api_post.php\", \
        \"api_option=paste&\"..\
        \"api_dev_key=\"..key..\"&\"..\
        \"api_paste_format=lua&\"..\
        \"api_paste_name=\"..textutils.urlEncode(sName)..\"&\"..\
        \"api_paste_code=\"..textutils.urlEncode(sText)\
    )\
        \
    if response then\
        print( \"Success.\" )\
        \
        local sResponse = response.readAll()\
        response.close()\
                \
        local sCode = string.match( sResponse, \"[^/]+$\" )\
        print( \"Uploaded as \"..sResponse )\
        print( \"Run \\\"pastebin get \"..sCode..\"\\\" to download anywhere\" )\
 \
    else\
        print( \"Failed.\" )\
    end\
    \
elseif sCommand == \"get\" then\
    -- Download a file from pastebin.com\
    if #tArgs < 3 then\
        printUsage()\
        return\
    end\
 \
    -- Determine file to download\
    local sCode = tArgs[2]\
    local sFile = tArgs[3]\
    local sPath = shell.resolve( sFile )\
    if fs.exists( sPath ) then\
        print( \"File already exists\" )\
        return\
    end\
    \
    -- GET the contents from pastebin\
    local res = get(sCode)\
    if res then        \
        local file = fs.open( sPath, \"w\" )\
        file.write( res )\
        file.close()\
        \
        print( \"Downloaded as \"..sFile )\
    end \
elseif sCommand == \"run\" then\
    local sCode = tArgs[2]\
 \
    local res = get(sCode)\
    if res then\
        local func, err = loadstring(res)\
        if not func then\
            printError( err )\
            return\
        end\
        setfenv(func, getfenv())\
        local success, msg = pcall(func, unpack(tArgs, 3))\
        if not success then\
            printError( msg )\
        end\
    end\
else\
    printUsage()\
    return\
end",
  [ "/rom/programs/pocket/falling" ] = "--[[\
Falling - Based on Tetris by Alexey Pajitnov\
This version written by Gopher, at the request of Dan200, for\
ComputerCraft v1.6. No particular rights are reserved.\
--]]\
\
local function colorass(c,bw)\
  return term.isColor() and c or bw\
end\
\
local block_s1= {\
    {\
      { 1,0,0,0, },\
      { 1,1,0,0, },\
      { 0,1,0,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 0,0,0,0, },\
      { 0,1,1,0, },\
      { 1,1,0,0, },\
      { 0,0,0,0, },\
    },\
    ch=colorass(\"  \",\"{}\"),\
    fg=colorass(colors.blue,colors.black),\
    bg=colorass(colors.cyan,colors.white),\
  }\
local block_s2= {\
    {\
      { 0,1,0,0, },\
      { 1,1,0,0, },\
      { 1,0,0,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 0,0,0,0, },\
      { 1,1,0,0, },\
      { 0,1,1,0, },\
      { 0,0,0,0, },\
    },\
    ch=colorass(\"  \",\"{}\"),\
    fg=colorass(colors.green,colors.black),\
    bg=colorass(colors.lime,colors.white),\
  }\
local block_line = {\
    {\
      { 0,1,0,0, },\
      { 0,1,0,0, },\
      { 0,1,0,0, },\
      { 0,1,0,0, },\
    },\
    {\
      { 0,0,0,0, },\
      { 1,1,1,1, },\
      { 0,0,0,0, },\
      { 0,0,0,0, },\
    },\
    ch=colorass(\"  \",\"[]\"),\
    fg=colorass(colors.pink,colors.black),\
    bg=colorass(colors.red,colors.white),\
  }\
local block_square = {\
    {\
      { 1,1,0,0, },\
      { 1,1,0,0, },\
      { 0,0,0,0, },\
      { 0,0,0,0, },\
    },\
    ch=colorass(\"  \",\"[]\"),\
    fg=colorass(colors.lightBlue,colors.black),\
    bg=colorass(colors.blue,colors.white),\
  }\
local block_L1 = {\
    {\
      { 1,1,0,0, },\
      { 0,1,0,0, },\
      { 0,1,0,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 0,0,0,0, },\
      { 1,1,1,0, },\
      { 1,0,0,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 0,1,0,0, },\
      { 0,1,0,0, },\
      { 0,1,1,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 0,0,1,0, },\
      { 1,1,1,0, },\
      { 0,0,0,0, },\
      { 0,0,0,0, },\
    },\
    ch=colorass(\"  \",\"()\"),\
    fg=colorass(colors.orange,colors.black),\
    bg=colorass(colors.yellow,colors.white),\
  }\
local block_L2 = {\
    {\
      { 0,1,0,0, },\
      { 0,1,0,0, },\
      { 1,1,0,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 0,0,0,0, },\
      { 1,1,1,0, },\
      { 0,0,1,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 0,1,1,0, },\
      { 0,1,0,0, },\
      { 0,1,0,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 1,0,0,0, },\
      { 1,1,1,0, },\
      { 0,0,0,0, },\
      { 0,0,0,0, },\
    },\
    ch=colorass(\"  \",\"()\"),\
    fg=colorass(colors.brown,colors.black),\
    bg=colorass(colors.orange,colors.white),\
  }\
local block_T = {\
    {\
      { 0,1,0,0, },\
      { 1,1,0,0, },\
      { 0,1,0,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 0,0,0,0, },\
      { 1,1,1,0, },\
      { 0,1,0,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 0,1,0,0, },\
      { 0,1,1,0, },\
      { 0,1,0,0, },\
      { 0,0,0,0, },\
    },\
    {\
      { 0,1,0,0, },\
      { 1,1,1,0, },\
      { 0,0,0,0, },\
      { 0,0,0,0, },\
    },\
    ch=colorass(\"  \",\"<>\"),\
    fg=colorass(colors.cyan,colors.black),\
    bg=colorass(colors.purple,colors.white),\
  }\
\
local blocks={ block_line, block_square, block_s1, block_s2, block_L1, block_L2, block_T}\
\
local points={4,10,30,120}\
\
local function lpad(text,amt)\
  text=tostring(text)\
  return string.rep(\" \",amt-#text)..text\
end\
\
local width,height=term.getSize()\
\
if height<19 or width<26 then\
  print(\"Your screen is too small to play :(\")\
  return\
end\
\
\
local speedsByLevel={\
  1.2,\
  1.0,\
   .8,\
   .65,\
   .5,\
   .4,\
   .3,\
   .25,\
   .2,\
   .15,\
   .1,\
   .05,}\
\
local level=1\
\
local function playGame()\
  local score=0\
  local lines=0\
  local initialLevel=level\
  local next=blocks[math.random(1,#blocks)]\
\
  local pit={}\
\
\
  local heightAdjust=0\
\
  if height<=19 then\
    heightAdjust=1\
  end\
\
\
\
  local function drawScreen()\
    term.setTextColor(colors.white)\
    term.setBackgroundColor(colors.black)\
    term.clear()\
\
    term.setTextColor(colors.black)\
    term.setBackgroundColor(colorass(colors.lightGray, colors.white))\
    term.setCursorPos(22,2)\
    term.write(\"Score\") --score\
    term.setCursorPos(22,5)\
    term.write(\"Level\")  --level\
    term.setCursorPos(22,8)\
    term.write(\"Lines\")  --lines\
    term.setCursorPos(22,12)\
    term.write(\"Next\") --next\
\
    term.setCursorPos(21,1)\
    term.write(\"      \")\
    term.setCursorPos(21,2)\
    term.write(\" \") --score\
    term.setCursorPos(21,3)\
    term.write(\" \")\
    term.setCursorPos(21,4)\
    term.write(\"      \")\
    term.setCursorPos(21,5)\
    term.write(\" \")  --level\
    term.setCursorPos(21,6)\
    term.write(\" \")\
    term.setCursorPos(21,7)\
    term.write(\"      \")\
    term.setCursorPos(21,8)\
    term.write(\" \")  --lines\
    term.setCursorPos(21,9)\
    term.write(\" \")\
    term.setCursorPos(21,10)\
    term.write(\"      \")\
    term.setCursorPos(21,11)\
    term.write(\"      \")\
    term.setCursorPos(21,12)\
    term.write(\" \") --next\
    term.setCursorPos(26,12)\
    term.write(\" \") --next\
    term.setCursorPos(21,13)\
    term.write(\"      \")\
    term.setCursorPos(21,14)\
    term.write(\" \")\
    term.setCursorPos(21,15)\
    term.write(\" \")\
    term.setCursorPos(21,16)\
    term.write(\" \")\
    term.setCursorPos(21,17)\
    term.write(\" \")\
    term.setCursorPos(21,18)\
    term.write(\" \")\
    term.setCursorPos(21,19)\
    term.write(\"      \")\
    term.setCursorPos(21,20)\
    term.write(\"      \")\
  end\
\
  local function updateNumbers()\
    term.setTextColor(colors.white)\
    term.setBackgroundColor(colors.black)\
\
    term.setCursorPos(22,3)\
    term.write(lpad(score,5)) --score\
    term.setCursorPos(22,6)\
    term.write(lpad(level,5))  --level\
    term.setCursorPos(22,9)\
    term.write(lpad(lines,5))  --lines\
  end\
\
  local function drawBlockAt(block,xp,yp,rot)\
    term.setTextColor(block.fg)\
    term.setBackgroundColor(block.bg)\
    for y=1,4 do\
      for x=1,4 do\
        if block[rot][y][x]==1 then\
          term.setCursorPos((xp+x)*2-3,yp+y-1-heightAdjust)\
          term.write(block.ch)\
        end\
      end\
    end\
  end\
\
  local function eraseBlockAt(block,xp,yp,rot)\
    term.setTextColor(colors.white)\
    term.setBackgroundColor(colors.black)\
    for y=1,4 do\
      for x=1,4 do\
        if block[rot][y][x]==1 then\
          term.setCursorPos((xp+x)*2-3,yp+y-1-heightAdjust)\
          term.write(\"  \")\
        end\
      end\
    end\
  end\
\
  local function testBlockAt(block,xp,yp,rot)\
    for y=1,4 do\
      local ty=yp+y-1\
      for x=1,4 do\
        local tx=xp+x-1\
        if block[rot][y][x]==1 then\
          if tx>10 or tx<1 or ty>20 or pit[ty][tx]~=0 then\
            return true\
          end\
        end\
      end\
    end\
  end\
\
  local function pitBlock(block,xp,yp,rot)\
    for y=1,4 do\
      for x=1,4 do\
        if block[rot][y][x]==1 then\
          pit[yp+y-1][xp+x-1]=block\
        end\
      end\
    end\
  end\
\
\
  local function clearPit()\
    for row=1,20 do\
      pit[row]={}\
      for col=1,10 do\
        pit[row][col]=0\
      end\
    end\
  end\
\
\
\
  drawScreen()\
  updateNumbers()\
\
  --declare & init the pit\
  clearPit()\
\
\
\
  local halt=false\
  local dropSpeed=speedsByLevel[math.min(level,12)]\
\
\
  local curBlock=next\
  next=blocks[math.random(1,7)]\
\
  local curX, curY, curRot=4, 1, 1\
  local dropTimer=os.startTimer(dropSpeed)\
\
  drawBlockAt(next,11.5,15+heightAdjust,1)\
  drawBlockAt(curBlock,curX,curY,curRot)\
\
  local function redrawPit()\
    for r=1+heightAdjust,20 do\
      term.setCursorPos(1,r-heightAdjust)\
      for c=1,10 do\
        if pit[r][c]==0 then\
          term.setTextColor(colors.black)\
          term.setBackgroundColor(colors.black)\
          term.write(\"  \")\
        else\
          term.setTextColor(pit[r][c].fg)\
          term.setBackgroundColor(pit[r][c].bg)\
          term.write(pit[r][c].ch)\
        end\
      end\
    end\
  end\
\
  local function hidePit()\
    for r=1+heightAdjust,20 do\
      term.setCursorPos(1,r-heightAdjust)\
      term.setTextColor(colors.black)\
      term.setBackgroundColor(colors.black)\
      term.write(\"                    \")\
    end\
  end\
\
  local function msgBox(message)\
    local x=math.floor((17-#message)/2)\
    term.setBackgroundColor(colorass(colors.lightGray,colors.white))\
    term.setTextColor(colors.black)\
    term.setCursorPos(x,9)\
    term.write(\"+\"..string.rep(\"-\",#message+2)..\"+\")\
    term.setCursorPos(x,10)\
    term.write(\"|\")\
    term.setCursorPos(x+#message+3,10)\
    term.write(\"|\")\
    term.setCursorPos(x,11)\
    term.write(\"+\"..string.rep(\"-\",#message+2)..\"+\")\
    term.setTextColor(colors.white)\
    term.setBackgroundColor(colors.black)\
    term.setCursorPos(x+1,10)\
    term.write(\" \"..message..\" \")\
  end\
\
  local function clearRows()\
    local rows={}\
    for r=1,20 do\
      local count=0\
      for c=1,10 do\
        if pit[r][c]~=0 then\
          count=count+1\
        else\
          break\
        end\
      end\
      if count==10 then\
        rows[#rows+1]=r\
      end\
    end\
\
    if #rows>0 then\
      for i=1,4 do\
        sleep(.1)\
        for r=1,#rows do\
          r=rows[r]\
          term.setCursorPos(1,r-heightAdjust)\
          for c=1,10 do\
            term.setTextColor(pit[r][c].bg)\
            term.setBackgroundColor(pit[r][c].fg)\
            term.write(pit[r][c].ch)\
          end\
        end\
        sleep(.1)\
        for r=1,#rows do\
          r=rows[r]\
          term.setCursorPos(1,r-heightAdjust)\
          for c=1,10 do\
            term.setTextColor(pit[r][c].fg)\
            term.setBackgroundColor(pit[r][c].bg)\
            term.write(pit[r][c].ch)\
          end\
        end\
      end\
      --now remove the rows and drop everythign else\
      term.setBackgroundColor(colors.black)\
      for r=1,#rows do\
        r=rows[r]\
        term.setCursorPos(1,r-heightAdjust)\
        term.write(\"                    \")\
      end\
      sleep(.25)\
      for r=1,#rows do\
        table.remove(pit,rows[r])\
        table.insert(pit,1,{0,0,0,0,0,0,0,0,0,0})\
      end\
      redrawPit()\
      lines=lines+#rows\
      score=score+points[#rows]*math.min(level,20)\
      level=math.floor(lines/10)+initialLevel\
      dropSpeed=speedsByLevel[math.min(level,12)]\
      updateNumbers()\
    end\
    sleep(.25)\
  end\
\
  local function blockFall()\
    local result = false\
    if testBlockAt(curBlock,curX,curY+1,curRot) then\
      pitBlock(curBlock,curX,curY,curRot)\
      --detect rows that clear\
      clearRows(rows)\
\
      curBlock=next\
      curX=4\
      curY=1\
      curRot=1\
      if testBlockAt(curBlock,curX,curY,curRot) then\
        halt=true\
      end\
      drawBlockAt(curBlock,curX,curY,curRot)\
      eraseBlockAt(next,11.5,15+heightAdjust,1)\
      next=blocks[math.random(1,7)]\
      drawBlockAt(next,11.5,15+heightAdjust,1)\
      return true\
    else\
      eraseBlockAt(curBlock,curX,curY,curRot)\
      curY=curY+1\
      drawBlockAt(curBlock,curX,curY,curRot)\
      return false\
    end\
  end\
\
\
  while not halt do\
    local e={os.pullEvent()}\
    if e[1]==\"timer\" then\
      if e[2]==dropTimer then\
        blockFall()\
        dropTimer=os.startTimer(dropSpeed)\
      end\
    elseif e[1]==\"key\" then\
      local key=e[2]\
      local dx,dy,dr=0,0,0\
      if key==keys.left or key==keys.a then\
        dx=-1\
      elseif key==keys.right or key==keys.d then\
        dx=1\
      elseif key==keys.up or key==keys.w then\
        dr=1\
      elseif key==keys.down or key==keys.s then\
        while not blockFall() do end\
        dropTimer=os.startTimer(dropSpeed)\
      elseif key==keys.space then\
        hidePit()\
        msgBox(\"Paused\")\
        while ({os.pullEvent(\"key\")})[2]~=keys.space do end\
        redrawPit()\
        drawBlockAt(curBlock,curX,curY,curRot)\
        dropTimer=os.startTimer(dropSpeed)\
      end\
      if dx+dr~=0 then\
        if not testBlockAt(curBlock,curX+dx,curY+dy,(dr>0 and curRot%#curBlock+dr or curRot)) then\
          eraseBlockAt(curBlock,curX,curY,curRot)\
          curX=curX+dx\
          curY=curY+dy\
          curRot=dr==0 and curRot or (curRot%#curBlock+dr)\
          drawBlockAt(curBlock,curX,curY,curRot)\
        end\
      end\
    elseif e[1]==\"term_resize\" then\
      local w,h=term.getSize()\
      if h==20 then\
        heightAdjust=0\
      else\
        heightAdjust=1\
      end\
      redrawPit()\
      drawBlockAt(curBlock,curX,curY,curRot)\
    end\
  end\
\
  msgBox(\"Game Over!\")\
  while true do\
    local _,k=os.pullEvent(\"key\")\
    if k==keys.space or k==keys.enter then\
      break\
    end\
  end\
\
  level = math.min(level,9)\
end\
\
\
local selected=1\
local playersDetected=false\
\
local function drawMenu()\
  term.setBackgroundColor(colors.black)\
  term.setTextColor(colorass(colors.red,colors.white))\
  term.clear()\
\
  local cx,cy=math.floor(width/2),math.floor(height/2)\
\
  term.setCursorPos(cx-6,cy-2)\
  term.write(\"F A L L I N G\")\
\
  if playersDetected then\
    if selected==0 then\
      term.setTextColor(colorass(colors.blue,colors.black))\
      term.setBackgroundColor(colorass(colors.gray,colors.white))\
    else\
      term.setTextColor(colorass(colors.lightBlue,colors.white))\
      term.setBackgroundColor(colors.black)\
    end\
    term.setCursorPos(cx-12,cy)\
    term.write(\" Play head-to-head game! \")\
  end\
\
  term.setCursorPos(cx-10,cy+1)\
  if selected==1 then\
    term.setTextColor(colorass(colors.blue,colors.black))\
    term.setBackgroundColor(colorass(colors.lightGray,colors.white))\
  else\
    term.setTextColor(colorass(colors.lightBlue,colors.white))\
    term.setBackgroundColor(colors.black)\
  end\
  term.write(\" Play from level: <\" .. level .. \"> \")\
\
  term.setCursorPos(cx-3,cy+3)\
  if selected==2 then\
    term.setTextColor(colorass(colors.blue,colors.black))\
    term.setBackgroundColor(colorass(colors.lightGray,colors.white))\
  else\
    term.setTextColor(colorass(colors.lightBlue,colors.white))\
    term.setBackgroundColor(colors.black)\
  end\
  term.write(\" Quit \")\
end\
\
\
local function runMenu()\
  drawMenu()\
\
  while true do\
    local event={os.pullEvent()}\
    if event[1]==\"key\" then\
      local key=event[2]\
      if key==keys.right or key==keys.d and selected==1 then\
        level=math.min(level+1,9)\
        drawMenu()\
      elseif key==keys.left or key==keys.a and selected==1 then\
        level=math.max(level-1,1)\
        drawMenu()\
      elseif key>=keys.one and key<=keys.nine and selected==1 then\
        level=(key-keys.one) + 1\
        drawMenu()\
      elseif key==keys.up or key==keys.w then\
        selected=selected-1\
        if selected==0 then\
          selected=2\
        end\
        drawMenu()\
      elseif key==keys.down or key==keys.s then\
        selected=selected%2+1\
        drawMenu()\
      elseif key==keys.enter or key==keys.space then\
        break --begin play!\
      end\
    end\
  end\
end\
\
while true do\
  runMenu()\
  if selected==2 then\
    break\
  end\
\
  playGame()\
end\
\
\
term.setTextColor(colors.white)\
term.setBackgroundColor(colors.black)\
term.clear()\
term.setCursorPos(1,1)",
  [ "/Shop/States/Account.lua" ] = "local StateLib = FDK.require('lib.state')\
local State = StateLib.names.Init\
local Main = StateLib.names.Main\
local Search = StateLib.names.Search\
local Account = StateLib.names.Account\
local Items = StateLib.names.Items\
\
local Field = FDK.require('lib.UI.elements.Field')\
local Text = FDK.require('lib.UI.elements.Text')\
local Button = FDK.require('lib.UI.elements.Button')\
\
-- Main Field\
Account.frame:newChild(Field(1, 1, Account.frame.width, Account.frame.height, colors.white))\
-- Header Field\
Account.frame:newChild(Field(1, 1, Account.frame.width, 3, colors.lightGray))\
\
local back = Account.frame:newChild( Button( 1, 1, 8, 3, \"< back\" ) )\
back.bc = colors.lightGray\
back.tc = colors.white\
\
function back:onClick()\
  Main:show()\
end\
\
local Header = Account.frame:newChild(Text(0, 0, 13, 1, '&b8&t0Account info'))\
Header.y = 2\
Header.width = #Header.text - #'&b7&t8'\
Header:alignX('centre')\
\
local Data = {\
  User = nil,\
  Balance = 100.00,\
  Position = {X = 1, Y = 50, Z = 100},\
  SkyblockPosition = {X = 1, Y = 50, Z = 100},\
}\
\
Account.process:spawnThread(function()\
  while true do\
    local Event, Side, SenderID, ReceiverID, Msg, Distance = coroutine.yield()\
    if Event == 'modem_message' then\
      if SenderID == 2773 then\
        --local File = fs.open('log','a')\
        --File.writeLine(Decompile(textutils.unserialize(Msg)))\
        --File.close()\
        --Data = textutils.unserialize(Decompile(textutils.unserialize(Msg)))\
      end\
    end\
  end\
end)\
Account.process:spawnThread(function()\
  while true do\
    local Texts = {\
      Username = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t7Username:')),\
      _Username = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&td' .. tostring(Data.User)..'                ')),\
      Balance = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t7Balance:')),\
      _Balance = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t1' .. tostring(Data.Balance)..'                ')),\
      Position = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t7Position')),\
      PositionX = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t7X:&b0&tb' .. tostring(Data.Position.X)..'                ')),\
      PositionY = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t7Y:&b0&tb' .. tostring(Data.Position.Y)..'                ')),\
      PositionZ = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t7Z:&b0&tb' .. tostring(Data.Position.Z)..'                ')),\
      SkyblockPosition = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t7Skyblock Location')),\
      SkyblockPositionX = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t7X:&b0&tb' .. tostring(Data.SkyblockPosition.X)..'   ')),\
      SkyblockPositionY = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t7Y:&b0&tb' .. tostring(Data.SkyblockPosition.Y)..'   ')),\
      SkyblockPositionZ = Account.frame:newChild(Text(1, 1, 0, 1, '&b0&t7Z:&b0&tb' .. tostring(Data.SkyblockPosition.Z)..'   ')),\
    }\
    function SetData(Name, Y, X, _D) Texts[Name].width = #Texts[Name].text - (_D == true and 12 or 6) Texts[Name].y, Texts[Name].x = Y, X end\
    SetData('Username', 5, 2)\
    SetData('_Username', 5, #Texts.Username.text - 3)\
    SetData('Balance', 7, 2)\
    SetData('_Balance', 7, #Texts.Balance.text - 3)\
    SetData('Position', 9, 2)\
    SetData('PositionX', 10, 6, true)\
    SetData('PositionY', 11, 6, true)\
    SetData('PositionZ', 12, 6, true)\
    SetData('SkyblockPosition', 9, 33)\
    SetData('SkyblockPositionX', 10, 39, true)\
    SetData('SkyblockPositionY', 11, 39, true)\
    SetData('SkyblockPositionZ', 12, 39, true)\
    sleep(0.5)\
  end\
end)\
",
  [ "/rom/apis/io" ] = "-- Definition for the IO API\
\
local g_defaultInput = {\
    bFileHandle = true,\
    bClosed = false,\
    close = function( self )\
    end,\
    read = function( self, _sFormat )\
        if _sFormat and _sFormat ~= \"*l\" then\
            error( \"Unsupported format\" )\
        end\
        return _G.read()\
    end,\
    lines = function( self )\
        return function()\
            return _G.read()\
        end\
    end,\
}\
\
local g_defaultOutput = {\
    bFileHandle = true,\
    bClosed = false,\
    close = function( self )\
    end,\
    write = function( self, _sText )\
        _G.write( _sText )\
    end,\
    flush = function( self )\
    end,\
}\
\
local g_currentInput = g_defaultInput\
local g_currentOutput = g_defaultOutput\
\
function close( _file )\
    (_file or g_currentOutput):close()\
end\
\
function flush()\
    g_currentOutput:flush()\
end\
\
function input( _arg )\
    if _G.type( _arg ) == \"string\" then\
        g_currentInput = open( _arg, \"r\" )\
    elseif _G.type( _arg ) == \"table\" then\
        g_currentInput = _arg\
    elseif _G.type( _arg ) == \"nil\" then\
        return g_currentInput\
    else\
        error( \"Expected file name or file handle\" )\
    end\
end\
\
function lines( _sFileName )\
    if _sFileName then\
        return open( _sFileName, \"r\" ):lines()\
    else\
        return g_currentInput:lines()\
    end\
end\
\
function open( _sPath, _sMode )\
    local sMode = _sMode or \"r\"\
    local file = fs.open( _sPath, sMode )\
    if not file then\
        return nil\
    end\
    \
    if sMode == \"r\"then\
        return {\
            bFileHandle = true,\
            bClosed = false,                \
            close = function( self )\
                file.close()\
                self.bClosed = true\
            end,\
            read = function( self, _sFormat )\
                local sFormat = _sFormat or \"*l\"\
                if sFormat == \"*l\" then\
                    return file.readLine()\
                elseif sFormat == \"*a\" then\
                    return file.readAll()\
                else\
                    error( \"Unsupported format\" )\
                end\
                return nil\
            end,\
            lines = function( self )\
                return function()\
                    local sLine = file.readLine()\
                    if sLine == nil then\
                        file.close()\
                        self.bClosed = true\
                    end\
                    return sLine\
                end\
            end,\
        }\
    elseif sMode == \"w\" or sMode == \"a\" then\
        return {\
            bFileHandle = true,\
            bClosed = false,                \
            close = function( self )\
                file.close()\
                self.bClosed = true\
            end,\
            write = function( self, _sText )\
                file.write( _sText )\
            end,\
            flush = function( self )\
                file.flush()\
            end,\
        }\
    \
    elseif sMode == \"rb\" then\
        return {\
            bFileHandle = true,\
            bClosed = false,                \
            close = function( self )\
                file.close()\
                self.bClosed = true\
            end,\
            read = function( self )\
                return file.read()\
            end,\
        }\
        \
    elseif sMode == \"wb\" or sMode == \"ab\" then\
        return {\
            bFileHandle = true,\
            bClosed = false,                \
            close = function( self )\
                file.close()\
                self.bClosed = true\
            end,\
            write = function( self, _number )\
                file.write( _number )\
            end,\
            flush = function( self )\
                file.flush()\
            end,\
        }\
    \
    else\
        file.close()\
        error( \"Unsupported mode\" )\
        \
    end\
end\
\
function output( _arg )\
    if _G.type( _arg ) == \"string\" then\
        g_currentOutput = open( _arg, \"w\" )\
    elseif _G.type( _arg ) == \"table\" then\
        g_currentOutput = _arg\
    elseif _G.type( _arg ) == \"nil\" then\
        return g_currentOutput\
    else\
        error( \"Expected file name or file handle\" )\
    end\
end\
\
function read( ... )\
    return input():read( ... )\
end\
\
function type( _handle )\
    if _G.type( _handle ) == \"table\" and _handle.bFileHandle == true then\
        if _handle.bClosed then\
            return \"closed file\"\
        else\
            return \"file\"\
        end\
    end\
    return nil\
end\
\
function write( ... )\
    return output():write( ... )\
end",
  [ "/rom/programs/type" ] = "\
local tArgs = { ... }\
if #tArgs < 1 then\
    print( \"Usage: type <path>\" )\
    return\
end\
\
local sPath = shell.resolve( tArgs[1] )\
if fs.exists( sPath ) then\
    if fs.isDir( sPath ) then\
        print( \"directory\" )\
    else\
        print( \"file\" )\
    end\
else\
    print( \"No such path\" )\
end\
",
  [ "/Flare/version/1.2/lib/class.lua" ] = "\
local class = {}\
\
function class:new( name )\
\
    local c = {}\
    c.name = name\
\
    local mt = {}\
\
    function c:new( ... )\
        local ob = {}\
        ob.class = self\
\
        setmetatable( ob, { __index = self, __tostring = self.tostring, __type = self.name } )\
\
        if ob[name] then\
            ob[name]( ob, ... )\
        end\
\
        return ob\
    end\
\
    function c:extend( e )\
        mt.__index = e\
        self.extends = e\
    end\
\
    function c:tostring()\
        return self.class and self.class.name or self.name\
    end\
\
    function c:type()\
        return self.class and self.class.name or self.name\
    end\
\
    function c:typeOf( class )\
        if self.class then\
            self = self.class\
        end\
        while self ~= class do\
            self = self.extends\
            if not self then\
                return false\
            end\
        end\
        return true\
    end\
\
    function c:can( method )\
        return type( self[method] ) == \"function\"\
    end\
\
    mt.__type = name\
    mt.__call = c.new\
    mt.__tostring = c.tostring\
    setmetatable( c, mt )\
\
    return c\
\
end\
\
setmetatable( class, { __call = class.new } )\
\
return class",
  [ "/rom/programs/exit" ] = "shell.exit()",
  [ "/rom/help/bg" ] = "bg is a program for Advanced Computers which opens a new tab in the background.\
\
ex:\
\"bg\" will open a background tab running the shell\
\"bg worm\" will open a background tab running the \"worm\" program",
  [ "/rom/help/keys" ] = "The keys API contains constants for all the key codes that can be returned by the \"key\" event:\
\
Example usage:\
local sEvent, nKey = os.pullEvent()\
if sEvent == \"key\" and nKey == keys.enter then\
   -- Do something  \
end\
\
See http://www.minecraftwiki.net/wiki/Key_codes, or the source code, for a complete reference.",
  [ "/rom/help/workbench" ] = "Workbenches are peripheral devices found on Crafty Turtles running CraftOS. Type \"help peripheral\" to learn about using the Peripheral API to connect with peripherals. When a workbench is attached to a turtle, peripheral.getType() will return \"workbench\".\
\
Methods exposed by Workbenches:\
craft( channel )",
  [ "/rom/help/programming" ] = "To learn the lua programming language, visit http://lua-users.org/wiki/TutorialDirectory.\
\
To experiment with lua in CraftOS, run the \"lua\" program and start typing code.\
To create programs, use \"edit\" to create files, then type their names in the shell to run them. If you name a program \"startup\" and place it in the root or on a disk drive, it will run automatically when the computer starts.\
\
To terminate a program stuck in a loop, hold Ctrl+T for 1 second.\
To quickly shutdown a computer, hold Ctrl+S for 1 second.\
To quickly reboot a computer, hold Ctrl+R for 1 second.\
\
To learn about the programming APIs availiable, type \"apis\" or \"help apis\".\
If you get stuck, visit the forums at http://www.computercraft.info/ for advice and tutorials.",
  [ "/rom/help/falling" ] = "\"From Russia with Fun\" comes a fun, new, suspiciously-familiar falling block game for CraftOS. Only on Pocket Computers!",
  [ "/rom/apis/disk" ] = "\
local function isDrive( name )\
    return peripheral.getType( name ) == \"drive\"\
end\
\
function isPresent( name )\
    if isDrive( name ) then\
        return peripheral.call( name, \"isDiskPresent\" )\
    end\
    return false\
end\
\
function getLabel( name )\
    if isDrive( name ) then\
        return peripheral.call( name, \"getDiskLabel\" )\
    end\
    return nil\
end\
\
function setLabel( name, label )\
    if isDrive( name ) then\
        peripheral.call( name, \"setDiskLabel\", label )\
    end\
end\
\
function hasData( name )\
    if isDrive( name ) then\
        return peripheral.call( name, \"hasData\" )\
    end\
    return false\
end\
\
function getMountPath( name )\
    if isDrive( name ) then\
        return peripheral.call( name, \"getMountPath\" )\
    end\
    return nil\
end\
\
function hasAudio( name )\
    if isDrive( name ) then\
        return peripheral.call( name, \"hasAudio\" )\
    end\
    return false\
end\
\
function getAudioTitle( name )\
    if isDrive( name ) then\
        return peripheral.call( name, \"getAudioTitle\" )\
    end\
    return nil\
end\
\
function playAudio( name )\
    if isDrive( name ) then\
        peripheral.call( name, \"playAudio\" )\
    end\
end\
\
function stopAudio( name )\
    if not name then\
        for n,sName in ipairs( peripheral.getNames() ) do\
            stopAudio( sName )\
        end\
    else\
        if isDrive( name ) then\
            peripheral.call( name, \"stopAudio\" )\
        end\
    end\
end\
\
function eject( name )\
    if isDrive( name ) then\
        peripheral.call( name, \"ejectDisk\" )\
    end\
end\
\
function getID( name )\
    if isDrive( name ) then\
        return peripheral.call( name, \"getDiskID\" )\
    end\
    return nil\
end\
",
  [ "/rom/help/tunnel" ] = "tunnel is a program for Mining Turtles. Tunnel will mine a 3x2 tunnel of the depth specified.\
\
ex:\
\"tunnel 20\" will tunnel a tunnel 20 blocks long.",
  [ "/rom/help/go" ] = "go is a program for Turtles, used to control the turtle without programming. It accepts one or more commands as a direction followed by a distance.\
\
ex:\
\"go forward\" moves the turtle 1 space forward.\
\"go forward 3\" moves the turtle 3 spaces forward.\
\"go forward 3 up left 2\" moves the turtle 3 spaces forward, 1 spaces up, then left 180 degrees.",
  [ "/rom/programs/shutdown" ] = "if term.isColour() then\
    term.setTextColour( colours.yellow )\
end\
print( \"Goodbye\" )\
term.setTextColour( colours.white )\
\
sleep( 1 )\
os.shutdown()",
  [ "/rom/programs/advanced/multishell" ] = "\
-- Setup process switching\
local parentTerm = term.current()\
local w,h = parentTerm.getSize()\
\
local tProcesses = {}\
local nCurrentProcess = nil\
local nRunningProcess = nil\
local bShowMenu = false\
local bWindowsResized = false\
\
local function selectProcess( n )\
    if nCurrentProcess ~= n then\
        if nCurrentProcess then\
            local tOldProcess = tProcesses[ nCurrentProcess ]\
            tOldProcess.window.setVisible( false )\
        end\
        nCurrentProcess = n\
        if nCurrentProcess then\
            local tNewProcess = tProcesses[ nCurrentProcess ]\
            tNewProcess.window.setVisible( true )\
            tNewProcess.bInteracted = true\
        end\
    end\
end\
\
local function setProcessTitle( n, sTitle )\
    tProcesses[ n ].sTitle = sTitle\
end\
\
local function resumeProcess( nProcess, sEvent, ... )\
    local tProcess = tProcesses[ nProcess ]\
    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\
\
local function launchProcess( tProgramEnv, sProgramPath, ... )\
    local tProgramArgs = { ... }\
    local nProcess = #tProcesses + 1\
    local tProcess = {}\
    tProcess.sTitle = fs.getName( sProgramPath )\
    if bShowMenu then\
        tProcess.window = window.create( parentTerm, 1, 2, w, h-1, false )\
    else\
        tProcess.window = window.create( parentTerm, 1, 1, w, h, false )\
    end\
    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\" )\
            os.pullEvent( \"char\" )\
        end\
    end )\
    tProcess.sFilter = nil\
    tProcess.terminal = tProcess.window\
    tProcess.bInteracted = false\
    tProcesses[ nProcess ] = tProcess\
    resumeProcess( nProcess )\
    return nProcess\
end\
\
local function cullProcess( nProcess )\
    local tProcess = tProcesses[ nProcess ]\
    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\
\
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\
local menuMainTextColor, menuMainBgColor, menuOtherTextColor, menuOtherBgColor\
if parentTerm.isColor() then\
    menuMainTextColor, menuMainBgColor = colors.yellow, colors.black\
    menuOtherTextColor, menuOtherBgColor = colors.black, colors.gray\
else\
    menuMainTextColor, menuMainBgColor = colors.white, colors.black\
    menuOtherTextColor, menuOtherBgColor = colors.black, colors.white\
end\
\
local function redrawMenu()\
    if bShowMenu then\
        -- Draw menu\
        parentTerm.setCursorPos( 1, 1 )\
        parentTerm.setBackgroundColor( menuOtherBgColor )\
        parentTerm.clearLine()\
        for n=1,#tProcesses do\
            if n == nCurrentProcess then\
                parentTerm.setTextColor( menuMainTextColor )\
                parentTerm.setBackgroundColor( menuMainBgColor )\
            else\
                parentTerm.setTextColor( menuOtherTextColor )\
                parentTerm.setBackgroundColor( menuOtherBgColor )\
            end\
            parentTerm.write( \" \" .. tProcesses[n].sTitle .. \" \" )\
        end\
\
        -- Put the cursor back where it should be\
        local tProcess = tProcesses[ nCurrentProcess ]\
        if tProcess then\
            tProcess.window.restoreCursor()\
        end\
    end\
end\
\
local function resizeWindows()\
    local windowY, windowHeight\
    if bShowMenu then\
        windowY = 2\
        windowHeight = h-1\
    else\
        windowY = 1\
        windowHeight = h\
    end\
    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( 1, windowY, w, windowHeight )\
    end\
    bWindowsResized = true\
end\
\
local function setMenuVisible( bVis )\
    if bShowMenu ~= bVis then\
        bShowMenu = bVis\
        resizeWindows()\
        redrawMenu()\
    end\
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 )\
    if n >= 1 and n <= #tProcesses then\
        setProcessTitle( n, sTitle )\
        redrawMenu()\
    end\
end\
\
function multishell.getCurrent()\
    return nRunningProcess\
end\
\
function multishell.launch( tProgramEnv, sProgramPath, ... )\
    local previousTerm = term.current()\
    setMenuVisible( (#tProcesses + 1) >= 2 )\
    local nResult = launchProcess( tProgramEnv, sProgramPath, ... )\
    redrawMenu()\
    term.redirect( previousTerm )\
    return nResult\
end\
\
function multishell.getCount()\
    return #tProcesses\
end\
\
-- Begin\
parentTerm.clear()\
setMenuVisible( false )\
selectProcess( launchProcess( {\
    [\"shell\"] = shell,\
    [\"multishell\"] = multishell,\
}, \"/rom/programs/shell\" ) )\
redrawMenu()\
\
-- Run processes\
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()\
        redrawMenu()\
\
    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\
            setMenuVisible( #tProcesses >= 2 )\
            redrawMenu()\
        end\
\
    elseif sEvent == \"mouse_click\" then\
        -- Click event\
        local button, x, y = tEventData[2], tEventData[3], tEventData[4]\
        if bShowMenu and y == 1 then\
            -- Switch process\
            local tabStart = 1\
            for n=1,#tProcesses do\
                tabEnd = tabStart + string.len( tProcesses[n].sTitle ) + 1\
                if x >= tabStart and x <= tabEnd then\
                    selectProcess( n )\
                    redrawMenu()\
                    break\
                end\
                tabStart = tabEnd + 1\
            end\
        else\
            -- Passthrough to current process\
            resumeProcess( nCurrentProcess, sEvent, button, x, (bShowMenu and y-1) or y )\
            if cullProcess( nCurrentProcess ) then\
                setMenuVisible( #tProcesses >= 2 )\
                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 (bShowMenu and y == 1) then\
            -- Passthrough to current process\
            resumeProcess( nCurrentProcess, sEvent, p1, x, (bShowMenu and y-1) or y )\
            if cullProcess( nCurrentProcess ) then\
                setMenuVisible( #tProcesses >= 2 )\
                redrawMenu()\
            end\
        end\
\
    else\
        -- 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\
            setMenuVisible( #tProcesses >= 2 )\
            redrawMenu()\
        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\
            setMenuVisible( #tProcesses >= 2 )\
            redrawMenu()\
        end\
    end\
end\
\
-- Shutdown\
term.redirect( parentTerm )",
  [ "/rom/programs/rednet/repeat" ] = "\
-- Find modems\
local tModems = {}\
for n,sModem in ipairs( peripheral.getNames() ) do\
    if peripheral.getType( sModem ) == \"modem\" then\
        table.insert( tModems, sModem )\
    end\
end\
if #tModems == 0 then\
    print( \"No modems found.\" )\
    return\
elseif #tModems == 1 then\
    print( \"1 modem found.\" )\
else\
    print( #tModems .. \" modems found.\" )\
end\
\
function open( nChannel )\
    for n=1,#tModems do\
        local sModem = tModems[n]\
        peripheral.call( sModem, \"open\", nChannel )\
    end\
end\
\
function close( nChannel )\
    for n=1,#tModems do\
        local sModem = tModems[n]\
        peripheral.call( sModem, \"close\", nChannel )\
    end\
end\
\
-- Open channels\
print( \"0 messages repeated.\" )\
open( rednet.CHANNEL_REPEAT )\
\
-- Main loop (terminate to break)\
local ok, error = pcall( function()\
    local tReceivedMessages = {}\
    local tReceivedMessageTimeouts = {}\
    local nTransmittedMessages = 0\
\
    while true do\
        local sEvent, sModem, nChannel, nReplyChannel, tMessage = os.pullEvent()\
        if sEvent == \"modem_message\" then\
            -- Got a modem message, rebroadcast it if it's a rednet thing\
            if nChannel == rednet.CHANNEL_REPEAT then\
                if type( tMessage ) == \"table\" and tMessage.nMessageID and tMessage.nRecipient then\
                    if not tReceivedMessages[ tMessage.nMessageID ] then\
                        -- Ensure we only repeat a message once\
                        tReceivedMessages[ tMessage.nMessageID ] = true\
                        tReceivedMessageTimeouts[ os.startTimer( 30 ) ] = tMessage.nMessageID\
\
                        -- Send on all other open modems, to the target and to other repeaters\
                        for n=1,#tModems do\
                            local sOtherModem = tModems[n]\
                            peripheral.call( sOtherModem, \"transmit\", rednet.CHANNEL_REPEAT, nReplyChannel, tMessage )\
                            peripheral.call( sOtherModem, \"transmit\", tMessage.nRecipient, nReplyChannel, tMessage )\
                        end\
\
                        -- Log the event\
                        nTransmittedMessages = nTransmittedMessages + 1\
                        local x,y = term.getCursorPos()\
                        term.setCursorPos( 1, y - 1 )\
                        term.clearLine()\
                        if nTransmittedMessages == 1 then\
                            print( nTransmittedMessages .. \" message repeated.\" )\
                        else\
                            print( nTransmittedMessages .. \" messages repeated.\" )\
                        end\
                    end\
                end\
            end\
\
        elseif sEvent == \"timer\" then\
            -- Got a timer event, use it to clear the message history\
            local nTimer = sModem\
            local nMessageID = tReceivedMessageTimeouts[ nTimer ]\
            if nMessageID then\
                tReceivedMessageTimeouts[ nTimer ] = nil\
                tReceivedMessages[ nMessageID ] = nil\
            end\
\
        end\
    end\
end )\
if not ok then\
    printError( error )\
end\
\
-- Close channels\
close( rednet.CHANNEL_REPEAT )",
  [ "/rom/help/sleep" ] = "sleep makes the computer idle for a specific number of seconds.\
\
ex:\
\"sleep 10\" puts the computer to sleep for 10 seconds",
  [ "/rom/programs/turtle/dance" ] = "\
local tMoves = {\
    function()\
        turtle.up()\
        turtle.down()\
    end,\
    function()\
        turtle.up()\
        turtle.turnLeft()\
        turtle.turnLeft()\
        turtle.turnLeft()\
        turtle.turnLeft()\
        turtle.down()\
    end,\
    function()\
        turtle.up()\
        turtle.turnRight()\
        turtle.turnRight()\
        turtle.turnRight()\
        turtle.turnRight()\
        turtle.down()\
    end,\
    function()\
        turtle.turnLeft()\
        turtle.turnLeft()\
        turtle.turnLeft()\
        turtle.turnLeft()\
    end,\
    function()\
        turtle.turnRight()\
        turtle.turnRight()\
        turtle.turnRight()\
        turtle.turnRight()\
    end,\
    function()\
        turtle.turnLeft()\
        turtle.back()\
        turtle.back()\
        turtle.turnRight()\
        turtle.turnRight()\
        turtle.back()\
        turtle.back()\
        turtle.turnLeft()\
    end,\
    function()\
        turtle.turnRight()\
        turtle.back()\
        turtle.back()\
        turtle.turnLeft()\
        turtle.turnLeft()\
        turtle.back()\
        turtle.back()\
        turtle.turnRight()\
    end,\
    function()\
        turtle.back()\
        turtle.turnLeft()\
        turtle.back()\
        turtle.turnLeft()\
        turtle.back()\
        turtle.turnLeft()\
        turtle.back()\
        turtle.turnLeft()\
    end,\
    function()\
        turtle.back()\
        turtle.turnRight()\
        turtle.back()\
        turtle.turnRight()\
        turtle.back()\
        turtle.turnRight()\
        turtle.back()\
        turtle.turnRight()\
    end,\
}\
\
textutils.slowWrite( \"Preparing to get down.\" )\
textutils.slowPrint( \"..\", 0.75 )\
\
local sAudio = nil\
for n,sName in pairs( peripheral.getNames() ) do\
    if disk.hasAudio( sName ) then\
        disk.playAudio( sName )\
        print( \"Jamming to \"..disk.getAudioTitle( sName ) )\
        sAudio = sName\
        break\
    end\
end\
\
print( \"Press any key to stop the groove\" )\
\
local bEnd = false\
parallel.waitForAll(\
    function()\
        while not bEnd do\
            local event, key = os.pullEvent(\"key\")\
            if key ~= keys.escape then\
                bEnd = true\
            end\
        end     \
    end,\
    function()\
        while not bEnd do\
            local fnMove = tMoves[math.random(1,#tMoves)]\
            fnMove()\
        end\
    end\
)\
\
if sAudio then\
    disk.stopAudio( sAudio )\
end",
  [ "/Shop/main.lua" ] = "_G.DB = {}\
_G.DB.Items = {}\
\
function Decompile(CompiledTbl)\
  local Str = ''\
  for k, v in pairs(CompiledTbl) do\
    Str = Str .. string.char(v)\
  end\
  return Str\
end\
\
function Compile(Str)\
  local Compiled = {string.byte(Str,1,#tostring(Str))}\
  return Compiled, table.concat(Compiled, ',')\
end\
\
Modem = peripheral.wrap('top')\
Modem.open(2773)\
\
FDK.process:spawnThread(function()\
    coroutine.yield('terminate')\
    --os.reboot()\
  FDK.running = false\
end)\
\
local State = FDK.require('lib.state')\
\
State:new('Init')\
State:new('Main')\
State:new('Search')\
State:new('Account')\
State:new('Items')\
\
FDK.dofile('States.Init')\
FDK.dofile('States.Main')\
FDK.dofile('States.Search')\
FDK.dofile('States.Account')\
FDK.dofile('States.Items')\
\
--[[\
local GotData = false\
\
local StateLib = FDK.require('lib.state')\
local State = StateLib.names.init\
\
local Field = FDK.require('lib.UI.elements.Field')\
local Text = FDK.require('lib.UI.elements.Text')\
local Button = FDK.require('lib.UI.elements.Button')\
\
-- Main Field\
State.frame:newChild(Field(1, 1, State.frame.width, State.frame.height, colours.grey))\
-- Header Field\
State.frame:newChild(Field(1, 1, State.frame.width, 3, colors.lightGray))\
\
-- Header Text\
local Header = State.frame:newChild(Text(0, 0, 13, 1, '&b8&t0Shop - Client'))\
Header:alignX('centre')\
Header.width = #Header.text - #'&b7&t8'\
Header.y = 2\
\
local Desc = State.frame:newChild(Text(0, 0, 17, 1, '&b7&t8Requesting data..'))\
Desc:alignX('centre')\
Desc.width = #Desc.text - #'&b7&t8'\
Desc.y = math.ceil(State.frame.height/2.3)\
\
local CurrentRead = State.frame:newChild(Text(0, 0, 0, 1, '&b7&tfNo data available'))\
CurrentRead.width = #CurrentRead.text - #'&b7&t8'\
CurrentRead.y = math.ceil(State.frame.height/2)+1\
CurrentRead:alignX('centre')\
\
\
]]\
\
\
\
-- Hello\
--[[\
State.process:spawnThread(function()\
  while not GotData do\
    -- File Event System --\
    if fs.exists('.Call') then\
      local File = fs.open('.Call', 'r')\
      local Call = textutils.unserialize(File.readAll())\
      File.close()\
      \
      if #Call > 0 then\
        for i, J in pairs(Call) do\
          local Line = ''\
          for k, v in pairs(J) do\
            Line = Line .. tostring(v) .. ','\
            -- Process File\
          end\
          CurrentRead.text = '&b7&tfRemote://' .. Line\
          CurrentRead.width = #CurrentRead.text - #'&b7&t8'\
\
          CurrentRead.x = 2\
          sleep(.5)\
        end\
        local File = fs.open('.Call', 'w')\
        File.writeLine('{}')\
        File.close()\
      else\
        CurrentRead.text = '&b7&tfNo data available'\
        CurrentRead.width = #CurrentRead.text - #'&b7&t8'\
        CurrentRead:alignX('centre')\
      end\
    end\
    sleep(.05)\
  end\
end)\
--]]",
  [ "/Flare/version/1.2/lib/state.lua" ] = "\
local Frame = FDK.require \"lib.UI.elements.Frame\"\
local keybind = FDK.require \"lib.UI.keybind\"\
\
local state = {}\
local states = 1\
\
state.names = {}\
\
function state:new( name )\
    local s = {}\
    s.show = self.show\
\
    s.bindings = {}\
\
    s.pos = states\
    states = states + 1\
\
    s.name = name\
    s.frame = Frame( 1, 1, FDK.frame.width, FDK.frame.height )\
    s.process = FDK.process:spawnSubProcess( name .. \"-state\" )\
    s.process:pause()\
\
    if not state.current then\
        FDK.frame:newChild( s.frame )\
        s.process:resume()\
        state.current = s\
    end\
\
    state.names[name] = s\
\
    return s\
end\
\
function state:show()\
    if state.current == self then return end\
    local x = FDK.frame.width + 1\
    if state.current then\
        local pos = state.current.pos\
        if pos < self.pos then\
            self.frame.x = 1 + FDK.frame.width\
            state.current.frame:move( 1 - FDK.frame.width, 1 )\
        else\
            self.frame.x = 1 - FDK.frame.width\
            state.current.frame:move( 1 + FDK.frame.width, 1 )\
        end\
    end\
    FDK.frame:newChild( self.frame )\
    self.frame:move( 1, 1, nil, function()\
        if state.current.onHide then\
            state.current:onHide()\
        end\
        state.current.process:pause()\
        for k, v in pairs( state.current.bindings ) do\
            keybind.unbind( k, v )\
        end\
        if self.onShow then\
            self:onShow()\
        end\
        self.process:resume()\
        state.current.frame:remove()\
        state.current = self\
        for k, v in pairs( self.bindings ) do\
            keybind.bind( k, v )\
        end\
    end )\
end\
\
return state",
  [ "/rom/help/http" ] = "Functions in the HTTP API:\
http.checkURL( url )\
http.request( url, [postData], [headers] )\
http.get( url, [headers] )\
http.post( url, postData, [headers] )\
\
The HTTP API may be disabled in ComputerCraft.cfg\
A period of time after a http.request() call is made, a \"http_success\" or \"http_failure\" event will be raised. Arguments are the url and a file handle if successful. http.get() and http.post() block until this event fires instead.",
  [ "/rom/programs/turtle/refuel" ] = "\
local tArgs = { ... }\
local nLimit = 1\
if #tArgs > 1 then\
    print( \"Usage: refuel [number]\" )\
    return\
elseif #tArgs > 0 then\
    if tArgs[1] == \"all\" then\
        nLimit = 64 * 16\
    else\
        nLimit = tonumber( tArgs[1] )\
    end\
end\
\
if turtle.getFuelLevel() ~= \"unlimited\" then\
    for n=1,16 do\
        local nCount = turtle.getItemCount(n)\
        if nLimit > 0 and nCount > 0 and turtle.getFuelLevel() < turtle.getFuelLimit() then\
            local nBurn = math.min( nLimit, nCount )\
            turtle.select( n )\
            if turtle.refuel( nBurn ) then\
                local nNewCount = turtle.getItemCount(n)\
                nLimit = nLimit - (nCount - nNewCount)\
            end\
        end\
    end\
    print( \"Fuel level is \"..turtle.getFuelLevel() )\
    if turtle.getFuelLevel() == turtle.getFuelLimit() then\
        print( \"Fuel limit reached\" )\
    end\
else\
    print( \"Fuel level is unlimited\" )\
end",
  [ "/Flare/version/1.2/lib/UI/elements/Field.lua" ] = "\
local class = require \"lib.class\"\
local base = require \"lib.UI.base\"\
local mouse = require \"lib.UI.event.mouse\"\
local graphics = require \"lib.graphics\"\
\
local Field = class \"Field\"\
Field:extend( base )\
\
Field.bc = \"white\"\
\
Field.mouse_click_timeout = .4\
\
function Field:Field( x, y, w, h, colour )\
    self:base( x, y, w, h )\
    self.bc = colour\
end\
\
function Field:draw( x, y, buffer )\
    buffer:setColours( graphics.colour( self.bc ) )\
    buffer:drawFilledRectangle( x, y, self.width, self.height )\
end\
\
function Field:handle( event )\
    if mouse.click( self, event ) then\
        if self.onClick then\
            self:onClick()\
        end\
    elseif event.name == \"mouse_ping\" then\
        mouse.ping( self, event )\
    end\
end\
\
return Field",
  [ "/rom/help/reboot" ] = "reboot will turn the computer off and on again.\
You can also hold Ctrl+R at any time to quickly reboot.",
  [ "/Flare/version/1.2/lib/video.lua" ] = "\
local image = require \"lib.image\"\
\
local colour = {}\
\
colour.lookup = {\
    [\"0\"] = colours.white;\
    [\"1\"] = colours.orange;\
    [\"2\"] = colours.magenta;\
    [\"3\"] = colours.lightBlue;\
    [\"4\"] = colours.yellow;\
    [\"5\"] = colours.lime;\
    [\"6\"] = colours.pink;\
    [\"7\"] = colours.grey;\
    [\"8\"] = colours.lightGrey;\
    [\"9\"] = colours.cyan;\
    [\"A\"] = colours.purple;\
    [\"B\"] = colours.blue;\
    [\"C\"] = colours.brown;\
    [\"D\"] = colours.green;\
    [\"E\"] = colours.red;\
    [\"F\"] = colours.black;\
    [\" \"] = 0;\
}\
\
colour.save = {}\
for k, v in pairs( colour.lookup ) do\
    colour.save[v] = k\
end\
\
local function changed( f1, f2, x, y )\
    local bc1, tc1, char1 = f1:getPixel( x, y )\
    local bc2, tc2, char2 = f2:getPixel( x, y )\
    return bc1 ~= bc2 or tc1 ~= tc2 or char1 ~= char2\
end\
\
local function px( x, y, width )\
    return ( y - 1 ) * width + x - 1\
end\
local function pad( n, w )\
    n = tostring( n )\
    return (\" \"):rep( math.max( w - #n, 0 ) ) .. n\
end\
local function pxstr( bc, tc, char )\
    if char == \"\" then\
        bc = 0\
        char = \" \"\
    end\
    return colour.save[bc] .. colour.save[tc] .. char\
end\
local function upx( s, w )\
    s = s:gsub( \"^%s*\", \"\" )\
    local n = tonumber( s )\
    return n % w + 1, math.floor( n / w ) + 1\
end\
\
local video = {}\
\
function video.save( frames )\
    local frame = frames[1]\
    local w, h = frame.width, frame.height\
    local output = w .. \",\" .. h .. \"\\n\"\
    output = output .. frame:save() .. \"\\n\"\
    local pxwidth = #tostring( px( w, h, w ) )\
    for i = 2, #frames do\
        local nframe = frames[i]\
        for x = 1, w do\
            for y = 1, h do\
                if changed( frame, nframe, x, y ) then\
                    output = output .. pad( px( x, y, w ), pxwidth ) .. pxstr( nframe:getPixel( x, y ) )\
                end\
            end\
        end\
        frame = nframe\
        output = output .. \"\\n\"\
    end\
    return output:sub( 1, -2 )\
end\
\
function video.load( str )\
    local width, height = str:match \"(%d+),(%d+)\\n\"\
    str = str:sub( #width + #height + 3 )\
    width, height = tonumber( width ), tonumber( height )\
    local is = ( ( width * 3 ) + 1 ) * height\
    local frames = { image.load( str:sub( 1, is - 1 ) ) }\
    frames[2] = frames[1]:clone()\
    str = str:sub( is + 1 )\
    local pxwidth = #tostring( px( width, height, width ) )\
    while #str > 0 do\
        if str:sub( 1, 1 ) == \"\\n\" then\
            frames[#frames+1] = frames[#frames]:clone()\
            str = str:sub( 2 )\
        else\
            local x, y = upx( str:sub( 1, pxwidth ), width )\
            local bc, tc, char = str:sub( pxwidth + 1, pxwidth + 1 ), str:sub( pxwidth + 2, pxwidth + 2 ), str:sub( pxwidth + 3, pxwidth + 3 )\
            bc = colour.lookup[bc]\
            tc = colour.lookup[tc]\
            frames[#frames]:setPixel( x, y, bc, tc, char )\
            str = str:sub( pxwidth + 4 )\
        end\
    end\
    return frames\
end\
\
return video",
  [ "/rom/programs/help" ] = "tArgs = { ... }\
if #tArgs > 0 then\
    sTopic = tArgs[1]\
else\
    sTopic = \"intro\"\
end\
\
if sTopic == \"index\" then\
    print( \"Help topics availiable:\" )\
    local tTopics = help.topics()\
    textutils.pagedTabulate( tTopics )\
    return\
end\
    \
local w,h = term.getSize()\
local sFile = help.lookup( sTopic )\
local file = ((sFile ~= nil) and io.open( sFile )) or nil\
local nLinesPrinted = 0\
if file then\
    local sLine = file:read()\
    local nLines = 0\
    while sLine do\
        nLines = nLines + textutils.pagedPrint( sLine, (h-3) - nLines )\
        sLine = file:read()\
    end\
    file:close()\
else\
    print( \"No help available\" )\
end",
  [ "/rom/help/shutdown" ] = "shutdown will turn off the computer.",
  [ "/rom/apis/vector" ] = "\
local vector = {\
    add = function( self, o )\
        return vector.new(\
            self.x + o.x,\
            self.y + o.y,\
            self.z + o.z\
        )\
    end,\
    sub = function( self, o )\
        return vector.new(\
            self.x - o.x,\
            self.y - o.y,\
            self.z - o.z\
        )\
    end,\
    mul = function( self, m )\
        return vector.new(\
            self.x * m,\
            self.y * m,\
            self.z * m\
        )\
    end,\
    dot = function( self, o )\
        return self.x*o.x + self.y*o.y + self.z*o.z\
    end,\
    cross = function( self, o )\
        return vector.new(\
            self.y*o.z - self.z*o.y,\
            self.z*o.x - self.x*o.z,\
            self.x*o.y - self.y*o.x\
        )\
    end,\
    length = function( self )\
        return math.sqrt( self.x*self.x + self.y*self.y + self.z*self.z )\
    end,\
    normalize = function( self )\
        return self:mul( 1 / self:length() )\
    end,\
    round = function( self, nTolerance )\
        nTolerance = nTolerance or 1.0\
        return vector.new(\
            math.floor( (self.x + (nTolerance * 0.5)) / nTolerance ) * nTolerance,\
            math.floor( (self.y + (nTolerance * 0.5)) / nTolerance ) * nTolerance,\
            math.floor( (self.z + (nTolerance * 0.5)) / nTolerance ) * nTolerance\
        )\
    end,\
    tostring = function( self )\
        return self.x..\",\"..self.y..\",\"..self.z\
    end,\
}\
\
local vmetatable = {\
    __index = vector,\
    __add = vector.add,\
    __sub = vector.sub,\
    __mul = vector.mul,\
    __unm = function( v ) return v:mul(-1) end,\
    __tostring = vector.tostring,\
}\
\
function new( x, y, z )\
    local v = {\
        x = x or 0,\
        y = y or 0,\
        z = z or 0\
    }\
    setmetatable( v, vmetatable )\
    return v\
end",
  [ "/rom/programs/monitor" ] = "\
function printUsage()\
    print( \"Usage: monitor <name> <program> <arguments>\" )\
    return\
end\
\
local tArgs = { ... }\
if #tArgs < 2 then\
    printUsage()\
    return\
end\
\
local sName = tArgs[1]\
if peripheral.getType( sName ) ~= \"monitor\" then\
    print( \"No monitor named \".. sName )\
    return\
end\
\
local sProgram = tArgs[2]\
local sPath = shell.resolveProgram( sProgram )\
if sPath == nil then\
    print( \"No such program: \"..sProgram )\
    return\
end\
\
print( \"Running \"..sProgram..\" on monitor \"..sName )\
\
local monitor = peripheral.wrap( sName )\
local previousTerm = term.redirect( monitor )\
\
local co = coroutine.create( function()\
    shell.run( sProgram, unpack( tArgs, 3 ) )\
end )\
\
local function resume( ... )\
    local ok, param = coroutine.resume( co, ... )\
    if not ok then\
        printError( param )\
    end\
    return param\
end\
\
local ok, param = pcall( function()\
    local sFilter = resume()\
    while coroutine.status( co ) ~= \"dead\" do\
        local tEvent = { os.pullEventRaw() }\
        if sFilter == nil or tEvent[1] == sFilter or tEvent[1] == \"terminate\" then\
            sFilter = resume( unpack( tEvent ) )\
        end\
        if coroutine.status( co ) ~= \"dead\" and (sFilter == nil or sFilter == \"mouse_click\") then\
            if tEvent[1] == \"monitor_touch\" and tEvent[2] == sName then\
                sFilter = resume( \"mouse_click\", 1, unpack( tEvent, 3 ) )\
            end\
        end\
        if coroutine.status( co ) ~= \"dead\" and (sFilter == nil or sFilter == \"term_resize\") then\
            if tEvent[1] == \"monitor_resize\" and tEvent[2] == sName then\
                sFilter = resume( \"term_resize\" )\
            end\
        end\
    end\
end )\
\
term.redirect( previousTerm )\
if not ok then\
    printError( param )\
end\
    ",
  [ "/rom/help/coroutine" ] = "coroutine is a standard Lua5.1 API.\
Refer to http://www.lua.org/manual/5.1/ for more information.",
  [ "/Flare/version/1.2/lib/UI/text/code.lua" ] = "\
local lang = {}\
local code = {}\
\
function code.registerLanguage( language, formatter )\
    lang[language] = formatter\
end\
\
function code.format( language, text )\
    local lines = {}\
    local last = 1\
    for i = 1, #text do\
        if text:sub( i, i ) == \"\\n\" then\
            lines[#lines + 1] = text:sub( last, i - 1 )\
            last = i + 1\
        end\
    end\
    lines[#lines + 1] = text:sub( last )\
\
    local str = \"\"\
    local lw = #tostring( #lines )\
\
    if not lang[language] then\
        str = \"&b0&tElanguage [\" .. language .. \"] not defined\\n&t7\"\
    end\
\
    local data = {}\
    local function pushLine( line )\
        str = str .. \"&b8&tF\" .. (\" \"):rep( lw - #tostring( line ) ) .. line .. \" &b0&t7 \"\
        if lang[language] then\
            str = str .. lang[language]( lines[line], data, line ) .. \"\\n\"\
        else\
            str = str .. \"`\" .. lines[line] .. \"`\\n\"\
        end\
    end\
\
    for i = 1, #lines do\
        pushLine( i )\
    end\
\
    if not lang[language] then\
        str = tostring( str:sub( 1, -2 ) )\
    end\
    return str\
end\
\
return code",
  [ "/Flare/version/1.2/lib/UI/keybind.lua" ] = "\
local bindings = {}\
\
local keybind = {}\
\
function keybind.isBound( key )\
    if bindings[key] and #bindings[key] > 0 then\
        return true\
    end\
    return false\
end\
\
function keybind.bind( key, action )\
    bindings[key] = bindings[key] or {}\
    bindings[key][#bindings[key] + 1] = action\
end\
\
function keybind.unbind( key, action )\
    if bindings[key] then\
        if action then\
            for i = #bindings[key], 1, -1 do\
                if bindings[key][i] == action then\
                    table.remove( bindings[key], i )\
                    return\
                end\
            end\
        else\
            bindings[key][#bindings[key]] = nil\
        end\
    end\
end\
\
function keybind.call( key )\
    if bindings[key] and bindings[key][#bindings[key]] then\
        bindings[key][#bindings[key]]()\
    end\
end\
\
return keybind",
  [ "/rom/programs/turtle/turn" ] = "local tArgs = { ... }\
if #tArgs < 1 then\
    print( \"Usage: turn <direction> <turns>\" )\
    return\
end\
\
local tHandlers = {\
    [\"lt\"] = turtle.turnLeft,\
    [\"left\"] = turtle.turnLeft,\
    [\"rt\"] = turtle.turnRight,\
    [\"right\"] = turtle.turnRight,\
}\
\
local nArg = 1\
while nArg <= #tArgs do\
    local sDirection = tArgs[nArg]\
    local nDistance = 1\
    if nArg < #tArgs then\
        local num = tonumber( tArgs[nArg + 1] )\
        if num then\
            nDistance = num\
            nArg = nArg + 1\
        end\
    end\
    nArg = nArg + 1\
\
    local fnHandler = tHandlers[string.lower(sDirection)]\
    if fnHandler then\
        for n=1,nDistance do\
            fnHandler( nArg )\
        end\
    else\
        print( \"No such direction: \"..sDirection )\
        print( \"Try: left, right\" )\
        return\
    end\
    \
end",
  [ "/Flare/version/1.2/lib/graphics.lua" ] = "\
local function linewrap( str, w )\
    if str:sub( 1, w + 1 ):find \"\\n\" then\
        return str:match \"(.-)\\n(.+)\"\
    end\
    if str:sub( 1, w + 1 ):find \"%s\" then\
        local pos = w - str:sub( 1, w + 1 ):reverse():find \"%s\" + 1\
        return str:sub( 1, pos), str:sub( pos + 2 ):gsub( \"^%s+\", \"\" )\
    end\
    return str:sub( 1, w ), str:sub( w + 1 )\
end\
\
local function wordwrap( str, w, h )\
    local s1, s2 = linewrap( str, w )\
    local lines = { s1 }\
    while #s2 > 0 do\
        s1, s2 = linewrap( s2, w )\
        lines[#lines + 1] = s1\
    end\
    while h and #lines > h do\
        lines[#lines] = nil\
    end\
    return lines\
end\
\
local graphics = {}\
\
function graphics:mixin( element ) -- graphics:mixin( buffer )  buffer:drawRectangle()\
    for k, v in pairs( self ) do\
        if k ~= \"mixin\" and not element[k] then\
            element[k] = v\
        end\
    end\
end\
\
function graphics:drawPixel( x, y, char )\
    if self.stencil then\
        if not self.stencil:withinBounds( x, y ) then\
            return false\
        end\
    end\
    local bc, tc = graphics.getColours( self )\
    return self:setPixel( x, y, bc, tc, char or \" \" )\
end\
\
function graphics:drawRectangle( x, y, w, h, char )\
    local x2, y2 = x + w - 1, y + h - 1\
    for _x = x, x2 do\
        graphics.drawPixel( self, _x, y, char )\
        graphics.drawPixel( self, _x, y2, char )\
    end\
    for _y = y + 1, y2 - 1 do\
        graphics.drawPixel( self, x, _y, char )\
        graphics.drawPixel( self, x2, _y, char )\
    end\
end\
\
function graphics:drawFilledRectangle( x, y, w, h, char )\
    for _x = x, x + w - 1 do\
        for _y = y, y + h - 1 do\
            graphics.drawPixel( self, _x, _y, char )\
        end\
    end\
end\
\
function graphics:drawCircle( x, y, r, char )\
    local function pixel( x, y )\
        graphics.drawPixel( self, x, y, char )\
    end\
\
    local c = 2 * math.pi * r\
    local n = 2 * math.pi * 2 / c\
    local c8 = c / 8\
    for i = 0, c8 do\
        local _x, _y = math.floor( math.sin( i * n ) * r + .5 ), math.floor( math.cos( i * n ) * r + .5 )\
        pixel( x + _x, y + _y )\
        pixel( x + _x, y - _y )\
        pixel( x - _x, y + _y )\
        pixel( x - _x, y - _y )\
        pixel( x + _y, y + _x )\
        pixel( x - _y, y + _x )\
        pixel( x + _y, y - _x )\
        pixel( x - _y, y - _x )\
    end\
end\
\
function graphics:drawFilledCircle( x, y, r, char, correction )\
    local r2 = r ^ 2\
    for _x = -r, r do\
        for _y = -r, r do\
            if _x ^ 2 + ( _y ^ 2 ) * ( correction or 1 ) < r2 then\
                graphics.drawPixel( self, x + _x, y + _y, char )\
            end\
        end\
    end\
end\
\
function graphics:drawVerticalLine( x, y, height, char )\
    for i = y, y + height - 1 do\
        grpahics.drawPixel( self, x, i, char )\
    end\
end\
\
function graphics:drawHorizontalLine( x, y, width, char )\
    for i = x, x + width - 1 do\
        grpahics.drawPixel( self, i, y, char )\
    end\
end\
\
function graphics:drawLine( x1, y1, x2, y2, char )\
    if x1 > x2 then\
        x1, x2 = x2, x1\
        y1, y2 = y2, y1\
    end\
    if x1 == x2 then\
        for i = math.min( y1, y2 ), math.max( y1, y2 ) do\
            graphics.drawPixel( self, x1, i, char )\
        end\
        return\
    elseif y1 == y2 then\
        for i = math.min( x1, x2 ), math.max( x1, x2 ) do\
            graphics.drawPixel( self, i, y1, char )\
        end\
        return\
    end\
    local dx, dy = x2 - x1, y2 - y1\
    local m = dy / dx\
    local c = y1 - m * x1\
\
    for x = x1, x2, math.min( math.abs( 1 / m ), 1 ) do\
        local y = m * x + c\
        graphics.drawPixel( self, math.floor( x + .5 ), math.floor( y + .5 ), char )\
    end\
end\
\
function graphics:applyShader( shader )\
    local new = {}\
    for x = 1, self.width do\
        new[x] = {}\
        for y = 1, self.height do\
            local bc, tc, char = self:getPixel( x, y )\
            local _bc, _tc, _char = shader( x, y, bc, tc, char )\
            local c = false\
            if _bc and _bc ~= bc then c = true end\
            if _tc and _tc ~= tc then c = true end\
            if _char and _char ~= char then c = true end\
            if c then\
                new[x][y] = { bc = _bc or bc, tc = _tc or tc, char = _char or char }\
            end\
        end\
    end\
    local _bc, _tc = self:getColours()\
    for x = 1, self.width do\
        for y = 1, self.height do\
            local px = new[x][y]\
            if px then\
                if px.bc ~= _bc or px.tc ~= _tc then\
                    _bc, _tc = px.bc, px.tc\
                    self:setColours( _bc, _tc )\
                end\
                self:drawPixel( x, y, px.char )\
            end\
        end\
    end\
end\
\
function graphics:drawPolygon( ... )\
    local points, char = { ... }, nil\
    if #points % 2 == 0 then\
        char = \" \"\
    else\
        char = points[#points]\
        points[#points] = nil\
    end\
    if #points < 6 then\
        return error \"expected at least 6 parameters (3 x,y pairs)\"\
    end\
    for i = 1, #points / 2 do\
        graphics.drawLine( self, points[2 * i - 1], points[2 * i], points[2 * ( i + 1 ) - 1], points[2 * ( i + 1 )], char )\
    end\
    graphics.drawLine( self, points[#points - 1], points[#points], points[1], points[2], char )\
end\
\
function graphics:drawTextLine( x, y, text )\
    for i = 1, #text do\
        graphics.drawPixel( self, x, y, text:sub( i, i ) )\
        x = x + 1\
    end\
end\
\
function graphics:drawTextWrapped( x, y, w, h, text )\
    self:drawFilledRectangle( x, y, w, h )\
    local lines = wordwrap( text, w, h )\
    for i = 1, #lines do\
        self:drawTextLine( x, y, lines[i] )\
        y = y + 1\
    end\
end\
\
function graphics:drawTextFormatted( x, y, w, h, formatted_text ) -- formatted_text is a table of lines containing an offset, colours, and the actual text\
\
    self:setColours( formatted_text.bc, formatted_text.tc )\
    local bc, tc = self:getColours()\
    local obc, otc = bc, tc\
    self:drawFilledRectangle( x, y, w, h )\
    y = y + ( formatted_text.offset.y or 0 )\
    for l = 1, #formatted_text.lines do\
        local text = formatted_text.lines[l].text\
        local colour = formatted_text.lines[l].colour or {}\
        local x = x + ( formatted_text.offset[l] or 0 )\
        for c = 1, #text do\
            colour[c] = colour[c] or {}\
            local _bc, _tc = colour[c].bc or formatted_text.bc, colour[c].tc or formatted_text.tc\
            if _bc ~= bc or _tc ~= tc then\
                self:setColours( _bc, _tc )\
                bc, tc = _bc, _tc\
            end\
            local char = text:sub( c, c )\
            if char == \"\\t\" then\
                char = \"    \"\
            end\
            if char ~= \"\\n\" then\
                graphics.drawPixel( self, x, y, char )\
                x = x + #char\
            end\
        end\
        y = y + 1\
    end\
    self:setColours( obc, otc )\
end\
\
function graphics:setColours( bc, tc )\
    self.graphics_bc = bc or self.graphics_bc\
    self.graphics_tc = tc or self.graphics_tc\
end\
\
function graphics:getColours()\
    return self.graphics_bc or 1, self.graphics_tc or 32768\
end\
\
graphics.colour = {}\
\
graphics.colour.short = {\
    [\"0\"] = colours.white;\
    [\"1\"] = colours.orange;\
    [\"2\"] = colours.magenta;\
    [\"3\"] = colours.lightBlue;\
    [\"4\"] = colours.yellow;\
    [\"5\"] = colours.lime;\
    [\"6\"] = colours.pink;\
    [\"7\"] = colours.grey;\
    [\"8\"] = colours.lightGrey;\
    [\"9\"] = colours.cyan;\
    [\"A\"] = colours.purple;\
    [\"B\"] = colours.blue;\
    [\"C\"] = colours.brown;\
    [\"D\"] = colours.green;\
    [\"E\"] = colours.red;\
    [\"F\"] = colours.black;\
    [\" \"] = 0;\
}\
\
graphics.colour.names = {\
    [\"white\"] = colours.white;\
    [\"orange\"] = colours.orange;\
    [\"magenta\"] = colours.magenta;\
    [\"lightBlue\"] = colours.lightBlue;\
    [\"yellow\"] = colours.yellow;\
    [\"lime\"] = colours.lime;\
    [\"pink\"] = colours.pink;\
    [\"grey\"] = colours.grey;\
    [\"lightGrey\"] = colours.lightGrey;\
    [\"cyan\"] = colours.cyan;\
    [\"purple\"] = colours.purple;\
    [\"blue\"] = colours.blue;\
    [\"brown\"] = colours.brown;\
    [\"green\"] = colours.green;\
    [\"red\"] = colours.red;\
    [\"black\"] = colours.black;\
    [\"invisible\"] = 0;\
}\
\
for k, v in pairs( graphics.colour.short ) do\
    graphics.colour.short[k:lower()] = v\
end\
for k, v in pairs( graphics.colour.short ) do\
    graphics.colour.short[v] = k\
end\
\
for k, v in pairs( graphics.colour.names ) do\
    graphics.colour.names[v] = k\
end\
\
setmetatable( graphics.colour, { __call = function( self, colour )\
    if type( colour ) == \"number\" then\
        return colour\
    end\
    if colour == \"R\" or colour == \"r\" or colour == \"random\" then\
        return 2 ^ math.random( 0, 15 )\
    end\
    return self.names[colour] or self.short[colour] or 0\
end } )\
\
graphics.shader = {}\
\
graphics.shader.darken = {\
    [colours.white] = colours.lightGrey, [colours.orange] = colours.red, [colours.magenta] = colours.purple, [colours.lightBlue] = colours.cyan;\
    [colours.yellow] = colours.orange, [colours.lime] = colours.green, [colours.pink] = colours.magenta, [colours.grey] = colours.black;\
    [colours.lightGrey] = colours.grey, [colours.cyan] = colours.blue, [colours.purple] = colours.black, [colours.blue] = colours.black;\
    [colours.brown] = colours.black, [colours.green] = colours.black, [colours.red] = colours.brown, [colours.black] = colours.black;\
}\
graphics.shader.lighten = {\
    [colours.white] = colours.white, [colours.orange] = colours.yellow, [colours.magenta] = colours.pink, [colours.lightBlue] = colours.white;\
    [colours.yellow] = colours.white, [colours.lime] = colours.white, [colours.pink] = colours.white, [colours.grey] = colours.lightGrey;\
    [colours.lightGrey] = colours.white, [colours.cyan] = colours.lightBlue, [colours.purple] = colours.magenta, [colours.blue] = colours.cyan;\
    [colours.brown] = colours.red, [colours.green] = colours.lime, [colours.red] = colours.orange, [colours.black] = colours.grey;\
}\
graphics.shader.greyscale = {\
    [colours.white] = 1, [colours.orange] = 256, [colours.magenta] = 256, [colours.lightBlue] = 256;\
    [colours.yellow] = 1, [colours.lime] = 256, [colours.pink] = 1, [colours.grey] = 256;\
    [colours.lightGrey] = 256, [colours.cyan] = 128, [colours.purple] = 128, [colours.blue] = 32768;\
    [colours.brown] = 32768, [colours.green] = 128, [colours.red] = 128, [colours.black] = 32768;\
}\
graphics.shader.sepia = {\
    [colours.white] = 1, [colours.orange] = 2, [colours.magenta] = 2, [colours.lightBlue] = 2;\
    [colours.yellow] = 1, [colours.lime] = 2, [colours.pink] = 1, [colours.grey] = 2;\
    [colours.lightGrey] = 2, [colours.cyan] = 16, [colours.purple] = 16, [colours.blue] = 4096;\
    [colours.brown] = 4096, [colours.green] = 16, [colours.red] = 16, [colours.black] = 4096;\
}\
\
return graphics",
  [ "/rom/help/lua" ] = "lua is an interactive prompt for the lua programming language. It's a useful tool for learning the language.",
  [ "/rom/programs/fun/advanced/redirection" ] = "--CCRedirection by : RamiLego4Game and Dan200--\
--Based on Redirection by Dan200: http://www.redirectiongame.com--\
--Clearing Screen--\
\
--Vars--\
local TermW,TermH = term.getSize()\
\
local sLevelTitle\
local tScreen\
local oScreen\
local SizeW,SizeH\
local aExits\
local fExit\
local nSpeed\
local Speed\
local fSpeed\
local fSpeedS\
local bPaused\
local Tick\
local Blocks\
local XOrgin,YOrgin\
\
local 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\
\
local InterFace = {}\
InterFace.cExit = colors.red\
InterFace.cSpeedD = colors.white\
InterFace.cSpeedA = colors.red\
InterFace.cTitle = colors.red\
\
local cG = colors.lightGray\
local cW = colors.gray\
local cS = colors.black\
local cR1 = colors.blue\
local cR2 = colors.red\
local cR3 = colors.green\
local cR4 = colors.yellow\
\
local tArgs = { ... }\
\
--Functions--\
local function printCentred( yc, stg )\
    local xc = math.floor((TermW - string.len(stg)) / 2) + 1\
    term.setCursorPos(xc,yc)\
    term.write( stg )\
end\
\
local function centerOrgin()\
    XOrgin = math.floor((TermW/2)-(SizeW/2))\
    YOrgin = math.floor((TermH/2)-(SizeH/2))\
end\
\
local 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\
\
local function tablecopy(t)\
  local t2 = {}\
  for k,v in pairs(t) do\
    t2[k] = v\
  end\
  return t2\
end\
\
local 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\
\
local function addRobot(x,y,side,color)\
    local obj = tScreen[x][y]\
    local 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\
\
local function addStart(x,y,side,color)\
    local obj = tScreen[x][y]\
    local 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\
\
local function addGround(x,y)\
    local 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\
\
local function addExit(x,y,cl)\
    local 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\
\
local function addWall(x,y)\
    local 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\
\
local function loadLevel(nNum)\
    sLevelTitle = \"Level \"..nNum\
    if nNum == nil then return error(\"nNum == nil\") end\
    local sDir = fs.getDir( shell.getRunningProgram() )\
    local 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\")\
    local Line = 0\
    local wl = true\
    Blocks = tonumber(string.sub(fLevel.readLine(),1,1))\
    local xSize = string.len(fLevel.readLine())+2\
    local Lines = 3\
    while wl do\
        local 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()\
        local chars = string.len(sLine)\
        for char = 1, chars do\
            local 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\
\
local function drawStars()\
    --CCR Background By : RamiLego--\
    local cStar,cStarG,crStar,crStarB = colors.lightGray,colors.gray,\".\",\"*\"\
    local DStar,BStar,nStar,gStar = 14,10,16,3\
    local TermW,TermH = term.getSize()\
\
    term.clear()\
    term.setCursorPos(1,1)\
    for x=1,TermW do\
        for y=1,TermH do\
            local 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\
\
local function drawMap()\
    for x=1,SizeW do\
        for y=1,SizeH do\
          \
            local 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\
         \
         local 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\
         \
         local st = tostring(tScreen[x][y].start)\
            if not(st == \"zz\" or st == \"nil\") then\
                local 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\
            \
            local rb = tostring(tScreen[x][y].robot)\
            if not(rb == \"zz\" or rb == \"nil\") then\
                local 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\
\
local function isBrick(x,y)\
    local brb = tostring(tScreen[x][y].robot)\
    local bobj = oScreen[x][y]\
    if (brb == \"zz\" or brb == \"nil\") and not bobj.wall == true then\
        return false\
    else\
        return true\
    end\
end\
\
local function gRender(sContext)\
    if sContext == \"start\" then\
        for x=1,SizeW do\
            for y=1,SizeH do\
                local st = tostring(tScreen[x][y].start)\
                if not(st == \"zz\" or st == \"nil\") then\
                    local Cr = string.sub(st,2,2)\
                    local 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\
                local rb = tostring(oScreen[x][y].robot)\
                if not(rb == \"zz\" or rb == \"nil\") then\
                    local Cr = string.sub(rb,2,2)\
                    local sSide = string.sub(rb,1,1)\
                    local 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\
                        local obj = isBrick(x,y-1)\
                        tScreen[x][y].robot = \"zz\"\
                        if not obj == true then\
                            addRobot(x,y-1,sSide,Cr)\
                        else\
                            local obj2 = isBrick(x-1,y)\
                            local 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\
                        local obj = isBrick(x+1,y)\
                        tScreen[x][y].robot = \"zz\"\
                        if not obj == true then\
                            addRobot(x+1,y,sSide,Cr)\
                        else\
                            local obj2 = isBrick(x,y-1)\
                            local 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\
                        local obj = isBrick(x,y+1)\
                        tScreen[x][y].robot = \"zz\"\
                        if not obj == true then\
                            addRobot(x,y+1,sSide,Cr)\
                        else\
                            local obj2 = isBrick(x-1,y)\
                            local 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\
                        local obj = isBrick(x-1,y)\
                        tScreen[x][y].robot = \"zz\"\
                        if not obj == true then\
                            addRobot(x-1,y,sSide,Cr)\
                        else\
                            local obj2 = isBrick(x,y-1)\
                            local 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()\
    local 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\
            local eobj = tScreen[p2-XOrgin][p3-YOrgin-1]\
            local 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\
\
local function startG(LevelN)\
    drawStars()\
    loadLevel(LevelN)\
    centerOrgin()\
    local create = true\
    drawMap()\
    InterFace.drawBar()\
    gRender(\"start\")\
    drawMap()\
    \
    local NExit = true\
    if aExits == 0 then\
        NExit = false\
    end\
    \
    while true do\
        local 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\
\
local ok, err = true, nil\
\
--Menu--\
local 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()\
        local nLevel\
        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",
  [ "/rom/help/repeat" ] = "repeat is a program for repeating rednet messages across long distances. To use, connect 2 or more modems to a computer and run the \"repeat\" program; from then on, any rednet message sent from any computer in wireless range or connected by networking cable to either of the modems will be repeated to those on the other side.",
  [ "/rom/programs/fun/advanced/levels/1" ] = "1\
     777\
     7b7\
     787\
7777778777\
7188888887\
7777777777",
  [ "/rom/apis/peripheral" ] = "local native = peripheral\
\
function getNames()\
    local tResults = {}\
    for n,sSide in ipairs( rs.getSides() ) do\
        if native.isPresent( sSide ) then\
            table.insert( tResults, sSide )\
            if native.getType( sSide ) == \"modem\" and not native.call( sSide, \"isWireless\" ) then\
                local tRemote = native.call( sSide, \"getNamesRemote\" )\
                for n,sName in ipairs( tRemote ) do\
                    table.insert( tResults, sName )\
                end\
            end\
        end\
    end\
    return tResults\
end\
\
function isPresent( _sSide )\
    if type( _sSide ) ~= \"string\" then\
        error( \"Expected string\", 2 )\
    end\
    if native.isPresent( _sSide ) then\
        return true\
    end\
    for n,sSide in ipairs( rs.getSides() ) do\
        if native.getType( sSide ) == \"modem\" and not native.call( sSide, \"isWireless\" ) then\
            if native.call( sSide, \"isPresentRemote\", _sSide )  then\
                return true\
            end\
        end\
    end\
    return false\
end\
\
function getType( _sSide )\
    if type( _sSide ) ~= \"string\" then\
        error( \"Expected string\", 2 )\
    end\
    if native.isPresent( _sSide ) then\
        return native.getType( _sSide )\
    end\
    for n,sSide in ipairs( rs.getSides() ) do\
        if native.getType( sSide ) == \"modem\" and not native.call( sSide, \"isWireless\" ) then\
            if native.call( sSide, \"isPresentRemote\", _sSide )  then\
                return native.call( sSide, \"getTypeRemote\", _sSide ) \
            end\
        end\
    end\
    return nil\
end\
\
function getMethods( _sSide )\
    if type( _sSide ) ~= \"string\" then\
        error( \"Expected string\", 2 )\
    end\
    if native.isPresent( _sSide ) then\
        return native.getMethods( _sSide )\
    end\
    for n,sSide in ipairs( rs.getSides() ) do\
        if native.getType( sSide ) == \"modem\" and not native.call( sSide, \"isWireless\" ) then\
            if native.call( sSide, \"isPresentRemote\", _sSide )  then\
                return native.call( sSide, \"getMethodsRemote\", _sSide ) \
            end\
        end\
    end\
    return nil\
end\
\
function call( _sSide, _sMethod, ... )\
    if type( _sSide ) ~= \"string\" or type( _sMethod ) ~= \"string\" then\
        error( \"Expected string, string\", 2 )\
    end\
    if native.isPresent( _sSide ) then\
        return native.call( _sSide, _sMethod, ... )\
    end\
    for n,sSide in ipairs( rs.getSides() ) do\
        if native.getType( sSide ) == \"modem\" and not native.call( sSide, \"isWireless\" ) then\
            if native.call( sSide, \"isPresentRemote\", _sSide )  then\
                return native.call( sSide, \"callRemote\", _sSide, _sMethod, ... ) \
            end\
        end\
    end\
    return nil\
end\
\
function wrap( _sSide )\
    if type( _sSide ) ~= \"string\"  then\
        error( \"Expected string\", 2 )\
    end\
    if peripheral.isPresent( _sSide ) then\
        local tMethods = peripheral.getMethods( _sSide )\
        local tResult = {}\
        for n,sMethod in ipairs( tMethods ) do\
            tResult[sMethod] = function( ... )\
                return peripheral.call( _sSide, sMethod, ... )\
            end\
        end\
        return tResult\
    end\
    return nil\
end\
\
function find( sType, fnFilter )\
    if type( sType ) ~= \"string\" or (fnFilter ~= nil and type( fnFilter ) ~= \"function\") then\
        error( \"Expected string, [function]\", 2 )\
    end\
    local tResults = {}\
    for n,sName in ipairs( peripheral.getNames() ) do\
        if peripheral.getType( sName ) == sType then\
            local wrapped = peripheral.wrap( sName )\
            if fnFilter == nil or fnFilter( sName, wrapped ) then\
                table.insert( tResults, wrapped )\
            end\
        end\
    end\
    return unpack( tResults )\
end",
  [ "/rom/help/textutils" ] = "Functions in the Text Utilities API:\
textutils.slowPrint( text )\
textutils.tabulate( table, table2, ... )\
textutils.pagedTabulate( table, table2, ... )\
textutils.formatTime( time, bTwentyFourHour )\
textutils.serialize( table )\
textutils.unserialize( string )\
textutils.urlEncode( string )",
  [ "/rom/help/apis" ] = "apis lists the currently loaded APIs available to programs in CraftOS.\
\
Type \"help <api>\" to see help for a specific api.\
Call os.loadAPI( path ) to load extra apis.",
  [ "/rom/help/cd" ] = "cd changes the the directory you're in.\
\
ex:\
\"cd rom\" will move to \"rom\" folder.\
\"cd ..\" will move up one folder.\
\"cd /\" will move to the root.",
  [ "/Shop/States/Init.lua" ] = "\
local StateLib = FDK.require('lib.state')\
local State = StateLib.names.Init\
local Main = StateLib.names.Main\
\
local Field = FDK.require('lib.UI.elements.Field')\
local Text = FDK.require('lib.UI.elements.Text')\
local Button = FDK.require('lib.UI.elements.Button')\
\
-- Main Field\
State.frame:newChild(Field(1, 1, State.frame.width, State.frame.height, colors.gray))\
-- Header Field\
State.frame:newChild(Field(1, 1, State.frame.width, 3, colors.lightGray))\
\
-- Header Text\
local Header = State.frame:newChild(Text(0, 0, 13, 1, '&b8&t0Shop - Client'))\
Header.width = #Header.text - #'&b7&t8'\
Header.y = 2\
Header:alignX('centre')\
\
local Desc = State.frame:newChild(Text(0, 0, 17, 1, '&b7&t8Requesting data..'))\
Desc.width = #Desc.text - #'&b7&t8'\
Desc.y = math.ceil(State.frame.height/2.3)\
Desc:alignX('centre')\
local CurrentRead = State.frame:newChild(Text(0, 0, 0, 1, '&b7&tfNo data available'))\
CurrentRead.width = #CurrentRead.text - #'&b7&t8'\
CurrentRead.y = math.ceil(State.frame.height/2)+1 \
CurrentRead:alignX('centre')\
  \
State.process:spawnThread(function()\
  while true do\
    -- Gather data --\
    Modem.transmit(2773, 2773, '@RequestData')\
    local Events, Side, Channel, Channel, Msg, Dist = coroutine.yield('modem_message')\
    --_G.DB = textutils.unserialize(Decompile(textutils.unserialize(Msg)))\
    break\
  end\
  Main:show()\
end)",
  [ "/rom/help/shellapi" ] = "Functions in the Shell API:\
shell.exit()\
shell.dir()\
shell.setDir( path )\
shell.path()\
shell.setPath( path )\
shell.resolve( localpath )\
shell.resolveProgram( name )\
shell.aliases()\
shell.setAlias( alias, command )\
shell.clearAlias( alias )\
shell.programs()\
shell.run( program, arguments )\
shell.getRunningProgram()\
shell.openTab( program, arguments ) (Advanced Computer required)\
shell.switchTab( n ) (Advanced Computer required)",
  [ "/Flare/version/1.2/lib/UI/base.lua" ] = "\
local class = require \"lib.class\"\
\
local base = class \"base\"\
\
function base:base( x, y, w, h )\
    self.x = x\
    self.y = y\
    self.width = w\
    self.height = h\
    self.root = {}\
    setmetatable( self.root, self.root )\
end\
\
function base:setX( x )\
    if type( x ) == \"string\" and x:find \"%d+%%$\" and self.parent then\
        x = math.floor( tonumber( x:sub( 1, -2 ) ) * self.parent.width + .5 )\
    end\
    self.x = x\
end\
\
function base:setY( y )\
    if type( y ) == \"string\" and y:find \"%d+%%$\" and self.parent then\
        y = math.floor( tonumber( y:sub( 1, -2 ) ) * self.parent.height + .5 )\
    end\
    self.y = y\
end\
\
function base:setWidth( width )\
    if type( width ) == \"string\" and width:find \"%d+%%$\" and self.parent then\
        width = math.floor( tonumber( width:sub( 1, -2 ) ) * self.parent.width + .5 )\
    end\
    self.width = width\
end\
\
function base:setHeight( width )\
    if type( height ) == \"string\" and height:find \"%d+%%$\" and self.parent then\
        height = math.floor( tonumber( height:sub( 1, -2 ) ) * self.parent.height + .5 )\
    end\
    self.height = height\
end\
\
function base:alignX( mode )\
    if mode == \"left\" then\
        self.x = 1\
    elseif mode == \"centre\" or mode == \"center\" or mode == \"middle\" then\
        self.x = math.floor( self.parent.width / 2 - self.width / 2 ) + 1\
    elseif mode == \"right\" then\
        self.x = self.parent.width - self.width + 1\
    else\
        return error( \"invalid x-alignment mode [\" .. mode .. \"]\" )\
    end\
end\
\
function base:alignY( mode )\
    if mode == \"top\" then\
        self.y = 1\
    elseif mode == \"centre\" or mode == \"center\" or mode == \"middle\" then\
        self.y = math.floor( self.parent.height / 2 - self.height / 2 ) + 1\
    elseif mode == \"bottom\" then\
        self.y = self.parent.height - self.height + 1\
    else\
        return error( \"invalid y-alignment mode [\" .. mode .. \"]\" )\
    end\
end\
\
function base:align( mode_x, mode_y )\
    if not mode_y then\
        return function( mode_y )\
            self:align( mode_x, mode_y )\
        end\
    end\
    self:alignX( mode_x )\
    self:alignY( mode_y )\
end\
\
function base:alignXTo( element, mode )\
    mode = mode or \"similar\"\
    if mode == \"similar\" or mode == \"same\" or mode == \"equal\" then\
        self.x = element.x\
    elseif mode == \"left\" then\
        self.x = element.x - self.width + 1\
    elseif mode == \"right\" then\
        self.x = element.x + element.width\
    else\
        return error( \"invalid x-alignment mode [\" .. mode .. \"]\" )\
    end\
end\
\
function base:alignYTo( element, mode )\
    mode = mode or \"similar\"\
    if mode == \"similar\" or mode == \"same\" or mode == \"equal\" then\
        self.y = element.y\
    elseif mode == \"above\" or mode == \"top\" then\
        self.y = element.y - self.height + 1\
    elseif mode == \"below\" or mode == \"bottom\" then\
        self.y = element.y + element.height\
    else\
        return error( \"invalid y-alignment mode [\" .. mode .. \"]\" )\
    end\
end\
\
function base:alignTo( element, mode_x, mode_y )\
    self:alignXTo( element, mode_x )\
    self:alignYTo( element, mode_y )\
end\
\
function base:remove()\
    if self.parent then\
        self.parent:removeChild( self )\
    end\
end\
\
function base:draw( x, y, buffer )\
\
end\
\
function base:update( dt )\
\
end\
\
function base:handle( event )\
\
end\
\
return base",
  [ "/rom/help/dj" ] = "dj plays Music Discs from disk drives attached to the computer.\
\
ex:\
\"dj\" or \"dj play\" plays a random disc.\
\"dj play left\" plays the disc in the drive on the left of the computer.\
\"dj stop\" stops the current disc.",
  [ "/Flare/version/1.2/lib/stencil.lua" ] = "\
local function bbox( x1, y1, w1, h1, x2, y2, w2, h2 )\
    local x = math.max( x1, x2 )\
    local y = math.max( y1, y2 )\
    local w = math.min( x1 + w1, x2 + w2 ) - x\
    local h = math.min( y1 + h1, y2 + h2 ) - y\
    if w < 1 or h < 1 then return false end\
    return x, y, w, h\
end\
\
local stencil = {}\
\
function stencil:new()\
\
    local s = {}\
\
    s.bounds = false\
    s.layers = {}\
\
    setmetatable( s, { __index = self, __type = \"stencil\" } )\
    return s\
\
end\
\
function stencil:newLayer( x, y, w, h )\
    if self.bounds then\
        if self.bounds.x then\
            local t = self.bounds\
            local _x, _y, _w, _h = bbox( x, y, w, h, t.x, t.y, t.width, t.height )\
            if _x then\
                self.bounds = {\
                    x = _x;\
                    y = _y;\
                    width = _w;\
                    height = _h;\
                }\
            else\
                self.bounds = {}\
            end\
        end\
    else\
        self.bounds = {\
            x = x;\
            y = y;\
            width = w;\
            height = h;\
        }\
    end\
    local id = {}\
    self.layers[#self.layers + 1] = {\
        x = x;\
        y = y;\
        width = w;\
        height = h;\
        id = id;\
    }\
    return id\
end\
\
function stencil:removeLayer( l )\
    for i = 1, #self.layers do\
        if self.layers[i].id == l then\
            while self.layers[i] do\
                table.remove( self.layers, i )\
            end\
        end\
    end\
    local t = self.layers\
    self.bounds = false\
    self.layers = {}\
    if #t > 0 then\
        for i = 1, #t do\
            self:newLayer( t[i].x, t[i].y, t[i].width, t[i].height )\
            self.layers[#self.layers].id = t[i].id\
            if not self.bounds.x then\
                break\
            end\
        end\
    end\
end\
\
function stencil:getBounds( x, y, w, h )\
    if self.bounds then\
        if self.bounds.x then\
            return self.bounds.x, self.bounds.y, self.bounds.width, self.bounds.height\
        end\
        return false\
    end\
    return x or true, y, w, h\
end\
\
function stencil:clearLayers()\
    self.layers = {}\
    self.bounds = false\
end\
\
function stencil:withinBounds( px, py )\
    local x, y, w, h = self:getBounds()\
    if x == true then return true end\
    if x == false then return false end\
    return px >= x and px < x + w and py >= y and py < y + h\
end\
\
return stencil",
  [ "/rom/programs/fun/advanced/levels/7" ] = "3\
728777778b7\
78888888887\
78777877787\
787 787 787\
787 7877788\
787 7888889\
88777877777\
e888887\
7777887",
  [ "/rom/apis/term" ] = "\
local native = (term.native and term.native()) or term\
local redirectTarget = native\
\
local function wrap( _sFunction )\
    return function( ... )\
        return redirectTarget[ _sFunction ]( ... )\
    end\
end\
\
local term = {}\
\
term.redirect = function( target )\
    if target == nil or type( target ) ~= \"table\" then\
        error( \"Invalid redirect target\", 2 )\
    end\
    if target == term then\
        error( \"term is not a recommended redirect target, try term.current() instead\", 2 )\
    end\
    for k,v in pairs( native ) do\
        if type( k ) == \"string\" and type( v ) == \"function\" then\
            if type( target[k] ) ~= \"function\" then\
                target[k] = function()\
                    error( \"Redirect object is missing method \"..k..\".\", 2 )\
                end\
            end\
        end\
    end\
    local oldRedirectTarget = redirectTarget\
    redirectTarget = target\
    return oldRedirectTarget\
end\
\
term.current = function()\
    return redirectTarget\
end\
\
term.native = function()\
    -- NOTE: please don't use this function unless you have to.\
    -- If you're running in a redirected or multitasked enviorment, term.native() will NOT be\
    -- the current terminal when your program starts up. It is far better to use term.current()\
    return native\
end\
\
for k,v in pairs( native ) do\
    if type( k ) == \"string\" and type( v ) == \"function\" then\
        if term[k] == nil then\
            term[k] = wrap( k )\
        end\
    end\
end\
    \
local env = getfenv()\
for k,v in pairs( term ) do\
    env[k] = v\
end",
  [ "/Flare/version/1.2/module.lua" ] = "\
local modules = {\
    [\"core\"] = {\
        files = {\
            \"buffer\";\
            \"class\";\
            \"graphics\";\
            \"image\";\
            \"process\";\
            \"sha256\";\
            \"state\";\
            \"stencil\";\
            \"trace\";\
            \"tween\";\
            \"video\";\
            \"UI.animation\";\
            \"UI.base\";\
            \"UI.keybind\";\
            \"UI.draw.draw\";\
            \"UI.draw.image\";\
            \"UI.draw.pixel\";\
            \"UI.draw.pixelbatch\";\
            \"UI.draw.text\";\
            \"UI.event.Dispatcher\";\
            \"UI.event.Event\";\
            \"UI.event.mouse\";\
            \"UI.text.code\";\
            \"UI.text.formatter\";\
            \"UI.elements.Button\";\
            \"UI.elements.ClippingFrame\";\
            \"UI.elements.Field\";\
            \"UI.elements.Frame\";\
            \"UI.elements.Image\";\
            \"UI.elements.Input\";\
            \"UI.elements.ProgressBar\";\
            \"UI.elements.ScrollBar\";\
            \"UI.elements.Text\";\
        };\
    };\
    [\"application\"] = {\
        files = {\
            \"UI.elements.DropdownButton\";\
            \"page\";\
        };\
    };\
}\
\
local module = {}\
\
function module.isInstalled( name )\
    if modules[name] then\
        for i = 1, #modules[name].files do\
            if not fs.exists( FDK.lib_path .. \"/\" .. modules[name].files[i]:gsub( \"%.\", \"/\" ) .. \".lua\" ) then\
                return false\
            end\
        end\
        return true\
    else\
        return error( (\"no such module %q\"):format( name ) )\
    end\
end\
\
function module.install( name )\
    if modules[name] then\
        if modules[name].pre then\
            modules[name].pre()\
        end\
        for i = 1, #modules[name].files do\
            print( \"Downloading \" .. modules[name].files[i] )\
            local file = modules[name].files[i]:gsub( \"%.\", \"/\" ) .. \".lua\"\
            local url = \"https://raw.githubusercontent.com/awsumben13/Flare/master/version/\" .. FDK.version.local_major() .. \"/module/\" .. textutils.urlEncode( name ) .. \"/\" .. textutils.urlEncode( file )\
            local h = http.get( url )\
            if h then\
                local content = h.readAll()\
                h.close()\
\
                local h = fs.open( FDK.lib_path .. \"/\" .. file, \"w\" )\
                if h then\
                    h.write( content )\
                    h.close()\
                else\
                    print \"Install failed\"\
                    return false\
                end\
            else\
                print \"Download failed\"\
                return false\
            end\
        end\
        if modules[name].post then\
            modules[name].post()\
        end\
        return true\
    else\
        return error( (\"no such module %q\"):format( name ) )\
    end\
end\
\
function module.shouldInstall( t )\
    for i = 1, #t do\
        if not module.isInstalled( t[i] ) then\
            module.install( t[i] )\
        end\
    end\
end\
\
return module",
  [ "/rom/apis/help" ] = "\
local sPath = \"/rom/help\"\
\
function path()\
    return sPath\
end\
\
function setPath( _sPath )\
    sPath = _sPath\
end\
\
function lookup( _sTopic )\
    -- Look on the path variable\
    for sPath in string.gmatch(sPath, \"[^:]+\") do\
        sPath = fs.combine( sPath, _sTopic )\
        if fs.exists( sPath ) and not fs.isDir( sPath ) then\
            return sPath\
        end\
    end\
    \
    -- Not found\
    return nil\
end\
\
function topics()\
    local tItems = {}\
    \
    -- Add topics from the path\
    for sPath in string.gmatch(sPath, \"[^:]+\") do\
        if fs.isDir( sPath ) then\
            local tList = fs.list( sPath )\
            for n,sFile in pairs( tList ) do\
                if string.sub( sFile, 1, 1 ) ~= \".\" then\
                    if not fs.isDir( fs.combine( sPath, sFile ) ) then\
                        tItems[ sFile ] = true\
                    end\
                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",
  [ "/rom/programs/reboot" ] = "if term.isColour() then\
    term.setTextColour( colours.yellow )\
end\
print( \"Goodbye\" )\
term.setTextColour( colours.white )\
\
sleep( 1 )\
os.reboot()",
  [ "/rom/help/bundled" ] = "To set bundled outputs:\
c = colors.combine( colors.red, colors.blue )\
rs.setBundledOutput( \"left\", c )\
\
c = colors.combine( c, colors.green )\
rs.setBundledOutput( \"left\", c )\
\
c = colors.subtract( c, colors.blue )\
rs.setBundledOutput( \"left\", c )\
\
To get bundled inputs:\
c = rs.getBundledInput( \"right\" )\
red = colors.test( c, colors.red )\
\
Type \"help colors\" for the list of wire colors.",
  [ "/rom/help/multishell" ] = "multishell is the toplevel program on Advanced Computers which manages background tabs.\
Type \"help shellapi\" for information about the shell lua api.",
  [ "/rom/help/delete" ] = "rm deletes a file or a directory and its contents.\
\
ex:\
\"rm foo\" will delete the file foo.\
\"rm disk/*\" will delete the contents of a disk.",
  [ "/rom/help/mkdir" ] = "mkdir creates a directory in the current location.\
\
ex:\
\"mkdir foo\" creates a directory named \"foo\".\
\"mkdir ../foo\" creates a directory named \"foo\" in the directory above the current directory.",
  [ "/rom/help/help" ] = "help is the help tool you're currently using.\
Type \"help index\" to see all help topics.\
Type \"help\" to see the help intro.\
Type \"help helpapi\" for information on the help Lua API.",
  [ "/rom/help/helpapi" ] = "Functions in the help API:\
help.setPath( path )\
help.lookup( topic )\
help.topics()",
  [ "/rom/help/gps" ] = "gps can be used to host a GPS server, or to determine a position using trilateration.\
Type \"help gpsapi\" for help using GPS functions in lua programs.\
\
ex:\
\"gps locate\" will connect to nearby GPS servers, and try to determine the position of the computer or turtle.\
\"gps host\" will try to determine the position, and host a GPS server if successful.\
\"gps host 10 20 30\" will host a GPS server, using the manually entered position 10,20,30. \
\
Take care when manually entering host positions. If the positions entered into multiple GPS hosts\
are not consistent, the results of locate calls will be incorrect.",
  [ "/rom/programs/fun/advanced/levels/6" ] = "4\
7777777777\
7288888837\
78      87\
788888b 87\
788888b 87\
788888b 87\
788888b 87\
78      87\
7188888807\
7777777777",
  [ "/Flare/version/1.2/lib/tween.lua" ] = "local tween = {\
  _VERSION     = 'tween 2.0.0',\
  _DESCRIPTION = 'tweening for lua',\
  _URL         = 'https://github.com/kikito/tween.lua',\
  _LICENSE     = \"\"\
}\
\
-- easing\
\
-- Adapted from https://github.com/EmmanuelOga/easing. See LICENSE.txt for credits.\
-- For all easing functions:\
-- t = time == how much time has to pass for the tweening to complete\
-- b = begin == starting property value\
-- c = change == ending - beginning\
-- d = duration == running time. How much time has passed *right now*\
\
local math, assert, tostring, type = math, assert, tostring, type\
local pow, sin, cos, pi, sqrt, abs, asin = math.pow, math.sin, math.cos, math.pi, math.sqrt, math.abs, math.asin\
\
-- linear\
local function linear(t, b, c, d) return c * t / d + b end\
\
-- quad\
local function inQuad(t, b, c, d) return c * pow(t / d, 2) + b end\
local function outQuad(t, b, c, d)\
  t = t / d\
  return -c * t * (t - 2) + b\
end\
local function inOutQuad(t, b, c, d)\
  t = t / d * 2\
  if t < 1 then return c / 2 * pow(t, 2) + b end\
  return -c / 2 * ((t - 1) * (t - 3) - 1) + b\
end\
local function outInQuad(t, b, c, d)\
  if t < d / 2 then return outQuad(t * 2, b, c / 2, d) end\
  return inQuad((t * 2) - d, b + c / 2, c / 2, d)\
end\
\
-- cubic\
local function inCubic (t, b, c, d) return c * pow(t / d, 3) + b end\
local function outCubic(t, b, c, d) return c * (pow(t / d - 1, 3) + 1) + b end\
local function inOutCubic(t, b, c, d)\
  t = t / d * 2\
  if t < 1 then return c / 2 * t * t * t + b end\
  t = t - 2\
  return c / 2 * (t * t * t + 2) + b\
end\
local function outInCubic(t, b, c, d)\
  if t < d / 2 then return outCubic(t * 2, b, c / 2, d) end\
  return inCubic((t * 2) - d, b + c / 2, c / 2, d)\
end\
\
-- quart\
local function inQuart(t, b, c, d) return c * pow(t / d, 4) + b end\
local function outQuart(t, b, c, d) return -c * (pow(t / d - 1, 4) - 1) + b end\
local function inOutQuart(t, b, c, d)\
  t = t / d * 2\
  if t < 1 then return c / 2 * pow(t, 4) + b end\
  return -c / 2 * (pow(t - 2, 4) - 2) + b\
end\
local function outInQuart(t, b, c, d)\
  if t < d / 2 then return outQuart(t * 2, b, c / 2, d) end\
  return inQuart((t * 2) - d, b + c / 2, c / 2, d)\
end\
\
-- quint\
local function inQuint(t, b, c, d) return c * pow(t / d, 5) + b end\
local function outQuint(t, b, c, d) return c * (pow(t / d - 1, 5) + 1) + b end\
local function inOutQuint(t, b, c, d)\
  t = t / d * 2\
  if t < 1 then return c / 2 * pow(t, 5) + b end\
  return c / 2 * (pow(t - 2, 5) + 2) + b\
end\
local function outInQuint(t, b, c, d)\
  if t < d / 2 then return outQuint(t * 2, b, c / 2, d) end\
  return inQuint((t * 2) - d, b + c / 2, c / 2, d)\
end\
\
-- sine\
local function inSine(t, b, c, d) return -c * cos(t / d * (pi / 2)) + c + b end\
local function outSine(t, b, c, d) return c * sin(t / d * (pi / 2)) + b end\
local function inOutSine(t, b, c, d) return -c / 2 * (cos(pi * t / d) - 1) + b end\
local function outInSine(t, b, c, d)\
  if t < d / 2 then return outSine(t * 2, b, c / 2, d) end\
  return inSine((t * 2) -d, b + c / 2, c / 2, d)\
end\
\
-- expo\
local function inExpo(t, b, c, d)\
  if t == 0 then return b end\
  return c * pow(2, 10 * (t / d - 1)) + b - c * 0.001\
end\
local function outExpo(t, b, c, d)\
  if t == d then return b + c end\
  return c * 1.001 * (-pow(2, -10 * t / d) + 1) + b\
end\
local function inOutExpo(t, b, c, d)\
  if t == 0 then return b end\
  if t == d then return b + c end\
  t = t / d * 2\
  if t < 1 then return c / 2 * pow(2, 10 * (t - 1)) + b - c * 0.0005 end\
  return c / 2 * 1.0005 * (-pow(2, -10 * (t - 1)) + 2) + b\
end\
local function outInExpo(t, b, c, d)\
  if t < d / 2 then return outExpo(t * 2, b, c / 2, d) end\
  return inExpo((t * 2) - d, b + c / 2, c / 2, d)\
end\
\
-- circ\
local function inCirc(t, b, c, d) return(-c * (sqrt(1 - pow(t / d, 2)) - 1) + b) end\
local function outCirc(t, b, c, d)  return(c * sqrt(1 - pow(t / d - 1, 2)) + b) end\
local function inOutCirc(t, b, c, d)\
  t = t / d * 2\
  if t < 1 then return -c / 2 * (sqrt(1 - t * t) - 1) + b end\
  t = t - 2\
  return c / 2 * (sqrt(1 - t * t) + 1) + b\
end\
local function outInCirc(t, b, c, d)\
  if t < d / 2 then return outCirc(t * 2, b, c / 2, d) end\
  return inCirc((t * 2) - d, b + c / 2, c / 2, d)\
end\
\
-- elastic\
local function calculatePAS(p,a,c,d)\
  p, a = p or d * 0.3, a or 0\
  if a < abs(c) then return p, c, p / 4 end -- p, a, s\
  return p, a, p / (2 * pi) * asin(c/a) -- p,a,s\
end\
local function inElastic(t, b, c, d, a, p)\
  local s\
  if t == 0 then return b end\
  t = t / d\
  if t == 1  then return b + c end\
  p,a,s = calculatePAS(p,a,c,d)\
  t = t - 1\
  return -(a * pow(2, 10 * t) * sin((t * d - s) * (2 * pi) / p)) + b\
end\
local function outElastic(t, b, c, d, a, p)\
  local s\
  if t == 0 then return b end\
  t = t / d\
  if t == 1 then return b + c end\
  p,a,s = calculatePAS(p,a,c,d)\
  return a * pow(2, -10 * t) * sin((t * d - s) * (2 * pi) / p) + c + b\
end\
local function inOutElastic(t, b, c, d, a, p)\
  local s\
  if t == 0 then return b end\
  t = t / d * 2\
  if t == 2 then return b + c end\
  p,a,s = calculatePAS(p,a,c,d)\
  t = t - 1\
  if t < 0 then return -0.5 * (a * pow(2, 10 * t) * sin((t * d - s) * (2 * pi) / p)) + b end\
  return a * pow(2, -10 * t) * sin((t * d - s) * (2 * pi) / p ) * 0.5 + c + b\
end\
local function outInElastic(t, b, c, d, a, p)\
  if t < d / 2 then return outElastic(t * 2, b, c / 2, d, a, p) end\
  return inElastic((t * 2) - d, b + c / 2, c / 2, d, a, p)\
end\
\
-- back\
local function inBack(t, b, c, d, s)\
  s = s or 1.70158\
  t = t / d\
  return c * t * t * ((s + 1) * t - s) + b\
end\
local function outBack(t, b, c, d, s)\
  s = s or 1.70158\
  t = t / d - 1\
  return c * (t * t * ((s + 1) * t + s) + 1) + b\
end\
local function inOutBack(t, b, c, d, s)\
  s = (s or 1.70158) * 1.525\
  t = t / d * 2\
  if t < 1 then return c / 2 * (t * t * ((s + 1) * t - s)) + b end\
  t = t - 2\
  return c / 2 * (t * t * ((s + 1) * t + s) + 2) + b\
end\
local function outInBack(t, b, c, d, s)\
  if t < d / 2 then return outBack(t * 2, b, c / 2, d, s) end\
  return inBack((t * 2) - d, b + c / 2, c / 2, d, s)\
end\
\
-- bounce\
local function outBounce(t, b, c, d)\
  t = t / d\
  if t < 1 / 2.75 then return c * (7.5625 * t * t) + b end\
  if t < 2 / 2.75 then\
    t = t - (1.5 / 2.75)\
    return c * (7.5625 * t * t + 0.75) + b\
  elseif t < 2.5 / 2.75 then\
    t = t - (2.25 / 2.75)\
    return c * (7.5625 * t * t + 0.9375) + b\
  end\
  t = t - (2.625 / 2.75)\
  return c * (7.5625 * t * t + 0.984375) + b\
end\
local function inBounce(t, b, c, d) return c - outBounce(d - t, 0, c, d) + b end\
local function inOutBounce(t, b, c, d)\
  if t < d / 2 then return inBounce(t * 2, 0, c, d) * 0.5 + b end\
  return outBounce(t * 2 - d, 0, c, d) * 0.5 + c * .5 + b\
end\
local function outInBounce(t, b, c, d)\
  if t < d / 2 then return outBounce(t * 2, b, c / 2, d) end\
  return inBounce((t * 2) - d, b + c / 2, c / 2, d)\
end\
\
tween.easing = {\
  linear    = linear,\
  inQuad    = inQuad,    outQuad    = outQuad,    inOutQuad    = inOutQuad,    outInQuad    = outInQuad,\
  inCubic   = inCubic,   outCubic   = outCubic,   inOutCubic   = inOutCubic,   outInCubic   = outInCubic,\
  inQuart   = inQuart,   outQuart   = outQuart,   inOutQuart   = inOutQuart,   outInQuart   = outInQuart,\
  inQuint   = inQuint,   outQuint   = outQuint,   inOutQuint   = inOutQuint,   outInQuint   = outInQuint,\
  inSine    = inSine,    outSine    = outSine,    inOutSine    = inOutSine,    outInSine    = outInSine,\
  inExpo    = inExpo,    outExpo    = outExpo,    inOutExpo    = inOutExpo,    outInExpo    = outInExpo,\
  inCirc    = inCirc,    outCirc    = outCirc,    inOutCirc    = inOutCirc,    outInCirc    = outInCirc,\
  inElastic = inElastic, outElastic = outElastic, inOutElastic = inOutElastic, outInElastic = outInElastic,\
  inBack    = inBack,    outBack    = outBack,    inOutBack    = inOutBack,    outInBack    = outInBack,\
  inBounce  = inBounce,  outBounce  = outBounce,  inOutBounce  = inOutBounce,  outInBounce  = outInBounce\
}\
\
\
\
-- private stuff\
\
local function copyTables(destination, keysTable, valuesTable)\
  valuesTable = valuesTable or keysTable\
  local mt = getmetatable(keysTable)\
  if mt and getmetatable(destination) == nil then\
    setmetatable(destination, mt)\
  end\
  for k,v in pairs(keysTable) do\
    if type(v) == 'table' then\
      destination[k] = copyTables({}, v, valuesTable[k])\
    else\
      destination[k] = valuesTable[k]\
    end\
  end\
  return destination\
end\
\
local function checkSubjectAndTargetRecursively(subject, target, path)\
  path = path or {}\
  local targetType, newPath\
  for k,targetValue in pairs(target) do\
    targetType, newPath = type(targetValue), copyTables({}, path)\
    table.insert(newPath, tostring(k))\
    if targetType == 'number' then\
      assert(type(subject[k]) == 'number', \"Parameter '\" .. table.concat(newPath,'/') .. \"' is missing from subject or isn't a number\")\
    elseif targetType == 'table' then\
      checkSubjectAndTargetRecursively(subject[k], targetValue, newPath)\
    else\
      assert(targetType == 'number', \"Parameter '\" .. table.concat(newPath,'/') .. \"' must be a number or table of numbers\")\
    end\
  end\
end\
\
local function checkNewParams(duration, subject, target, easing)\
  assert(type(duration) == 'number' and duration > 0, \"duration must be a positive number. Was \" .. tostring(duration))\
  local tsubject = type(subject)\
  assert(tsubject == 'table' or tsubject == 'userdata', \"subject must be a table or userdata. Was \" .. tostring(subject))\
  assert(type(target)== 'table', \"target must be a table. Was \" .. tostring(target))\
  assert(type(easing)=='function', \"easing must be a function. Was \" .. tostring(easing))\
  checkSubjectAndTargetRecursively(subject, target)\
end\
\
local function getEasingFunction(easing)\
  easing = easing or \"linear\"\
  if type(easing) == 'string' then\
    local name = easing\
    easing = tween.easing[name]\
    if type(easing) ~= 'function' then\
      error(\"The easing function name '\" .. name .. \"' is invalid\")\
    end\
  end\
  return easing\
end\
\
local function performEasingOnSubject(subject, target, initial, clock, duration, easing, round)\
  local t,b,c,d\
  for k,v in pairs(target) do\
    if type(v) == 'table' then\
      performEasingOnSubject(subject[k], v, initial[k], clock, duration, easing)\
    else\
      t,b,c,d = clock, initial[k], v - initial[k], duration\
      if round then\
        subject[k] = math.floor( easing(t,b,c,d) + 0.5 )\
      else\
        subject[k] = easing(t,b,c,d)\
      end\
    end\
  end\
end\
\
-- Tween methods\
\
local Tween = {}\
local Tween_mt = {__index = Tween}\
\
function Tween:set(clock)\
  assert(type(clock) == 'number', \"clock must be a positive number or 0\")\
\
  self.clock = clock\
\
  if self.clock <= 0 then\
\
    self.clock = 0\
    copyTables(self.subject, self.initial)\
\
  elseif self.clock >= self.duration then -- the tween has expired\
\
    self.clock = self.duration\
    copyTables(self.subject, self.target)\
\
  else\
\
    performEasingOnSubject(self.subject, self.target, self.initial, self.clock, self.duration, self.easing, self.round)\
\
  end\
\
  return self.clock >= self.duration\
end\
\
function Tween:reset()\
  return self:set(0)\
end\
\
function Tween:update(dt)\
  assert(type(dt) == 'number', \"dt must be a number\")\
  return self:set(self.clock + dt)\
end\
\
function Tween:isFinished()\
  return self.clock >= self.duration\
end\
\
function Tween:run()\
  local time = os.clock()\
  while not self:isFinished() do\
    self:update( os.clock() - time )\
    time = os.clock()\
    coroutine.yield()\
  end\
end\
\
-- Public interface\
\
function tween.new(duration, subject, target, easing)\
  easing = getEasingFunction(easing)\
  checkNewParams(duration, subject, target, easing)\
  return setmetatable({\
    duration  = duration,\
    subject   = subject,\
    target    = target,\
    easing    = easing,\
\
    initial   = copyTables({},target,subject),\
    clock     = 0\
  }, Tween_mt)\
end\
\
return tween",
  [ "/rom/help/term" ] = "Functions in the Terminal API:\
term.write( text )\
term.clear()\
term.clearLine()\
term.getCursorPos()\
term.setCursorPos( x, y )\
term.setCursorBlink( blink )\
term.isColor()\
term.setTextColor( color )\
term.setBackgroundColor( color )\
term.getSize()\
term.scroll( n )\
term.redirect( object )\
term.current()\
\
Events emitted by the terminals:\
\"term_resize\", when the size of a terminal changes. This can happen in multitasking environments, or when the terminal out is being redirected by the \"monitor\" program.",
  [ "/Flare/version/1.2/lib/image.lua" ] = "\
local colour = {}\
\
colour.lookup = {\
    [\"0\"] = colours.white;\
    [\"1\"] = colours.orange;\
    [\"2\"] = colours.magenta;\
    [\"3\"] = colours.lightBlue;\
    [\"4\"] = colours.yellow;\
    [\"5\"] = colours.lime;\
    [\"6\"] = colours.pink;\
    [\"7\"] = colours.grey;\
    [\"8\"] = colours.lightGrey;\
    [\"9\"] = colours.cyan;\
    [\"A\"] = colours.purple;\
    [\"B\"] = colours.blue;\
    [\"C\"] = colours.brown;\
    [\"D\"] = colours.green;\
    [\"E\"] = colours.red;\
    [\"F\"] = colours.black;\
    [\" \"] = 0;\
}\
\
colour.save = {}\
for k, v in pairs( colour.lookup ) do\
    colour.save[v] = k\
end\
\
local image = {}\
\
image.colour = colour\
\
function image:new( width, height )\
\
    local i = {}\
\
    i.width = width or 0\
    i.height = height or 0\
\
    i.pixels = {}\
\
    for y = 1, height or 0 do\
        i.pixels[y] = {}\
        for x = 1, width or 0 do\
            i.pixels[y][x] = { bc = 0, tc = 0, char = \"\" }\
        end\
    end\
\
    setmetatable( i, { __index = self, __type = \"image\" } )\
    return i\
\
end\
\
function image:setPixel( x, y, bc, tc, char )\
    if self.pixels[y] and self.pixels[y][x] then\
        self.pixels[y][x] = {\
            bc = bc;\
            tc = tc;\
            char = char;\
        }\
    end\
end\
\
function image:getPixel( x, y )\
    if self.pixels[y] and self.pixels[y][x] then\
        return self.pixels[y][x].bc, self.pixels[y][x].tc, self.pixels[y][x].char\
    end\
end\
\
function image:save()\
    local str = \"\"\
    for y = 1, self.height do\
        for x = 1, self.width do\
            local bc, tc, char = self:getPixel( x, y )\
            bc = colour.save[bc]\
            tc = colour.save[tc]\
            if #char == 0 then\
                char = \" \"\
                bc = colours.save[0]\
            end\
            str = str .. bc .. tc .. char\
        end\
        str = str .. \"\\n\"\
    end\
    return str:sub( 1, -2 )\
end\
\
function image:clone()\
    local new = image:new( self.width, self.height )\
    for x = 1, self.width do\
        for y = 1, self.height do\
            new:setPixel( x, y, self:getPixel( x, y ) )\
        end\
    end\
    return new\
end\
\
function image.load( str )\
    local lines = {}\
    local last = 1\
    for i = 1, #str do\
        if str:sub( i, i ) == \"\\n\" then\
            table.insert( lines, str:sub( last, i - 1 ) )\
            last = i + 1\
        end\
    end\
    table.insert( lines, str:sub( last ) )\
    local width = #lines[1] / 3\
    local height = #lines\
    local frame = image:new( width, height )\
    for i = 1, #lines do\
        local x = 1\
        for pixel in lines[i]:gmatch( \"[0123456789ABCDEF ][0123456789ABCDEF ].\" ) do\
            local bc = colour.lookup[pixel:sub( 1, 1 )]\
            local tc = colour.lookup[pixel:sub( 2, 2 )]\
            local ch = pixel:sub( 3, 3 )\
            frame:setPixel( x, i, bc, tc, ch )\
            x = x + 1\
        end\
    end\
    return frame\
end\
\
return image",
  [ "/rom/programs/turtle/excavate" ] = "\
local tArgs = { ... }\
if #tArgs ~= 1 then\
    print( \"Usage: excavate <diameter>\" )\
    return\
end\
\
-- Mine in a quarry pattern until we hit something we can't dig\
local size = tonumber( tArgs[1] )\
if size < 1 then\
    print( \"Excavate diameter must be positive\" )\
    return\
end\
    \
local depth = 0\
local unloaded = 0\
local collected = 0\
\
local xPos,zPos = 0,0\
local xDir,zDir = 0,1\
\
local goTo -- Filled in further down\
local refuel -- Filled in further down\
 \
local function unload( _bKeepOneFuelStack )\
    print( \"Unloading items...\" )\
    for n=1,16 do\
        local nCount = turtle.getItemCount(n)\
        if nCount > 0 then\
            turtle.select(n)            \
            local bDrop = true\
            if _bKeepOneFuelStack and turtle.refuel(0) then\
                bDrop = false\
                _bKeepOneFuelStack = false\
            end         \
            if bDrop then\
                turtle.drop()\
                unloaded = unloaded + nCount\
            end\
        end\
    end\
    collected = 0\
    turtle.select(1)\
end\
\
local function returnSupplies()\
    local x,y,z,xd,zd = xPos,depth,zPos,xDir,zDir\
    print( \"Returning to surface...\" )\
    goTo( 0,0,0,0,-1 )\
    \
    local fuelNeeded = 2*(x+y+z) + 1\
    if not refuel( fuelNeeded ) then\
        unload( true )\
        print( \"Waiting for fuel\" )\
        while not refuel( fuelNeeded ) do\
            os.pullEvent( \"turtle_inventory\" )\
        end\
    else\
        unload( true )  \
    end\
    \
    print( \"Resuming mining...\" )\
    goTo( x,y,z,xd,zd )\
end\
\
local function collect()    \
    local bFull = true\
    local nTotalItems = 0\
    for n=1,16 do\
        local nCount = turtle.getItemCount(n)\
        if nCount == 0 then\
            bFull = false\
        end\
        nTotalItems = nTotalItems + nCount\
    end\
    \
    if nTotalItems > collected then\
        collected = nTotalItems\
        if math.fmod(collected + unloaded, 50) == 0 then\
            print( \"Mined \"..(collected + unloaded)..\" items.\" )\
        end\
    end\
    \
    if bFull then\
        print( \"No empty slots left.\" )\
        return false\
    end\
    return true\
end\
\
function refuel( ammount )\
    local fuelLevel = turtle.getFuelLevel()\
    if fuelLevel == \"unlimited\" then\
        return true\
    end\
    \
    local needed = ammount or (xPos + zPos + depth + 2)\
    if turtle.getFuelLevel() < needed then\
        local fueled = false\
        for n=1,16 do\
            if turtle.getItemCount(n) > 0 then\
                turtle.select(n)\
                if turtle.refuel(1) then\
                    while turtle.getItemCount(n) > 0 and turtle.getFuelLevel() < needed do\
                        turtle.refuel(1)\
                    end\
                    if turtle.getFuelLevel() >= needed then\
                        turtle.select(1)\
                        return true\
                    end\
                end\
            end\
        end\
        turtle.select(1)\
        return false\
    end\
    \
    return true\
end\
\
local function tryForwards()\
    if not refuel() then\
        print( \"Not enough Fuel\" )\
        returnSupplies()\
    end\
    \
    while not turtle.forward() do\
        if turtle.detect() then\
            if turtle.dig() then\
                if not collect() then\
                    returnSupplies()\
                end\
            else\
                return false\
            end\
        elseif turtle.attack() then\
            if not collect() then\
                returnSupplies()\
            end\
        else\
            sleep( 0.5 )\
        end\
    end\
    \
    xPos = xPos + xDir\
    zPos = zPos + zDir\
    return true\
end\
\
local function tryDown()\
    if not refuel() then\
        print( \"Not enough Fuel\" )\
        returnSupplies()\
    end\
    \
    while not turtle.down() do\
        if turtle.detectDown() then\
            if turtle.digDown() then\
                if not collect() then\
                    returnSupplies()\
                end\
            else\
                return false\
            end\
        elseif turtle.attackDown() then\
            if not collect() then\
                returnSupplies()\
            end\
        else\
            sleep( 0.5 )\
        end\
    end\
\
    depth = depth + 1\
    if math.fmod( depth, 10 ) == 0 then\
        print( \"Descended \"..depth..\" metres.\" )\
    end\
\
    return true\
end\
\
local function turnLeft()\
    turtle.turnLeft()\
    xDir, zDir = -zDir, xDir\
end\
\
local function turnRight()\
    turtle.turnRight()\
    xDir, zDir = zDir, -xDir\
end\
\
function goTo( x, y, z, xd, zd )\
    while depth > y do\
        if turtle.up() then\
            depth = depth - 1\
        elseif turtle.digUp() or turtle.attackUp() then\
            collect()\
        else\
            sleep( 0.5 )\
        end\
    end\
\
    if xPos > x then\
        while xDir ~= -1 do\
            turnLeft()\
        end\
        while xPos > x do\
            if turtle.forward() then\
                xPos = xPos - 1\
            elseif turtle.dig() or turtle.attack() then\
                collect()\
            else\
                sleep( 0.5 )\
            end\
        end\
    elseif xPos < x then\
        while xDir ~= 1 do\
            turnLeft()\
        end\
        while xPos < x do\
            if turtle.forward() then\
                xPos = xPos + 1\
            elseif turtle.dig() or turtle.attack() then\
                collect()\
            else\
                sleep( 0.5 )\
            end\
        end\
    end\
    \
    if zPos > z then\
        while zDir ~= -1 do\
            turnLeft()\
        end\
        while zPos > z do\
            if turtle.forward() then\
                zPos = zPos - 1\
            elseif turtle.dig() or turtle.attack() then\
                collect()\
            else\
                sleep( 0.5 )\
            end\
        end\
    elseif zPos < z then\
        while zDir ~= 1 do\
            turnLeft()\
        end\
        while zPos < z do\
            if turtle.forward() then\
                zPos = zPos + 1\
            elseif turtle.dig() or turtle.attack() then\
                collect()\
            else\
                sleep( 0.5 )\
            end\
        end \
    end\
    \
    while depth < y do\
        if turtle.down() then\
            depth = depth + 1\
        elseif turtle.digDown() or turtle.attackDown() then\
            collect()\
        else\
            sleep( 0.5 )\
        end\
    end\
    \
    while zDir ~= zd or xDir ~= xd do\
        turnLeft()\
    end\
end\
\
if not refuel() then\
    print( \"Out of Fuel\" )\
    return\
end\
\
print( \"Excavating...\" )\
\
local reseal = false\
turtle.select(1)\
if turtle.digDown() then\
    reseal = true\
end\
\
local alternate = 0\
local done = false\
while not done do\
    for n=1,size do\
        for m=1,size-1 do\
            if not tryForwards() then\
                done = true\
                break\
            end\
        end\
        if done then\
            break\
        end\
        if n<size then\
            if math.fmod(n + alternate,2) == 0 then\
                turnLeft()\
                if not tryForwards() then\
                    done = true\
                    break\
                end\
                turnLeft()\
            else\
                turnRight()\
                if not tryForwards() then\
                    done = true\
                    break\
                end\
                turnRight()\
            end\
        end\
    end\
    if done then\
        break\
    end\
    \
    if size > 1 then\
        if math.fmod(size,2) == 0 then\
            turnRight()\
        else\
            if alternate == 0 then\
                turnLeft()\
            else\
                turnRight()\
            end\
            alternate = 1 - alternate\
        end\
    end\
    \
    if not tryDown() then\
        done = true\
        break\
    end\
end\
\
print( \"Returning to surface...\" )\
\
-- Return to where we started\
goTo( 0,0,0,0,-1 )\
unload( false )\
goTo( 0,0,0,0,1 )\
\
-- Seal the hole\
if reseal then\
    turtle.placeDown()\
end\
\
print( \"Mined \"..(collected + unloaded)..\" items total.\" )",
  [ "/rom/programs/id" ] = "\
local sDrive = nil\
local tArgs = { ... }\
if #tArgs > 0 then\
    sDrive = tostring( tArgs[1] )\
end\
\
if sDrive == nil then\
    print( \"This is computer #\"..os.getComputerID() )\
    \
    local label = os.getComputerLabel()\
    if label then\
        print( \"This computer is labelled \\\"\"..label..\"\\\"\" )\
    end\
\
else\
    local bData = disk.hasData( sDrive )\
    if not bData then\
        print( \"No disk in drive \"..sDrive )\
        return\
    end\
    \
    print( \"The disk is #\"..disk.getID( sDrive ) )\
\
    local label = disk.getLabel( sDrive )\
    if label then\
        print( \"The disk is labelled \\\"\"..label..\"\\\"\" )\
    end\
end\
",
  [ "/rom/help/drives" ] = "The Disk Drive is a peripheral device available for CraftOS. Type \"help peripheral\" to learn about using the Peripheral API to connect with peripherals. When a Disk Drive is connected, peripheral.getType() will return \"drive\".\
\
Methods exposed by the Disk Drive:\
isDiskPresent()\
getDiskLabel()\
setDiskLabel( label )\
hasData()\
getMountPath()\
hasAudio()\
getAudioTitle()\
playAudio()\
stopAudio()\
ejectDisk()\
getDiskID()\
\
Events fired by the Disk Drive:\
\"disk\" when a disk or other item is inserted into the drive. Argument is the name of the drive.\
\"disk_eject\" when a disk is removed from a  drive. Argument is the name of the drive.\
Type \"help events\" to learn about the event system.",
  [ "/rom/help/fg" ] = "fg is a program for Advanced Computers which opens a new tab in the foreground.\
\
ex:\
\"fg\" will open a foreground tab running the shell\
\"fg worm\" will open a foreground tab running the \"worm\" program",
  [ "/rom/help/bit" ] = "Functions in the bit manipulation API:\
bit.bnot(n)          -- bitwise not (~n)\
bit.band(m, n)       -- bitwise and (m & n)\
bit.bor(m, n)        -- bitwise or (m | n)\
bit.bxor(m, n)       -- bitwise xor (m ^ n)\
bit.brshift(n, bits) -- right shift (n >> bits)\
bit.blshift(n, bits) -- left shift (n << bits)",
  [ "/rom/help/eject" ] = "eject ejects the contents of an attached disk drive.\
\
ex:\
\"eject left\" ejects the contents of the disk drive to the left of the computer.",
  [ "/rom/help/hello" ] = "hello prints the text \"Hello World!\" to the screen.",
  [ "/rom/apis/rednet" ] = "\
CHANNEL_BROADCAST = 65535\
CHANNEL_REPEAT = 65533\
\
local tReceivedMessages = {}\
local tReceivedMessageTimeouts = {}\
local tHostnames = {}\
\
function open( sModem )\
    if type( sModem ) ~= \"string\" then\
        error( \"expected string\", 2 )\
    end\
    if peripheral.getType( sModem ) ~= \"modem\" then   \
        error( \"No such modem: \"..sModem, 2 )\
    end\
    peripheral.call( sModem, \"open\", os.getComputerID() )\
    peripheral.call( sModem, \"open\", CHANNEL_BROADCAST )\
end\
\
function close( sModem )\
    if sModem then\
        -- Close a specific modem\
        if type( sModem ) ~= \"string\" then\
            error( \"expected string\", 2 )\
        end\
        if peripheral.getType( sModem ) ~= \"modem\" then\
            error( \"No such modem: \"..sModem, 2 )\
        end\
        peripheral.call( sModem, \"close\", os.getComputerID() )\
        peripheral.call( sModem, \"close\", CHANNEL_BROADCAST )\
    else\
        -- Close all modems\
        for n,sModem in ipairs( peripheral.getNames() ) do\
            if isOpen( sModem ) then\
                close( sModem )\
            end\
        end\
    end\
end\
\
function isOpen( sModem )\
    if sModem then\
        -- Check if a specific modem is open\
        if type( sModem ) ~= \"string\" then\
            error( \"expected string\", 2 )\
        end\
        if peripheral.getType( sModem ) == \"modem\" then\
            return peripheral.call( sModem, \"isOpen\", os.getComputerID() ) and peripheral.call( sModem, \"isOpen\", CHANNEL_BROADCAST )\
        end\
    else\
        -- Check if any modem is open\
        for n,sModem in ipairs( peripheral.getNames() ) do\
            if isOpen( sModem ) then\
                return true\
            end\
        end\
    end\
    return false\
end\
\
function send( nRecipient, message, sProtocol )\
    -- Generate a (probably) unique message ID\
    -- We could do other things to guarantee uniqueness, but we really don't need to\
    -- Store it to ensure we don't get our own messages back\
    local nMessageID = math.random( 1, 2147483647 )\
    tReceivedMessages[ nMessageID ] = true\
    tReceivedMessageTimeouts[ os.startTimer( 30 ) ] = nMessageID\
\
    -- Create the message\
    local nReplyChannel = os.getComputerID()\
    local tMessage = {\
        nMessageID = nMessageID,\
        nRecipient = nRecipient,\
        message = message,\
        sProtocol = sProtocol,\
    }\
\
    if nRecipient == os.getComputerID() then\
        -- Loopback to ourselves\
        os.queueEvent( \"rednet_message\", nReplyChannel, message, sProtocol )\
\
    else\
        -- Send on all open modems, to the target and to repeaters\
        local sent = false\
        for n,sModem in ipairs( peripheral.getNames() ) do\
            if isOpen( sModem ) then\
                peripheral.call( sModem, \"transmit\", nRecipient, nReplyChannel, tMessage );\
                peripheral.call( sModem, \"transmit\", CHANNEL_REPEAT, nReplyChannel, tMessage );\
                sent = true\
            end\
        end\
    end\
end\
\
function broadcast( message, sProtocol )\
    send( CHANNEL_BROADCAST, message, sProtocol )\
end\
\
function receive( sProtocolFilter, nTimeout )\
    -- The parameters used to be ( nTimeout ), detect this case for backwards compatibility\
    if type(sProtocolFilter) == \"number\" and nTimeout == nil then\
        sProtocolFilter, nTimeout = nil, sProtocolFilter\
    end\
\
    -- Start the timer\
    local timer = nil\
    local sFilter = nil\
    if nTimeout then\
        timer = os.startTimer( nTimeout )\
        sFilter = nil\
    else\
        sFilter = \"rednet_message\"\
    end\
\
    -- Wait for events\
    while true do\
        local sEvent, p1, p2, p3 = os.pullEvent( sFilter )\
        if sEvent == \"rednet_message\" then\
            -- Return the first matching rednet_message\
            local nSenderID, message, sProtocol = p1, p2, p3\
            if sProtocolFilter == nil or sProtocol == sProtocolFilter then\
                return nSenderID, message, sProtocol\
            end\
        elseif sEvent == \"timer\" then\
            -- Return nil if we timeout\
            if p1 == timer then\
                return nil\
            end\
        end\
    end\
end\
\
function host( sProtocol, sHostname )\
    if type( sProtocol ) ~= \"string\" or type( sHostname ) ~= \"string\" then\
        error( \"expected string, string\", 2 )\
    end\
    if sHostname == \"localhost\" then\
        error( \"Reserved hostname\", 2 )\
    end\
    if tHostnames[ sProtocol ] ~= sHostname then\
        if lookup( sProtocol, sHostname ) ~= nil then\
            error( \"Hostname in use\", 2 )\
        end\
        tHostnames[ sProtocol ] = sHostname\
    end\
end\
\
function unhost( sProtocol )\
    if type( sProtocol ) ~= \"string\" then\
        error( \"expected string\", 2 )\
    end\
    tHostnames[ sProtocol ] = nil\
end\
\
function lookup( sProtocol, sHostname )\
    if type( sProtocol ) ~= \"string\" then\
        error( \"expected string\", 2 )\
    end\
\
    -- Build list of host IDs\
    local tResults = nil\
    if sHostname == nil then\
        tResults = {}\
    end\
\
    -- Check localhost first\
    if tHostnames[ sProtocol ] then\
        if sHostname == nil then\
            table.insert( tResults, os.getComputerID() )\
        elseif sHostname == \"localhost\" or sHostname == tHostnames[ sProtocol ] then\
            return os.getComputerID()\
        end\
    end\
\
    if not isOpen() then\
        if tResults then\
            return unpack( tResults )\
        end\
        return nil\
    end\
\
    -- Broadcast a lookup packet\
    broadcast( {\
        sType = \"lookup\",\
        sProtocol = sProtocol,\
        sHostname = sHostname,\
    }, \"dns\" )\
\
    -- Start a timer\
    local timer = os.startTimer( 2 )\
\
    -- Wait for events\
    while true do\
        local event, p1, p2, p3 = os.pullEvent()\
        if event == \"rednet_message\" then\
            -- Got a rednet message, check if it's the response to our request\
            local nSenderID, tMessage, sMessageProtocol = p1, p2, p3\
            if sMessageProtocol == \"dns\" and tMessage.sType == \"lookup response\" then\
                if tMessage.sProtocol == sProtocol then\
                    if sHostname == nil then\
                        table.insert( tResults, nSenderID )\
                    elseif tMessage.sHostname == sHostname then\
                        return nSenderID\
                    end\
                end\
            end\
        else\
            -- Got a timer event, check it's the end of our timeout\
            if p1 == timer then\
                break\
            end\
        end\
    end\
    if tResults then\
        return unpack( tResults )\
    end\
    return nil\
end\
\
local bRunning = false\
function run()\
    if bRunning then\
        error( \"rednet is already running\", 2 )\
    end\
    bRunning = true\
    \
    while bRunning do\
        local sEvent, p1, p2, p3, p4 = os.pullEventRaw()\
        if sEvent == \"modem_message\" then\
            -- Got a modem message, process it and add it to the rednet event queue\
            local sModem, nChannel, nReplyChannel, tMessage = p1, p2, p3, p4\
            if isOpen( sModem ) and ( nChannel == os.getComputerID() or nChannel == CHANNEL_BROADCAST ) then\
                if type( tMessage ) == \"table\" and tMessage.nMessageID then\
                    if not tReceivedMessages[ tMessage.nMessageID ] then\
                        tReceivedMessages[ tMessage.nMessageID ] = true\
                        tReceivedMessageTimeouts[ os.startTimer( 30 ) ] = nMessageID\
                        os.queueEvent( \"rednet_message\", nReplyChannel, tMessage.message, tMessage.sProtocol )\
                    end\
                end\
            end\
\
        elseif sEvent == \"rednet_message\" then\
            -- Got a rednet message (queued from above), respond to dns lookup\
            local nSenderID, tMessage, sProtocol = p1, p2, p3\
            if sProtocol == \"dns\" and tMessage.sType == \"lookup\" then\
                local sHostname = tHostnames[ tMessage.sProtocol ]\
                if sHostname ~= nil and (tMessage.sHostname == nil or tMessage.sHostname == sHostname) then\
                    rednet.send( nSenderID, {\
                        sType = \"lookup response\",\
                        sHostname = sHostname,\
                        sProtocol = tMessage.sProtocol,\
                    }, \"dns\" )\
                end\
            end\
\
        elseif sEvent == \"timer\" then\
            -- Got a timer event, use it to clear the event queue\
            local nTimer = p1\
            local nMessage = tReceivedMessageTimeouts[ nTimer ]\
            if nMessage then\
                tReceivedMessageTimeouts[ nTimer ] = nil\
                tReceivedMessages[ nMessage ] = nil\
            end\
        end\
    end\
end",
  [ "/rom/programs/fun/advanced/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",
  [ "/rom/apis/gps" ] = "\
CHANNEL_GPS = 65534\
\
local function trilaterate( A, B, C )\
    local a2b = B.vPosition - A.vPosition\
    local a2c = C.vPosition - A.vPosition\
        \
    if math.abs( a2b:normalize():dot( a2c:normalize() ) ) > 0.999 then\
        return nil\
    end\
    \
    local d = a2b:length()\
    local ex = a2b:normalize( )\
    local i = ex:dot( a2c )\
    local ey = (a2c - (ex * i)):normalize()\
    local j = ey:dot( a2c )\
    local ez = ex:cross( ey )\
\
    local r1 = A.nDistance\
    local r2 = B.nDistance\
    local r3 = C.nDistance\
        \
    local x = (r1*r1 - r2*r2 + d*d) / (2*d)\
    local y = (r1*r1 - r3*r3 - x*x + (x-i)*(x-i) + j*j) / (2*j)\
        \
    local result = A.vPosition + (ex * x) + (ey * y)\
\
    local zSquared = r1*r1 - x*x - y*y\
    if zSquared > 0 then\
        local z = math.sqrt( zSquared )\
        local result1 = result + (ez * z)\
        local result2 = result - (ez * z)\
        \
        local rounded1, rounded2 = result1:round( 0.01 ), result2:round( 0.01 )\
        if rounded1.x ~= rounded2.x or rounded1.y ~= rounded2.y or rounded1.z ~= rounded2.z then\
            return rounded1, rounded2\
        else\
            return rounded1\
        end\
    end\
    return result:round( 0.01 )\
    \
end\
\
local function narrow( p1, p2, fix )\
    local dist1 = math.abs( (p1 - fix.vPosition):length() - fix.nDistance )\
    local dist2 = math.abs( (p2 - fix.vPosition):length() - fix.nDistance )\
    \
    if math.abs(dist1 - dist2) < 0.01 then\
        return p1, p2\
    elseif dist1 < dist2 then\
        return p1:round( 0.01 )\
    else\
        return p2:round( 0.01 )\
    end\
end\
\
function locate( _nTimeout, _bDebug )\
\
    -- Find a modem\
    local sModemSide = nil\
    for n,sSide in ipairs( rs.getSides() ) do\
        if peripheral.getType( sSide ) == \"modem\" and peripheral.call( sSide, \"isWireless\" ) then   \
            sModemSide = sSide\
            break\
        end\
    end\
\
    if sModemSide == nil then\
        if _bDebug then\
            print( \"No wireless modem attached\" )\
        end\
        return nil\
    end\
    \
    if _bDebug then\
        print( \"Finding position...\" )\
    end\
    \
    -- Open a channel\
    local modem = peripheral.wrap( sModemSide )\
    local bCloseChannel = false\
    if not modem.isOpen( os.getComputerID() ) then\
        modem.open( os.getComputerID() )\
        bCloseChannel = true\
    end\
    \
    -- Send a ping to listening GPS hosts\
    modem.transmit( CHANNEL_GPS, os.getComputerID(), \"PING\" )\
        \
    -- Wait for the responses\
    local tFixes = {}\
    local pos1, pos2 = nil, nil\
    local timeout = os.startTimer( _nTimeout or 2 )\
    while true do\
        local e, p1, p2, p3, p4, p5 = os.pullEvent()\
        if e == \"modem_message\" then\
            -- We received a message from a modem\
            local sSide, sChannel, sReplyChannel, tMessage, nDistance = p1, p2, p3, p4, p5\
            if sSide == sModemSide and sChannel == os.getComputerID() and sReplyChannel == CHANNEL_GPS then\
                -- Received the correct message from the correct modem: use it to determine position\
                if type(tMessage) == \"table\" and #tMessage == 3 then\
                    local tFix = { vPosition = vector.new( tMessage[1], tMessage[2], tMessage[3] ), nDistance = nDistance }\
                    if _bDebug then\
                        print( tFix.nDistance..\" metres from \"..tostring( tFix.vPosition ) )\
                    end\
                    if tFix.nDistance == 0 then\
                        pos1, pos2 = tFix.vPosition, nil\
                    else\
                        table.insert( tFixes, tFix )\
                        if #tFixes >= 3 then\
                            if not pos1 then\
                                pos1, pos2 = trilaterate( tFixes[1], tFixes[2], tFixes[#tFixes] )\
                            else\
                                pos1, pos2 = narrow( pos1, pos2, tFixes[#tFixes] )\
                            end\
                        end\
                    end\
                    if pos1 and not pos2 then\
                        break\
                    end\
                end\
            end\
            \
        elseif e == \"timer\" then\
            -- We received a timeout\
            local timer = p1\
            if timer == timeout then\
                break\
            end\
        \
        end \
    end\
    \
    -- Close the channel, if we opened one\
    if bCloseChannel then\
        modem.close( os.getComputerID() )\
    end\
    \
    -- Return the response\
    if pos1 and pos2 then\
        if _bDebug then\
            print( \"Ambiguous position\" )\
            print( \"Could be \"..pos1.x..\",\"..pos1.y..\",\"..pos1.z..\" or \"..pos2.x..\",\"..pos2.y..\",\"..pos2.z )\
        end\
        return nil\
    elseif pos1 then\
        if _bDebug then\
            print( \"Position is \"..pos1.x..\",\"..pos1.y..\",\"..pos1.z )\
        end\
        return pos1.x, pos1.y, pos1.z\
    else\
        if _bDebug then\
            print( \"Could not determine position\" )\
        end\
        return nil\
    end\
end",
  [ "/rom/programs/fun/advanced/levels/4" ] = "2\
    77777777\
777778888887\
788888777787\
7b77787  787\
787 787  787\
7b77787  787\
7888887  787\
7777707  707\
    777  777",
  [ "/Flare/version/1.2/lib/sha256.lua" ] = "local MOD = 2^32\
local MODM = MOD-1\
local function memoize(f)\
    local mt = {}\
    local t = setmetatable({}, mt)\
    function mt:__index(k)\
        local v = f(k)\
        t[k] = v\
        return v\
    end\
    return t\
end\
local function make_bitop_uncached(t, m)\
    local function bitop(a, b)\
        local res,p = 0,1\
        while a ~= 0 and b ~= 0 do\
            local am, bm = a % m, b % m\
            res = res + t[am][bm] * p\
            a = (a - am) / m\
            b = (b - bm) / m\
            p = p*m\
        end\
        res = res + (a + b) * p\
        return res\
    end\
    return bitop\
end\
local function make_bitop(t)\
    local op1 = make_bitop_uncached(t,2^1)\
    local op2 = memoize(function(a) return memoize(function(b) return op1(a, b) end) end)\
    return make_bitop_uncached(op2, 2 ^ (t.n or 1))\
end\
local bxor1 = make_bitop({[0] = {[0] = 0,[1] = 1}, [1] = {[0] = 1, [1] = 0}, n = 4})\
local function bxor(a, b, c, ...)\
    local z = nil\
    if b then\
        a = a % MOD\
        b = b % MOD\
        z = bxor1(a, b)\
        if c then z = bxor(z, c, ...) end\
        return z\
    elseif a then return a % MOD\
    else return 0 end\
end\
local function band(a, b, c, ...)\
    local z\
    if b then\
        a = a % MOD\
        b = b % MOD\
        z = ((a + b) - bxor1(a,b)) / 2\
        if c then z = bit32_band(z, c, ...) end\
        return z\
    elseif a then return a % MOD\
    else return MODM end\
end\
local function bnot(x) return (-1 - x) % MOD end\
local function rshift1(a, disp)\
    if disp < 0 then return lshift(a,-disp) end\
    return math.floor(a % 2 ^ 32 / 2 ^ disp)\
end\
local function rshift(x, disp)\
    if disp > 31 or disp < -31 then return 0 end\
    return rshift1(x % MOD, disp)\
end\
local function lshift(a, disp)\
    if disp < 0 then return rshift(a,-disp) end \
    return (a * 2 ^ disp) % 2 ^ 32\
end\
local function rrotate(x, disp)\
    x = x % MOD\
    disp = disp % 32\
    local low = band(x, 2 ^ disp - 1)\
    return rshift(x, disp) + lshift(low, 32 - disp)\
end\
local k = {\
    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,\
    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\
    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,\
    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\
    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\
    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,\
    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\
    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,\
    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\
    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,\
    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,\
    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\
    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\
    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,\
}\
local function str2hexa(s)\
    return (string.gsub(s, \".\", function(c) return string.format(\"%02x\", string.byte(c)) end))\
end\
local function num2s(l, n)\
    local s = \"\"\
    for i = 1, n do\
        local rem = l % 256\
        s = string.char(rem) .. s\
        l = (l - rem) / 256\
    end\
    return s\
end\
local function s232num(s, i)\
    local n = 0\
    for i = i, i + 3 do n = n*256 + string.byte(s, i) end\
    return n\
end\
local function preproc(msg, len)\
    local extra = 64 - ((len + 9) % 64)\
    len = num2s(8 * len, 8)\
    msg = msg .. \"\\128\" .. string.rep(\"\\0\", extra) .. len\
    assert(#msg % 64 == 0)\
    return msg\
end\
local function initH256(H)\
    H[1] = 0x6a09e667\
    H[2] = 0xbb67ae85\
    H[3] = 0x3c6ef372\
    H[4] = 0xa54ff53a\
    H[5] = 0x510e527f\
    H[6] = 0x9b05688c\
    H[7] = 0x1f83d9ab\
    H[8] = 0x5be0cd19\
    return H\
end\
local function digestblock(msg, i, H)\
    local w = {}\
    for j = 1, 16 do w[j] = s232num(msg, i + (j - 1)*4) end\
    for j = 17, 64 do\
        local v = w[j - 15]\
        local s0 = bxor(rrotate(v, 7), rrotate(v, 18), rshift(v, 3))\
        v = w[j - 2]\
        w[j] = w[j - 16] + s0 + w[j - 7] + bxor(rrotate(v, 17), rrotate(v, 19), rshift(v, 10))\
    end\
    local a, b, c, d, e, f, g, h = H[1], H[2], H[3], H[4], H[5], H[6], H[7], H[8]\
    for i = 1, 64 do\
        local s0 = bxor(rrotate(a, 2), rrotate(a, 13), rrotate(a, 22))\
        local maj = bxor(band(a, b), band(a, c), band(b, c))\
        local t2 = s0 + maj\
        local s1 = bxor(rrotate(e, 6), rrotate(e, 11), rrotate(e, 25))\
        local ch = bxor (band(e, f), band(bnot(e), g))\
        local t1 = h + s1 + ch + k[i] + w[i]\
        h, g, f, e, d, c, b, a = g, f, e, d + t1, c, b, a, t1 + t2\
    end\
    H[1] = band(H[1] + a)\
    H[2] = band(H[2] + b)\
    H[3] = band(H[3] + c)\
    H[4] = band(H[4] + d)\
    H[5] = band(H[5] + e)\
    H[6] = band(H[6] + f)\
    H[7] = band(H[7] + g)\
    H[8] = band(H[8] + h)\
end\
local function sha256(msg)\
    msg = preproc(msg, #msg)\
    local H = initH256({})\
    for i = 1, #msg, 64 do digestblock(msg, i, H) end\
    return str2hexa(num2s(H[1], 4) .. num2s(H[2], 4) .. num2s(H[3], 4) .. num2s(H[4], 4) ..\
        num2s(H[5], 4) .. num2s(H[6], 4) .. num2s(H[7], 4) .. num2s(H[8], 4))\
end\
\
return sha256",
  [ "/rom/help/parallel" ] = "Functions in the Parallel API:\
parallel.waitForAny( function1, function2, ... )\
parallel.waitForAll( function1, function2, ... )\
These methods provide an easy way to run multiple lua functions simultaneously.",
  [ "/rom/programs/lua" ] = "\
local tArgs = { ... }\
if #tArgs > 0 then\
    print( \"This is an interactive Lua prompt.\" )\
    print( \"To run a lua program, just type its name.\" )\
    return\
end\
\
local bRunning = true\
local tCommandHistory = {}\
local tEnv = {\
    [\"exit\"] = function()\
        bRunning = false\
    end,\
    [\"_echo\"] = function( ... )\
        return ...\
    end,\
}\
setmetatable( tEnv, { __index = getfenv() } )\
\
if term.isColour() then\
    term.setTextColour( colours.yellow )\
end\
print( \"Interactive Lua prompt.\" )\
print( \"Call exit() to exit.\" )\
term.setTextColour( colours.white )\
\
while bRunning do\
    --if term.isColour() then\
    --  term.setTextColour( colours.yellow )\
    --end\
    write( \"lua> \" )\
    --term.setTextColour( colours.white )\
    \
    local s = read( nil, tCommandHistory )\
    table.insert( tCommandHistory, s )\
    \
    local nForcePrint = 0\
    local func, e = loadstring( s, \"lua\" )\
    local func2, e2 = loadstring( \"return _echo(\"..s..\");\", \"lua\" )\
    if not func then\
        if func2 then\
            func = func2\
            e = nil\
            nForcePrint = 1\
        end\
    else\
        if func2 then\
            func = func2\
        end\
    end\
    \
    if func then\
        setfenv( func, tEnv )\
        local tResults = { pcall( func ) }\
        if tResults[1] then\
            local n = 1\
            while (tResults[n + 1] ~= nil) or (n <= nForcePrint) do\
                local value = tResults[ n + 1 ]\
                if type( value ) == \"table\" then\
                    local ok, serialised = pcall( textutils.serialise, value )\
                    if ok then\
                        print( serialised )\
                    else\
                        print( tostring( value ) )\
                    end\
                else\
                    print( tostring( value ) )\
                end\
                n = n + 1\
            end\
        else\
            printError( tResults[2] )\
        end\
    else\
        printError( e )\
    end\
    \
end",
  [ "/rom/programs/move" ] = "\
local tArgs = { ... }\
if #tArgs < 2 then\
    print( \"Usage: mv <source> <destination>\" )\
    return\
end\
\
local sSource = shell.resolve( tArgs[1] )\
local sDest = shell.resolve( tArgs[2] )\
local tFiles = fs.find( sSource )\
if #tFiles > 0 then\
    for n,sFile in ipairs( tFiles ) do\
        if fs.isDir( sDest ) then\
            fs.move( sFile, fs.combine( sDest, fs.getName(sFile) ) )\
        elseif #tFiles == 1 then\
            fs.move( sFile, sDest )\
        else\
            printError( \"Cannot overwrite file multiple times\" )\
            return\
        end\
    end\
else\
    printError( \"No matching files\" )\
end",
  [ "/rom/help/move" ] = "mv moves a file or directory from one location to another.\
\
ex:\
\"mv foo bar\" renames the file \"foo\" to \"bar\".\
\"mv foo bar/foo\" moves the file \"foo\" to a folder called \"bar\".\
\"mv disk/* disk2\" moves the contents of one disk to another",
  [ "/rom/help/drive" ] = "drive tells you which disk drive the current or specified directory is located in.\
\
ex:\
\"drive\" tell you the disk drive of the current directory.\
\"drive foo\" tells you the disk drive of the subdirectory \"foo\"",
  [ "/Flare/version/1.2/lib/UI/event/Event.lua" ] = "\
local class = require \"lib.class\"\
\
local Event = class \"Event\"\
\
function Event:Event( name, ... )\
    self.handled = false\
    self.name = name\
    self.parameters = {}\
end\
\
function Event:setParam( pname, value )\
    self.parameters[pname] = value\
    return self\
end\
\
function Event:getParam( pname )\
    return self.parameters[pname]\
end\
\
function Event:checkParam( pname, value )\
    return self:getParam( pname ) == value\
end\
\
function Event:clone( t )\
    local e = Event( self.name )\
    e.handled = nil\
    for k, v in pairs( self.parameters ) do\
        e:setParam( k, v )\
    end\
    for k, v in pairs( t ) do\
        e:setParam( k, v )\
    end\
    getmetatable( e ).__index = function( t, k )\
        return k == \"handled\" and self.handled or Event[k]\
    end\
    getmetatable( e ).__newindex = function( t, k, v )\
        if k == \"handled\" then\
            self.handled = v\
        else\
            rawset( t, k, v )\
        end\
    end\
    return e\
end\
\
function Event:isHandled()\
    return self.handled\
end\
\
return Event",
  [ "/Flare/version/1.2/lib/UI/draw/image.lua" ] = "\
local pixelbatch = require \"lib.UI.draw.pixelbatch\"\
\
local function image( image, _x, _y, buffer )\
    _x, _y = _x - 1, _y - 1\
    local pixels = {}\
    for x = 1, image.width do\
        for y = 1, image.height do\
            local t = {\
                x = _x + x;\
                y = _y + y;\
            }\
            t.bc, t.tc, t.char = image:getPixel( x, y )\
            pixels[#pixels + 1] = t\
        end\
    end\
    pixelbatch( buffer, pixels )\
end\
\
return pixelbatch",
  [ "/rom/apis/colors" ] = "-- Colors\
white = 1\
orange = 2\
magenta = 4\
lightBlue = 8\
yellow = 16\
lime = 32\
pink = 64\
gray = 128\
lightGray = 256\
cyan = 512\
purple = 1024\
blue = 2048\
brown = 4096\
green = 8192\
red = 16384\
black = 32768\
\
function combine( ... )\
    local r = 0\
    for n,c in ipairs( { ... } ) do\
        r = bit.bor(r,c)\
    end\
    return r\
end\
\
function subtract( colors, ... )\
    local r = colors\
    for n,c in ipairs( { ... } ) do\
        r = bit.band(r, bit.bnot(c))\
    end\
    return r\
end\
\
function test( colors, color )\
    return ((bit.band(colors, color)) == color)\
end",
  [ "/rom/programs/fun/advanced/levels/0" ] = "0\
77     77\
718888887\
 8     8\
 8     8\
 8     8\
788888897\
77     77",
  [ "/Flare/version/1.2/lib/UI/draw/text.lua" ] = " \
local function text( self, fmt, x, y, buffer )\
    local layer = buffer.stencil and buffer.stencil:newLayer( x, y, self.width, self.height )\
\
    local _lines = fmt.lines\
    fmt.lines = {}\
    for i = 1, #_lines do\
        fmt.lines[i] = _lines[i]\
    end\
\
    while ( fmt.offset.y or 0 ) < 0 do\
        fmt.offset.y = ( fmt.offset.y or 0 ) + 1\
        table.remove( fmt.lines, 1 )\
    end\
    while #fmt.lines + ( fmt.offset.y or 0 ) > self.height do\
        fmt.lines[#fmt.lines] = nil\
    end\
    buffer:drawTextFormatted( x, y, self.width, self.height, fmt )\
\
    if layer then\
        buffer.stencil:removeLayer( layer )\
    end\
end\
\
return text",
  [ "/Flare/version/1.2/lib/UI/text/formatter.lua" ] = "\
local class = require \"lib.class\"\
local graphics = require \"lib.graphics\"\
\
local function linewrap( str, w )\
    if str:sub( 1, w + 1 ):find \"\\n\" then\
        if str:sub( 1, 1 ) == \"\\n\" then\
            return \"\\n\", str:sub( 2 )\
        end\
        return str:match \"^(.-\\n)(.*)$\"\
    end\
    if #str <= w then\
        return str, nil\
    end\
    if str:sub( 1, w + 1 ):find \"%s\" then\
        local pos = w - str:sub( 1, w + 1 ):reverse():find \"%s\" + 2\
        while str:sub( pos, pos ):find \"%s\" do\
            if str:sub( pos, pos ) == \"\\n\" then\
                pos = pos + 1\
                break\
            end\
            pos = pos + 1\
        end\
        return str:sub( 1, pos - 1 ), str:sub( pos )\
    end\
    return str:sub( 1, w ), str:sub( w + 1 )\
end\
\
local formatter = {}\
\
function formatter.tostream( text, metadata )\
    local stream = {\
        text = \"\";\
        colour = {};\
        link = {};\
        mark = {};\
    }\
    local markstack, mark, link = {}\
    local bc, tc = graphics.colour( metadata.bc or 1 ), graphics.colour( metadata.tc or 32768 )\
    local escaping = false\
    local function append( text )\
        stream.text = stream.text .. text\
        local streampos = #stream.colour + 1\
        for i = 1, #text do\
            local c = { bc = bc, tc = tc }\
            if link and link.protocol == \"default\" then\
                c.bc = graphics.colour( metadata.bc or 1 )\
                c.tc = colours.blue\
            end\
            stream.link[streampos] = link\
            stream.mark[streampos] = mark\
            stream.colour[streampos] = c\
            streampos = streampos + 1\
        end\
    end\
    local i = 1\
    while i <= #text do\
        if text:sub( i, i ) == \"|\" then\
            escaping = not escaping\
            i = i + 1\
        elseif not escaping and text:sub( i, i ) == \"&\" then\
            local code = text:sub( i + 1, i + 1 )\
            if code == \"b\" then\
                local c = text:sub( i + 2, i + 2 )\
                if graphics.colour( c ) then\
                    bc = graphics.colour( c )\
                    i = i + 3\
                else\
                    bc, tc = colours.white, colours.red\
                    append \"expected valid colour modifier after &b code in text\"\
                    break\
                end\
            elseif code == \"t\" then\
                local c = text:sub( i + 2, i + 2 )\
                if graphics.colour( c ) then\
                    tc = graphics.colour( c )\
                    i = i + 3\
                else\
                    bc, tc = colours.white, colours.red\
                    append \"expected valid colour modifier after &t code in text\"\
                    break\
                end\
            elseif code == \"l\" then\
                if text:find( \"^%[[^\\n]-%]%([^\\n]-%)\", i + 2 ) then\
                    local display, target = text:match( \"^%[([^\\n]-)%]%(([^\\n]-)%)\", i + 2 )\
                    i = i + 6 + #display + #target\
                    local protocol = \"default\"\
                    if target:find \"^!%w+:\" then\
                        protocol, target = target:match( \"^!(%w+):(.*)$\" )\
                    end\
                    link = { protocol = protocol, target = target }\
                    append( display )\
                    link = nil\
                else\
                    bc, tc = colours.white, colours.red\
                    append \"expected []() after &l code in text\"\
                    break\
                end\
            elseif code == \"m\" then\
                if text:find( \"^%[[^\\n]-%]\", i + 2 ) then\
                    local m = text:match( \"^%[([^\\n]-)%]\", i + 2 )\
                    i = i + 4 + #m\
                    markstack[#markstack + 1] = m\
                    mark = m\
                elseif text:sub( i + 2, i + 2 ) == \"-\" then\
                    markstack[#markstack] = nil\
                    mark = markstack[#markstack]\
                    i = i + 3\
                else\
                    bc, tc = colours.white, colours.red\
                    append \"expected [] or - after &m code in text\"\
                    break\
                end\
            else\
                append( code )\
                i = i + 2\
            end\
        else\
            append( text:sub( i, i ) )\
            i = i + 1\
        end\
    end\
    return stream\
end\
\
function formatter.wrapstream( stream, metadata )\
    if metadata.width < 1 then return {} end\
    local pos = 1\
    local lines = {}\
    local text, line = stream.text, \"\"\
    while text do\
        line, text = linewrap( text, metadata.width )\
\
        local l = {\
            text = line;\
            colour = {};\
            link = {};\
            mark = {};\
        }\
\
        for i = 1, #line do\
            l.link[i] = stream.link[pos]\
            l.mark[i] = stream.mark[pos]\
            l.colour[i] = stream.colour[pos]\
            pos = pos + 1\
        end\
\
        lines[#lines + 1] = l\
    end\
    return lines\
end\
\
function formatter.lines( text, metadata )\
    local stream = formatter.tostream( text, metadata )\
    return formatter.wrapstream( stream, metadata )\
end\
\
function formatter.renderPrep( lines, metadata )\
    if type( lines ) == \"string\" then\
        lines = formatter.lines( lines, metadata )\
    end\
    return {\
        lines = lines;\
        bc = graphics.colour( metadata.bc or 1 );\
        tc = graphics.colour( metadata.tc or 32768 );\
        offset = {\
            y = 0;\
        }\
    }\
end\
\
function formatter.fixAlignment( fmt, width, height, horizontal, vertical )\
    fmt.offset.y = vertical == \"centre\" and math.floor( height / 2 - #fmt.lines / 2 )\
                or vertical == \"bottom\" and height - #fmt.lines\
                or 0\
    for i = 1, #fmt.lines do\
        fmt.offset[i] = horizontal == \"centre\" and math.floor( width / 2 - #fmt.lines[i].text / 2 )\
                     or horizontal == \"right\"  and width - #fmt.lines[i].text\
                     or 0\
    end\
end\
\
return formatter",
  [ "/rom/apis/parallel" ] = "\
local function create( first, ... )\
    if first ~= nil then\
        if type( first ) ~= \"function\" then\
            error( \"Expected function, got \"..type( first ), 3 )\
        end\
        return coroutine.create(first), create( ... )\
    end\
    return nil\
end\
\
local function runUntilLimit( _routines, _limit )\
    local count = #_routines\
    local living = count\
    \
    local tFilters = {}\
    local eventData = {}\
    while true do\
        for n=1,count do\
            local r = _routines[n]\
            if r then\
                if tFilters[r] == nil or tFilters[r] == eventData[1] or eventData[1] == \"terminate\" then\
                    local ok, param = coroutine.resume( r, unpack(eventData) )\
                    if not ok then\
                        error( param, 0 )\
                    else\
                        tFilters[r] = param\
                    end\
                    if coroutine.status( r ) == \"dead\" then\
                        _routines[n] = nil\
                        living = living - 1\
                        if living <= _limit then\
                            return n\
                        end\
                    end\
                end\
            end\
        end\
        for n=1,count do\
            local r = _routines[n]\
            if r and coroutine.status( r ) == \"dead\" then\
                _routines[n] = nil\
                living = living - 1\
                if living <= _limit then\
                    return n\
                end\
            end\
        end\
        eventData = { os.pullEventRaw() }\
    end\
end\
\
function waitForAny( ... )\
    local routines = { create( ... ) }\
    return runUntilLimit( routines, #routines - 1 )\
end\
\
function waitForAll( ... )\
    local routines = { create( ... ) }\
    runUntilLimit( routines, 0 )\
end",
  [ "/rom/programs/list" ] = "\
local tArgs = { ... }\
\
-- Get all the files in the directory\
local sDir = shell.dir()\
if tArgs[1] ~= nil then\
    sDir = shell.resolve( tArgs[1] )\
end\
\
-- Sort into dirs/files, and calculate column count\
local tAll = fs.list( sDir )\
local tFiles = {}\
local tDirs = {}\
\
for n, sItem in pairs( tAll ) do\
    if string.sub( sItem, 1, 1 ) ~= \".\" then\
        local sPath = fs.combine( sDir, sItem )\
        if fs.isDir( sPath ) then\
            table.insert( tDirs, sItem )\
        else\
            table.insert( tFiles, sItem )\
        end\
    end\
end\
table.sort( tDirs )\
table.sort( tFiles )\
\
if term.isColour() then\
    textutils.pagedTabulate( colors.green, tDirs, colors.white, tFiles )\
else\
    textutils.pagedTabulate( tDirs, tFiles )\
end",
  [ "/rom/help/os" ] = "Functions in the os (Operating System) API:\
os.version()\
os.getComputerID()\
os.getComputerLabel()\
os.setComputerLabel()\
os.run( environment, programpath, arguments )\
os.loadAPI( path )\
os.unloadAPI( name )\
os.pullEvent( [filter] )\
os.queueEvent( event, arguments )\
os.clock()\
os.startTimer( timeout )\
os.cancelTimer( token )\
os.sleep( timeout )\
os.time()\
os.day()\
os.setAlarm( time )\
os.cancelAlarm( token )\
os.shutdown()\
os.reboot()\
\
Events emitted by the os API:\
\"timer\" when a timeout started by os.startTimer() completes. Argument is the token returned by os.startTimer().\
\"alarm\" when a time passed to os.setAlarm() is reached. Argument is the token returned by os.setAlarm().\
Type \"help events\" to learn about the event system.",
  [ "/Flare/version/1.2/lib/UI/elements/Image.lua" ] = "\
local class = require \"lib.class\"\
local base = require \"lib.UI.base\"\
local mouse = require \"lib.UI.event.mouse\"\
local drawimage = require \"lib.UI.draw.image\"\
local image = require \"lib.image\"\
\
local Image = class \"Image\"\
Image:extend( base )\
\
Image.mouse_click_timeout = .4\
\
function Image:Image( x, y, im )\
\
    if type( im ) == \"string\" then\
        if fs.exists( im ) then\
            local h = fs.open( im, \"r\" )\
            if h then\
                im = h.readAll()\
                h.close()\
            end\
        end\
        im = image.load( im )\
    end\
\
    self.image = im\
\
    self:base( x, y, im.width, im.height )\
end\
\
function Image:draw( x, y, buffer )\
    drawimage( self.image, x, y, buffer )\
end\
\
function Image:handle( event )\
    if mouse.click( self, event ) then\
        if self.onClick then\
            self:onClick()\
        end\
    elseif event.name == \"mouse_ping\" then\
        mouse.ping( self, event )\
    end\
end\
\
return Image",
  [ "/rom/help/licenses/luaj" ] = "Copyright (c) 2007 LuaJ. All rights reserved.\
\
Permission is hereby granted, free of charge, to any person obtaining a copy\
of this software and associated documentation files (the \"Software\"), to deal\
in the Software without restriction, including without limitation the rights\
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\
copies of the Software, and to permit persons to whom the Software is\
furnished to do so, subject to the following conditions:\
\
The above copyright notice and this permission notice shall be included in\
all copies or substantial portions of the Software.\
\
THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\
THE SOFTWARE.",
  [ "/rom/programs/mkdir" ] = "local tArgs = { ... }\
if #tArgs < 1 then\
    print( \"Usage: mkdir <path>\" )\
    return\
end\
\
local sNewDir = shell.resolve( tArgs[1] )\
fs.makeDir( sNewDir )\
",
  [ "/rom/programs/turtle/tunnel" ] = "\
local tArgs = { ... }\
if #tArgs ~= 1 then\
    print( \"Usage: tunnel <length>\" )\
    return\
end\
\
-- Mine in a quarry pattern until we hit something we can't dig\
local length = tonumber( tArgs[1] )\
if length < 1 then\
    print( \"Tunnel length must be positive\" )\
    return\
end\
    \
local depth = 0\
local collected = 0\
\
local function collect()\
    collected = collected + 1\
    if math.fmod(collected, 25) == 0 then\
        print( \"Mined \"..collected..\" items.\" )\
    end\
end\
\
local function tryDig()\
    while turtle.detect() do\
        if turtle.dig() then\
            collect()\
            sleep(0.5)\
        else\
            return false\
        end\
    end\
    return true\
end\
\
local function tryDigUp()\
    while turtle.detectUp() do\
        if turtle.digUp() then\
            collect()\
            sleep(0.5)\
        else\
            return false\
        end\
    end\
    return true\
end\
\
local function tryDigDown()\
    while turtle.detectDown() do\
        if turtle.digDown() then\
            collect()\
            sleep(0.5)\
        else\
            return false\
        end\
    end\
    return true\
end\
\
local function refuel()\
    local fuelLevel = turtle.getFuelLevel()\
    if fuelLevel == \"unlimited\" or fuelLevel > 0 then\
        return\
    end\
    \
    local function tryRefuel()\
        for n=1,16 do\
            if turtle.getItemCount(n) > 0 then\
                turtle.select(n)\
                if turtle.refuel(1) then\
                    turtle.select(1)\
                    return true\
                end\
            end\
        end\
        turtle.select(1)\
        return false\
    end\
    \
    if not tryRefuel() then\
        print( \"Add more fuel to continue.\" )\
        while not tryRefuel() do\
            os.pullEvent( \"turtle_inventory\" )\
        end\
        print( \"Resuming Tunnel.\" )\
    end\
end\
\
local function tryUp()\
    refuel()\
    while not turtle.up() do\
        if turtle.detectUp() then\
            if not tryDigUp() then\
                return false\
            end\
        elseif turtle.attackUp() then\
            collect()\
        else\
            sleep( 0.5 )\
        end\
    end\
    return true\
end\
\
local function tryDown()\
    refuel()\
    while not turtle.down() do\
        if turtle.detectDown() then\
            if not tryDigDown() then\
                return false\
            end\
        elseif turtle.attackDown() then\
            collect()\
        else\
            sleep( 0.5 )\
        end\
    end\
    return true\
end\
\
local function tryForward()\
    refuel()\
    while not turtle.forward() do\
        if turtle.detect() then\
            if not tryDig() then\
                return false\
            end\
        elseif turtle.attack() then\
            collect()\
        else\
            sleep( 0.5 )\
        end\
    end\
    return true\
end\
\
print( \"Tunnelling...\" )\
\
for n=1,length do\
    turtle.placeDown()\
    tryDigUp()\
    turtle.turnLeft()\
    tryDig()\
    tryUp()\
    tryDig()\
    turtle.turnRight()\
    turtle.turnRight()\
    tryDig()\
    tryDown()\
    tryDig()\
    turtle.turnLeft()\
    \
    if n<length then\
        tryDig()\
        if not tryForward() then\
            print( \"Aborting Tunnel.\" )\
            break\
        end\
    else\
        print( \"Tunnel complete.\" )\
    end\
\
end\
\
--[[\
print( \"Returning to start...\" )\
\
-- Return to where we started\
turtle.turnLeft()\
turtle.turnLeft()\
while depth > 0 do\
    if turtle.forward() then\
        depth = depth - 1\
    else\
        turtle.dig()\
    end\
end\
turtle.turnRight()\
turtle.turnRight()\
]]\
\
print( \"Tunnel complete.\" )\
print( \"Mined \"..collected..\" items total.\" )",
  [ "/rom/apis/keys" ] = "\
-- Minecraft key code bindings\
-- See http://www.minecraftwiki.net/wiki/Key_codes for more info\
\
local nothing = 42\
local tKeys = {\
    nil,        \"one\",        \"two\",        \"three\",  \"four\",           -- 1\
    \"five\",   \"six\",        \"seven\",  \"eight\",  \"nine\",           -- 6\
    \"zero\",   \"minus\",  \"equals\",     \"backspace\",\"tab\",          -- 11\
    \"q\",      \"w\",      \"e\",      \"r\",      \"t\",          -- 16\
    \"y\",      \"u\",      \"i\",      \"o\",      \"p\",          -- 21\
    \"leftBracket\",\"rightBracket\",\"enter\",\"leftCtrl\",\"a\",          -- 26\
    \"s\",      \"d\",      \"f\",      \"g\",      \"h\",          -- 31\
    \"j\",      \"k\",      \"l\",      \"semiColon\",\"apostrophe\",   -- 36\
    \"grave\",  \"leftShift\",\"backslash\",\"z\",      \"x\",          -- 41\
    \"c\",      \"v\",      \"b\",      \"n\",      \"m\",          -- 46\
    \"comma\",  \"period\", \"slash\",  \"rightShift\",\"multiply\",    -- 51\
    \"leftAlt\",    \"space\",  \"capsLock\",   \"f1\",     \"f2\",         -- 56\
    \"f3\",     \"f4\",     \"f5\",     \"f6\",     \"f7\",         -- 61\
    \"f8\",     \"f9\",     \"f10\",        \"numLock\",    \"scollLock\",  -- 66   \
    \"numPad7\",    \"numPad8\",    \"numPad9\",    \"numPadSubtract\",\"numPad4\", -- 71\
    \"numPad5\",    \"numPad6\",    \"numPadAdd\",\"numPad1\",  \"numPad2\",        -- 76\
    \"numPad3\",    \"numPad0\",    \"numPadDecimal\",nil,  nil,            -- 81\
    nil,        \"f11\",        \"f12\",        nil,        nil,            -- 86\
    nil,        nil,        nil,        nil,        nil,            -- 91\
    nil,        nil,        nil,        nil,        \"f13\",            -- 96\
    \"f14\",        \"f15\",        nil,        nil,        nil,            -- 101\
    nil,        nil,        nil,        nil,        nil,            -- 106\
    nil,        \"kana\",       nil,        nil,        nil,            -- 111\
    nil,        nil,        nil,        nil,        nil,            -- 116  \
    \"convert\",    nil,        \"noconvert\",nil,      \"yen\",            -- 121\
    nil,        nil,        nil,        nil,        nil,            -- 126\
    nil,        nil,        nil,        nil,        nil,            -- 131\
    nil,        nil,        nil,        nil,        nil,            -- 136\
    \"numPadEquals\",nil,       nil,        \"cimcumflex\",\"at\",          -- 141\
    \"colon\",  \"underscore\",\"kanji\",   \"stop\",       \"ax\",         -- 146\
    nil,        \"numPadEnter\",\"rightCtrl\",nil,      nil,            -- 151\
    nil,        nil,        nil,        nil,        nil,            -- 156\
    nil,        nil,        nil,        nil,        nil,            -- 161\
    nil,        nil,        nil,        nil,        nil,            -- 166\
    nil,        nil,        nil,        nil,        nil,            -- 171\
    nil,        nil,        nil,        \"numPadComma\",nil,            -- 176\
    \"numPadDivide\",nil,       nil,        \"rightAlt\",   nil,            -- 181\
    nil,        nil,        nil,        nil,        nil,            -- 186\
    nil,        nil,        nil,        nil,        nil,            -- 191\
    nil,        \"pause\",  nil,        \"home\",       \"up\",         -- 196\
    \"pageUp\", nil,        \"left\",       nil,        \"right\",      -- 201\
    nil,        \"end\",        \"down\",       \"pageDown\",   \"insert\",     -- 206\
    \"delete\"                                                      -- 211\
}\
\
local keys = getfenv()\
for nKey, sKey in pairs( tKeys ) do\
    keys[sKey] = nKey\
end\
keys[\"return\"] = keys.enter\
\
function getName( _nKey )\
    return tKeys[ _nKey ]\
end",
  [ "/rom/programs/fun/advanced/paint" ] = "-- Paint created by nitrogenfingers (edited by dan200)\
-- http://www.youtube.com/user/NitrogenFingers\
\
------------\
-- Fields --\
------------\
\
-- The width and height of the terminal\
local w,h = term.getSize()\
\
-- The selected colours on the left and right mouse button, and the colour of the canvas\
local leftColour, rightColour = colours.white, nil\
local canvasColour = colours.black\
\
-- The values stored in the canvas\
local canvas = {}\
\
-- The menu options\
local mChoices = { \"Save\",\"Exit\" }\
\
-- The message displayed in the footer bar\
local fMessage = \"Press Ctrl to access menu\"\
\
-------------------------\
-- Initialisation --\
-------------------------\
\
-- Determine if we can even run this\
if not term.isColour() then\
    print(\"Requires an Advanced Computer\")\
    return\
end\
\
-- Determines if the file exists, and can be edited on this computer\
local tArgs = {...}\
if #tArgs == 0 then\
    print(\"Usage: paint <path>\")\
    return\
end\
local sPath = shell.resolve(tArgs[1])\
local bReadOnly = fs.isReadOnly(sPath)\
if fs.exists(sPath) and fs.isDir(sPath) then\
    print(\"Cannot edit a directory.\")\
    return\
end\
\
---------------\
-- Functions --\
---------------\
\
local function getCanvasPixel( x, y )\
    if canvas[y] then\
        return canvas[y][x]\
    end\
    return nil\
end\
\
--[[\
    Converts a colour value to a text character\
    params: colour = the number to convert to a hex value\
    returns: a string representing the chosen colour\
]]\
local function getCharOf( colour )\
    -- Incorrect values always convert to nil\
    if type(colour) == \"number\" then\
        local value = math.floor( math.log(colour) / math.log(2) ) + 1\
        if value >= 1 and value <= 16 then\
            return string.sub( \"0123456789abcdef\", value, value )\
        end\
    end\
    return \" \"\
end \
\
--[[\
    Converts a text character to colour value\
    params: char = the char (from string.byte) to convert to number\
    returns: the colour number of the hex value\
]]\
local tColourLookup = {}\
for n=1,16 do\
    tColourLookup[ string.byte( \"0123456789abcdef\",n,n ) ] = 2^(n-1)\
end\
local function getColourOf( char )\
    -- Values not in the hex table are transparent (canvas coloured)\
    return tColourLookup[char]\
end\
\
--[[ \
    Loads the file into the canvas\
    params: path = the path of the file to open\
    returns: nil\
]]\
local function load(path)\
    -- Load the file\
    if fs.exists(path) then\
        local file = fs.open(sPath, \"r\")\
        local sLine = file.readLine()\
        while sLine do\
            local line = {}\
            for x=1,w-2 do\
                line[x] = getColourOf( string.byte(sLine,x,x) )\
            end\
            table.insert( canvas, line )\
            sLine = file.readLine()\
        end\
        file.close()\
    end\
end\
\
--[[  \
    Saves the current canvas to file  \
    params: path = the path of the file to save\
    returns: true if save was successful, false otherwise\
]]\
local function save(path)\
    -- Open file\
    local sDir = string.sub(sPath, 1, #sPath - #fs.getName(sPath))\
    if not fs.exists(sDir) then\
        fs.makeDir(sDir)\
    end\
\
    local file = fs.open( path, \"w\" )\
    if not file then\
        return false\
    end\
\
    -- Encode (and trim)\
    local tLines = {}\
    local nLastLine = 0\
    for y=1,h-1 do\
        local sLine = \"\"\
        local nLastChar = 0\
        for x=1,w-2 do\
            local c = getCharOf( getCanvasPixel( x, y ) )\
            sLine = sLine .. c\
            if c ~= \" \" then\
                nLastChar = x\
            end\
        end\
        sLine = string.sub( sLine, 1, nLastChar )\
        tLines[y] = sLine\
        if string.len( sLine ) > 0 then\
            nLastLine = y\
        end\
    end\
\
    -- Save out\
    for n=1,nLastLine do\
        file.writeLine( tLines[ n ] )\
    end\
    file.close()\
    return true\
end\
\
--[[  \
    Draws colour picker sidebar, the pallette and the footer\
    returns: nil\
]]\
local function drawInterface()\
    -- Footer\
    term.setCursorPos(1, h)\
    term.setBackgroundColour(colours.black)\
    term.setTextColour(colours.yellow)\
    term.clearLine()\
    term.write(fMessage)\
    \
    -- Colour Picker\
    for i=1,16 do\
        term.setCursorPos(w-1, i)\
        term.setBackgroundColour( 2^(i-1) )\
        term.write(\"  \")\
    end\
\
    term.setCursorPos(w-1, 17)\
    term.setBackgroundColour( canvasColour )\
    term.setTextColour( colours.grey )\
    term.write(\"XX\")\
            \
    -- Left and Right Selected Colours\
    for i=18,18 do\
        term.setCursorPos(w-1, i)\
        if leftColour ~= nil then\
            term.setBackgroundColour( leftColour )\
            term.write(\" \")\
        else\
            term.setBackgroundColour( canvasColour )\
            term.setTextColour( colours.grey )\
            term.write(\"X\")\
        end\
        if rightColour ~= nil then\
            term.setBackgroundColour( rightColour )\
            term.write(\" \")\
        else\
            term.setBackgroundColour( canvasColour )\
            term.setTextColour( colours.grey )\
            term.write(\"X\")\
        end\
    end\
\
    -- Padding\
    term.setBackgroundColour( canvasColour )\
    for i=20,h-1 do\
        term.setCursorPos(w-1, i)\
        term.write(\"  \")\
    end\
end\
\
--[[  \
    Converts a single pixel of a single line of the canvas and draws it\
    returns: nil\
]]\
local function drawCanvasPixel( x, y )\
    local pixel = getCanvasPixel( x, y )\
    if pixel then\
        term.setBackgroundColour( pixel or canvasColour )\
        term.setCursorPos(x, y)\
        term.write(\" \")\
    else\
        term.setBackgroundColour( canvasColour )\
        term.setTextColour( colours.grey )\
        term.setCursorPos(x, y)\
        term.write(\"-\")\
    end\
end\
\
--[[  \
    Converts each colour in a single line of the canvas and draws it\
    returns: nil\
]]\
local function drawCanvasLine( y )\
    for x = 1, w-2 do\
        drawCanvasPixel( x, y )\
    end\
end\
\
--[[  \
    Converts each colour in the canvas and draws it\
    returns: nil\
]]\
local function drawCanvas()\
    for y = 1, h-1 do\
        drawCanvasLine( y )\
    end\
end\
\
--[[\
    Draws menu options and handles input from within the menu.\
    returns: true if the program is to be exited; false otherwise\
]]\
local function accessMenu()\
    -- Selected menu option\
    local selection = 1\
    \
    term.setBackgroundColour(colours.black)\
    while true do\
        -- Draw the menu\
        term.setCursorPos(1,h)\
        term.clearLine()\
        term.setTextColour(colours.white)\
        for k,v in pairs(mChoices) do\
            if selection==k then \
                term.setTextColour(colours.yellow)\
                local ox,_ = term.getCursorPos()\
                term.write(\"[\"..string.rep(\" \",#v)..\"]\")\
                term.setCursorPos(ox+1,h)\
                term.setTextColour(colours.white)\
                term.write(v)\
                term.setCursorPos(term.getCursorPos()+1,h)\
            else\
                term.write(\" \"..v..\" \")\
            end\
        end\
        \
        -- Handle input in the menu\
        local id,key = os.pullEvent(\"key\")\
        if id == \"key\" then\
            -- S and E are shortcuts\
            if key == keys.s then\
                selection = 1\
                key = keys.enter\
            elseif key == keys.e then\
                selection = 2\
                key = keys.enter\
            end\
        \
            if key == keys.right then\
                -- Move right\
                selection = selection + 1\
                if selection > #mChoices then\
                    selection = 1\
                end\
                \
            elseif key == keys.left and selection > 1 then\
                -- Move left\
                selection = selection - 1\
                if selection < 1 then\
                    selection = #mChoices\
                end\
                \
            elseif key == keys.enter then\
                -- Select an option\
                if mChoices[selection]==\"Save\" then \
                    if bReadOnly then \
                        fMessage = \"Access Denied\"\
                        return false\
                    end\
                    local success = save(sPath)\
                    if success then\
                        fMessage = \"Saved to \"..sPath\
                    else\
                        fMessage = \"Error saving to \"..sPath\
                    end\
                    return false\
                elseif mChoices[selection]==\"Exit\" then \
                    return true\
                end\
            elseif key == keys.leftCtrl or keys == keys.rightCtrl then\
                -- Cancel the menu\
                return false \
            end\
        end\
    end\
end\
\
--[[  \
    Runs the main thread of execution. Draws the canvas and interface, and handles\
    mouse and key events.\
    returns: nil\
]]\
local function handleEvents()\
    local programActive = true\
    while programActive do\
        local id,p1,p2,p3 = os.pullEvent()\
        if id==\"mouse_click\" or id==\"mouse_drag\" then\
            if p2 >= w-1 and p3 >= 1 and p3 <= 17 then\
                if id ~= \"mouse_drag\" then\
                    -- Selecting an items in the colour picker\
                    if p3 <= 16 then\
                        if p1==1 then\
                            leftColour = 2^(p3-1)\
                        else\
                            rightColour = 2^(p3-1)\
                        end\
                    else\
                        if p1==1 then\
                            leftColour = nil\
                        else\
                            rightColour = nil\
                        end\
                    end\
                    --drawCanvas()\
                    drawInterface()\
                end\
            elseif p2 < w-1 and p3 <= h-1 then\
                -- Clicking on the canvas\
                local paintColour = nil\
                if p1==1 then\
                    paintColour = leftColour\
                elseif p1==2 then\
                    paintColour = rightColour\
                end\
                if not canvas[p3] then\
                    canvas[p3] = {}\
                end\
                canvas[p3][p2] = paintColour\
\
                drawCanvasPixel( p2, p3 )\
            end\
        elseif id==\"key\" then\
            if p1==keys.leftCtrl or p1==keys.rightCtrl then\
                programActive = not accessMenu()\
                drawInterface()\
            end\
        elseif id==\"term_resize\" then\
            w,h = term.getSize()\
            drawCanvas()\
            drawInterface()\
        end\
    end\
end\
\
-- Init\
load(sPath)\
drawCanvas()\
drawInterface()\
\
-- Main loop\
handleEvents()\
\
-- Shutdown\
term.setBackgroundColour(colours.black)\
term.setTextColour(colours.white)\
term.clear()\
term.setCursorPos(1,1)",
  [ "/rom/programs/copy" ] = "\
local tArgs = { ... }\
if #tArgs < 2 then\
    print( \"Usage: cp <source> <destination>\" )\
    return\
end\
\
local sSource = shell.resolve( tArgs[1] )\
local sDest = shell.resolve( tArgs[2] )\
local tFiles = fs.find( sSource )\
if #tFiles > 0 then\
    for n,sFile in ipairs( tFiles ) do\
        if fs.isDir( sDest ) then\
            fs.copy( sFile, fs.combine( sDest, fs.getName(sFile) ) )\
        elseif #tFiles == 1 then\
            fs.copy( sFile, sDest )\
        else\
            printError( \"Cannot overwrite file multiple times\" )\
            return\
        end\
    end\
else\
    printError( \"No matching files\" )\
end",
  [ "/rom/apis/window" ] = "\
function create( parent, nX, nY, nWidth, nHeight, bStartVisible )\
\
    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 nCursorX = 1\
    local nCursorY = 1\
    local bCursorBlink = false\
    local nTextColor = colors.white\
    local nBackgroundColor = colors.black\
    local sEmpty = string.rep( \" \", nWidth )\
    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 - 1, nY + nCursorY - 1 )\
        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 )\
        parent.setCursorPos( nX, nY + n - 1 )\
        local tLine = tLines[ n ]\
        for m=1,#tLine do\
            local tBit = tLine[ m ]\
            parent.setTextColor( tBit[2] )\
            parent.setBackgroundColor( tBit[3] )\
            parent.write( tBit[1] )\
        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 = 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()\
        for n=1,nHeight do\
            redrawLine( n )\
        end\
    end\
\
    local window = {}\
\
    -- Terminal implementation\
    function window.write( sText )\
        local nLen = string.len( sText )\
        local nStart = nCursorX\
        local nEnd = nStart + nLen - 1\
        if nCursorY >= 1 and nCursorY <= nHeight then\
            -- Work out where to put new line\
            --assert( math.floor(nStart) == nStart )\
            --assert( math.floor(nEnd) == nEnd )\
            if nStart <= nWidth and nEnd >= 1 then\
                -- Construct new line\
                local tLine = tLines[ nCursorY ]\
                if nStart == 1 and nEnd == nWidth then\
                    -- Exactly replace line\
                    tLine = {\
                        { sText, nTextColor, nBackgroundColor }\
                    }\
                    --assert( lineLen( tLine ) == nWidth )\
                elseif nStart <= 1 and nEnd >= nWidth then\
                    -- Overwrite line with subset\
                    tLine = {\
                        { string.sub( sText, 1 - nStart + 1, nWidth - 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 )\
                    )\
                    --assert( lineLen( tLine ) == nWidth )\
                elseif nEnd >= nWidth then\
                    -- Overwrite end of line\
                    tLine = lineJoin(\
                        lineSub( tLine, 1, nStart - 1 ),\
                        { { string.sub( sText, 1, nWidth - 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 )\
                    )\
                    --assert( lineLen( tLine ) == nWidth )\
                end\
\
                -- Store and redraw new line\
                tLines[ nCursorY ] = tLine\
                if bVisible then\
                    redrawLine( nCursorY )\
                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 then\
                error( \"Colour 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\
\
    local function setBackgroundColor( color )\
        if not parent.isColor() then\
            if color ~= colors.white and color ~= colors.black then\
                error( \"Colour not supported\", 3 )\
            end\
        end\
        nBackgroundColor = color\
    end\
\
    function window.setBackgroundColor( color )\
        setBackgroundColor( color )\
    end\
\
    function window.setBackgroundColour( color )\
        setBackgroundColor( color )\
    end\
\
    function window.getSize()\
        return nWidth, nHeight\
    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\
\
    if bVisible then\
        window.redraw()\
    end\
    return window\
end",
  [ "/rom/help/turtle" ] = "turtle is an api availiable on Turtles, which controls their movement.\
Functions in the Turtle API:\
turtle.forward()\
turtle.back()\
turtle.up()\
turtle.down()\
turtle.turnLeft()\
turtle.turnRight()\
turtle.select( slotNum )\
turtle.getSelectedSlot()\
turtle.getItemCount( [slotNum] )\
turtle.getItemSpace( [slotNum] )\
turtle.getItemDetail( [slotNum] )\
turtle.equipLeft()\
turtle.equipRight()\
turtle.dig( [toolSide] )\
turtle.digUp( [toolSide] )\
turtle.digDown( [toolSide] )\
turtle.place()\
turtle.placeUp()\
turtle.placeDown()\
turtle.attack( [toolSide] )\
turtle.attackUp( [toolSide] )\
turtle.attackDown( [toolSide] )\
turtle.detect()\
turtle.detectUp()\
turtle.detectDown()\
turtle.compare()\
turtle.compareUp()\
turtle.compareDown()\
turtle.inspect()\
turtle.inspectUp()\
turtle.inspectDown()\
turtle.inspectSlot( [slotNum] )\
turtle.compareTo( slotNum )\
turtle.transferTo( slotNum, [quantity] )\
turtle.drop( [quantity] )\
turtle.dropUp( [quantity] )\
turtle.dropDown( [quantity] )\
turtle.suck( [quantity] )\
turtle.suckUp( [quantity] )\
turtle.suckDown( [quantity] )\
turtle.getFuelLevel()\
turtle.getFuelLimit()\
turtle.refuel( [quantity] )\
turtle.craft( [quantity] ) (requires Crafty Turtle)\
\
Events fired by the Turtle API:\
\"turtle_inventory\" when any of the items in the inventory are changed. Use comparison operations to inspect the changes.",
  [ "/rom/help/paintutils" ] = "Functions in the Paint Utilities API:\
paintutils.drawPixel( x, y, colour )\
paintutils.drawLine( startX, startY, endX, endY, colour )\
paintutils.drawBox( startX, startY, endX, endY, colour )\
paintutils.drawFilledBox( startX, startY, endX, endY, colour )\
paintutils.loadImage( path )\
paintutils.drawImage( image, x, y )",
  [ "/rom/help/modems" ] = "Wired and Wireless Modems are peripheral devices available for CraftOS. Type \"help peripheral\" to learn about using the Peripheral API to connect with peripherals. When a Modem is connected, peripheral.getType() will return \"modem\".\
\
Methods exposed by Modems:\
open( channel )\
isOpen( channel )\
close( channel )\
closeAll()\
transmit( channel, replyChannel, message )\
isWireless()\
\
Events fired by Modems:\
\"modem_message\" when a message is received on an open channel. Arguments are name, channel, replyChannel, message, distance",
  [ "/rom/programs/fun/advanced/levels/2" ] = "1\
777777777\
7888888b7\
787778887\
787 78777\
7877787\
7888887\
7777787\
    707\
    777",
  [ "/rom/help/worm" ] = "You've played it in the arcades, now experience the high-octane thrills of the hit game \"WORM!\" on your home computer! Only on CraftOS!",
  [ "/Shop/States/Items.lua" ] = "local StateLib = FDK.require('lib.state')\
local State = StateLib.names.Init\
local Main = StateLib.names.Main\
local Search = StateLib.names.Search\
local Account = StateLib.names.Account\
local Items = StateLib.names.Items\
\
local Field = FDK.require('lib.UI.elements.Field')\
local Text = FDK.require('lib.UI.elements.Text')\
local Button = FDK.require('lib.UI.elements.Button')\
local ScrollBar = FDK.require('lib.UI.elements.ScrollBar')\
local Frame = FDK.require('lib.UI.elements.ClippingFrame')\
\
-- Main Field\
Items.frame:newChild(Field(1, 1, Items.frame.width, Items.frame.height, colors.white))\
-- Header Field\
Items.frame:newChild(Field(1, 1, Items.frame.width, 3, colors.lightGray))\
\
local back = Items.frame:newChild( Button( 1, 1, 8, 3, \"< back\" ) )\
back.bc = colors.lightGray\
back.tc = colors.white\
\
function back:onClick()\
  Main:show()\
end\
\
local ItemsFrame = Items.frame:newChild(Frame(1, 4,\
  Items.frame.width-2,\
  Items.frame.height-3\
))\
local ItemsBar = Items.frame:newChild(ScrollBar(Items.frame.width, 4, 1, Items.frame.height-3, ItemsFrame))\
-- Add every Item from the database\
\
for k,v  in pairs(_G.DB.Items) do\
\
\
end",
  [ "/rom/help/changelog" ] = "New Features in ComputerCraft 1.65:\
\
* Fixed a multiplayer-only crash with turtle.place()\
* Fixed some problems with http.post()\
* Fixed fs.getDrive() returning incorrect results on remote peripherals\
\
New Features in ComputerCraft 1.64:\
\
* Ported to Minecraft 1.7.10\
* New turtle functions: turtle.inspect(), turtle.inspectUp(), turtle.inspectDown(), turtle.getItemDetail()\
* Lots of bug and crash fixes, a huge stability improvement over previous versions\
\
New Features in ComputerCraft 1.63:\
\
* Turtles can now be painted with dyes, and cleaned with water buckets\
* Added a new game: Redirection - ComputerCraft Edition\
* Turtle label nameplates now only show when the Turtle is moused-over\
* The HTTP API is now enabled by default, and can be configured with a whitelist of permitted domains\
* http.get() and http.post() now accept parameters to control the request headers\
* New fs function: fs.getDir( path )\
* Fixed some bugs\
\
New Features in ComputerCraft 1.62:\
\
* Added IRC-style commands to the \"chat\" program\
* Fixed some bugs and crashes\
\
New Features in ComputerCraft 1.6:\
\
* Added Pocket Computers\
* Added a multi-tasking system for Advanced Computers and Turtles\
* Turtles can now swap out their tools and peripherals at runtime\
* Turtles can now carry two tools or peripherals at once in any combination\
* Turtles and Computers can now be labelled using Name Tags and Anvils\
* Added a configurable fuel limit for Turtles\
* Added hostnames, protocols and long distance routing to the rednet API\
* Added a peer-to-peer chat program to demonstrate new rednet capabilities\
* Added a new game, only on Pocket Computers: \"falling\" by GopherATL\
* File system commands in the shell now accept wildcard arguments\
* The shell now accepts long arguments in quotes\
* Terminal redirection now no longer uses a stack-based system. Instead: term.current() gets the current terminal object and term.redirect() replaces it. term.restore() has been removed.\
* Added a new Windowing API for addressing sub-areas of the terminal\
* New programs: fg, bg, multishell, chat, repeat, redstone, equip, unequip\
* Improved programs: copy, move, delete, rename, paint, shell\
* Removed programs: redset, redprobe, redpulse\
* New APIs: window, multishell\
* New turtle functions: turtle.equipLeft() and turtle.equipRight()\
* New peripheral functions: peripheral.find( [type] )\
* New rednet functions: rednet.host( protocol, hostname ), rednet.unhost( protocol ), rednet.locate( protocol, [hostname] )\
* New fs function: fs.find( wildcard )\
* New shell functions: shell.openTab(), shell.switchTab( [number] )\
* New event \"term_resize\" fired when the size of a terminal changes\
* Improved rednet functions: rednet.send(), rednet.broadcast() and rednet.receive() now take optional protocol parameters\
* turtle.craft(0) and turtle.refuel(0) now return true if there is a valid recipe or fuel item, but do not craft of refuel anything\
* turtle.suck( [limit] ) can now be used to limit the number of items picked up\
* Users of turtle.dig() and turtle.attack() can now specify which side of the turtle to look for a tool to use (by default, both will be considered)\
* textutils.serialise( text ) now produces human-readable output\
* Refactored most of the codebase and fixed many old bugs and instabilities, turtles should never ever lose their content now\
* Fixed the \"turtle_inventory\" event firing when it shouldn't have\
* Added error messages to many more turtle functions after they return false\
* Documented all new programs and API changes in the \"help\" system\
\
New Features in ComputerCraft 1.58:\
\
* Fixed a long standing bug where turtles could lose their identify if they travel too far away\
* Fixed use of deprecated code, ensuring mod compatibility with the latest versions of Minecraft Forge, and world compatibility with future versions of Minecraft\
\
New Features in ComputerCraft 1.57:\
\
* Ported to Minecraft 1.6.4\
* Added two new Treasure Disks: ConwayåA2?2¬?4¢s Game of Life by vilsol and Protector by fredthead\
* Fixed a very nasty item duplication bug\
\
New Features in ComputerCraft 1.56:\
\
* Added Treasure Disks: Floppy Disks in dungeons which contain interesting community made programs. Find them all!\
* All turtle functions now return additional error messages when they fail.\
* Resource Packs with Lua Programs can now be edited when extracted to a folder, for easier editing.\
\
New Features in ComputerCraft 1.55:\
\
* Ported to Minecraft 1.6.2\
* Added Advanced Turtles\
* Added \"turtle_inventory\" event. Fires when any change is made to the inventory of a turtle\
* Added missing functions io.close, io.flush, io.input, io.lines, io.output\
* Tweaked the screen colours used by Advanced Computers, Monitors and Turtles\
* Added new features for Peripheral authors\
* Lua programs can now be included in Resource Packs\
\
New Features in ComputerCraft 1.52:\
\
* Ported to Minecraft 1.5.1\
\
New Features in ComputerCraft 1.51:\
\
* Ported to Minecraft 1.5\
* Added Wired Modems\
* Added Networking Cables\
* Made Wireless Modems more expensive to craft\
* New redstone API functions: getAnalogInput(), setAnalogOutput(), getAnalogOutput()\
* Peripherals can now be controlled remotely over wired networks. New peripheral API function: getNames()\
* New event: \"monitor_resize\" when the size of a monitor changes\
* Except for labelled computers and turtles, ComputerCraft blocks no longer drop items in creative mode\
* The pick block function works in creative mode now works for all ComputerCraft blocks\
* All blocks and items now use the IDs numbers assigned by FTB by default\
* Fixed turtles sometimes placing blocks with incorrect orientations\
* Fixed Wireless modems being able to send messages to themselves\
* Fixed turtle.attack() having a very short range\
* Various bugfixes\
\
New Features in ComputerCraft 1.5:\
\
* Redesigned Wireless Modems; they can now send and receive on multiple channels, independent of the computer ID. To use these features, interface with modem peripherals directly. The rednet API still functions as before\
* Floppy Disks can now be dyed with multiple dyes, just like armour\
* The \"excavate\" program now retains fuel in it's inventory, so can run unattended\
* turtle.place() now tries all possible block orientations before failing\
* turtle.refuel(0) returns true if a fuel item is selected\
* turtle.craft(0) returns true if the inventory is a valid recipe\
* The in-game help system now has documentation for all the peripherals and their methods, including the new modem functionality\
* A romantic surprise\
\
New Features in ComputerCraft 1.48:\
\
* Ported to Minecraft 1.4.6\
* Advanced Monitors now emit a \"monitor_touch\" event when right clicked\
* Advanced Monitors are now cheaper to craft\
* Turtles now get slightly less fuel from items\
* Computers can now interact with Command Blocks (if enabled in ComputerCraft.cfg)\
* New API function: os.day()\
* A christmas surprise\
\
New Features in ComputerCraft 1.45:\
\
* Added Advanced Computers\
* Added Advanced Monitors\
* New program: paint by nitrogenfingers\
* New API: paintutils\
* New term functions: term.setBackgroundColor, term.setTextColor, term.isColor\
* New turtle function: turtle.transferTo\
\
New Features in ComputerCraft 1.43:\
\
* Added Printed Pages\
* Added Printed Books\
* Fixed incompatibility with Forge 275 and above\
* Labelled Turtles now keep their fuel when broken\
\
New Features in ComputerCraft 1.42:\
\
* Ported to Minecraft 1.3.2\
* Added Printers\
* Floppy Disks can be dyed different colours\
* Wireless Crafty Turtles can now be crafted\
* New textures\
* New forge config file\
* Bug fixes\
\
New Features in ComputerCraft 1.4:\
\
* Ported to Forge Mod Loader. ComputerCraft can now be ran directly from the .zip without extraction\
* Added Farming Turtles\
* Added Felling Turtles\
* Added Digging Turtles\
* Added Melee Turtles\
* Added Crafty Turtles\
* Added 14 new Turtle Combinations accessible by combining the turtle upgrades above\
* Labelled computers and turtles can now be crafted into turtles or other turtle types without losing their ID, label and data\
* Added a \"Turtle Upgrade API\" for mod developers to create their own tools and peripherals for turtles\
* Turtles can now attack entities with turtle.attack(), and collect their dropped items\
* Turtles can now use turtle.place() with any item the player can, and can interact with entities\
* Turtles can now craft items with turtle.craft()\
* Turtles can now place items into inventories with turtle.drop()\
* Changed the behaviour of turtle.place() and turtle.drop() to only consider the currently selected slot\
* Turtles can now pick up items from the ground, or from inventories, with turtle.suck()\
* Turtles can now compare items in their inventories\
* Turtles can place signs with text on them with turtle.place( [signText] )\
* Turtles now optionally require fuel items to move, and can refuel themselves\
* The size of the the turtle inventory has been increased to 16\
* The size of the turtle screen has been increased\
* New turtle functions: turtle.compareTo( [slotNum] ), turtle.craft(), turtle.attack(), turtle.attackUp(), turtle.attackDown(), turtle.dropUp(), turtle.dropDown(), turtle.getFuelLevel(), turtle.refuel()\
* New disk function: disk.getID()\
* New turtle programs: craft, refuel\
* \"excavate\" program now much smarter: Will return items to a chest when full, attack mobs, and refuel itself automatically\
* New API: keys\
* Added optional Floppy Disk and Hard Drive space limits for computers and turtles\
* New fs function: fs.getFreeSpace( path ), also fs.getDrive() works again\
* The send and receive range of wireless modems now increases with altitude, allowing long range networking from high-altitude computers (great for GPS networks)\
* http.request() now supports https:// URLs\
* Right clicking a Disk Drive with a Floppy Disk or a Record when sneaking will insert the item into the Disk Drive automatically\
* The default size of the computer screen has been increased\
* Several stability and security fixes. LuaJ can now no longer leave dangling threads when a computer is unloaded, turtles can no longer be destroyed by tree leaves or walking off the edge of the loaded map. Computers no longer crash when used with RedPower frames.\
\
New Features in ComputerCraft 1.31:\
\
* Ported to Minecraft 1.2.3\
* Added Monitors (thanks to Cloudy)\
* Updated LuaJ to a newer, less memory hungry version\
* rednet_message event now has a third parameter, \"distance\", to support position triangulation.\
* New programs: gps, monitor, pastebin.\
* Added a secret program. Use with large monitors!\
* New apis: gps, vector\
* New turtle functions: turtle.compare(), turtle.compareUp(), turtle.compareDown(), turtle.drop( quantity )\
* New http functions: http.post().\
* New term functions: term.redirect(), term.restore()\
* New textutils functions: textutils.urlEncode()\
* New rednet functions: rednet.isOpen()\
* New config options: modem_range, modem_rangeDuringStorm\
* Bug fixes, program tweaks, and help updates\
\
New Features in ComputerCraft 1.3:\
\
* Ported to Minecraft Forge\
* Added Turtles\
* Added Wireless Modems\
* Added Mining Turtles\
* Added Wireless Turtles\
* Added Wireless Mining Turtles\
* Computers and Disk Drives no longer get destroyed by water.\
* Computers and Turtles can now be labelled with the label program, and labelled devices keep their state when destroyed.\
* Computers/Turtles can connect to adjacent devices, and turn them on and off\
* User programs now give line numbers in their error messages\
* New APIs: turtle, peripheral\
* New programs for turtles: tunnel, excavate, go, turn, dance\
* New os functions: os.getComputerLabel(), os.setComputerLabel()\
* Added \"filter\" parameter to os.pullEvent()\
* New shell function: shell.getCurrentProgram()\
* New textutils functions: textutils.serialize(), textutils.unserialize(), textutils.tabulate(), textutils.pagedTabulate(), textutils.slowWrite()\
* New io file function: file:lines()\
* New fs function: fs.getSize()\
* Disk Drives can now play records from other mods\
* Bug fixes, program tweaks, and help updates\
\
New Features in ComputerCraft 1.2:\
\
* Added Disk Drives and Floppy Disks\
* Added Ctrl+T shortcut to terminate the current program (hold)\
* Added Ctrl+S shortcut to shutdown the computer (hold)\
* Added Ctrl+R shortcut to reboot the computer (hold)\
* New Programs: alias, apis, copy, delete, dj, drive, eject, id, label, list, move, reboot, redset, rename, time, worm.\
* New APIs: bit, colours, disk, help, rednet, parallel, textutils.\
* New color functions: colors.combine(), colors.subtract(), colors.test()\
* New fs functions: fs.getName(), new modes for fs.open()\
* New os functions: os.loadAPI(), os.unloadAPI(),\
os.clock(), os.time(), os.setAlarm(),\
os.reboot(), os.queueEvent()\
* New redstone function: redstone.getSides()\
* New shell functions: shell.setPath(), shell.programs(), shell.resolveProgram(), shell.setAlias()\
* Lots of updates to the help pages\
* Bug fixes\
\
New Features in ComputerCraft 1.1:\
\
* Added Multiplayer support throughout.\
* Added connectivity with RedPower bundled cables\
* Added HTTP api, enabled via the mod config, to allow computers to access the real world internet\
* Added command history to the shell.\
* Programs which spin in an infinite loop without yielding will no longer freeze minecraft\
* Help updates and bug fixes\
\
New Features in ComputerCraft 1.0:\
\
* First Release!",
  [ "/rom/startup" ] = "\
-- Setup paths\
local sPath = \".:/rom/programs\"\
if term.isColor() then\
    sPath = sPath..\":/rom/programs/advanced\"\
end\
if turtle then\
    sPath = sPath..\":/rom/programs/turtle\"\
else\
    sPath = sPath..\":/rom/programs/rednet:/rom/programs/fun\"\
    if term.isColor() then\
        sPath = sPath..\":/rom/programs/fun/advanced\"\
    end\
end\
if pocket then\
    sPath = sPath..\":/rom/programs/pocket\"\
end\
if http then\
    sPath = sPath..\":/rom/programs/http\"\
end\
shell.setPath( sPath )\
help.setPath( \"/rom/help\" )\
\
-- Setup aliases\
shell.setAlias( \"ls\", \"list\" )\
shell.setAlias( \"dir\", \"list\" )\
shell.setAlias( \"cp\", \"copy\" )\
shell.setAlias( \"mv\", \"move\" )\
shell.setAlias( \"rm\", \"delete\" )\
shell.setAlias( \"clr\", \"clear\" )\
shell.setAlias( \"rs\", \"redstone\" )\
shell.setAlias( \"sh\", \"shell\" )\
if term.isColor() then\
    shell.setAlias( \"background\", \"bg\" )\
    shell.setAlias( \"foreground\", \"fg\" )\
end\
\
-- Run autorun files\
if fs.exists( \"/rom/autorun\" ) and fs.isDir( \"/rom/autorun\" ) then\
    local tFiles = fs.list( \"/rom/autorun\" )\
    table.sort( tFiles )\
    for n, sFile in ipairs( tFiles ) do\
        if string.sub( sFile, 1, 1 ) ~= \".\" then\
            local sPath = \"/rom/autorun/\"..sFile\
            if not fs.isDir( sPath ) then\
                shell.run( sPath )\
            end\
        end\
    end\
end\
\
-- Run the user created startup, either from disk drives or the root\
local sUserStartup = shell.resolveProgram( \"/startup\" )\
for n,sName in pairs( peripheral.getNames() ) do\
    if disk.isPresent( sName ) and disk.hasData( sName ) then\
        local sDiskStartup = shell.resolveProgram( \"/\" .. disk.getMountPath( sName ) .. \"/startup\" )\
        if sDiskStartup then\
            sUserStartup = sDiskStartup\
            break\
        end\
    end\
end\
if sUserStartup then\
    shell.run( sUserStartup )\
end",
  [ "/rom/programs/redstone" ] = "\
local tArgs = { ... }\
\
local function printUsage()\
    print( \"Usages:\" )\
    print( \"redstone probe\" )\
    print( \"redstone set <side> <value>\" )\
    print( \"redstone set <side> <color> <value>\" )\
    print( \"redstone pulse <side> <count> <period>\" )\
end\
\
local sCommand = tArgs[1]\
if sCommand == \"probe\" then\
    -- \"redstone probe\"\
    -- Regular input\
    print( \"Redstone inputs: \" )\
\
    local count = 0\
    local bundledCount = 0\
    for n,sSide in ipairs( redstone.getSides() ) do\
        if redstone.getBundledInput( sSide ) > 0 then\
            bundledCount = bundledCount + 1\
        end\
        if redstone.getInput( sSide ) then\
            if count > 0 then\
                io.write( \", \" )\
            end\
            io.write( sSide )\
            count = count + 1\
        end\
    end\
    if count > 0 then\
        print( \".\" )\
    else\
        print( \"None.\" )\
    end\
\
    -- Bundled input\
    if bundledCount > 0 then\
        print()\
        print( \"Bundled inputs:\" )\
        for i,sSide in ipairs( redstone.getSides() ) do\
            local nInput = redstone.getBundledInput( sSide )\
            if nInput ~= 0 then\
                write( sSide..\": \" )\
                local count = 0\
                for sColour,nColour in pairs( colors ) do\
                    if type( nColour ) == \"number\" and colors.test( nInput, nColour ) then\
                        if count > 0 then\
                            write( \", \" )\
                        end\
                        if term.isColour() then\
                            term.setTextColour( nColour )\
                        end\
                        write( sColour )\
                        if term.isColour() then\
                            term.setTextColour( colours.white )\
                        end\
                        count = count + 1\
                    end\
                end\
                print( \".\" )\
            end\
        end\
    end\
\
elseif sCommand == \"pulse\" then\
    -- \"redstone pulse\"\
    local sSide = tArgs[2]\
    local nCount = tonumber( tArgs[3] ) or 1\
    local nPeriod = tonumber( tArgs[4] ) or 0.5\
    for n=1,nCount do\
        redstone.setOutput( sSide, true )\
        sleep( nPeriod / 2 )\
        redstone.setOutput( sSide, false )\
        sleep( nPeriod / 2 )\
    end\
\
elseif sCommand == \"set\" then\
    -- \"redstone set\"\
    local sSide = tArgs[2]\
    if #tArgs > 3 then\
        -- Bundled cable output\
        local sColour = tArgs[3]\
        local nColour = colors[sColour] or colours[sColour]\
        if type(nColour) ~= \"number\" then\
            printError( \"No such color\" )\
            return\
        end\
\
        local sValue = tArgs[4]\
        if sValue == \"true\" then\
            rs.setBundledOutput( sSide, colors.combine( rs.getBundledOutput( sSide ), nColour ) )\
        elseif sValue == \"false\" then\
            rs.setBundledOutput( sSide, colors.subtract( rs.getBundledOutput( sSide ), nColour ) )\
        else\
            print( \"Value must be boolean\" )\
        end\
    else\
        -- Regular output\
        local sValue = tArgs[3]\
        local nValue = tonumber(sValue)\
        if sValue == \"true\" then\
            rs.setOutput( sSide, true )\
        elseif sValue == \"false\" then\
            rs.setOutput( sSide, false )\
        elseif nValue and nValue >= 0 and nValue <= 15 then\
            rs.setAnalogOutput( sSide, nValue )\
        else\
            print( \"Value must be boolean or 0-15\" )\
        end\
    end\
\
else\
    -- Something else\
    printUsage()\
\
end",
  [ "/rom/programs/apis" ] = "\
local tApis = {}\
for k,v in pairs( _G ) do\
    if type(k) == \"string\" and type(v) == \"table\" and k ~= \"_G\" then\
        table.insert( tApis, k )\
    end\
end\
table.insert( tApis, \"shell\" )\
table.sort( tApis )\
\
textutils.pagedTabulate( tApis )",
  [ "/rom/help/earth" ] = "Mostly harmless.",
  [ "/Flare/version/1.2/lib/UI/event/Dispatcher.lua" ] = "\
local class = require \"lib.class\"\
local event = require \"lib.UI.event\"\
\
local Dispatcher = class \"Dispatcher\"\
\
function Dispatcher:Dispatcher()\
    self.timer = os.startTimer( 0 )\
    self.updateTime = .05\
    self.time = os.clock()\
end\
\
function Dispatcher:handle( ev, ... )\
    local params = { ... }\
    local event_obj\
    if ev == \"timer\" and params[1] == self.timer then\
\
        self.timer = os.startTimer( self.updateTime )\
        local dt = os.clock() - self.time\
        self.time = os.clock()\
\
        ev = \"update\"\
        params = { dt }\
\
    elseif ev == \"mouse_click\" then\
        event_obj = event:new \"mouse_down\"\
            :setParam( \"button\", params[1] )\
            :setParam( \"x\", params[2] )\
            :setParam( \"y\", params[3] )\
        if not _CC_VERSION or _CC_VERSION:match \"(1.74)pr%d+\" < 1.74 then\
            os.queueEvent( \"mouse_up\", params[1], params[2], params[3] )\
        end\
    elseif ev == \"mouse_up\" then\
        event_obj = event:new \"mouse_up\"\
            :setParam( \"button\", params[1] )\
            :setParam( \"x\", params[2] )\
            :setParam( \"y\", params[3] )\
    elseif ev == \"mouse_drag\" then\
        event_obj = event:new \"mouse_drag\"\
            :setParam( \"button\", params[1] )\
            :setParam( \"x\", params[2] )\
            :setParam( \"y\", params[3] )\
    elseif ev == \"mouse_scroll\" then\
        event_obj = event:new \"mouse_scroll\"\
            :setParam( \"direction\", params[1] )\
            :setParam( \"x\", params[2] )\
            :setParam( \"y\", params[3] )\
    elseif ev == \"key\" then\
        local name = keys.getName( params[1] )\
        event_obj = event:new \"key\"\
            :setParam( \"key\", name )\
            :setParam( \"keycode\", params[1] )\
    elseif ev == \"char\" then\
        event_obj = event:new \"char\"\
            :setParam( \"char\", params[1] )\
    elseif ev == \"paste\" then\
        event_obj = event:new \"paste\"\
            :setParam( \"data\", params[1] )\
    end\
\
    if event_obj then\
        return true, event_obj, { ev, unpack( params ) }\
    end\
    return false, ev, params\
end\
\
return Dispatcher",
  [ "/rom/help/unequip" ] = "unequip is a program for Turtles. unequip will remove tools of peripherals from the specified side of the turtle.\
\
ex:\
\"unequip left\" will remove the item on the left side of the turtle",
  [ "/rom/help/chat" ] = "Surf the rednet superhighway with \"chat\", the networked chat program for CraftOS! Host chatrooms and invite your friends! Requires a Wired or Wireless Modem on each computer. When running chat, type \"/help\" to see a list of available commands.\
\
ex:\
\"chat host forgecraft\" will create a chatroom with the name \"forgecraft\"\
\"chat join forgecraft direwolf20\" will connect to the chatroom with the name \"forgecraft\", using the nickname \"direwolf20\"",
  [ "/Flare/version/1.2/version.lua" ] = "\
local version = {}\
\
version.current = \"1.2.1\"\
version.name = \"PRERELEASE\"\
\
function version.local_major()\
    return version.current:match \"(%d+%.%d+)%.%d+\"\
end\
\
function version.local_patch()\
    return version.current:match \"%d+%.%d+%.(%d+)\"\
end\
\
function version.online_major()\
    local h = http.get \"https://raw.githubusercontent.com/awsumben13/Flare/master/version.txt\"\
    if h then\
        local content = h.readAll()\
        h.close()\
        if content:find \"%d+%.%d+%.%d+\" then\
            return content:match \"(%d+%.%d+)%.%d+\"\
        end\
    end\
    return version.local_major()\
end\
\
function version.online_version_patch( v )\
    local h = http.get( \"https://raw.githubusercontent.com/awsumben13/Flare/master/version/\" .. v .. \"/patch.txt\" )\
    if h then\
        local content = h.readAll()\
        h.close()\
        if content:find \"^%d+$\" then\
            return content\
        end\
    end\
    return version.local_patch()\
end\
\
function version.compareVersions( v1, v2 )\
    local v1ma, v1mi, v1p = v1:match \"(%d+)%.(%d+)%.(%d+)\"\
    local v2ma, v2mi, v2p = v2:match \"(%d+)%.(%d+)%.(%d+)\"\
    if v1ma and v1mi and v1p and v2ma and v2mi and v2p then\
        if v1ma > v2ma then return true end\
        if v1ma == v2ma and v1mi > v2mi then return true end\
        if v1ma == v2ma and v1mi == v2mi and v1p > v2p then return true end\
        return false\
    end\
end\
\
function version.shouldUpdate()\
    return version.local_patch() < version.online_version_patch( version.local_major() )\
end\
\
function version.install( version )\
    local h = http.get( \"https://raw.githubusercontent.com/awsumben13/Flare/master/version/\" .. version .. \"/install.lua\" )\
    if h then\
        local content = h.readAll()\
        h.close()\
        local f, err = loadstring( content, \"Installer\" )\
        return f()\
    end\
    return false\
end\
\
return version",
  [ "/rom/programs/drive" ] = "local tArgs = { ... }\
\
-- Get where a directory is mounted\
local sPath = shell.dir()\
if tArgs[1] ~= nil then\
    sPath = shell.resolve( tArgs[1] )\
end\
\
if fs.exists( sPath ) then\
    write( fs.getDrive( sPath ) .. \" (\" )\
    local nSpace = fs.getFreeSpace( sPath )\
    if nSpace > 1024 * 1024 then\
        print( (math.floor( nSpace / (100 * 1000) ) / 10) .. \"MB remaining)\" )\
    elseif nSpace > 1024 then\
        print( math.floor( nSpace / 1000 ) .. \"KB remaining)\" )\
    else\
        print ( nSpace .. \"B remaining)\" )\
    end\
else\
    print( \"No such path\" )\
end",
  [ "/Flare/version/1.2/FDK.lua" ] = "\
-- Flare Development Kit\
\
local FDK = {}\
FDK.name = \"Flare\"\
FDK.install_path = \"Flare/version/1.2\"\
FDK.lib_path = FDK.install_path .. \"/lib\"\
FDK.running = true\
FDK.updateTime = .05\
FDK.source_path = nil -- loaded later\
FDK.module = nil -- loaded later\
FDK.environment = setmetatable( { FDK = FDK }, { __index = getfenv() } )\
\
local function load_internal_file( file )\
    local f, err = loadfile( FDK.install_path .. \"/\" .. file:gsub( \"%.\", \"/\" ) .. \".lua\" )\
    if f then\
        setfenv( f, FDK.environment )\
        return f()\
    else\
        error( err, 0 )\
    end\
end\
\
FDK.version = load_internal_file \"version\"\
FDK.module = load_internal_file \"module\"\
\
local _type = type\
function FDK.type( object )\
    local rawtype = _type( object )\
    if rawtype == \"table\" then\
        pcall( function()\
            rawtype = getmetatable( object ).__type or rawtype\
        end )\
    end\
    if rawtype == \"table\" and _type( object.type ) == \"function\" then\
        pcall( function()\
            rawtype = object:type()\
        end )\
    end\
    return rawtype\
end\
\
function FDK.sleep( time )\
    local t = os.clock() + ( time or -1 )\
    repeat\
        coroutine.yield \"update\"\
    until os.clock() >= t\
end\
\
function FDK.setup( project )\
    FDK.source_path = project\
end\
\
local function getFilePath( file )\
    local _dir = \"\"\
    if FDK.source_path then\
        _dir = FDK.source_path\
    end\
    if file:sub( 1, 4 ):lower() == \"lib.\" then\
        path = fs.combine( FDK.lib_path, tostring( file:sub( 5 ):gsub( \"%.\", \"/\" ) ) )\
    else\
        path = fs.combine( _dir, tostring( file:gsub( \"%.\", \"/\" ) ) )\
    end\
    if fs.isDir( path ) then\
        local name = fs.getName( path )\
        if fs.exists( path .. \"/\" .. name .. \".lua\" ) then\
            return path .. \"/\" .. name .. \".lua\"\
        elseif fs.exists( path .. \"/main.lua\" ) then\
            return path .. \"/main.lua\"\
        end\
    elseif fs.exists( path .. \".lua\" ) then\
        return path .. \".lua\"\
    end\
end\
\
local r = {}\
local d = {}\
function FDK.require( file )\
    local path = getFilePath( file )\
    if not path then return error( (\"No such file %q\"):format( file ) ) end\
    if r[path] then return d[path] end\
    r[path] = true\
    local f, err = loadfile( path )\
    if f then\
        local ok\
        setfenv( f, FDK.environment )\
        ok, d[path] = pcall( f, fs.getDir( path ) )\
        if not ok then\
            error( d[path], 0 )\
        end\
        return d[path]\
    else\
        error( (\"Failed to load %q (%q): %s\"):format( file, path, tostring( err ) ), 0 )\
    end\
end\
\
FDK.environment.require = FDK.require\
\
if FDK.version.shouldUpdate() then\
    FDK.version.install( FDK.version.local_major() )\
end\
\
if not FDK.module.isInstalled \"core\" then\
    if not FDK.module.install \"core\" then\
        error \"Failed to download core module\"\
    end\
end\
\
local process          = FDK.require \"lib.process\"\
local buffer           = FDK.require \"lib.buffer\"\
local graphics         = FDK.require \"lib.graphics\"\
local stencil          = FDK.require \"lib.stencil\"\
local Frame            = FDK.require \"lib.UI.elements.Frame\"\
local animation        = FDK.require \"lib.UI.animation\"\
local event            = FDK.require \"lib.UI.event\"\
local keybind          = FDK.require \"lib.UI.keybind\"\
local trace            = FDK.require \"lib.trace\"\
local event_dispatcher = FDK.require \"lib.UI.event.Dispatcher\"\
\
local main_event_dispatcher = event_dispatcher:new()\
\
FDK.process = process:new \"main\"\
FDK.buffer = buffer:new( term.getSize() )\
FDK.buffer.stencil = stencil:new()\
graphics:mixin( FDK.buffer )\
FDK.frame = Frame( 1, 1, term.getSize() )\
\
function FDK.begin()\
    local timer = os.startTimer( 0 )\
    local time = os.clock()\
    FDK.running = true\
    while FDK.running do\
        main_event_dispatcher.updateTime = FDK.updateTime\
        local handled, event, params = main_event_dispatcher:handle( coroutine.yield() )\
\
        if not handled and event == \"update\" then\
\
            FDK.frame:update( params[1] )\
\
            FDK.buffer:clear()\
            FDK.buffer:setCursorBlink()\
            FDK.frame:draw( 1, 1, FDK.buffer )\
            FDK.buffer:draw()\
\
        end\
        \
        if handled then\
            local ok, err = FDK.process:spawnThread( function()\
                FDK.frame:handle( event )\
                if not event.handled then\
                    handled = false\
                    event = params[1]\
                    params = { unpack( params, 2 ) }\
                end\
            end ):update()\
            if not ok then\
                printError( err )\
                break\
            end\
        end\
\
        if not handled then\
            if event == \"key\" and keybind.isBound( keys.getName( params[1] ) ) then\
                keybind.call( keys.getName( params[1] ) )\
            else\
                local ok, data = FDK.process:update( event, unpack( params ) )\
                if not ok then\
                    printError( data )\
                    break\
                end\
            end\
        end\
    end\
end\
\
function FDK.dofile( file, ... )\
    local args = { ... }\
    local path = getFilePath( file )\
    if not path then return error( (\"No such file %q\"):format( file ) ) end\
    local f, err = loadfile( path )\
    if f then\
        local thread = FDK.process:spawnThread( function()\
            setfenv( f, getfenv() )\
            local ok, err = trace( f, unpack( args ) )\
            if not ok then\
                error( err, 0 )\
            end\
        end )\
        thread.environment = FDK.environment\
        return thread\
    else\
        error( (\"Failed to load %q (%q): %s\"):format( tostring( file ), tostring( path ), tostring( err ) ), 0 )\
    end\
end\
\
return FDK",
  [ "/rom/help/time" ] = "time prints the current time of day.",
  [ "/rom/help/whatsnew" ] = "New Features in ComputerCraft 1.65:\
\
* Fixed a multiplayer-only crash with turtle.place()\
* Fixed some problems with http.post()\
* Fixed fs.getDrive() returning incorrect results on remote peripherals\
\
Type \"help changelog\" to see the full version history.",
  [ "/Flare/version/1.2/lib/UI/elements/ClippingFrame.lua" ] = "\
local class = require \"lib.class\"\
local Frame = require \"lib.UI.elements.Frame\"\
\
local ClippingFrame = class \"ClippingFrame\"\
ClippingFrame:extend( Frame )\
\
function ClippingFrame:ClippingFrame( x, y, w, h )\
    self:Frame( x, y, w, h )\
end\
\
function ClippingFrame:draw( x, y, buffer )\
    local layer = buffer.stencil:newLayer( x, y, self.width, self.height )\
    for i = 1, #self.children do\
        self.children[i]:draw( x + self.children[i].x - 1 + self.ox, y + self.children[i].y - 1 + self.oy, buffer )\
    end\
    buffer.stencil:removeLayer( layer )\
end\
\
return ClippingFrame",
  [ "/rom/help/math" ] = "math is a standard Lua5.1 API.\
Refer to http://www.lua.org/manual/5.1/ for more information.",
  [ "/rom/help/turn" ] = "turn is a program for Turtles, used to turn the turtle around without programming. It accepts one or more commands as a direction and a number of turns. The \"go\" program can also be used for turning.\
\
ex:\
\"turn left\" turns the turtle 90 degrees left.\
\"turn right 2\" turns the turtle 180 degrees right.\
\"turn left 2 right\" turns left 180 degrees, then right 90 degrees.",
  [ "/rom/help/redirection" ] = "Redirection ComputerCraft Edition is the CraftOS version of a fun new puzzle game by Dan200, the author of ComputerCraft.\
Play it on any Advanced Computer, then visit http://www.redirectiongame.com to play the full game!",
  [ "/Flare/version/1.2/lib/trace.lua" ] = "\
local trace = {}\
\
function trace.traceback(ignore, level)\
    level = type(level) == \"number\" and level\
    local errorLevel = 3 + (type(ignore) == \"number\" and ignore or 0)\
    local errorDiff = errorLevel\
    local errorPos, result = nil, {}\
    repeat\
        errorPos = select(2, pcall(error, \"@\", errorLevel)):match(\"^(.+): @$\")\
        if errorPos then\
            result[#result + 1] = errorPos\
            errorLevel = errorLevel + 1\
            if errorLevel - errorDiff == level then return result end\
        end\
    until not errorPos\
    return result\
end\
\
function trace.trace( f, ... )\
    local args = { ... }\
    return xpcall( function() return f( unpack( args ) ) end, function( err )\
        local t = trace.traceback( 2 )\
        for i = #t, 1, -1 do\
            if t[i] == \"xpcall\" then\
                table.remove( t, i )\
                break\
            end\
            table.remove( t, i )\
        end\
        local txt = tostring( err )\
        for i = 1, #t do\
            txt = txt .. \"\\n  in \" .. tostring( t[i] )\
        end\
        return txt\
    end )\
end\
\
setmetatable( trace, { __call = function( self, ... )\
    return self.trace( ... )\
end } )\
\
return trace",
  [ "/rom/programs/fun/dj" ] = "local tArgs = { ... }\
\
local function printUsage()\
    print( \"Usages:\")\
    print( \"dj play\" )\
    print( \"dj play <drive>\" )\
    print( \"dj stop\" )\
end\
\
if #tArgs > 2 then\
    printUsage()\
    return\
end\
\
local sCommand = tArgs[1]\
if sCommand == \"stop\" then\
    -- Stop audio\
    disk.stopAudio()\
\
elseif sCommand == \"play\" or sCommand == nil then\
    -- Play audio\
    local sName = tArgs[2]\
    if sName == nil then\
        -- No disc specified, pick one at random\
        local tNames = {}\
        for n,sName in ipairs( peripheral.getNames() ) do\
            if disk.isPresent( sName ) and disk.hasAudio( sName ) then\
                table.insert( tNames, sName )\
            end\
        end\
        if #tNames == 0 then\
            print( \"No Music Discs in attached disk drives\" )\
            return\
        end\
        sName = tNames[ math.random(1,#tNames) ]\
    end\
\
    -- Play the disc\
    if disk.isPresent( sName ) and disk.hasAudio( sName ) then\
        print( \"Playing \"..disk.getAudioTitle( sName ) )\
        disk.playAudio( sName )\
    else\
        print( \"No Music Disc in disk drive: \"..sName )\
        return\
    end\
    \
else\
    printUsage()\
    \
end",
  [ "/rom/programs/turtle/craft" ] = "\
if not turtle.craft then\
    print( \"Requires a Crafty Turtle\" )\
    return\
end\
\
local tArgs = { ... }\
local nLimit = nil\
if #tArgs < 1 then\
    print( \"Usage: craft [number]\" )\
    return\
else\
    nLimit = tonumber( tArgs[1] )\
end\
\
local nCrafted = 0\
local nOldCount = turtle.getItemCount( turtle.getSelectedSlot() )\
if turtle.craft( nLimit ) then\
    local nNewCount = turtle.getItemCount( turtle.getSelectedSlot() )\
    if nOldCount <= nLimit then\
        nCrafted = nNewCount\
    else\
        nCrafted = nOldCount - nNewCount\
    end\
end\
\
if nCrafted > 1 then\
    print( nCrafted..\" items crafted\" )\
elseif nCrafted == 1 then\
    print( \"1 item crafted\" )\
else\
    print( \"No items crafted\" )\
end",
  [ "/rom/help/craft" ] = "craft is a program for Crafty Turtles. Craft will craft a stack of items using the current inventory.\
\
ex:\
\"craft\" will craft as many items as possible\
\"craft 5\" will craft at most 5 times",
  [ "/rom/programs/fun/advanced/levels/11" ] = "4\
   777777777\
   727872787\
   787878787\
777787878787777\
7be888888888be7\
777787878787777\
   787878787\
   787478747\
   777777777",
  [ "/rom/help/intro" ] = "Welcome to CraftOS!\
Type \"programs\" to see the programs you can run.\
Type \"help <program>\" to see help for a specific program.\
Type \"help programming\" to learn about programming.\
Type \"help whatsnew\" to find out about new features.\
Type \"help credits\" to learn who made all this.\
Type \"help index\" to see all help topics.",
  [ "/rom/help/disk" ] = "Functions in the disk API. These functions are for interacting with disk drives:\
disk.isPresent( drive )\
disk.setLabel( drive, label )\
disk.getLabel( drive )\
disk.hasData( drive )\
disk.getMountPath( drive )\
disk.hasAudio( drive )\
disk.getAudioTitle( drive )\
disk.playAudio( drive )\
disk.stopAudio( )\
disk.eject( drive )\
disk.getID( drive )\
\
Events fired by the disk API:\
\"disk\" when a disk or other item is inserted into a disk drive. Argument is the name of the drive\
\"disk_eject\" when a disk is removed from a disk drive. Argument is the name of the drive\
Type \"help events\" to learn about the event system.",
  [ "/rom/help/equip" ] = "equip is a program for Turtles. equip will equip an item from the Turtle's inventory for use as a tool of peripheral.\
\
ex:\
\"equip 5 left\" will equip the item from slot 5 of the turtle onto the left side of the turtle",
  [ "/rom/programs/turtle/unequip" ] = "\
local tArgs = { ... }\
local function printUsage()\
    print( \"Usage: unequip <side>\" )\
end\
\
if #tArgs ~= 1 then\
    printUsage()\
    return\
end\
\
local function unequip( fnEquipFunction )\
    for nSlot=1,16 do\
        local nOldCount = turtle.getItemCount( nSlot )\
        if nOldCount == 0 then\
            turtle.select( nSlot )\
            if fnEquipFunction() then\
                local nNewCount = turtle.getItemCount( nSlot )\
                if nNewCount > 0 then\
                    print( \"Item unequipped\" )\
                    return\
                else\
                    print( \"Nothing to unequip\" )\
                    return\
                end\
            end\
        end\
    end\
    print( \"No space to unequip item\" )\
end\
\
local sSide = tArgs[1]\
if sSide == \"left\" then\
    unequip( turtle.equipLeft )\
elseif sSide == \"right\" then\
    unequip( turtle.equipRight )\
else\
    printUsage()\
    return\
end",
  [ "/rom/programs/eject" ] = "\
-- Get arguments\
local tArgs = { ... }\
if #tArgs == 0 then\
    print( \"Usage: eject <drive>\" )\
    return\
end\
\
local sDrive = tArgs[1]\
\
-- Check the disk exists\
local bPresent = disk.isPresent( sDrive )\
if not bPresent then\
    print( \"Nothing in \"..sDrive..\" drive\" )\
    return\
end\
\
disk.eject( sDrive )",
  [ "/rom/help/table" ] = "table is a standard Lua5.1 API.\
Refer to http://www.lua.org/manual/5.1/ for more information.",
  [ "/Flare/version/1.2/lib/buffer.lua" ] = "\
local function hasChanged( p1, p2 )\
    return p1.bc ~= p2.bc or p1.char ~= p2.char or ( p1.tc ~= p2.tc and p1.char ~= \" \" )\
end\
local function drawCurrent( state )\
    local t = state.target\
    if state.text ~= \"\" then\
        t.setCursorPos( state.x, state.y )\
        local bc = state.bc\
        bc = ( type( bc ) == \"function\" and bc() ) or ( bc == 0 and state.buffer.bc ) or bc\
        local tc = state.tc\
        tc = ( type( tc ) == \"function\" and tc() ) or ( tc == 0 and state.buffer.tc ) or tc\
        t.setBackgroundColour( bc )\
        t.setTextColour( tc )\
        t.write( state.text )\
        state.x = state.x + #state.text\
        state.text = \"\"\
    end\
end\
local function px( buffer, state, x, y )\
    local px = buffer.pixels[y][x]\
    if not hasChanged( px, buffer.last[y][x] ) and not state.all then\
        drawCurrent( state )\
        state.x = state.x + 1\
        state.bc = nil\
        return\
    end\
    if not state.bc then\
        state.bc = px.bc\
        state.tc = px.tc\
        state.text = px.char\
        return\
    end\
    if state.bc ~= px.bc or ( state.tc ~= px.tc and px.char ~= \" \" ) then\
        drawCurrent( state )\
        state.bc = px.bc\
        state.tc = px.tc\
        state.text = px.char\
    else\
        state.text = state.text .. px.char\
    end\
end\
\
local col_lookup = {}\
for i = 0, 15 do\
    col_lookup[2 ^ i] = (\"%01x\"):format( i )\
end\
\
local function toHex( c )\
    return col_lookup[c] or \"0\"\
end\
\
local function blitline( line )\
    local s, b, t = \"\", \"\", \"\"\
    for i = 1, #line do\
        s = s .. line[i].char:sub( 1, 1 )\
        if line[i].char == \"\" then s = s .. \" \" end\
        b = b .. toHex( line[i].bc )\
        t = t .. toHex( line[i].tc )\
    end\
    term.blit( s, t, b )\
end\
\
local buffer = {}\
local main\
\
function buffer:new( width, height, bc, tc, char )\
    local b = {}\
\
    b.allowInvisiblePixels = false\
\
    b.width = width\
    b.height = height\
\
    b.bc = bc or 1\
    b.tc = tc or 32768\
    b.char = char or \" \"\
\
    b.pixels = {}\
    b.last = {}\
\
    b.cb = false\
\
    for y = 1, height do\
        b.pixels[y] = {}\
        b.last[y] = {}\
        for x = 1, width do\
            b.pixels[y][x] = { bc = b.bc, tc = b.tc, char = b.char }\
            b.last[y][x] = {}\
        end\
    end\
\
    setmetatable( b, { __index = self, __type = \"buffer\" } )\
\
    return b\
end\
\
function buffer:setPixel( x, y, bc, tc, char )\
    if self.pixels[y] and self.pixels[y][x] then\
        local px = self.pixels[y][x]\
        px.bc = ( bc == 0 and not self.allowInvisiblePixels and px.bc ) or bc\
        px.tc = ( tc == 0 and not self.allowInvisiblePixels and px.tc ) or tc\
        px.char = ( tc == 0 and px.char ) or ( char == \"\" and px.char ) or char\
    end\
end\
\
function buffer:getPixel( x, y )\
    if self.pixels[y] and self.pixels[y][x] then\
        local px = self.pixels[y][x]\
        return px.bc, px.tc, px.char\
    end\
end\
\
function buffer:clear()\
    for y = 1, self.height do\
        for x = 1, self.width do\
            self.pixels[y][x] = { bc = self.bc, tc = self.tc, char = self.char }\
        end\
    end\
end\
\
function buffer:foreach( f )\
    local new = {}\
    for x = 1, self.width do\
        new[x] = {}\
        for y = 1, self.height do\
            local bc, tc, char = self:getPixel( x, y )\
            local _bc, _tc, _char = f( x, y, bc, tc, char )\
            local c = false\
            if _bc and _bc ~= bc then c = true end\
            if _tc and _tc ~= tc then c = true end\
            if _char and _char ~= char then c = true end\
            if c then\
                new[x][y] = { bc = _bc or bc, tc = _tc or tc, char = _char or char }\
            end\
        end\
    end\
    for x = 1, self.width do\
        for y = 1, self.height do\
            local px = new[x][y]\
            if px then\
                self:setPixel( x, y, px.bc, px.tc, px.char )\
            end\
        end\
    end\
end\
\
function buffer:resize( width, height )\
    while self.height < height do\
        local t = {}\
        for i = 1, self.width do\
            t[i] = { bc = self.bc, tc = self.tc, char = self.char }\
        end\
        self.pixels[#self.pixels + 1] = t\
        self.last[#self.last + 1] = {}\
        self.height = self.height + 1\
    end\
    while self.height > height do\
        self.pixels[#self.pixels] = nil\
        self.last[#self.last] = nil\
        self.height = self.height - 1\
    end\
    while self.width < width do\
        for i = 1, self.height do\
            self.pixels[i][#self.pixels[i] + 1] = { bc = self.bc, tc = self.tc, char = self.char }\
        end\
        self.width = self.width + 1\
    end\
    while self.width > width do\
        for i = 1, self.height do\
            self.pixels[i][#self.pixels[i]] = nil\
        end\
        self.width = self.width - 1\
    end\
end\
\
function buffer:setCursorBlink( x, y, tc )\
    if x then\
        self.cb = { x = x, y = y, tc = tc }\
    else\
        self.cb = false\
    end\
end\
\
function buffer:getCursorBlink()\
    if self.cb then\
        return self.cb.x, self.cb.y, self.cb.tc\
    end\
end\
\
local function drawToBuffer( buffer, target, _x, _y )\
    buffer:foreach( function( x, y, bc, tc, char )\
        target:setPixel( x + _x - 1, y + _y - 1, bc, tc, char )\
    end )\
end\
\
function buffer:draw( target, x, y, all )\
    target = target or term.current()\
\
    if pcall( function()\
        if getmetatable( target ).__type ~= \"buffer\" then\
            error \"\"\
        end\
    end ) then\
        return drawToBuffer( self, target, x, y )\
    end\
\
    x = x or 1\
    y = y or 1\
    if target.blit then\
        for i = 1, self.height do\
            term.setCursorPos( x, y + i - 1 )\
            blitline( self.pixels[i] )\
        end\
    else\
        for i = 1, self.height do\
            local state = {\
                x = x;\
                y = y;\
                target = target;\
                text = \"\";\
                all = all;\
                buffer = self;\
            }\
            for x = 1, self.width do\
                px( self, state, x, i )\
            end\
            drawCurrent( state )\
            y = y + 1\
        end\
    end\
\
    if self.cb then\
        term.setTextColour( self.cb.tc )\
        term.setCursorPos( self.cb.x, self.cb.y )\
        term.setCursorBlink( true )\
    else\
        term.setCursorBlink( false )\
    end\
end\
\
function buffer:redirect()\
    main = self\
end\
\
function buffer.current()\
    return main\
end\
\
return buffer",
  [ "/rom/programs/fun/advanced/levels/8" ] = "4\
777777 7777\
7287b7 7867\
788787 7887\
77878777877\
 7888eb8887\
 77877787877\
 7887 787887\
 7487 7e7807\
 7777 777777",
  [ "/rom/programs/turtle/go" ] = "local tArgs = { ... }\
if #tArgs < 1 then\
    print( \"Usage: go <direction> <distance>\" )\
    return\
end\
\
local tHandlers = {\
    [\"fd\"] = turtle.forward,\
    [\"forward\"] = turtle.forward,\
    [\"forwards\"] = turtle.forward,\
    [\"bk\"] = turtle.back,\
    [\"back\"] = turtle.back,\
    [\"up\"] = turtle.up,\
    [\"dn\"] = turtle.down,\
    [\"down\"] = turtle.down,\
    [\"lt\"] = turtle.turnLeft,\
    [\"left\"] = turtle.turnLeft,\
    [\"rt\"] = turtle.turnRight,\
    [\"right\"] = turtle.turnRight,\
}\
\
local nArg = 1\
while nArg <= #tArgs do\
    local sDirection = tArgs[nArg]\
    local nDistance = 1\
    if nArg < #tArgs then\
        local num = tonumber( tArgs[nArg + 1] )\
        if num then\
            nDistance = num\
            nArg = nArg + 1\
        end\
    end\
    nArg = nArg + 1\
\
    local fnHandler = tHandlers[string.lower(sDirection)]\
    if fnHandler then\
        while nDistance > 0 do\
            if fnHandler() then\
                nDistance = nDistance - 1\
            elseif turtle.getFuelLevel() == 0 then\
                print( \"Out of fuel\" )\
                return\
            else\
                sleep(0.5)\
            end\
        end\
    else\
        print( \"No such direction: \"..sDirection )\
        print( \"Try: forward, back, up, down\" )\
        return\
    end\
\
end",
  [ "/Flare/version/1.2/lib/UI/elements/Text.lua" ] = "\
local class = require \"lib.class\"\
local base = require \"lib.UI.base\"\
local formatter = require \"lib.UI.text.formatter\"\
local drawtext = require \"lib.UI.draw.text\"\
local mouse = require \"lib.UI.event.mouse\"\
\
local Text = class \"Text\"\
Text:extend( base )\
\
Text.bc = \"white\"\
Text.tc = \"grey\"\
\
Text.noAlign = false\
\
Text.xAlign = \"left\"\
Text.yAlign = \"top\"\
\
Text.mouse_click_timeout = .4\
\
function Text:Text( x, y, w, h, text )\
    self:base( x, y, w, h )\
\
    self.text = text or \"\"\
    self:update( 0 )\
end\
\
function Text:update( dt )\
    self.metadata = {\
        bc = self.bc;\
        tc = self.tc;\
        width = self.width;\
        height = self.height;\
    }\
    self.lines = formatter.lines( self.text, self.metadata )\
    self.fmt = formatter.renderPrep( self.lines, self.metadata )\
end\
\
function Text:draw( x, y, buffer )\
    formatter.fixAlignment( self.fmt, self.width, self.height, self.xAlign, self.yAlign )\
    drawtext( self, self.fmt, x, y, buffer )\
end\
\
function Text:handle( event )\
    if mouse.click( self, event ) then\
        local protocol, target = mouse.text_link_check( self.lines, event:getParam \"x\", event:getParam \"y\", self.fmt.offset )\
        if protocol and self.onLinkOpened then\
            self:onLinkOpened( protocol, target )\
        end\
    elseif event.name == \"mouse_ping\" then\
        mouse.ping( self, event )\
    end\
end\
\
return Text",
  [ "/rom/help/vector" ] = "Functions in the 3D Vector Math API:\
vector.new( x,y,z )\
\
Vectors returned by vector.new() have the following fields and methods:\
vector.x\
vector.y\
vector.z\
vector:add( vector )\
vector:sub( vector )\
vector:mul( number )\
vector:dot( vector )\
vector:cross( vector )\
vector:length()\
vector:normalize()\
vector:round()\
vector:tostring()\
The +, - and * operators can also be used on vectors.",
  [ "/rom/programs/programs" ] = "\
local bAll = false\
local tArgs = { ... }\
if #tArgs > 0 and tArgs[1] == \"all\" then\
    bAll = true\
end\
\
local tPrograms = shell.programs( bAll )\
textutils.pagedTabulate( tPrograms )",
  [ "/rom/help/monitors" ] = "The Monitor is a peripheral device available for CraftOS. Type \"help peripheral\" to learn about using the Peripheral API to connect with peripherals. When a Monitor is connected, peripheral.getType() will return \"monitor\". A wrapped monitor can be used with term.redirect() to send all terminal output to the monitor.\
\
Methods exposed by the Monitor:\
write( text )\
clear()\
clearLine()\
getCursorPos()\
setCursorPos( x, y )\
setCursorBlink( blink )\
isColor()\
setTextColor( color )\
setBackgroundColor( color )\
getSize()\
scroll( n )\
\
Events fired by the Monitor:\
\"monitor_touch\" when an Advanced Monitor is touched by the player. Arguments are name, x, y\
\"monitor_resize\" when the size of a Monitor changes. Argument is the name of the monitor.",
  [ "/rom/programs/alias" ] = "\
local tArgs = { ... }\
if #tArgs > 2 then\
    print( \"Usage: alias <alias> <program>\" )\
    return\
end\
\
local sAlias = tArgs[1]\
local sProgram = tArgs[2]\
\
if sAlias and sProgram then\
    -- Set alias\
    shell.setAlias( sAlias, sProgram )\
elseif sAlias then\
    -- Clear alias\
    shell.clearAlias( sAlias )\
else\
    -- List aliases\
    local tAliases = shell.aliases()\
    local tList = {}\
    for sAlias, sCommand in pairs( tAliases ) do\
        table.insert( tList, sAlias )\
    end\
    table.sort( tList )\
    textutils.pagedTabulate( tList )\
end\
    ",
  [ "/rom/help/peripheral" ] = "The peripheral API is for interacting with external peripheral devices. Type \"help peripherals\" to learn about the peripherals available.\
\
Functions in the peripheral API:\
peripheral.getNames()\
peripheral.isPresent( name )\
peripheral.getType( name )\
peripheral.getMethods( name )\
peripheral.call( name, methodName, param1, param2, etc )\
peripheral.wrap( name )\
peripheral.find( type, [fnFilter] )\
\
Events fired by the peripheral API:\
\"peripheral\" when a new peripheral is attached. Argument is the name.\
\"peripheral_detach\" when a peripheral is removed. Argument is the name.\
Type \"help events\" to learn about the event system.",
  [ "/rom/help/paint" ] = "paint is a program for creating images on Advanced Computers. Select colors from the color pallette on the right, and click on the canvas to draw. Press Ctrl to access the menu and save your pictures.\
\
ex:\
\"edit mario\" opens an image called \"mario\" for editing.",
  [ "/rom/programs/rednet/chat" ] = "\
local tArgs = { ... }\
\
local function printUsage()\
    print( \"Usages:\" )\
    print( \"chat host <hostname>\" )\
    print( \"chat join <hostname> <nickname>\" )\
end\
\
local sOpenedModem = nil\
local function openModem()\
    for n,sModem in ipairs( peripheral.getNames() ) do\
        if peripheral.getType( sModem ) == \"modem\" then\
            if not rednet.isOpen( sModem ) then\
                rednet.open( sModem )\
                sOpenedModem = sModem\
            end\
            return true\
        end\
    end\
    print( \"No modems found.\" )\
    return false\
end\
\
local function closeModem()\
    if sOpenedModem ~= nil then\
        rednet.close( sOpenedModem )\
        sOpenedModem = nil\
    end\
end\
\
-- Colours\
local highlightColour, textColour\
if term.isColour() then\
    textColour = colours.white\
    highlightColour = colours.yellow\
else\
    textColour = colours.white\
    highlightColour = colours.white\
end\
\
local sCommand = tArgs[1]\
if sCommand == \"host\" then\
    -- \"chat host\"\
    -- Get hostname\
    local sHostname = tArgs[2]\
    if sHostname == nil then\
        printUsage()\
        return\
    end\
\
    -- Host server\
    if not openModem() then\
        return\
    end\
    rednet.host( \"chat\", sHostname )\
    print( \"0 users connected.\" )\
\
    local tUsers = {}\
    local nUsers = 0\
    function send( sText, nUserID )\
        if nUserID then\
            local tUser = tUsers[ nUserID ]\
            if tUser then\
                rednet.send( tUser.nID, {\
                    sType = \"text\",\
                    nUserID = nUserID,\
                    sText = sText,\
                }, \"chat\" )\
            end\
        else\
            for nUserID, tUser in pairs( tUsers ) do\
                rednet.send( tUser.nID, {\
                    sType = \"text\",\
                    nUserID = nUserID,\
                    sText = sText,\
                }, \"chat\" )\
            end\
        end\
    end\
\
    -- Setup ping pong\
    local tPingPongTimer = {}\
    function ping( nUserID )\
        local tUser = tUsers[ nUserID ]\
        rednet.send( tUser.nID, {\
            sType = \"ping to client\",\
            nUserID = nUserID,\
        }, \"chat\" )\
\
        local timer = os.startTimer( 15 )\
        tUser.bPingPonged = false\
        tPingPongTimer[ timer ] = nUserID\
    end\
\
    function printUsers()\
        local x,y = term.getCursorPos()\
        term.setCursorPos( 1, y - 1 )\
        term.clearLine()\
        if nUsers == 1 then\
            print( nUsers .. \" user connected.\" )\
        else\
            print( nUsers .. \" users connected.\" )\
        end\
    end\
\
    -- Handle messages\
    local ok, error = pcall( function()\
        parallel.waitForAny( function()\
            while true do\
                local sEvent, timer = os.pullEvent( \"timer\" )\
                local nUserID = tPingPongTimer[ timer ]\
                if nUserID and tUsers[ nUserID ] then\
                    local tUser = tUsers[ nUserID ]\
                    if tUser then\
                        if not tUser.bPingPonged then\
                            send( \"* \"..tUser.sUsername..\" has timed out\" )\
                            tUsers[ nUserID ] = nil\
                            nUsers = nUsers - 1\
                            printUsers()\
                        else\
                            ping( nUserID )\
                        end\
                    end\
                end\
            end\
        end,\
        function()\
            while true do\
                local tCommands\
                tCommands = {\
                    [\"me\"] = function( tUser, sContent )\
                        if string.len(sContent) > 0 then\
                            send( \"* \"..tUser.sUsername..\" \"..sContent )\
                        else\
                            send( \"* Usage: /me [words]\", tUser.nUserID )\
                        end\
                    end,\
                    [\"nick\"] = function( tUser, sContent )\
                        if string.len(sContent) > 0 then\
                            local sOldName = tUser.sUsername\
                            tUser.sUsername = sContent\
                            send( \"* \"..sOldName..\" is now known as \"..tUser.sUsername )\
                        else\
                            send( \"* Usage: /nick [nickname]\", tUser.nUserID )\
                        end\
                    end,\
                    [\"users\"] = function( tUser, sContent )\
                        send( \"* Connected Users:\", tUser.nUserID )\
                        local sUsers = \"*\"\
                        for nUserID, tUser in pairs( tUsers ) do\
                            sUsers = sUsers .. \" \" .. tUser.sUsername\
                        end\
                        send( sUsers, tUser.nUserID )\
                    end,\
                    [\"help\"] = function( tUser, sContent )\
                        send( \"* Available commands:\", tUser.nUserID )\
                        local sCommands = \"*\"\
                        for sCommand, fnCommand in pairs( tCommands ) do\
                            sCommands = sCommands .. \" /\" .. sCommand\
                        end\
                        send( sCommands..\" /logout\", tUser.nUserID )\
                    end,\
                }\
\
                local nSenderID, tMessage = rednet.receive( \"chat\" )\
                if type( tMessage ) == \"table\" then\
                    if tMessage.sType == \"login\" then\
                        -- Login from new client\
                        local nUserID = tMessage.nUserID\
                        local sUsername = tMessage.sUsername\
                        if nUserID and sUsername then\
                            tUsers[ nUserID ] = {\
                                nID = nSenderID,\
                                nUserID = nUserID,\
                                sUsername = sUsername,\
                            }\
                            nUsers = nUsers + 1\
                            printUsers()\
                            send( \"* \"..sUsername..\" has joined the chat\" )\
                            ping( nUserID )\
                        end\
\
                    else\
                        -- Something else from existing client\
                        local nUserID = tMessage.nUserID\
                        local tUser = tUsers[ nUserID ]\
                        if tUser and tUser.nID == nSenderID then\
                            if tMessage.sType == \"logout\" then\
                                send( \"* \"..tUser.sUsername..\" has left the chat\" )\
                                tUsers[ nUserID ] = nil\
                                nUsers = nUsers - 1\
                                printUsers()\
\
                            elseif tMessage.sType == \"chat\" then\
                                local sMessage = tMessage.sText\
                                if sMessage then\
                                    local sCommand = string.match( sMessage, \"^/([a-z]+)\" )\
                                    if sCommand then\
                                        local fnCommand = tCommands[ sCommand ]\
                                        if fnCommand then\
                                            local sContent = string.sub( sMessage, string.len(sCommand)+3 )\
                                            fnCommand( tUser, sContent )\
                                        else\
                                            send( \"* Unrecognised command: /\"..sCommand, tUser.nUserID )\
                                        end\
                                    else\
                                        send( \"<\"..tUser.sUsername..\"> \"..tMessage.sText )\
                                    end\
                                end\
\
                            elseif tMessage.sType == \"ping to server\" then\
                                rednet.send( tUser.nID, {\
                                    sType = \"pong to client\",\
                                    nUserID = nUserID,\
                                }, \"chat\" )\
\
                            elseif tMessage.sType == \"pong to server\" then\
                                tUser.bPingPonged = true\
\
                            end\
                        end\
                    end\
                 end\
            end\
        end )\
    end )\
    if not ok then\
        printError( error )\
    end\
\
    -- Unhost server\
    for nUserID, tUser in pairs( tUsers ) do\
        rednet.send( tUser.nID, {\
            sType = \"kick\",\
            nUserID = nUserID,\
        }, \"chat\" )\
    end\
    rednet.unhost( \"chat\" )\
    closeModem()\
\
elseif sCommand == \"join\" then\
    -- \"chat join\"\
    -- Get hostname and username\
    local sHostname = tArgs[2]\
    local sUsername = tArgs[3]\
    if sHostname == nil or sUsername == nil then\
        printUsage()\
        return\
    end\
\
    -- Connect\
    if not openModem() then\
        return\
    end\
    write( \"Looking up \" .. sHostname .. \"... \" )\
    local nHostID = rednet.lookup( \"chat\", sHostname )\
    if nHostID == nil then\
        print( \"Failed.\" )\
        return\
    else\
        print( \"Success.\" )\
    end\
\
    -- Login\
    local nUserID = math.random( 1, 2147483647 )\
    rednet.send( nHostID, {\
        sType = \"login\",\
        nUserID = nUserID,\
        sUsername = sUsername,\
    }, \"chat\" )\
\
    -- Setup ping pong\
    local bPingPonged = true\
    local pingPongTimer = os.startTimer( 0 )\
\
    function ping()\
        rednet.send( nHostID, {\
            sType = \"ping to server\",\
            nUserID = nUserID,\
        }, \"chat\" )\
        bPingPonged = false\
        pingPongTimer = os.startTimer( 15 )\
    end\
\
    -- Handle messages\
    local w,h = term.getSize()\
    local parentTerm = term.current()\
    local titleWindow = window.create( parentTerm, 1, 1, w, 1, true )\
    local historyWindow = window.create( parentTerm, 1, 2, w, h-2, true )\
    local promptWindow = window.create( parentTerm, 1, h, w, 1, true )\
    historyWindow.setCursorPos( 1, h-2 )\
\
    term.clear()\
    term.setTextColour( textColour )\
    term.redirect( promptWindow )\
    promptWindow.restoreCursor()\
\
    function drawTitle()\
        local x,y = titleWindow.getCursorPos()\
        local w,h = titleWindow.getSize()\
        local sTitle = sUsername..\" on \"..sHostname\
        titleWindow.setTextColour( highlightColour )\
        titleWindow.setCursorPos( math.floor( w/2 - string.len(sTitle)/2 ), 1 )\
        titleWindow.clearLine()\
        titleWindow.write( sTitle )\
        promptWindow.restoreCursor()\
    end\
\
    function printMessage( sMessage )\
        term.redirect( historyWindow )\
        print()\
        if string.match( sMessage, \"^\\*\" ) then\
            -- Information\
            term.setTextColour( highlightColour )\
            write( sMessage )\
            term.setTextColour( textColour )\
        else\
            -- Chat\
            local sUsernameBit = string.match( sMessage, \"^\\<[^\\>]*\\>\" )\
            if sUsernameBit then\
                term.setTextColour( highlightColour )\
                write( sUsernameBit )\
                term.setTextColour( textColour )\
                write( string.sub( sMessage, string.len( sUsernameBit ) + 1 ) )\
            else\
                write( sMessage )\
            end\
        end\
        term.redirect( promptWindow )\
        promptWindow.restoreCursor()\
    end\
\
    drawTitle()\
\
    local ok, error = pcall( function()\
        parallel.waitForAny( function()\
            while true do\
                local sEvent, timer = os.pullEvent()\
                if sEvent == \"timer\" then\
                    if timer == pingPongTimer then\
                        if not bPingPonged then\
                            printMessage( \"Server timeout.\" )\
                            return\
                        else\
                            ping()\
                        end\
                    end\
\
                elseif sEvent == \"term_resize\" then\
                    local w,h = parentTerm.getSize()\
                    titleWindow.reposition( 1, 1, w, 1 )\
                    historyWindow.reposition( 1, 2, w, h-2 )\
                    promptWindow.reposition( 1, h, w, 1 )\
\
                end\
            end\
        end,\
        function()\
            while true do\
                local nSenderID, tMessage = rednet.receive( \"chat\" )\
                if nSenderID == nHostID and type( tMessage ) == \"table\" and tMessage.nUserID == nUserID then\
                    if tMessage.sType == \"text\" then\
                        local sText = tMessage.sText\
                        if sText then\
                            printMessage( sText )\
                        end\
\
                    elseif tMessage.sType == \"ping to client\" then\
                        rednet.send( nSenderID, {\
                            sType = \"pong to server\",\
                            nUserID = nUserID,\
                        }, \"chat\" )\
\
                    elseif tMessage.sType == \"pong to client\" then\
                        bPingPonged = true\
\
                    elseif tMessage.sType == \"kick\" then\
                        return\
\
                    end\
                end\
            end\
        end,\
        function()\
            local tSendHistory = {}\
            while true do\
                promptWindow.setCursorPos( 1,1 )\
                promptWindow.clearLine()\
                promptWindow.setTextColor( highlightColour )\
                promptWindow.write( \": \")\
                promptWindow.setTextColor( textColour )\
\
                local sChat = read( nil, tSendHistory )\
                if string.match( sChat, \"^/logout\" ) then\
                    break\
                else\
                    rednet.send( nHostID, {\
                        sType = \"chat\",\
                        nUserID = nUserID,\
                        sText = sChat,\
                    }, \"chat\" )\
                    table.insert( tSendHistory, sChat )\
                end\
            end\
        end )\
    end )\
\
    -- Close the windows\
    term.redirect( parentTerm )\
\
    -- Print error notice\
    local w,h = term.getSize()\
    term.setCursorPos( 1, h )\
    term.clearLine()\
    term.setCursorBlink( false )\
    if not ok then\
        printError( error )\
    end\
\
    -- Logout\
    rednet.send( nHostID, {\
        sType = \"logout\",\
        nUserID = nUserID,\
    }, \"chat\" )\
    closeModem()\
\
    -- Print disconnection notice\
    print( \"Disconnected.\" )\
\
else\
    -- \"chat somethingelse\"\
    printUsage()\
\
end",
  [ "/rom/help/rednet" ] = "The rednet API provides a simple computer networking model using modems.\
\
Functions in the rednet API:\
rednet.open( side )\
rednet.close( [side] )\
rednet.isOpen( [side] )\
rednet.send( receiverID, message, [protocol] ) -- Send to a specific computer\
rednet.broadcast( message, [protocol] ) -- Send to all computers\
rednet.receive( [protocol], [timeout] ) -- Returns: senderID, message, protocol\
rednet.host( protocol, hostname )\
rednet.unhost( protocol )\
rednet.lookup( protocol, [hostname] ) -- Returns: ID\
\
Events fired by the rednet API:\
\"rednet_message\" when a message is received. Arguments are senderID, message, protocol\
Type \"help events\" to learn about the event system.\
\
Rednet is not the only way to use modems for networking. Interfacing with the modem directly using the peripheral API and listening for the \"modem_message\" event allows for lower level control, at the expense of powerful high level networking features.",
  [ "/rom/help/printers" ] = "The Printer is a peripheral device available for CraftOS. Type \"help peripheral\" to learn about using the Peripheral API to connect with peripherals. When a Printer is connected, peripheral.getType() will return \"printer\".\
\
Methods exposed by the Printer:\
getInkLevel()\
getPaperLevel()\
newPage()\
setPageTitle( title )\
getPageSize()\
setCursorPos( x, y )\
getCursorPos()\
write( text )\
endPage()",
}  for k, v in pairs(tbl) do
    local X = fs.open(k, 'w')
    X.write(v)
    X.close()
  end