Teachutils

local function main(...)
    --[[PACKET API: This API allows information to be easily transferred between computers. Packets are formed in a similar fashion to real network packets. Each packet
    contains the type of the program sending it ("server", "client", "browser", etc.), the sender's computer name and ID, the recipient's (destination's) computer name and
    ID, the type of the data being sent, and the data itself. The data may be anything except a function or a table containing a function. Packets are serialized as strings
    and sent over rednet. The recipient ID is used as the sending channel: pastebin:8CfjPgCu]]
    print("Packet Utility 1.0")
    --Utility for quickly yielding. This is very important for the queue functions as they are intended to run parallel to other functions
    function yield()
        --Queue an event and then yield for it. This is faster than using a timer, but does the same job
        os.queueEvent("threadyield")
        coroutine.yield("threadyield")

    end
    --[[Utility for checking if a variable is of a required type. If the type matches, true is returned. Otherwise false may be returned, or a function may be provided to
    take come custom action such as raising an error or returning an error message. Passing "standard_error" as the function will cause an error to be raised with a common
    error message. The level argument is the stack level above this function call which is responsible for the error. This defaults to the level above the caller]]
    function checkType(mVar, sType, func, nLevel)
        --The function to run if the type doesn't match, or a default function returning false
        local func = func or function() return false end
        --The level above this function's call which caused the issue, or the level above the caller
        local nLevel = nLevel or 2
        --Response to most type mismatches: "Expected [expected type], got [actual type]"
        local function standard_error(gVar, sExpectedType, sType, nLevel)

            error(string.format("Expected %s, got %s", sExpectedType, sType), nLevel)

        end

        if func == "standard_error" then

            func = standard_error

        end
        --Check our argument's types
        if type(sType) ~= "string" then standard_error(nil, "string", type(sType), 3) end
        if type(func) ~= "function" then standard_error(nil, "function", type(func), 3) end
        if type(nLevel) ~= "number" then standard_error(nil, "number", type(nLevel), 3) end
        --If the level is 0, leave it. Otherwise, add 2 to compensate for the two function calls to get to func. The level of the calling function is technically 3, but for
        --convenience we add 2 so they may use 1 as their level
        if nLevel ~= 0 then

            nLevel = nLevel + 2

        end
        --If the type of mVar does not match what is defined in sType, call func
        if type(mVar) ~= sType then
            --func is passed the variable which failed the test, the type which it needed to be, the actual type, and the level to raise the error at
            return func(mVar, sType, type(mVar), nLevel)

        end
        --mVar passed the test
        return true

    end
    --UnProtected CALL at a specified Level. Re-raises any error raised by the given function at the specified level. This makes sure our functions don't get blamed for a
    --user's mistake
    local function upcallL(nLevel, func, ...)
        --Call the function with pcall
        local tResult = {pcall(func, ...)}
        --Extract the result of pcall's attempt
        local bResult = table.remove(tResult, 1)
        --If the level is 0, leave it. Otherwise, add 1 to compensate for the call to this function. The level of the calling function is technically 2, but for
        --convenience we add 1 so they may use 1 as their level
        if nLevel ~= 0 then

            nLevel = nLevel + 1

        end

        if bResult then
            --Unpack what the function returned
            return unpack(tResult)

        else
            --Raise an error at the specified level
            error(tResult[1], nLevel)

        end

    end
    --Utility for quickly clearing a table, used to empty the queues after they've been processed in multi-packet mode
    function clearTable(tTbl)

        checkType(tTbl, "table", "standard_error")
        --Get the first index in the table
        local k = next(tTbl)

        while k do
            --Set the index's value to nil
            tTbl[k] = nil
            --Set the index to the next non-nil index. This will be nil if the table is empty, which will end the loop
            k = next(tTbl)

        end

    end
    --Copies a table (in case you didn't know)
    function copyTable(tTbl)

        checkType(tTbl, "table", "standard_error")
        --The table to copy to
        local tCopy = {}
        --Get the first index in the table
        local k = next(tTbl)

        while k do
            --Set the index's value in the copy, to its value in the original
            tCopy[k] = tTbl[k]
            --Get the next index after the current one. This will be nil if there are no more indexes, which will end the loop
            k = next(tTbl, k)

        end
        --Return the copy, and the original next to it for convenience
        return tCopy, tTbl

    end
    --Utility for creating packet tables
    function asPacketData(senderType, senderName, senderID, recipientName, recipientID, dataType, data, tOther)
        --[[
            Packet contains:
                -what kind of server or client is sending the information
                -the computer name and ID of the sender
                -the computer name and ID of the computer intended to receive the packet (the ID is usually used as the sending channel)
                -the type of data being sent
                -the data itself
                -any other information which a program may acknowledge, but the packet API will ignore
        ]]
        local tPacket = {

            senderType=senderType,
            senderName=senderName,
            senderID=senderID,
            recipientName=recipientName,
            recipientID=recipientID,
            dataType=dataType,
            data=data

        }
        --If tOther is nil, set it to an empty table
        local tOther = tOther or {}
        checkType(tOther, "table", "standard_error")
        --Add all the values in tOther to the packet
        for k, v in pairs(tOther) do

            tPacket[k] = v

        end

        return tPacket

    end
    --Utility for creating packet tables to be passed to send as send does not need to know the sender name or ID
    function asPacketDataS(senderType, recipientName, recipientID, dataType, data, tOther)
        --Leave the sender name and ID nil, as send will set it to this computer's name and ID for us
        return upcallL(2, asPacketData,

            senderType,
            nil, nil,
            recipientName,
            recipientID,
            dataType,
            data,
            tOther

        )

    end
    --[[Compares two packets, a sample and a real packet, to check for things like who the sender was, and who they were sending to. This is intended to be used to check if
    this computer was the intended recipient. If all values in the sample packet match the same values in the real packet, all values in the sample packets are functions
    which take the same value of the sample packet as an argument and calling these functions return true, or any combination of the two, this function will return true.
    Otherwise, it will return false. Any values in the packet which are not in the sample packet will be ignored]]
    function checkPacket(tSamplePacket, tPacket)

        checkType(tSamplePacket, "table", "standard_error")
        checkType(tPacket, "table", "standard_error")
        --We only care about items that tSamplePacket has in it. If tPacket has an item the tSamplePacket doesn't, we'll ignore it
        for k, v in pairs(tSamplePacket) do
            --If the packet value doesn't match the sample packet value, and the sample packet value is not a function or is a function and it returns false
            if not (tPacket[k] == v or (checkType(v, "function") and v(tPacket[k]))) then

                return false

            end

        end

        return true

    end
    --Confirms that a table contains all of the parts of a standard packet
    local function validatePacket(tPacket)

        --Create a sample packet of functions which returns if the types of the packet match the defined standard component types, and check it against the packet with checkPacket
        return checkPacket(asPacketData(

            function(mData) return checkType(mData, "string") end,--Sender type
            function(mData) return checkType(mData, "string") end,--Sender name
            function(mData) return checkType(mData, "number") end,--Sender ID
            function(mData) return checkType(mData, "string") end,--Recipient name
            function(mData) return checkType(mData, "number") end,--Recipient ID
            function(mData) return checkType(mData, "string") end--Data type

        ), tPacket)

    end
    --Formats informations about who's sending, who they're sending to, and what they're sending and returns it as a string which can be sent over rednet
    function asPacket(...)
        --Convert the arguments into a packet table
        local tPacket = upcallL(2, asPacketData, ...)
        --Check it against the standard
        if not validatePacket(tPacket) then

            error("asPacket: You are not allowed to generate corrupted packets", 2)

        end
        --Serialize the packet as a string to be sent over rednet. If the packet contains a function, an error will be raised
        return upcallL(2, textutils.serialize, tPacket)

    end
    --Formats a string as a table of data, handling any error caused by the process and returning them as an errorMessage packet
    function asData(sPacket)

        checkType(sPacket, "string", "standard_error")
        --Attempt to format the string as a table of information
        local tPacket = textutils.unserialize(sPacket)
        --If the result is a table, and the table passes as a standard packet, return it
        if checkType(tPacket, "table") and validatePacket(tPacket) then

            return tPacket

        end
        --Corrupted packet error, will usually be ignored as checkPacket will reject it in most cases
        return asPacketData(

            "system",
            "asData",
            -1,
            "none",
            -1,
            "errorMessage",
            "Packet corrupted"

        )

    end
    --Sends a packet on the channel of the given recipient recipient ID
    function send(sSenderType, sRecipientName, nRecipientID, sDataType, mData)

        --The packet is sent to the specified recipient's computer ID, assuming it will be receiving over rednet. This computers label and ID are used to form the packet
        rednet.send(nRecipientID,
            upcallL(2, asPacket, sSenderType, (os.getComputerLabel() or "LABEL_NOT_SET"), os.getComputerID(),
                sRecipientName, nRecipientID, sDataType, mData)
        )

    end
    --[[Receives a packet and converts it into data. If a timeout is specified, and no data is received in that amount of time, an empty or "blank" packet will be returned
    If a sample packet is specified, this function will not return until it receives a packet which passes the check against the specified sample packet. If specified, this
    function may return blank packets, even if they do not match the sample packet. This defaults to false]]
    function receive(nTimeout, tSamplePacket)
        --nTimeout may be nil, but otherwise it must be a number
        if nTimeout then

            checkType(nTimeout, "number", "standard_error")

        end
        --If tSamplePacket is nil, set it to an empty table
        local tSamplePacket = tSamplePacket or {}
        checkType(tSamplePacket, "table", "standard_error")

        while true do
            --Rednet may raise a termination error, we will catch this and return it as an error message if this is permitted
            local tMessage = {pcall(rednet.receive, nTimeout)}
            local tPacket

            if not tMessage[1] then
                --Some error occurred, create a packet containing the error message
                tPacket = asPacketData(

                    "system",
                    "receive",
                    -1,
                    "none",
                    -1,
                    "errorMessage",
                    tMessage[2]

                )

            end
            --If receive timed out, it returned nil. If this is the case, create a blank packet
            if not tMessage[3] then

                tPacket = asPacketData(

                    "system",
                    "receive",
                    -1,
                    "none",
                    -1,
                    "blank"

                )

            end
            --If nothing has gone wrong so far, try to convert the received message into a packet
            if not tPacket then

                tPacket = asData(tMessage[3])

            end
            --Compare the packet to the sample packet. If it fails, we'll receive again until we get a packet that passes. When we get a packet that passes, we'll return it.
            --If the packet is blank, we'll return it regardless of whether or not it passes
            if checkPacket(tSamplePacket, tPacket) or tPacket.dataType == "blank" then

                return tPacket

            end

        end

    end
    --Receives a packet, or multi-packet, and places it in the queue
    function queueReceiver(tQueue, tSamplePacket)

        checkType(tQueue, "table", "standard_error")
        --If tSamplePacket is nil, set it to an empty table
        local tSamplePacket = tSamplePacket or {}
        checkType(tSamplePacket, "table", "standard_error")

        while true do
            --Wait indefinitely for a packet which matches the sample packet
            tPacket = receive(nil, tSamplePacket)
            --If the packet was sent in multi-mode, it must be received in multi-mode. This means the data will be a table containing multiple pieces of data, and a flag the
            --multiMode flag in this table will be set to true
            if checkType(tPacket.data, "table") and tPacket.data.multiMode then
                --Erase the flag, we don't need it any more
                tPacket.data.multiMode = nil
                --Add every piece of data being sent to the queue
                for k, v in pairs(tPacket.data) do

                    table.insert(tQueue, v)

                end

            else
                --Add the data to the queue
                table.insert(tQueue, tPacket.data)

            end

        end

    end
    --Runs parallel to a function which should fill the given queue with information to send. This information should NOT be formatted as a packet. As information is
    --received, it will be formatted as a packet, or as a multi-packet if the third function argument is true
    function queueSender(tQueue, tTemplatePacket, bMultiPacketMode)

        checkType(tQueue, "table", "standard_error")
        checkType(tTemplatePacket, "table", "standard_error")
        checkType(bMultiPacketMode, "boolean", "standard_error")
        --tTemplatePacket may specify multiple recipients. They will be stored here
        local tRecipients = {}

        if tTemplatePacket.recipients and checkType(tTemplatePacket.recipients, "table") then

            for k, v in pairs(tTemplatePacket.recipients) do
                --If v is not a table
                checkType(v, "table",
                    function(gVar, sExpectedType, sType, nLevel)

                        error(string.format("Error processing entry %s, entry: Expected %s, got %s", tostring(k), sExpectedType, sType), nLevel)

                    end)
                --If v.recipientName is not a string
                checkType(v.recipientName, "string",
                    function(gVar, sExpectedType, sType, nLevel)

                        error(string.format("Error processing entry %s, recipientName: Expected %s, got %s", tostring(k), sExpectedType, sType), nLevel)

                    end)
                --If v.recipientID is not a number
                checkType(v.recipientID, "number",
                    function(gVar, sExpectedType, sType, nLevel)

                        error(string.format("Error processing entry %s, recipientID: Expected %s, got %s", tostring(k), sExpectedType, sType), nLevel)

                    end)

                table.insert(tRecipients, {recipientName=v.recipientName, recipientID=v.recipientID})

            end

        else
            --Just treat tTemplatePacket as a regular packet
            table.insert(tRecipients, {recipientName=tTemplatePacket.recipientName, recipientID=tTemplatePacket.recipientID})

        end

        while true do
            --If there is something in the queue
            if #tQueue > 0 then

                for k, v in pairs(tRecipients) do
                    --In multi-mode we send the entire queue at once as a table, then clear the entire queue at once
                    if bMultiPacketMode then

                        tQueue.multiMode = true
                        upcallL(2, send, tTemplatePacket.senderType, v.recipientName,
                        v.recipientID, tTemplatePacket.dataType, tQueue)
                        clearTable(tQueue)

                    else
                        --In single-mode, we clear one entry at a time, sending its value as the packet data
                        upcallL(2, send, tTemplatePacket.senderType, v.recipientName,
                        v.recipientID, tTemplatePacket.dataType, table.remove(tQueue, 1))

                    end

                end

            end
            --In single packet mode, if this runs too fast, the receiver will glitch out. yield is too fast, so we use sleep to slow the loop down a little
            pcall(sleep, 0)

        end

    end
    --Runs the given function parallel to the queueReceiver. The function is called every time a new piece of data is received and is passed that piece of data as an argument
    function packetListener(func, tSamplePacket)

        checkType(func, "function", "standard_error")
        --The queue to receive our packets in
        local tQueue = {}

        parallel.waitForAny(

            function()

                upcallL(2, queueReceiver, tQueue, tSamplePacket)

            end,
            function()

                while true do

                    if #tQueue > 0 then
                        --Empty out the queue
                        while #tQueue > 0 do
                            --Call the function, passing it the value being removed from the queue. If the function returns false, end the loop
                            if not func(table.remove(tQueue, 1)) then

                                return

                            end

                        end

                    end

                    yield()

                end

            end

        )

    end
    --Runs the given function parallel to the queueSender. The queue is passed to the function as an argument, anything placed in the queue will be sent over rednet and deleted
    function packetSender(func, tTemplatePacket, bMultiPacketMode)

        checkType(func, "function", "standard_error")
        --The queue to send out packets from
        local tQueue = {}

        parallel.waitForAny(

            function()

                upcallL(2, queueSender, tQueue, tTemplatePacket, bMultiPacketMode)

            end,
            function()
                --The running loop must happen in this function
                func(tQueue)

            end

        )

    end
    --END PACKET API
    --[[TRoR API: This API allows a program to share screen output with other computers, or receive it from another computer. It allows events to be transferred between
    computers, and it allows them to be modified, both before and after being sent, and just before they are pulled. It allows the shell to be escaped and a function to be
    run in the top level coroutine. This is because the multishell will strip flags off of mouse click events. Three built in functions will run the shell, the multishell,
    and a modified version of the multishll which doesn't strip mouse click events: pastebin:kjKrUP41]]
    print("TRoR Term Redirect over Rednet 1.0")
    --Kills the current running shell, allowing the given function to run in the top level coroutine
    --TLCO: http://www.computercraft.info/forums2/index.php?/topic/22078-extremely-short-no-multishell-tlco-kills-multishell-runs-normal-shell-as-the-top-level-coroutine/
    function killShell(func, ...)

        checkType(func, "function", "standard_error")
        local tArgs = {...}
        --Store the original versions of the functions we'll be overriding
        local nativeShutdown = os.shutdown
        local nativeYield = coroutine.yield
        --This is called just before the bios exits, after the shell has died
        os.shutdown = function()
            --In theory, if this is true then a program (such as a custom operating system) tried to call shutdown. We need the shell to be completely dead before we can proceed
            if shell or multishell then

                error("Shell death", 0)

            end
            --We're ready to move on, set these variables back to their native values for normal operation
            os.shutdown = nativeShutdown
            coroutine.yield = nativeYield
            --Clean out any terms that anyone has set up
            term.redirect(term.native())
            --Make sure these are dead and gone
            multishell = nil
            shell = nil
            --This has to be reset or it won't run again
            os.unloadAPI("rom/apis/rednet")
            os.loadAPI("rom/apis/rednet")
            --Run the function
            ok, err = pcall(func, unpack(tArgs))

            if not ok then
                --Attempt to show the user any errors which may have occurred
                pcall(function()

                    term.redirect(term.native())
                    printError(err)
                    print("Press any key to continue...")
                    os.pullEventRaw("key")

                end)

            end
            --The bios won't attempt another shutdown, so we will. This also allows the shell to be killed again, the overridden shutdown will be called here
            os.shutdown()

        end
        --When whatever program is currently running tries to yield or pull an event, this will crash it. This will eventually crash the shell, which will return control
        --to the bios, where our overridden shutdown function will be called
        coroutine.yield = function(...) error("Shell death", 0) end
        --Begin the chaos
        error("Shell death", 0)

    end
    --Creates a startup file which runs a set of specified commands. If a startup file already exists, it will be moved by this function, then moved back by the new startup
    local function replaceStartup(tArgs)
        --Collection of commands for the new shell to run
        local tConverted = {}
        --A single command being formed
        local tCommand = {}
        --Adds a command to the collection and clears it from the working variable
        local function addCommand()

            if #tCommand > 0 then

                table.insert(tConverted, tCommand)
                tCommand = {}

            end

        end

        for k, v in pairs(tArgs) do
            --If it's a table, convert everything in it to a string.
            if checkType(v, "table") then
                --Add whatever command was previously being built; we're now working on a new command
                addCommand()

                for ke, va in pairs(v) do

                    table.insert(tCommand, tostring(va))

                end

            else

                addCommand()
                --Convert whatever else v is into a string, we'll try to run it anyway
                table.insert(tCommand, tostring(v))

            end
            --Add whatever we've got left
            addCommand()

        end
        --If there are no commands to run, we don't need to override the startup
        if #tConverted < 1 then

            return

        end
        --In case the default name already exists for some reason, we'll find a name which doesn't exist
        local sStartupRelocation

        if fs.exists("startup") then

            local sName = ".startup"
            local nAttemptCount = 1
            local sStartupRelocation = sName
            --We'll check for ".startup" first, then ".startup2", ".startup3", etc.
            while fs.exists(sStartupRelocation) do

                nAttemptCount = nAttemptCount + 1
                --".startup[attempt count]"
                sStartupRelocation = sName .. nAttemptCount

            end

        end

        local sStartup = string.format(

            [[
                --The serialized converted commands, these will just be a normal table when it is loaded
                local tCommands = %s
                --The startup location, or nil if there was no startup
                local sStartupLocation = %s
                local bRunStartup
                --We need to make sure this happens as soon as possible, we don't want to leave a mess if we crash or the user reboots the computer
                fs.delete("startup")
                --If there was a startup here before, move it back in place
                if sStartupLocation then

                    fs.move(sStartupLocation, "startup")

                end

                if multishell then
                    --On the multishell, we run everything in its own tab all at once
                    for k, v in pairs(tCommands) do

                        --The last command, or only command if there is only one, will be run in the main shell tab
                        if next(tCommands, k) then

                            shell.openTab(unpack(v))

                        else

                            shell.run(unpack(v))

                        end

                    end

                else
                    --On the shell, we run everything in the order it was provided, one at a time
                    for k, v in pairs(tCommands) do

                        shell.run(unpack(v))

                    end

                end

            ]],

            textutils.serialize(tConverted),
            tostring(sStartupRelocation)

        )
        --If there is already a startup, move it out of the way
        if sStartupRelocation then

            fs.move("startup", sStartupRelocation)

        end
        --Write our new startup in the actual startup file
        local tFile = fs.open("startup", "w")
        tFile.write(sStartup)
        tFile.close()

    end
    --Clears the screen and prints a message in yellow or white text, depending on if the term is color or not respectively
    local function printStartupMessage(sMessage)
        --User yellow for advanced computers, and white for regular computers
        if term.isColor() then

            term.setTextColor(colors.yellow)

        else

            term.setTextColor(colors.white)

        end
        --Background should always be black
        term.setBackgroundColor(colors.black)
        --Clear the screen
        term.clear()
        term.setCursorPos(1, 1)
        print(sMessage)
        term.setTextColor(colors.white)

    end
    --Designed to be passed to killShell as the func argument. Runs the regular shell. This is one of the two functions which may be run to fix mouse click modification
    function runShell(...)

        replaceStartup({...})
        --Display the running mode
        printStartupMessage("Regular shell")
        --Start the shell and rednet coroutines
        parallel.waitForAny(

            function()

                os.run({}, "rom/programs/shell")

            end,
            function()

                rednet.run()

            end

        )

    end
    --Designed to be passed to killShell as the func argument. Runs the multishell. This program will break mouse click modification
    function runMultishell(...)
        --Same as runShell, but running the multishell program instead
        replaceStartup({...})
        printStartupMessage("Regular multishell")

        parallel.waitForAny(

            function()

                os.run({}, "rom/programs/advanced/multishell")

            end,
            function()

                rednet.run()

            end

        )

    end
    --Runs a modified version of the multishell which doesn't strip the flags off of mouse click events.
    function clickSafeMultishell()
        --The new program will be stored in this string
        local sNewMultiShell = ""
        --Simple convenience function for adding to the program
        local function add(sText) sNewMultiShell = sNewMultiShell.."\n".. sText end
        --This goes after the function definitions, before the multishell starts running
        local sPreStart = [[
            multishell.isClickSafe = true
            local function copyEvent(tEventData)
                local tEventCopy = {}
                local k = next(tEventData)
                while k do
                    tEventCopy[k] = tEventData[k]
                    k = next(tEventData, k)
                end
                return tEventCopy
            end
        ]]
        --This replaces the portion of the running loop which handles click events. Rather than extracting the data normally found in a click event and passing that on, it
        --copies the whole event, modifies it as needed, and then passes the copy with all its parts intact to the process
        local sClickEvent = [[
            -- 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
                tEventCopy = copyEvent(tEventData)
                tEventCopy[4] = (bShowMenu and y-1) or y
                resumeProcess( nCurrentProcess, table.unpack(tEventCopy) )
                if cullProcess( nCurrentProcess ) then
                    setMenuVisible( #tProcesses >= 2 )
                    redrawMenu()
                end
            end

        elseif sEvent == "mouse_drag" or sEvent == "mouse_up" 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
                tEventCopy = copyEvent(tEventData)
                tEventCopy[4] = (bShowMenu and y-1) or y
                resumeProcess( nCurrentProcess, table.unpack(tEventCopy) )
                if cullProcess( nCurrentProcess ) then
                    setMenuVisible( #tProcesses >= 2 )
                    redrawMenu()
                end
            end

        ]]
        --This is basically a copy of os.run, except in runs strings instead of files
        local function run(tEnv, sFunc, sName, ...)
            --Prints an error message if it isn't nil and isn't an empty string
            local function perr(sErr) if sErr and sErr ~= "" then printError(sErr) end end
            local tEnv_ = tEnv
            --Use the global environment as our index
            setmetatable(tEnv_, {__index=_G})
            --Attempt to load the string
            local func, err = load(sFunc, sName, "t", tEnv_)

            if func then
                --If it loaded, run it
                ok, err = pcall(func, ...)

                if not ok then
                    --Print out anything that goes wrong and return false
                    perr(err)

                    return false

                end
                --If everything went okay, return true
                return true

            end

            perr(err)

            return false

        end

        local bAddLines = true
        local tFile = fs.open("rom/programs/advanced/multishell", "r")
        --This can only happen if the function is used on a non-advanced computer
        checkType(tFile, "table", function(gVar, gExpectedType, gType, nLevel) error("Multishell not found", nLevel) end, 1)

        repeat

            local sLine = tFile.readLine()
            --This is the start of the running loop
            if sLine == "-- Begin" then

                add(sPreStart)
                add(sLine)
                --This is the start of the click event handler. We stop adding lines after this until we reach the "else" statement, which marks the end of the click handler
            elseif sLine == "    elseif sEvent == \"mouse_click\" then" then

                bAddLines = false
                add(sLine)
                add(sClickEvent)
                --This is the end of the click event handler. Start adding lines again
            elseif sLine == "    else" then

                bAddLines = true
                add(sLine)

            else
                --If we're not in the click event handler portion, add the line
                if bAddLines and sLine ~= nil then add(sLine) end

            end
            --Until there are no more lines to read
        until sLine == nil

        return run({}, sNewMultiShell, "ModdedMultiShell")

    end
    --Designed to be passed to killShell as the func argument. Runs the multishell in the top level coroutine. This is one of the two functions which may be run to fix mouse
    --click modification
    function runClickSafeMultishell(...)

        replaceStartup({...})
        printStartupMessage("Click safe multishell")

        parallel.waitForAny(

            function()

                clickSafeMultishell()

            end,
            function()

                rednet.run()

            end

        )

    end
    --Receives terminal commands from a remote computer and draws them on this computers screen
    function receiveScreen(tSamplePacket)

        local tSamplePacket = tSamplePacket or {}
        checkType(tSamplePacket, "table", "standard_error")
        --Create a new packet listener
        upcallL(2, packetListener, function(tCommand)
                --Make sure this is at least an empty table
                tCommand.args = tCommand.args or {}
                --The sender terminated, so we will too
                if tCommand.command == "exit" then

                    return false

                end
                --The term commands are the names of the function, so get the function and call it with the args table as its arguments
                term[tCommand.command](unpack(tCommand.args))
                --Tell the packet listener to keep running
                return true

            end,
            asPacketData(
                --We can use all the tests from the sample packet, except the data type must be "termCommand", and the data must be a table
                tSamplePacket.senderType,
                tSamplePacket.senderName,
                tSamplePacket.senderID,
                tSamplePacket.recipientName,
                tSamplePacket.recipientID,
                "termCommand",
                function(mData) return checkType(mData, "table") end

            )
        )

    end
    --Sends terminal commands over rednet to be drawn by a remote computer
    function sendScreen(func, tTemplatePacket, bMultiPacketMode)

        checkType(func, "function", "standard_error")
        checkType(tTemplatePacket, "table", "standard_error")

        upcallL(2, packetSender, function(tQueue)

                local tNewTerm = {}
                --These functions do not need to be sent
                local tReturnOnly = {

                    ["getCursorPos"] = true,
                    ["isColor"] = true,
                    ["isColour"] = true,
                    ["getSize"] = true,
                    ["getTextColor"] = true,
                    ["getBackgroundColor"] = true,
                    ["getTextColour"] = true,
                    ["getBackgroundColour"] = true,

                }

                local tParentTerm

                for k, v in pairs(term.native()) do

                    local sName = k

                    tNewTerm[k] = (tReturnOnly[k] and function()
                        --Return only functions are just called and their return values are returned
                        return tParentTerm[sName]()

                    end)
                        or function(...)
                            --Other functions are called, but not returned, and their name and arguments are sent as a command to any receiving computer
                            tParentTerm[sName](...)
                            table.insert(tQueue, {command=sName, args={...}})

                        end

                end

                tParentTerm = term.redirect(tNewTerm)
                --Resets the term to what it was before we got to it
                term.resetTerm = function()

                    term.redirect(tParentTerm)
                    term.resetTerm = nil

                end
                --Set the remote term(s) cursor position
                term.setCursorPos(term.getCursorPos())
                --We'll let the function error, but not yet
                ok, err = pcall(func, tQueue)
                --Send the exit command
                table.insert(tQueue, {command="exit"})
                --Wait for any remain queued commands to be sent
                while #tQueue > 0 do yield() end
                --Reset the term if someone hasn't already
                if term.resetTerm then

                    term.resetTerm()

                end
                --Now let the error be raised
                if not ok then

                    error(err, 0)

                end

            end,
            asPacketDataS(

                tTemplatePacket.senderType,
                tTemplatePacket.recipientName,
                tTemplatePacket.recipientID,
                "termCommand"

            ), bMultiPacketMode
        )

    end
    --Receives events and queues them. A table containing functions which receive a table containing an event and return a table containing a modified version may be
    --provided. These may return the event as is, modify it as needed, or return nil to cancel the event
    function receiveEvents(func, tSamplePacket, tEventModifiers)
        --Default function just queues any even it receives
        local func = func or function(tEvent) os.queueEvent(unpack(tEvent)) return true end
        local tSamplePacket = tSamplePacket or {}
        local tEventModifiers = tEventModifiers or {}
        checkType(func, "function", "standard_error")
        checkType(tSamplePacket, "table", "standard_error")
        checkType(tEventModifiers, "table", "standard_error")

        for k, v in pairs(tEventModifiers) do

            checkType(v, "function", function(gVar, gExpectedType, gType, nLevel) error("All elements in the tEventModifiers table must be functions", nLevel) end)

        end

        local nativePullEvent = os.pullEventRaw

        os.pullEventRaw = function(...)

            while true do
                --Get a copy of the event
                local tEvent = copyTable({nativePullEvent(...)})
                --If there is a modification function, set the event to its call with the first copy as its arguments
                if tEventModifiers[tEvent[1]] then

                    tEvent = tEventModifiers[tEvent[1]](tEvent)

                end

                --If the modifications function returned something other than a table, usually nil, we assume it wants us to void this event and wait for another one
                if checkType(tEvent, "table") then

                    return unpack(tEvent)

                end

            end

        end
        --Resets os.pullEventRaw to what it was before we got to it
        os.resetOsTable = function()

            os.pullEventRaw = nativePullEvent
            os.resetOsTable = nil

        end

        ok, err = nil

        upcallL(2, packetListener, function(tEvent)

                ok, err = pcall(func, tEvent)

                if ok then

                    return err

                end

                return false

            end,
            asPacketData(

                tSamplePacket.senderType,
                tSamplePacket.senderName,
                tSamplePacket.senderID,
                tSamplePacket.recipientName,
                tSamplePacket.recipientID,
                "remoteEvent",
                function(mData) return checkType(mData, "table") end

            )
        )
        --Reset the os table if someone hasn't already
        if os.resetOsTable then

            os.resetOsTable()

        end

        if not ok then

            error(err, 0)

        end

    end
    --Sends events to a remote computer. A table containing functions which receive a table containing an event and return a table containing a modified version may be
    --provided. These may return the event as is, modify it as needed, or return nil to cancel the event
    function sendEvents(tTemplatePacket, tEventModifiers, bMultiPacketMode)

        tEventModifiers = tEventModifiers or {}
        checkType(tTemplatePacket, "table", "standard_error")
        checkType(tEventModifiers, "table", "standard_error")

        upcallL(2, packetSender, function(tQueue)

                while true do

                    local tEvent = copyTable({os.pullEventRaw()})

                    if tEventModifiers[tEvent[1]] then

                        tEvent = tEventModifiers[tEvent[1]](tEvent)

                    end

                    if checkType(tEvent, "table") then

                        table.insert(tQueue, tEvent)

                    end

                end

            end,
            asPacketDataS(

                tTemplatePacket.senderType,
                tTemplatePacket.recipientName,
                tTemplatePacket.recipientID,
                "remoteEvent"

            ), bMultiPacketMode
        )

    end
    --Tests if an event table contains the EventModified flag
    local function eventModified(tEvent)

        for k, v in pairs(tEvent) do

            if v == "EventModified" then

                return true

            end

        end

        return false

    end
    --This function returns nil on any even which hasn't been modified, but just returns the event otherwise. The return result will always be nil, which will make the event
    --it processes void. This may be used as an event modifier
    function eventVoider(tEvent)

        if eventModified(tEvent) then

            return tEvent

        end

    end
    --When called, this creates a function which swaps out the name of the event for whatever the specified new name is. The return value may be used as an event modifier
    function createEventSwapper(sNewName, ...)

        local tArgs = {...}

        return function(tEvent)

            if not eventModified(tEvent) then

                tEvent[1] = sNewName

                for k, v in pairs(tArgs) do

                    table.insert(tEvent, v)

                end

            end

            return tEvent

        end

    end
    --END TRoR API
    for k, v in pairs(rs.getSides()) do

        pcall(rednet.open, v)

    end

    if not rednet.isOpen() then

        error("No modem connected, please connect a modem to this computer")

    end

    if not os.getComputerLabel() then

        error("Computer label not set")

    end

    tArgs = {}
    sUsages = [[
Usage:
    teachutils -help [flag name]
    teachutils -student
    teachutils -broadScreen -all/(-names [student name(s)])
    teachutils -sync -all/(-names [student name(s)] -args) (-allowedit)
    teachutils -setEditable true/false
    teachutils -force -all/(-names [student name(s)] -args) -runProgram [name] ([args])/-shutdown/-reboot/-terminate
    teachutils -list
    teachutils -sendMessage -all/(-names [student name(s)] -args) -args [message]
]]
    --teachutils -FTP -all/(-names [student name(s)] -args) [flag: see -help] ([args]...)
    tHelp = {

        ["-help"] = "displays information about the specified flag",--Asking what a flag does as you use that flag
        ["-student"] = "runs student mode, this program can not be terminated by the host computer",
        ["-broadScreen"] = "causes all student computers to display a realtime, uneditable version of your screen, also clears your screen",
        ["-sync"] = "shows you the target student screen(s), you can control it from your terminal or allow them to from theirs",
        ["-force"] = "forces the target student computer(s) to take the speicified action",
        ["-list"] = "shows a list of all running, in range student computers",
        --[[["-FTP"] = "performs the specified FTP action, all writes will overwrite any existing files, transfering multiple files of the "..
        "same name will cause the files to be broken up into directories named after the computer they were transfered from, "..
        "not specifying a desination name for a transfer will result in the FTP using the origin name, -delete [file name] deletes "..
        "a file/directory on the specified student computer(s), -mkdir [file name] creates a new directory on the specified student computer(s), "..
        "-upload [local file name] ([remote file name]) uploads a file/directory to the specified student computer(s), "..
        "-download [remote file name] ([local file name]) downloads a file/directory from the specified student computer(s), "..
        "-list ([file name]) lists the current working dir, or the specified directory on the specified student computer(s), "..
        "-cd [file name] changes the shell's current working directory on the specified student computer(s)",]]
        ["-sendMessage"] = "sends a message to the target student computer(s)",
        ["-setEditable"] = "sets whether or not the current computer can be controlled by the user"

    }
    bRun = true
    tPacket = {}
    tTeacher = {}
    tSendableFuncs = {

        rollCallResponder=[[

            send(

                "student",
                tTeacher.name,
                tTeacher.ID,
                "string",
                "rollReponse"

            )

        ]],

        messagePrinter=[[

            printMessage("%s", "%s", %d, %d)

        ]],

        screenReceiver=[[

            printMessage("Screen Sharer", "Starting screen share with "..tTeacher.name.."...", colors.green, colors.lightBlue)
            sleep(2)
            clear()

            receiveScreen(asPacketData(

                "teacher",
                nil,
                tTeacher.ID,
                nil,
                rednet.CHANNEL_BROADCAST

            ))

            if term.resetTerm then

                term.resetTerm()

            end

            clear()
            term.setCursorBlink(false)
            printMessage("Screen Sharer", "Screen share complete", colors.green, colors.lightBlue)

        ]],

        syncClient=[[

            printMessage("Screen Sharer", "Starting screen share with "..tTeacher.name.."...", colors.green, colors.lightBlue)
            sleep(4)
            clear()

            local bVoid = true

            local function cVoidEvent(tEvent)

                if bVoid

                    return eventVoider(tEvent)

                end

                return tEvent

            end

            parallel.waitForAny(

                function()

                    receiveEvents(

                        function(tEvent)

                            if tEvent[1] == "void_events" then

                                bVoid = tEvent[2]

                            end

                            os.queueEvent(unpack(tEvent))

                        end,
                        asPacketData(

                            "teacher",
                            nil,
                            teacher.ID

                        ),
                        {

                            ["remote_terminate"]=createEventSwapper("terminate", "EventModified"),
                            ["remote_key"]=createEventSwapper("key", "EventModified"),
                            ["remote_char"]=createEventSwapper("char", "EventModified"),
                            ["remote_key_up"]=createEventSwapper("key_up", "EventModified"),
                            ["remote_mouse_click"]=createEventSwapper("mouse_click", "EventModified"),
                            ["remote_mouse_up"]=createEventSwapper("mouse_up", "EventModified"),
                            ["remote_mouse_scroll"]=createEventSwapper("mouse_scroll", "EventModified"),
                            ["remote_mouse_drag"]=createEventSwapper("mouse_drag", "EventModified"),
                            ["terminate"]=cVoidEvent,
                            ["key"]=cVoidEvent,
                            ["char"]=.cVoidEvent,
                            ["key_up"]=cVoidEvent,
                            ["mouse_click"]=cVoidEvent,
                            ["mouse_up"]=cVoidEvent,
                            ["mouse_scroll"]=cVoidEvent,
                            ["mouse_drag"]=cVoidEvent

                        }

                    )

                end,
                function()

                    sendScreen(function()

                        if term.isColor() then

                            clickSafeMultishell()

                        else

                            shell.run("shell")

                        end

                    end,
                    tror.asPacketDataS(

                        "student",
                        teacher.name,
                        teacher.ID

                    ), true

                end

            )

        ]],

        ["-shutdown@force"]=[[

            printMessage("System", "Shutdown ordered by " .. tTeacher.name .. ", goodbye.", colors.green, colors.red)
            sleep(2)
            os.shutdown()

        ]],

        ["-reboot@force"]=[[

            printMessage("System", "Reboot ordered by " .. tTeacher.name .. ", goodbye.", colors.green, colors.red)
            sleep(2)
            os.reboot()

        ]],

        ["-terminate@force"]=[[

            printMessage("System", "Exit ordered by " .. tTeacher.name .. ", goodbye.", colors.green, colors.red)
            sleep(2)
            clear()
            bRun = false

        ]],

        ["-runProgram@force"]=[[

            tRun = textutils.unserialize("%s")
            printMessage("System", "Running %s, as ordered by " .. tTeacher.name .. "...", colors.green, colors.blue)
            sleep(2)
            shell.run(unpack(tRun))
            printMessage("System", "Execution complete.", colors.green, colors.blue)

        ]]

    }

    function printUsage()

        setTextColor(colors.lime)
        --print(sUsages)
        textutils.pagedPrint(sUsages, ({term.getSize()})[2] - 2)
        setTextColor(colors.white)

    end

    function studentArgumentsValid(tArgs)

        return #(tArgs.students) > 0 or tArgs.broadcast

    end

    function clear()

        term.clear()
        term.setCursorPos(1, 1)

    end

    function setTextColor(nColor)

        if term.isColor() then

            term.setTextColor(nColor)

            return true

        end

        return false

    end

    function setBackgroundColor(nColor)

        if term.isColor() then

            term.setBackgroundColor(nColor)

            return true

        end

        return false

    end

    function printMessage(sSender, sMessage, nSenderColor, nMessageColor)

        nCurrentTextColor = term.getTextColor()
        setTextColor(nSenderColor)
        write(sSender .. ">")
        setTextColor(nMessageColor)
        print(sMessage)
        setTextColor(nCurrentTextColor)

    end

    function sendFunction(sName, nTarget, sFunction)

        send("teacher",
            sName,
            nTarget,
            "function",
            sFunction)

    end

    function rollCall()

        tPacket = {}
        tPackets = {}
        sendFunction("all", rednet.CHANNEL_BROADCAST, tSendableFuncs.rollCallResponder)

        while tPacket.dataType ~= "blank" do

            tPacket = receive(.5)

            if tPacket.dataType ~= "blank" then

                tCopy = copyTable(tPacket)

                table.insert(tPackets, tCopy)

            end

        end

        tStudents = {}

        for k, v in pairs(tPackets) do

            if checkPacket(asPacketData("student",
                nil, nil, nil,
                os.getComputerID(),
                "string",
                "rollReponse"), v) then

                table.insert(tStudents, {name=v.senderName, ID=v.senderID})

            end

        end

        return tStudents

    end

    function parseArgs(tArgs)

        local tProcessedArgs = {superFlag=tostring(tArgs[1]), broadcast=false, superArgs={}, students={}, hasArgs=false, args={}}

        local tStudents
        i=2
        local bUseAll = false

        function getStudents()

            if tStudents == nil then

                tStudents = rollCall()

            end

            return tStudents

        end

        function getStudent(sName)

            for k, v in pairs(getStudents()) do

                if v.name == sName then return v end

            end

            printError("Ignoring non-existant student name: " ..  sName)

        end

        tProcessFuncs = {

            function()

                if tArgs[i] == "-all" or tArgs[i] == "-names" then

                    tProcessedArgs.broadcast = tArgs[i] == "-all"
                    i = i + 1

                    if tProcessedArgs.broadcast then

                        tProcessedArgs.students = getStudents()

                    end

                    return false

                end

                table.insert(tProcessedArgs.superArgs, tostring(tArgs[i]))
                i = i + 1

                return true

            end,

            function()

                if tProcessedArgs.broadcast then

                    return false

                end

                if tArgs[i] == "-args" then

                    i = i + 1

                    return false

                end

                table.insert(tProcessedArgs.students, getStudent(tostring(tArgs[i])))
                i = i + 1

                return true

            end,

            function()

                tProcessedArgs.hasArgs = true
                table.insert(tProcessedArgs.args, tostring(tArgs[i]))
                i = i + 1

                return true

            end

        }

        for k, v in pairs(tProcessFuncs) do

            while not (i > #tArgs) and v() do end

        end

        return tProcessedArgs

    end

    tFuncs = {

        ["-help"]=function()

            setTextColor(colors.green)

            if #(tArgs.superArgs) == 0 then

                printUsage()

                return

            end

            sFlag = tArgs.superArgs[1]

            textutils.pagedPrint(tHelp[sFlag] or "No such flag: " .. sFlag, ({term.getSize()})[2] - 2)

            setTextColor(colors.white)

        end,

        ["-student"]=function()

            sleep(1)
            clear()
            printMessage("teachutils 1.0 student mode", string.format("Welcome, %s!", os.getComputerLabel()), colors.green, colors.white)

            local err

            while bRun do

                ok, err = pcall(function()

                    if err ~= nil then

                        if string.find(err, "Terminated") == nil then

                            bRun = false

                            error(err)

                        end

                        printMessage("System", "You are not allowed to terminate this program.", colors.red, colors.red)

                    end

                    while bRun do

                        tPacket = receive()

                        if checkPacket(asPacketData("teacher",
                            nil, nil, nil,
                            function(nID) return nID == os.getComputerID() or nID == rednet.CHANNEL_BROADCAST end,
                            "function"), tPacket) then

                            tTeacher = {name=tPacket.senderName, ID=tPacket.senderID}
                            func, e = loadstring(tPacket.data)
                            func = func or function() printMessage("System", e, colors.red, colors.red) end
                            setfenv(func, getfenv())
                            ok2, err2 = pcall(func)

                            if not ok2 then

                                printMessage("System", err2, colors.red, colors.red)

                            end

                        end

                    end

                end)

            end

            if not ok then

                error(err)

            end

        end,

        ["-broadScreen"]=function()

            if not studentArgumentsValid(tArgs) then

                printUsage()

                return

            end

            print("Initializing...")

            for k, v in pairs(tArgs.students) do

                sendFunction(v.name, v.ID,
                tSendableFuncs.screenReceiver)

            end

            sleep(3)
            clear()
            sendScreen(function()

                    clickSafeMultishell()

                end,
                asPacketDataS(

                    "teacher",
                    "all",
                    rednet.CHANNEL_BROADCAST

                ), true
            )

            sleep(2)
            clear()
            print("Screen share stopped")

        end,

        ["-sync"]=function()

            if not term.isColor() then

                printError("Sync not supported")

            end

            if not studentArgumentsValid(tArgs) then

                printUsage()

                return

            end

            print("Initializing...")

            local bAllowEdit = false

            for k, v in pairs(tArgs.args) do

                if v == "-allowEdit" then

                    bAllowEdit = true

                end

            end

            for k, v in pairs(tArgs.students) do

                sendFunction(v.name, v.ID,
                tSendableFuncs.syncClient)

            end

            local tTabs = {}

            for k, v in pairs(tArgs.students) do

                local nID = shell.openTab(shell.getRunningProgram(), "~sync", textutils.serialize(v))
                table.insert(tTabs, nID)

            end

            sleep(5)

            if bAllowEdit then

                os.queueEvent("void_events", false)

            end

            clear()
            setTextColor(colors.blue)
            print("CONTROL SCREEN: TERMINATE THIS SCREEN TO TERMINATE ALL SCREENS")

            parallel.waitForAny(

                function()

                    os.pullEventRaw("terminate")

                end,
                function()

                    while #tTabs > 0 do

                        local tEvent = {os.pullEventRaw("sync_death")}
                        local nIndex

                        for k, v in pairs(tTabs) do

                            if v == tEvent[2] then

                                nIndex = k

                            end

                        end

                        if nIndex then

                            table.remove(tTabs, nIndex)

                        end

                    end

                end

            )

            os.queueEvent("*END TRANSMISSION*")

            sleep(2)
            clear()
            print("Sync stopped")

        end,

        ["~sync"]=function()

            local tStudent = textutils.unserializ(tArgs.superArgs[1])
            if not tStudent and tStudent.name and tStudent.ID then error("INVALID") end
            sendFunction(tStudent.name, tStudent.ID,
                tSendableFuncs.syncClient)
            parallel.waitForAny(

                function()

                    local tEventModifiers = {

                        ["terminate"]=createEventSwapper("remote_terminate"),
                        ["*END TRANSMISSION*"]=createEventSwapper("remote_terminate"),
                        ["key"]=createEventSwapper("remote_key"),
                        ["char"]=createEventSwapper("remote_char"),
                        ["key_up"]=createEventSwapper("remote_key_up"),
                        ["mouse_click"]=createEventSwapper("remote_mouse_click"),
                        ["mouse_up"]=createEventSwapper("remote_mouse_up"),
                        ["mouse_scroll"]=createEventSwapper("remote_mouse_scroll"),
                        ["mouse_drag"]=createEventSwapper("remote_mouse_drag")

                    }

                    setmetatable(tEventModifiers, {__index = function() return eventVoider end})

                    sendEvents(asPacketDataS(

                            "teacher",
                            tStudent.name,
                            tStudent.ID

                        ),
                        tEventModifiers, true)

                end,
                function()

                    receiveScreen(asPacketData(

                            "student",
                            nil,
                            tStudent.ID,
                            nil,
                            os.getComputerID()

                        ))

                end

            )

            os.queueEvent("sync_death", multishell.getCurrent())

        end,

        ["-setEditable"]=function()

            if #(tArgs.superArgs) < 0 then

                printUsage()

                return

            end

            if tArgs.superArgs[1] == "true" then

                os.queueEvent("void_events", true)

            elseif tArgs.superArgs[1] == "false" then

                os.queueEvent("void_events", false)

            else

                printUsage()

            end

        end,

        ["-force"]=function()

            if not studentArgumentsValid(tArgs) then

                printUsage()

                return

            end

            sFlag = table.remove(tArgs.args, 1)
            sFunc = tSendableFuncs[tostring(sFlag) .. "@force"]

            if not sFunc then

                printUsage()

                return

            end

            sRun = ""

            if sFlag == "-runProgram" then

                sRun = textutils.serialize(tArgs.args):gsub("\"", "\\\""):gsub("\n", " ")

                if sRun == "{}" then

                    printUsage()

                    return

                end

            end

            for k, v in pairs(tArgs.students) do

                sendFunction(v.name, v.ID,
                string.format(sFunc, sRun, tostring(tArgs.args[1])))

            end

        end,

        ["-list"]=function()

            tStudentList = rollCall()

            for k, v in pairs(tStudentList) do

                print(string.format("name: %s, ID: %s", v.name, v.ID))

            end

        end,

        ["-FTP"]=function()

            printError("NYI")

        end,

        ["-sendMessage"]=function()

            if not studentArgumentsValid(tArgs) or not tArgs.hasArgs then

                printUsage()

                return

            end

            sMessage = ""

            for k, v in pairs(tArgs.args) do

                sMessage = sMessage .. v .. " "

            end

            for k, v in pairs(tArgs.students) do

                sendFunction(v.name, v.ID,
                string.format(tSendableFuncs.messagePrinter,
                "(Teacher)" .. os.getComputerLabel(), sMessage,
                colors.lightBlue, colors.white))

            end

        end

    }

    tArgs = parseArgs({...})
    func = tFuncs[tArgs.superFlag] or function() printUsage() end
    func()

end

main(...)