install

local t={"CoolisOS",true,"CoolisOS/bin",true,"CoolisOS/bin/kernel",true,"CoolisOS/bin/kernel/compat.lua",[===================[--compat

local interface_events={
    'mouse_click',
    'mouse_scroll',
    'mouse_drag',
    'monitor_touch',
    'key',
    'char',
    }


--needs to determine the terminal in some other way.
local check=require'checker'.check

local compat={}
function compat.get_pullEventRaw(term_em,plat_em)
    return function (filter)
        check('?string',filter)
        local t=assert(sched.running)
        if not t._native then
            local pipe=sched.pipe()
            t._native=pipe
            local h=sched.sighook(function(em,ev,...)
                if plat_em and em==plat_em and interface_events[ev] then
                    return
                else
                    pipe:send{ev,...}
                end
            end)
            if plat_em then h:link(plat_em,'*') end
            if term_em then h:link{[term_em]=interface_events} end
        end
        local pipe=t._native
        repeat
            local r=pipe:receive()
        until (filter==nil or filter==r[1])
        return unpack(r)
    end
end

function compat.adapt_env(env,term_em,plat_em)
    env.os.pullEventRaw=compat.get_pullEventRaw(term_em,plat_em)
end


function compat.adapt_global(_Gnative)
    local Box=require'kernel.class.Box'

    local turtle=_Gnative.turtle
    if turtle then
        local waitForResponse=function(id)
            repeat
                local em,ev,rid,p1=sched.wait(sched.platform,'turtle_response')
                if em==sched.platform then
                    if id==rid then
                        return p1
                    end
                else return false,'timer' end
            until false
        end
        local native=turtle.native or turtle
        local turtle={}
        rawset(_Gnative,'turtle',turtle)
        turtle["getItemCount"] = native.getItemCount
        turtle["getItemSpace"] = native.getItemSpace
        turtle["getFuelLevel"] = native.getFuelLevel
        local function wrap( _sCommand )
            return function( ... )
                local id = _Gnative.debug and debug.wrap(native[_sCommand])(...) or native[_sCommand]( ... )
                if id == -1 then
                    return false
                end
                return waitForResponse( id )
            end
        end
        for k,v in pairs( native ) do
            if type( k ) == "string" and type( v ) == "function" then
                if turtle[k] == nil then
                    turtle[k] = wrap( k )
                end
            end
        end
        if peripheral.getType("left") == "workbench" then
            turtle["craft"] = function( ... )
                local id = peripheral.call( "left", "craft", ... )
                return waitForResponse( id )
            end
        elseif peripheral.getType("right") == "workbench" then
            turtle["craft"] = function( ... )
                local id = peripheral.call( "right", "craft", ... )
                return waitForResponse( id )
            end
        end

    end
    rednet.receive=function( nTimeout )
        local em,e, p1, p2, p3 = sched.wait(sched.platform,'rednet_message',nTimeout)
        if em==sched.platform then
            return p1, p2, p3
        else
            return
        end
    end


    local dyn_k={
    'term',
    'os',
    'shell',
    }
    local dyn_f={
    'write',
    'printError',
    'read',
    }
    for _,k in pairs(dyn_f) do
        rawset(_Gnative,k,function(...)
            local box=assert(Box.get_current(1))
            return box.env[k](...)
        end)
    end
    setmetatable(_Gnative,{
    __index=function(t,k)
        if k=='_BOX' then
            return Box.get_current(1)
        elseif dyn_k[k] then
            local box=assert(Box.get_current(1))
            return box.env[k]
        else return rawget(t,k) end
    end
    })

end

return compat]===================],"CoolisOS/bin/kernel/debug.lua",[===================[--debug
include'kernel.class'
local check=require'kernel.checker'.check
local debug={}

local function wrap(text, limit) --from Kingdaroo
        local lines = {''}
        for word, space in text:gmatch('(%S+)(%s*)') do
                local temp = lines[#lines] .. word .. space:gsub('\n','')
                if #temp > limit then
                        table.insert(lines, '')
                end
                if space:find('\n') then
                        lines[#lines] = lines[#lines] .. word

                        space = space:gsub('\n', function()
                                table.insert(lines, '')
                                return ''
                        end)
                else
                        lines[#lines] = lines[#lines] .. word .. space
                end
        end
        return lines
end

function debug.step_print(s,t)
    check('string,Terminal',s,t)
    local x,y=t.term:getSize()
    y=y-1
    local tt=wrap(s,x)
    local r=#tt%y
    local n=(#tt-r)/y
    for i=0,n-1 do
        if i~=0 then t:write('\n') end
        t:write(table.concat(tt,'\n',i*y+1,(i+1)*y))
        t:write('\nPress any key to continue')
        repeat until (t.pin:receive())[2]=='char'
        if i==n-1 then t:write('\n') end
    end
    t:write(table.concat(tt,'\n',n*y+1,n*y+r))
    t:write('\n')
end

function debug.printError(s,t)
    check('string,Terminal',s,t)
    if t.term:isColour() then
        t.term:setTextColour( colours.red )
    end
    debug.step_print(s,t)
    t.term:setTextColour( colours.white )
end

--debug.traceback
do
--[[ Notes:
getfenv(1)=getfenv()~=getfenv(0)~~_G
error('',1)~=error('',0)
]]
rawset(_G,'loadfile',function( _sFile )
  local file = fs.open( _sFile, "r" )
  if file then
    local func, err = loadstring( file.readAll(),_sFile)
    file.close()
    return func, err
  end
  return nil, "File not found"
end)
local traceback=function(level,terr,maxlevel)
  local terr=terr or {}
  local passed={}
  local err,ok=terr
  local j=2+(level or 0)
  repeat
    j=j+1
    passed[err]=true
    ok,err=pcall(error,'',j)
    --if err:match('^[^:]+')=='bios' then break end
    table.insert(terr,err)
  until (passed[err] or (maxlevel and (j+1-2>maxlevel) ) )

  return terr
end

local function classify(t,f)
  local bins={}
  local c
  for i,v in ipairs(t) do
    local fi,r=f(v)
    if fi~=nil then
      if c==nil or c.n~=fi then
        table.insert(bins,c)
        c={n=fi}
      end
      table.insert(c,r)
    end
  end
  table.insert(bins,c)
  return bins
end
local function get_chunks(terr)
  return classify(terr,function(v) return v:match('^([^:]+):(.*)') end)
end

local function get_lines(terr)
  return classify(terr,function(v) return v:match('^(%d+):(.*)') end)
end

local function put_lines(path,diameter,ts,l)
  local ok,f=pcall(fs.open,path,'r')
  if not ok or not f then table.insert(ts,'  (could not open file)')
  else
    for i=1,l-diameter-1 do
      f.readLine()
    end
    for i=1,diameter do
      table.insert(ts,'  '..f.readLine())
    end
    table.insert(ts,'->'..f.readLine())
    for i=1,diameter do
      local l=f.readLine()
      if l then table.insert(ts,'  '..l)
      else break end
    end
  end
end

local function format_traceback(terr)
  local ts={}
  for i,v in ipairs(get_chunks(terr)) do
    local name=v.n or '(no name)'
    local path
    if fs.exists(name) then
      name,dir,path=fs.getName(name),name:match('^(.*)/') or '/',name
      name=name..' ('..(dir or 'unknown')..')'
    elseif false then
      --shell has input string; modify to behave as file?
    end
    table.insert(ts,name)
    for j,line in ipairs(get_lines(v)) do
      table.insert(ts,' line '..(line.n or '(no line)')..', *'..(#line))
      local n=line.n and tonumber(line.n) or 1
      if path and n then
        put_lines(path,1,ts,n)
      end
    end
  end
  return ts
end

function debug.traceback(msg,level,maxlevel)
  local level=level or 0
  local ts=format_traceback(traceback(level+1,{},maxlevel))
  msg=(msg and '\n' or '')..'['..(msg or 'debug.traceback')
  table.insert(ts,1,msg)
  return table.concat(ts,'\n')..'\n]'
end

function debug.printTraceback(msg,level)
    debug.printError(debug.traceback(msg,(level or 0)+1))
end

function debug.tracebackError(msg,level)
    error(debug.traceback(msg,(level or 0)+1),2)
end
end
function debug.raw(t)
    if type(t)=='table' then
        local mt=getmetatable(t)
        if mt then
            local f=rawget(mt,'__tostring')
            rawset(mt,'__tostring',nil)
            local s=tostring(t)
            rawset(mt,'__tostring',f)
            return s
        else
            return tostring(t)
        end
    else
        return tostring(t)
    end
end
function debug.log(...)
    return log('debug','DEBUG','(%s):\nMsg:\n\t%s\nFrom:%s',sched.running or 'nil',debug.args_tostring(...),debug.traceback('',1,2))
end


function debug.objinfo(s)
    local name=debug.named[s]
    return (name and name..'|' or '')
        ..(typeof(s)=='object' and (classname(s) or debug.raw(s))..' instance|' or '')
        ..debug.raw(s) or ''
end


function debug.getinfo(v)
    if type(v)=='table' then
        return debug.objinfo(v)
    else
        return type(v)..':'..tostring(v)
    end
end
function debug.args_tostring(...)
    local args = {}
    local t = {...}
    for k = 1, table.maxn(t) do table.insert(args, (debug.getinfo)(t[k])) end
    return table.concat(args,',')
end
function debug.wrap(f,silent)
    return function(...)
        --wrapped level
        f=util.bindn(f,...)
        local r={xpcall(f,debug.traceback)}
        local ok=table.remove(r,1)
        if not ok then
            local er=r[1]
            if silent then return nil,er
            else error(er,2) end
        end
        return unpack(r)
    end
end

debug.named=setmetatable({},{__mode='kv'})
function debug.name(obj,name)
    debug.named[obj]=name
    return obj
end

function debug.namefield(self,k,v)
    v=v==nil and self[k] or v
    check('table,!nil,!nil',self,k,v)
    self[k]=v
    debug.name(v,('(%s).(%s)'):format(debug.getinfo(self),debug.getinfo(k)))
    return v
end

debug.say=function(s) return log('init','INFO','task:(%s) says:%s',tostring(sched.running),s) end

return debug]===================],"CoolisOS/bin/kernel/driver.lua",[===================[local driver={}

local peripheral=peripheral
function driver.update()
    for _, side in ipairs(rs.getSides()) do
        if peripheral.isPresent(side) then
            driver[side]=peripheral.wrap(side)
            -- sched.signal(peripheral,peripheral[side].getType(),side)
        else
            driver[side]=nil
        end
    end
end

return driver]===================],"CoolisOS/bin/kernel/init.lua",[===================[local path=shell.getRunningProgram()
local function override(f)
local t={}
local fo=printError
local key='printError'
local co=coroutine.status
local wrapped=function(s)
    coroutine.status=co
    for i,v in pairs(t) do
        rawset(v,key,fo)
    end
    local ok,err=pcall(f)
    if not ok then
        fo(err)
    end
    coroutine.yield()
    coroutine.yield()
end
for i=1,20 do
    local ok,err=pcall(getfenv,i)
    if ok then
        if rawget(err,key)~=nil and not t[err] then
            t[i]=err
            rawset(err,key,wrapped)
        end
    end
end
coroutine.status=nil
repeat
    os.pullEvent()
until false
end

local function fixes()
    local string=string
    local rawset, rawget,type=rawset, rawget,type
    local nativegetmetatable=getmetatable
    local s_meta=getfenv(('').sub)
    rawset(_G,'getmetatable',nil)
    local function getmetatable(t)
        if type(t)=='string' then
            return s_meta
        else
            return nativegetmetatable(t)
        end
    end
    rawset(_G,'getmetatable',getmetatable)

    local nativesetmetatable = setmetatable
    rawset(_G,'setmetatable',nil)
    local function setmetatable( _o, _t )
        if _t and type(_t) == "table" then
            local idx = rawget( _t, "__index" )
            local newidx=rawget( _t, "__newindex" )
            rawset(_t,"__index",nil)
            rawset(_t,"__newindex",nil)
            local r= nativesetmetatable( _o, _t )
            rawset(_t,"__index",idx)
            rawset(_t,"__newindex",newidx)
            local meta=getmetatable(_o)
            rawset(meta,"__index",idx)
            rawset(meta,"__newindex",newidx)
            return r
        else
            return nativesetmetatable( _o, _t )
        end
    end
    rawset(_G,'setmetatable',setmetatable)

    rawset(_G,'loadfile',function( _sFile )
        local file = fs.open( _sFile, "r" )
        if file then
            local func, err = loadstring( file.readAll(),_sFile)
            file.close()
            return func, err
        end
        return nil, "File not found"
    end)

end

local function start()
    debug.name(sched.running,'shell')
    --log.setLevel('sched','DEBUG')
    log.setLevel('DEBUG','debug')
    --log.setLevel('DEBUG','pipe')
    --log.setLevel('ALL')
    --log.store=require'kernel.log.store'
    --log.store.reset()
    --log.store.instant=true
    require'kernel.compat'.adapt_global(_G)
    local gui=require'kernel.gui'

    local terminal=gui.Terminal.from_native(_G.term,sched.platform)
    local shell=require'kernel.gui.shell'

    local Box=require'kernel.class.Box'
    Box{pin=terminal.pin,pout=terminal.pout,terminal=terminal}:run(
    function()
        local s=shell.new()
        s.run_startups()
    end)
    sched.wait('end')
end

local main=function()
    --save copy of old _G
    rawset(_G,'_Gstore',{
    old=(function()
        local c={}
        for i,v in pairs(_G) do
            c[i]=v
        end
        return c
    end)(),
    base=_G,
    base_env=getfenv(),
    })
    --overrides
    fixes()

    ---set install variables and module loading utilities
    do
    _FILE_PATH=path
    local loc=(_FILE_PATH:match'(.*)bin/kernel/init%.lua'):sub(1,-2)
    rawset(_G,'_INSTALL_PATH',loc)
    rawset(_G,'loadreq',dofile(fs.combine(_INSTALL_PATH,'bin/kernel/loadreq/init.lua')))
    rawset(_G,'require',loadreq.require)
    rawset(_G,'include',loadreq.include)
    loadreq.vars.paths=loadreq.vars.paths:gsub('%?',fs.combine(_INSTALL_PATH,'bin')..'/%?')..';'..loadreq.vars.paths..';'..loadreq.vars.paths:gsub('%?',_INSTALL_PATH..'/%?')
    end

    ---load modules
    do
    local function G(k,v)
        rawset(_G,k,v)
    end
    G('util',require'kernel.util')
    G('log',require'kernel.log')

    do
    local serpent=require'utils.serpent'
    G('pstring',function(this,max_level) return serpent.serialize(this,{debug=true,indent = '  ', sortkeys = true, comment = true,maxlevel=max_level}) end)
    G('pprint',function(this,max_level)
            debug.step_print(pstring(this),getfenv(2).term)
        end)
    G('debug',require'kernel.debug')
    G('log',require'kernel.log')
    G('sched',require'kernel.sched')

    G('net',require'kernel.net')
    for i,v in pairs(require'kernel.class') do
        G(i,v)
    end
    end


    --overrided to os
    do
    os.sleep(0)
    local o_os=os
    local check=require'kernel.checker'.check
    local os=util.shcopy(o_os)
    local function wrap(f,i,e)
        return function(...)
            local ir,fr=nil,nil
            if i then ir={i(...)} end
            fr={f(...)}
            if e then e(fr,ir) end
            return unpack(fr)
        end
    end
    os.version=function()
        return 'CoolisOS.1'
    end
    os.sleep=function(n)
        if sched.running then
            check('number',n) sched.wait(n)
        else return o_os.sleep(n) end
    end
    rawset(_G,'sleep',os.sleep)
    rawset(_G,'os',os)
    end
    end

    sched.task(function()
        debug.wrap(start)()
    end):run()

    sched.loop()
    log.store.flush()
    print'Press any key to shutdown'
    sleep(2)
    os.pullEvent'key'
    os.shutdown()
end

override(function()
    local ok,er=xpcall(main,function(msg,level)
        if _G.debug then
            return _G.debug.traceback(msg)
        else
            return msg
        end
    end)
    if not ok then
        if log then
            log('init','ERROR','%s',er)
            error(er)
        end
    end
end)]===================],"CoolisOS/bin/kernel/net.lua",[===================[local string_mt=getfenv(('').len)
local net=string_mt.__net or {}
string_mt.__net=net
net.ids=net.ids or setmetatable({},{__mode='v'})
local ids=net.ids
local id=os.getComputerID()
ids[id]=_G

net.queueEvent=function(id,...)
    if net.ids[id] then
        ok,err=pcall(net.ids[id].os.queueEvent,...)
        if not ok then
            net.ids[id]=nil
            return
        end
        return true
    end
end
net.queueAll=function(...)
    local t={}
    for id in pairs(net.ids) do
        t[id]=net.queueEvent(id,...)
    end
    return t
end
net.rednet={
send=function(id,msg)
    return net.queueEvent(id,'rednet_message',os.getComputerID(),msg,nil)
end,
broadcast=function(id,msg)
    return net.queueAll('rednet_message',os.getComputerID(),msg,nil)
end,
}
return net]===================],"CoolisOS/bin/kernel/util.lua",[===================[--- ## Moses: <em>A utility-belt library for functional programming in Lua.</em><br/>
-- @author Roland_Yonaba
-- @copyright 2012
-- @license [MIT](http://www.opensource.org/licenses/mit-license.php)
-- @script moses
-- Internalisation
local error,pcall=error,pcall
local next, type, unpack, select = next, type, unpack, select
local setmetatable, getmetatable = setmetatable, getmetatable
local t_insert, t_sort = table.insert, table.sort
local t_remove,t_concat = table.remove, table.concat
local randomseed, random, huge = math.randomseed, math.random, math.huge
local floor, max, min = math.floor, math.max, math.min
local getfenv = getfenv
local unpack = unpack
local pairs,ipairs = pairs,ipairs
local _ = {}


-- ======== Private helpers

local function f_max(a,b) return a>b end
local function f_min(a,b) return a<b end
local function clamp(var,a,b) return (var<a) and a or (var>b and b or var) end
local function isTrue(_,value) return value and true end
local function iNot(value) return not value end
local function count(t)
    local i
    for k,v in pairs(t) do i = (i or 0) + 1 end
    return i
end
local function extract(list,comp,transform,...)
  local _ans
  local transform = transform or _.identity
  for index,value in pairs(list) do
    if not _ans then _ans = transform(value,...)
    else
      local value = transform(value,...)
      _ans = comp(_ans,value) and _ans or value
    end
  end
  return _ans
end

-- Internal counter for unique ids generation
local unique_id_counter = -1
-- ========= Math utilities
function _.format_number(n,r)     local e=10^r     local b=n%1     local a=n-b     local c=b*e     local c=c-c%1     return a+c/e end


-- ========= Filesystem utilities
function _.with(handle,f,...)
  local ok, err=pcall(f,handle,...)
  if handle and handle.close then handle:close() end
  if not ok then error('util.with:'..err,2) end
  return ok,err
end
-- ========== Table utilities
function _.set(t,...)
    local arg={...}
    local t,n=t,#arg
    for i=1,(n-2) do
        t[arg[i]]=t[arg[i]] or {}
        t=t[arg[i]]
    end
    t[arg[n-1]]=arg[n]
end

function _.get(t,...)
    local arg={...}
    for i=1,#arg do
        t=t[arg[i]]
        if t==nil then return nil end
    end
end

function _.delete(t,...)
    local arg={...}
    local n=#arg
    for i=1,n-1 do
        t=t[arg[i]]
        if t==nil then return nil end
    end
    t[arg[n]]=nil
end

function _.map_args(t,f,...)
    local args = {}
    for k = 1, table.maxn(t) do table.insert(args,f(t[k],...)) end
    return args
end


-- ========= Scheduler utilities
function _.wait(f,match,...)
    local r,b
    repeat
        r={f(...)}
        b=true
        for i,v in pairs(match) do
            if r[i]~=nil and r[i]~=v then
                b=false
                break
            end
        end
    until b
    return r
end


-- ========= Table functions
--------------------------------------------------------------------------------
---nils a table of arbitrary keys/values
-- @function [parent=#utils.table] tnil
-- @param table to nil
function _.tnil(t)
    local del=next(t)
    if del then
        for i,v in next,t,del do
            t[del]=nil
            del=i
        end
        t[del]=nil
    end
end
function _.shcopy(src, dst)
    dst = dst or {}
    for k, v in pairs(src) do
        dst[k]=v
    end
    return dst
end
--------------------------------------------------------------------------------
-- Copies a table from the source to destination table.
--
-- The copy is recursive.
--
-- @function [parent=#utils.table] copy
-- @param src a table to be used as the source of the copy.
-- @param dst a table to be used as the destination of the copy.
-- @param overwrite boolean value, to enable overwrite of existing field in dst table.
-- @return the resulting dst table.
--
local _copy
_copy=function(passed,src, dst, overwrite)
    dst = dst or {}
    passed[src]=dst
    for k, v in pairs(src) do
        if type(v) == 'table' then -- recursively go into tables
            if passed[v] then
                dst[k]=passed[v]
            else
                if not (type(dst[k]) == 'table') and (overwrite or dst[k]==nil) then
                    dst[k] = {}
                end
                _copy(passed,v, dst[k], overwrite)
            end
        elseif overwrite or dst[k]==nil then dst[k] = v end
    end

    return dst
end
_.copy=function(...) return _copy({},...) end
--------------------------------------------------------------------------------
-- Produces a diff of two tables.
--
-- Recursive diff by default.
--
-- @function [parent=#utils.table] diff
-- @param t1 first table to compare.
-- @param t2 second table to compare.
-- @param norecurse boolean value to disable recursive diff.
-- @return the diff result as a table.
-- @usage
--> t1 = { a = 1, b=3, c = "foo"}
--> t2 = { a = 1, b=3, c = "foo"}
--> :diff(t1, t2)
--= {  }
--> t1 = { a = 1, b=3, c = "foo"}
--> t2 = { a = 1, b=4, c = "foo"}
--> :diff(t1, t2)
--= { "b" }
--> t1 = { a = 1, b=3, c = "foo"}
--> t2 = { a = 1, b=3}
--> :diff(t1, t2)
--= { "c" }
--> t1 = { b=3, c = "foo", d="bar"}
--> t2 = { a = 1, b=3, c = "foo"}
--> :diff(t1, t2)
--= {
--   "a",
--   "d" }
--

function _.diff(t1, t2, norecurse)
    local d = {}
    local t3 = {}

    local rpairs = norecurse and pairs or _.recursivepairs
    for k, v in rpairs(t1) do t3[k] = v end
    for k, v in rpairs(t2) do
        if v ~= t3[k] then table.insert(d, k) end
        t3[k] = nil
    end

    for k, v in pairs(t3) do table.insert(d, k) end

    return d
end

--- Iterators
-- @section It

--------------------------------------------------------------------------------
-- Iterator that iterates on the table in key ascending order.
--
-- @function [parent=#utils.table] sortedPairs
-- @param t table to iterate.
-- @return iterator function.
--

function _.sortedpairs(t)
    local a = {}
    local insert = table.insert
    for n in pairs(t) do insert(a, n) end
    table.sort(a)
    local i = 0
    return function()
        i = i + 1
        return a[i], t[a[i]]
    end
end

--------------------------------------------------------------------------------
-- Iterator that returns key/value pairs except walking through sub tables and concatenating the path in the key.
--
-- This iterator break cycles: it does not recur. If it detects a cycle, the entry causing a cycle is ignored.
-- However, if a table is repeated, its contents will be repeated by this function.
--
-- @function [parent=#utils.table] recursivePairs
-- @param t table to iterate.
-- @param prefix path prefix to prepend to the key path returned.
-- @return iterator function.
-- @usage {toto={titi=1, tutu=2}, tata = 3, tonton={4, 5}} will iterate through
-- ("toto.titi",1), ("toto.tutu",2), ("tata",3) ("tonton.1", 4), ("tonton.2"=5)
--

function _.recursivepairs(t, prefix)
    check('table,?|string',t, prefix)
    local function it(t, prefix, cp)
        cp[t] = true
        local pp = prefix == "" and prefix or "."
        for k, v in pairs(t) do
            k = pp..tostring(k)
            if type(v) == 'table' then
                if not cp[v] then it(v, prefix..k, cp) end
            else
                coroutine.yield(prefix..k, v)
            end
        end
        cp[t] = nil
    end

    prefix = prefix or ""
    return coroutine.wrap(function() it(t, cleanpath(prefix), {}) end)
end

--------------------------------------------------------------------------------
-- Iterator that returns key/value on multiple tables.
--
-- @function [parent=#utils.map] multiPairs
-- Tables are traversed in the same order as they are passed as parameters.
-- @param t1 first table to traverse.
-- @param ... additional tables to traverse.
-- @return iterator function.
--

function _.multipairs(t1, ...)
    local state = { tables = {t1, ...}, i=1, k=next(t1) }
    local function f()
        if not state.i then return end
        local current_table = state.tables[state.i]
        local k, v = state.k, current_table[state.k]
        local next_k = next(current_table, k)
        while next_k==nil do
            state.i = state.i+1
            local next_table = state.tables [state.i]
            if not next_table then state.i=false; break
            else next_k = next (next_table) end
        end
        state.k = next_k
        return k, current_table[k]
    end
    return f, nil, nil
end

-- ========= Collection functions

--- Calls function `f` on each key-value of a given collection. <br/><em>Aliased as @{forEach}</em>.
-- @name each
-- @tparam table list a collection
-- @tparam function f an iterator function, prototyped as `f(key,value,...)`
-- @tparam[opt] var_arg ... Optional extra-args to be passed to function `f`
-- @see forEach
function _.each(list, f, ...)
  if not _.isObject(list) then return end
  for index,value in pairs(list) do
    f(index,value,...)
  end
  return list
end

--- Alias for @{each}.
-- @function forEach
-- @param list
-- @param f
-- @param[opt] ...
_.forEach = _.each

--- Maps function `f` on each key-value of a given collection. Collects
-- and returns the outputs.<br/><em>Aliased as @{collect}</em>.
-- @name map
-- @tparam table list a collection
-- @tparam function f  an iterator function, prototyped as `f(key,value,...)`
-- @tparam[opt] var_arg ... Optional extra-args to be passed to function `f`
-- @treturn table a table of results
-- @see collect
function _.map(list, f, ...)
  local _list = {}
  for index,value in pairs(list) do
    _list[index] = f(index,value,...)
  end
  return _list
end

--- Alias for @{map}.
-- @function collect
-- @param list
-- @param f
-- @param[opt] ...
_.collect = _.map

--- Reduces an entire collection. Folds from left to right to a single value,
-- with respect to a given iterator and an initial state.
-- The given function takes a state and a value, and returns a new state.
-- <br/><em>Aliased as @{inject}, @{foldl}</em>.
-- @name reduce
-- @tparam table list a collection
-- @tparam function f an iterator function, prototyped as `f(state,value)`
-- @tparam[opt] state state an initial state of reduction. Defaults to the first value in the list.
-- @treturn state state a final state of reduction
-- @see inject
-- @see foldl
function _.reduce(list,f,state)
  for _,value in pairs(list) do
    state = not state and value or f(state,value)
  end
  return state
end

--- Alias for @{reduce}.
-- @function inject
-- @param list
-- @param f
-- @param[opt] state
_.inject = _.reduce

--- Alias for @{reduce}.
-- @function foldl
-- @param list
-- @param f
-- @param[opt] state
_.foldl = _.reduce

--- Reduces an entire collection. Folds from right to left to a single value,
-- with respect to a given iterator and an initial state.
-- The given function takes a state and a value, and returns a new state.
-- <br/><em>Aliased as @{injectr}, @{foldr}</em>.
-- @name reduceRight
-- @tparam table list a collection
-- @tparam function f an iterator function, prototyped as `f(state,value)`
-- @tparam[opt] state state an initial state of reduction. Defaults to the last value in the list.
-- @treturn state state a final state of reduction
-- @see injectr
-- @see foldr
function _.reduceRight(list,f,state)
  return _.reduce(_.reverse(list),f,state)
end

--- Alias for @{reduceRight}.
-- @function injectr
-- @param list
-- @param f
-- @param[opt] state
_.injectr = _.reduceRight

--- Alias for @{reduceRight}.
-- @function foldr
-- @param list
-- @param f
-- @param[opt] state
_.foldr = _.reduceRight

--- Reduces a collection while saving intermediate states.
-- Folds the collection from left to right to a single value,
-- with respect to a given iterator and an initial state.
-- The given function takes a state and a value, and returns a new state.
-- The function returns an array of intermediate states.
-- <br/><em>Aliased as @{mapr}</em>
-- @name mapReduce
-- @tparam table list a collection
-- @tparam function f an iterator function, prototyped as `f(state,value)`
-- @tparam[opt] state state an initial state of reduction. Defaults to the last value in the list.
-- @treturn table an array of states
-- @see mapr
function _.mapReduce(list,f,state)
  local t = {}
  for i,value in pairs(list) do
    t[i] = not state and value or f(state,value)
    state = t[i]
  end
  return t
end

--- Alias for @{mapReduce}.
-- @function mapr
-- @param list
-- @param f
-- @param[opt] state
_.mapr = _.mapReduce

--- Reduces a collection while saving intermediate states. It proceeds in reverse order,
-- folding the collection from right to left to a single value,
-- with respect to a given iterator and an initial state.
-- The given function takes a state and a value, and returns a new state.
-- The function returns an array of intermediate states.
-- <br/><em>Aliased as @{maprr}</em>
-- @name mapReduceRight
-- @tparam table list a collection
-- @tparam function f an iterator function, prototyped as `f(state,value)`
-- @tparam[opt] state state an initial state of reduction. Defaults to the last value in the list.
-- @treturn table an array of states
-- @see maprr
function _.mapReduceRight(list,f,state)
  return _.mapReduce(_.reverse(list),f,state)
end

--- Alias for @{mapReduceRight}.
-- @function maprr
-- @param list
-- @param f
-- @param[opt] state
_.maprr = _.mapReduceRight

--- Looks for an object in a collection. <br/><em>Aliased as @{any}, @{some}</em>
-- @name include
-- @tparam table list a collection
-- @tparam object item a value to be searched
-- @treturn boolean a boolean : __true__ when found, __false__ otherwise
-- @see any
-- @see some
function _.include(list,item)
  local _iter = _.isFunction(item) and item or _.isEqual
  for _,value in pairs(list) do
    if _iter(value,item) then return true end
  end
  return false
end

--- Alias for @{include}.
-- @function any
-- @param list
-- @param item
_.any = _.include

--- Alias for @{include}.
-- @function some
-- @param list
-- @param item
_.some = _.include

--- Looks for an object index in a collection. <br/><em>Aliased as @{where}, @{find}</em>
-- @name detect
-- @tparam table list a collection
-- @tparam object item a value to be searched
-- @treturn key the object key or __nil__
-- @see find
-- @see where
function _.detect(list,item)
  local _iter = _.isFunction(item) and item or _.isEqual
  for key,arg in pairs(list) do
    if _iter(arg,item) then return key end
  end
end

--- Alias for @{detect}.
-- @function find
-- @param list
-- @param item
_.find = _.detect

--- Alias for @{detect}.
-- @function where
-- @param list
-- @param item
_.where = _.detect

--- Selects and extracts objects passing an iterator test.
-- <br/><em>Aliased as @{filter}</em>
-- @name select
-- @tparam table list a collection
-- @tparam function f an iterator function, prototyped as `f(key,value,...)`
-- @tparam[opt] var_arg ... Optional extra-args to be passed to function `f`
-- @treturn table the selected objects
-- @see filter
function _.select(list,f,...)
  local _mapped = _.map(list,f,...)
  local _list = {}
  for index,value in pairs(_mapped) do
    if value then _list[#_list+1] = list[index] end
  end
  return _list
end

--- Alias for @{select}.
-- @function filter
-- @param list
-- @param f
-- @param[opt] ...
_.filter = _.select

--- Clones a collection, rejecting objects passing an iterator test.
-- <br/><em>Aliased as @{discard}</em>
-- @name reject
-- @tparam table list a collection
-- @tparam function f an iterator function, prototyped as `f(key,value,...)`
-- @tparam[opt] var_arg ... Optional extra-args to be passed to function `f`
-- @treturn table the remaining objects
-- @see discard
function _.reject(list,f,...)
  local _mapped = _.map(list,f,...)
  local _list = {}
  for index,value in pairs (_mapped) do
    if not value then _list[#_list+1] = list[index] end
  end
  return _list
end

--- Alias for @{reject}.
-- @function discard
-- @param list
-- @param f
-- @param[opt] ...
_.discard = _.reject

--- Tests if all objects in a collection passes an iterator test. <br/><em>Aliased as @{every}</em>
-- @name all
-- @tparam table list a collection
-- @tparam function f an iterator function, prototyped as `f(key,value,...)`
-- @tparam[opt] var_arg ... Optional extra-args to be passed to function `f`
-- @treturn boolean __true__ or __false__
-- @see every
function _.all(list,f,...)
  return ((#_.select(_.map(list,f,...), isTrue)) == (#list))
end

--- Alias for @{all}.
-- @function every
-- @param list
-- @param f
-- @param[opt] ...
_.every = _.all

--- Invokes a method on each object in a collection.
-- @name invoke
-- @tparam table list a collection
-- @tparam function method a function, prototyped as `f(object,...)`
-- @tparam[opt] var_arg ... Optional extra-args to be passed to function `method`
-- @treturn table an array of results
function _.invoke(list,method,...)
  local args = {...}
  return _.map(list, function(__,v)
        if _.isObject(v) then
            if _.has(v,method) then
                if _.isCallable(v[method]) then
                    return v[method](v,unpack(args))
                else return v[method]
                end
            else
                if _.isCallable(method) then
                    return method(v,unpack(args))
                end
            end
        elseif _.isCallable(method) then
            return method(v,unpack(args))
        end
    end)
end

--- Extracts property-values from a collection of objects.
-- @name pluck
-- @tparam table list a collection
-- @tparam string a property, to index in each object: `object[property]`
-- @treturn table an array of values for the specified property
function _.pluck(list,property)
  return _.reject(_.map(list,function(__,value)
      return value[property]
    end),
  iNot)
end

--- Returns the maximum value in a collection. If an iterator is passed, it will
-- be used to extract the property value by which all objects will be ranked.
-- @name max
-- @tparam table list a collection
-- @tparam[opt] function iter an iterator function, prototyped as `iter(value,...)`, defaults to @{identity}
-- @tparam[optchain] var_arg ... Optional extra-args to be passed to function `iter`
-- @treturn value the maximum property value found
function _.max(list,iter,...)
  return extract(list,f_max,iter,...)
end

--- Returns the minimum value in a collection. If an iterator is passed, it will
-- be used to extract the property value by which all objects will be ranked.
-- @name min
-- @tparam table list a collection
-- @tparam[opt] function iter an iterator function, prototyped as `iter(value,...)`, defaults to @{identity}
-- @tparam[optchain] var_arg ... Optional extra-args to be passed to function `iter`
-- @treturn value the minimum property value found
function _.min(list, iter,...)
  return extract(list,f_min, iter,...)
end

--- Returns a shuffled copy of a given collection. If a seed is provided, it will
-- be used to init the random number generator.
-- @name shuffle
-- @tparam table list a collection
-- @tparam[opt] number seed a seed
-- @treturn table a shuffled copy of the given collection
function _.shuffle(list,seed)
  if seed then randomseed(seed) end
  local _shuffled = {}
  _.each(list,function(index,value)
           local randPos = floor(random()*index)+1
          _shuffled[index] = _shuffled[randPos]
          _shuffled[randPos] = value
        end)
  return _shuffled
end

--- Tests if two collections are the same. I.e, they feature the same objects, but not
-- necessarily at the same keys
-- @name same
-- @tparam table a a collection
-- @tparam table b a collection
-- @treturn boolean __true__ or __false__
function _.same(a,b)
  return _.all(a, function (i,v)
            return _.include(b,v)
        end)
    and _.all(b, function (i,v)
            return _.include(a,v)
        end)
end

--- Sorts a collection. If a comparison function is given, it will be used to sort objects
-- @name sort
-- @tparam table list a collection
-- @tparam[opt] function comp a comparison function prototyped as `comp(a,b)`, defaults to <tt><</tt> operator.
-- @treturn table the given list, sorted.
function _.sort(list,comp)
  t_sort(list,comp)
  return list
end

--- Converts a list of __var_args__ to a collection.
-- @name toArray
-- @tparam[opt] var_arg ... Optional variable number of arguments
-- @treturn table an array of all passed-in args
function _.toArray(...)
  return {...}
end

--- Splits a collection into subsets. Each subset feature objects grouped by the result of passing it through an iterator.
-- If iterator is a string instead of a function, groups by the property named by iterator on each of the values.
-- @name groupBy
-- @tparam table list a collection
-- @tparam function iter an iterator function, prototyped as `iter(key,value,...)`
-- @tparam[opt] var_arg ... Optional extra-args to be passed to function `iter`
-- @treturn table a new collection with items grouped by subsets
function _.groupBy(list,iter,...)
  local var_arg = {...}
  local _list = {}
  local _iter = _.isFunction(iter) and iter
    or (_.isString(iter) and function(_,item)
        return item[iter](item,unpack(var_arg))
      end)
  if not _iter then return end
  _.each(list, function(i,v)
      local _key = _iter(i,v)
      if _list[_key] then _list[_key][#_list[_key]+1] = v
      else _list[_key] = {v}
      end
    end)
  return _list
end

--- Groups objects in a collection and counts them.
-- @name countBy
-- @tparam table list a collection
-- @tparam function iter an iterator function, prototyped as `iter(key,value,...)`
-- @tparam[opt] var_arg ... Optional extra-args to be passed to function `iter`
-- @treturn table a new collection with subsets names and count
function _.countBy(list,iter,...)
  local var_arg = {...}
    local stats = {}
    _.each(list,function(i,v)
            local key = iter(i,v,unpack(var_arg))
            stats[key] = (stats[key] or 0) +1
        end)
    return stats
end

--- Counts the number of values in a collection. If being passed more than one args
-- it will return the number of passed-in args.
-- @name size
-- @tparam[opt] var_arg ... Optional variable number of arguments
-- @treturn number a size
function _.size(...)
  local args = {...}
  local arg1 = args[1]
  if _.isNil(arg1) then
    return 0
  elseif _.isObject(arg1) then
    return count(args[1])
  else
    return count(args)
  end
end

--- Checks if all the keys of `other` object exists in a `list`. It does not
-- compares values. The test is not commutative, i.e `list` may contains keys
-- not existing in `other`.
-- @name containsKeys
-- @tparam table list a collection
-- @tparam table other a collection
-- @treturn boolean __true__ or __false__
function _.containsKeys(list,other)
  for key in pairs(other) do
    if not list[key] then return false end
  end
  return true
end

--- Checks if both given lists have the same keys. It does not compares values.
-- @name sameKeys
-- @tparam table listA a collection
-- @tparam table listB a collection
-- @treturn boolean __true__ or __false__
function _.sameKeys(listA,listB)
  _.each(listA,function(key)
      if not listB[key] then return false end
     end)
  _.each(listB,function(key)
      if not listA[key] then return false end
     end)
  return true
end

-- ========= Array functions

--- Reverses values in a given array. The passed-in array should not be sparse.
-- @name reverse
-- @tparam table array an array
-- @treturn table a copy of the given array, reversed
function _.reverse(array)
  local _array = {}
  for i = #array,1,-1 do
    _array[#_array+1] = array[i]
  end
  return _array
end

--- Collects values from a given array. The passed-in array should not be sparse.
-- This function collects values as long as they satisfy a given predicate.
-- Therefore, it returns on the first false test.
-- <br/><em>Aliased as @{takeWhile}</em>
-- @name selectWhile
-- @tparam table array an array
-- @tparam function f an iterator function prototyped as `f(key,value,...)`
-- @tparam[opt] var_arg ... Optional extra-args to be passed to function `f`
-- @treturn table a new table containing the first truthy values collected
-- @see takeWhile
function _.selectWhile(array,f,...)
  local t = {}
  for i,v in ipairs(array) do
    if f(i,v,...) then t[i] = v else break end
  end
  return t
end

--- Alias for @{selectWhile}.
-- @function takeWhile
-- @param array
-- @param f
-- @param[opt] ...
_.takeWhile = _.selectWhile

--- Collects values from a given array. The passed-in array should not be sparse.
-- This function collects values as soon as they do not satisfy a given predicate.
-- Therefore it returns on the first true test.
-- <br/><em>Aliased as @{rejectWhile}</em>
-- @name dropWhile
-- @tparam table array an array
-- @tparam function f an iterator function prototyped as `f(key,value,...)`
-- @tparam[opt] var_arg ... Optional extra-args to be passed to function `f`
-- @treturn table a new table containing the first falsy values collected
-- @see rejectWhile
function _.dropWhile(array, f,...)
  local _i
  for i,v in ipairs(array) do
    if not f(i,v,...) then
      _i = i
      break
    end
  end
  if _.isNil(_i) then return {} end
  return _.rest(array,_i)
end

--- Alias for @{dropWhile}.
-- @function rejectWhile
-- @param array
-- @param f
-- @param[opt] ...
_.rejectWhile = _.dropWhile

--- Returns the index at which a value should be inserted. This returned index is determined so that it maintains the sort.
-- If a comparison function is passed, it will be used to determine the sort ranking of each
-- value, including the passed-in value.
-- @name sortedIndex
-- @tparam table array an array
-- @tparam value the value to be inserted
-- @tparam[opt] function comp an comparison function prototyped as `f(a,b)`, defaults to <tt><</tt> operator
-- @tparam[optchain] boolean sort whether or not to sort the passed-in array
-- @treturn index the index at which the passed-in value should be inserted
function _.sortedIndex(array,value,comp,sort)
  local _comp = comp or f_min
  if sort then _.sort(array,_comp) end
  for i = 1,#array do
    if not _comp(array[i],value) then return i end
  end
  return #array+1
end

--- Returns the index of the given value in an array. If the passed-in value exists
-- more than once in the array, it will return the index of the first occurence.
-- @name indexOf
-- @tparam table array an array
-- @tparam value the value to be searched
-- @treturn index the index of the passed-in value or __nil__
function _.indexOf(array, value)
  for k = 1,#array do
    if array[k] == value then return k end
  end
end

--- Returns the last occurence index of a given value.
-- @name lastIndexOf
-- @tparam table array an array
-- @tparam value the value to be searched
-- @treturn index the index of the last occurence of the passed-in value or __nil__
function _.lastIndexOf(array,value)
  local key = _.indexOf(_.reverse(array),value)
  if key then return #array-key+1 end
end

--- Adds all passed-in values at the top of an array. The latter args will come the
-- first in the given array.
-- @name add
-- @tparam table array an array
-- @tparam var_arg ... a variable number of arguments
-- @treturn table the passed-in array
function _.add(array,...)
  _.each({...},function(i,v) t_insert(array,1,v) end)
  return array
end

--- Pushes all passed-in values at the end of an array.
-- @name push
-- @tparam table array an array
-- @tparam var_arg ... a variable number of arguments
-- @treturn table the passed-in array
function _.push(array,...)
  _.each({...}, function(i,v) array[#array+1] = v end)
  return array
end

--- Removes and returns the value at the top of a given array.
-- <br/><em>Aliased as @{shift}</em>
-- @name pop
-- @tparam table array an array
-- @treturn value the popped value
-- @see shift
function _.pop(array)
  local retValue = array[1]
  t_remove(array,1)
  return retValue
end

--- Alias for @{pop}.
-- @function shift
-- @param array
_.shift = _.pop

--- Removes and returns the value at the end of a given array.
-- @name unshift
-- @tparam table array an array
-- @treturn value the popped value
function _.unshift(array)
  local retValue = array[#array]
  t_remove(array)
  return retValue
end

--- Trims all values indexed within the range `[start,finish]`.
-- <br/><em>Aliased as @{rmRange}</em>
-- @name removeRange
-- @tparam table array an array
-- @tparam[opt] index start the lower bound index, defaults to the first index in the array.
-- @tparam[optchain] index finish the upper bound index, defaults to the array length.
-- @treturn table the passed-in array
-- @see rmRange
function _.removeRange(array,start,finish)
  local array = _.clone(array)
  local i,n = (next(array)),#array
  if n < 1 then return array end

  start = clamp(start or i,i,n)
  finish = clamp(finish or n,i,n)

  if finish < start then return array end

  local count = finish - start + 1
  local i = start
  while count > 0 do
    t_remove(array,i)
    count = count - 1
  end
  return array
end

--- Alias for @{removeRange}.
-- @function rmRange
-- @param array
-- @param[opt] start
-- @param[optchain] finish
_.rmRange = _.removeRange

--- Slices values indexed within `[start,finish]` range.
-- @name slice
-- @tparam table array an array
-- @tparam[opt] index start the lower bound index, defaults to the first index in the array.
-- @tparam[optchain] index finish the upper bound index, defaults to the array length.
-- @treturn table a new array
function _.slice(array,start,finish)
  return _.select(array, function(index)
      return (index >= (start or next(array)) and index <= (finish or #array))
    end)
end

--- Returns the first N values in an array. <br/><em>Aliased as @{head}, @{take}</em>
-- @name first
-- @tparam table array an array
-- @tparam[opt] number n the number of values to be collected, defaults to 1.
-- @treturn table a new array
-- @see head
-- @see take
function _.first(array,n)
  local n = n or 1
  return _.slice(array,1, min(n,#array))
end

--- Alias for @{first}.
-- @function head
-- @param array
-- @param[opt] n
_.head = _.first

--- Alias for @{first}.
-- @function take
-- @param array
-- @param[opt] n
_.take = _.first

--- Returns all values in an array excluding the last N values.
-- @name initial
-- @tparam table array an array
-- @tparam[opt] number n the number of values to be left, defaults to the array length.
-- @treturn table a new array
function _.initial(array,n)
  if n and n < 0 then return end
  return _.slice(array,1, n and #array-(min(n,#array)) or #array-1)
end

--- Returns the last N values in an array.
-- @name last
-- @tparam table array an array
-- @tparam[opt] number n the number of values to be collected, defaults to the array length.
-- @treturn table a new array
function _.last(array,n)
  if n and n <= 0 then return end
  return _.slice(array,n and #array-min(n-1,#array-1) or 2,#array)
end

--- Trims all values before index. <br/><em>Aliased as @{tail}</em>
-- @name rest
-- @tparam table array an array
-- @tparam[opt] index index an index, defaults to 1
-- @treturn table a new array
-- @see tail
function _.rest(array,index)
  if index and index > #array then return {} end
  return _.slice(array,index and max(1,min(index,#array)) or 1,#array)
end

--- Alias for @{rest}.
-- @function tail
-- @param array
-- @param[opt] index
_.tail = _.rest

--- Trims all falsy values.
-- @name compact
-- @tparam table array an array
-- @treturn table a new array
function _.compact(array)
  return _.reject(array, function (_,value)
        return not value
    end)
end

--- Flattens a nested array. Passing `shallow` will only flatten at the first single level.
-- @name flatten
-- @tparam table array an array
-- @tparam[opt] boolean shallow specifies the flattening depth
-- @treturn table a new array, flattened
function _.flatten(array, shallow)
  local shallow = shallow or false
  local new_flattened
  local _flat = {}
  for key,value in pairs(array) do
    if _.isObject(value) and not shallow then
      new_flattened = _.flatten (value)
      _.each(new_flattened, function(_,item) _flat[#_flat+1] = item end)
    else _flat[#_flat+1] = value
    end
  end
  return _flat
end

--- Returns values from an array not present in all passed-in args. <br/><em>Aliased as @{without}</em>
-- @name difference
-- @tparam table array an array
-- @tparam var_arg ... a variable number of arguments
-- @treturn table a new array
-- @see without
function _.difference(array,...)
  local values = _.toArray(...)
  return _.select(array,function(i,value)
      return not _.include(values,value)
    end)
end

--- Alias for @{difference}.
-- @function without
-- @param array
-- @param ...
_.without = _.difference

--- Produces a duplicate-free version of a given array. Passing `isSorted` will
-- provide a much faster version, but will produce the desired result if the array
-- is properly sorted. If `iter` is passed, it will be used to compute new values based on
-- a transformation.
-- <br/><em>Aliased as @{unique}</em>
-- @name uniq
-- @tparam table array an array
-- @tparam[opt] boolean isSorted whether or not the passed-in array is already sorted, defaults to `false`
-- @tparam[optchain] function iter an iterator function prototyped as `iter(key,value,...)`
-- @tparam[optchain] var_arg ... Optional extra-args to be passed to `iter` function
-- @treturn table a new array
-- @see unique
function _.uniq(array,isSorted,iter,...)
  local init = iter and _.map(array,iter,...) or array
  local result = {}
  if not isSorted then
    for __,v in ipairs(init) do
      if not _.include(result,v) then
        result[#result+1] = v
        end
    end
  return result
  end

  result[#result+1] = init[1]
  for i = 2,#init do
    if init[i] ~= result[#result] then
        result[#result+1] = init[i]
    end
  end
  return result
end

--- Alias for @{uniq}.
-- @function unique
-- @param array
-- @param[opt] isSorted
-- @param[optchain] iter
-- @param[optchain] ...
_.unique = _.uniq

--- Returns the duplicate-free union of all passed in arrays.
-- @name union
-- @tparam var_arg ... a variable number of arrays arguments
-- @treturn table a new array
function _.union(...)
  return _.uniq(_.flatten({...}))
end

--- Returns the  intersection of all passed-in arrays.
-- Each value in the result is present in each of the passed-in arrays.
-- @name intersection
-- @tparam table array an array
-- @tparam var_arg ... a variable number of array arguments
-- @treturn table a new array
function _.intersection(array,...)
  local arg = {...}
  local _intersect = {}
  for i,value in ipairs(array) do
    if _.all(arg,function(i,v)
          return _.include(v,value)
        end) then
      t_insert(_intersect,value)
    end
  end
  return _intersect
end

--- Merges values of each of the passed-in arrays in subsets.
-- Only values at the same position in the initial array are merged.
-- @name zip
-- @tparam var_arg ... a variable number of array arguments
-- @treturn table a new array
function _.zip(...)
  local arg = {...}
  local _len = _.max(_.map(arg,function(i,v)
      return #v
    end))
  local _ans = {}
  for i = 1,_len do
    _ans[i] = _.pluck(arg,i)
  end
  return _ans
end

--- Clones `array` and appends `other` to the result.
-- @name append
-- @tparam table array an array
-- @tparam table other an array
-- @treturn table a new array
function _.append(array,other)
  local t = {}
  for i,v in ipairs(array) do t[i] = v end
  for i,v in ipairs(other) do t[#t+1] = v end
  return t
end

--- Produce a flexible list of numbers. If one positive value is passed, will count from 0 to that value,
-- with a default step of 1. If two values were passed, will count from the first one to the second one, with the
-- same default step of 1. A third passed value will be considered a step value.
-- <br/><em>Aliased as @{count}</em>
-- @name range
-- @tparam var_arg ... a variable list of numbers
-- @treturn table a new array of numbers
-- @see count
function _.range(...)
  local arg = {...}
  local _start,_stop,_step
  if #arg==0 then return {}
  elseif #arg==1 then _stop,_start,_step = arg[1],0,1
  elseif #arg==2 then _start,_stop,_step = arg[1],arg[2],1
  elseif #arg == 3 then _start,_stop,_step = arg[1],arg[2],arg[3]
  end
  if (_step and _step==0) then return {} end
  local _ranged = {}
  local _steps = max(floor((_stop-_start)/_step),0)
  for i=1,_steps do _ranged[#_ranged+1] = _start+_step*i end
  if #_ranged>0 then t_insert(_ranged,1,_start) end
  return _ranged
end

--- Alias for @{range}.
-- @function count
-- @param ...
_.count = _.range

--- Inverts `key-value` pairs. Keys becomes values, while values becomes keys.
-- <br/><em>Aliased as @{mirror}</em>
-- @name invert
-- @tparam table array a given array
-- @treturn table a new array
-- @see mirror
function _.invert(array)
  local _ret = {}
  _.each(array,function(i,v) _ret[v] = i end)
  return _ret
end

--- Alias for @{invert}.
-- @function mirror
-- @param array
_.mirror = _.invert

--- Concatenates values in a given array. Handles booleans as well. If `sep` string is
-- passed, it will be used as a separator. Optional `i` and `j` will only concatenate
-- values within `[i,j]` range. <br/><em>Aliased as @{join}</em>
-- @name concat
-- @tparam table array a given array
-- @tparam[opt] string sep a separator string, defaults to `''`.
-- @tparam[optchain] number i the starting index, defaults to 1.
-- @tparam[optchain] number j the final index, defaults to the array length.
-- @treturn string a string
-- @see join
function _.concat(array,sep,i,j)
  local _array = _.map(array,function(i,v)
        return tostring(v)
    end)
    return t_concat(_array,sep,i,j)

end

--- Alias for @{concat}.
-- @function join
-- @param array
-- @param[opt] sep
-- @param[optchain] i
-- @param[optchain] j
_.join = _.concat

-- ========= Utility functions

--- Returns the passed-in value. Used internally as a default iterator.
-- @name identity
-- @tparam arg value a value
-- @treturn arg the passed-in value
function _.identity(...)
  return ...
end

--- Returns a version of `f` that runs only once. Successive calls will make `f`
-- keep yielding the same answer, no matter what the passed-in arguments are. Can be used to
-- init variables as well.
-- @name once
-- @tparam function f a function
-- @treturn function a new function
function _.once(f)
  local _internal = 0
  local _args = {}
  return function(...)
      _internal = _internal+1
      if _internal<=1 then _args = {...} end
      return f(unpack(_args))
    end
end

--- Memoizes a given function by caching the computed result.
-- Useful for speeding up slow-running functions. If function `hash` is passed,
-- it will be used to compute unique keys from args passed to `hash` for results caching.
-- <br/><em>Aliased as @{cache}</em>
-- @name memoize
-- @tparam function f a function
-- @tparam[opt] function hash a hash function, defaults to @{identity}
-- @treturn function a new function
-- @see cache
function _.memoize(f,hash)
  local _cache = setmetatable({},{__mode = 'kv'})
  local _hasher = hash or _.identity
  return function (...)
      local _hashKey = _hasher(...)
      local _result = _cache[_hashKey]
      if not _result then _cache[_hashKey] = f(...) end
      return _cache[_hashKey]
    end
end

--- Alias for @{memoize}.
-- @function cache
-- @param f
-- @param[opt] hash
_.cache = _.memoize

--- Returns a version of `f` that runs on the `count-th` call.
-- Useful when dealing with asynchronous tasks.
-- @name after
-- @tparam function f a function
-- @tparam number count the number of calls before `f` answers
-- @treturn function a new function
function _.after(f,count)
  local _limit,_internal = count, 0
  return function(...)
      _internal = _internal+1
      if _internal >= _limit then return f(...) end
    end
end

--- Composes functions. Each passed-in function consumes the return value of the function that follows.
-- In math terms, composing the functions `f`, `g`, and `h` produces `f(g(h(...)))`.
-- @name compose
-- @tparam var_arg ... a variable number of functions
-- @treturn function a new function
function _.compose(...)
  local f = _.reverse {...}
  return function (...)
      local _temp
      for i,func in pairs(f) do
        _temp = _temp and func(_temp) or func(...)
      end
      return _temp
    end
end

--- Wraps `f` inside of the `wrapper` function. It passes `f` as the first argument to `wrapper`.
-- This allows the wrapper to execute code before and after `f` runs,
-- adjust the arguments, and execute it conditionally.
-- @name wrap
-- @tparam function f a function to be wrapped, prototyped as `f(...)`
-- @tparam function wrapper a wrapper function, prototyped as `wrapper(f,...)`
-- @treturn function a new function
function _.wrap(f,wrapper)
    return function (...)
      return  wrapper(f,...)
    end
end

--- Runs `iter` function `n` times.
-- Collects the results of each run and returns them in an array.
-- @name times
-- @tparam number n the number of times `iter` should be called
-- @tparam function iter an iterator function, prototyped as `iter(i,...)`
-- @tparam var_arg ... extra-args to be passed to `iter` function
-- @treturn table an array of results
function _.times(n,iter,...)
  local results = {}
  for i = 1,n do
    results[i] = iter(i,...)
  end
  return results
end

--- Binds `v` to be the first argument to function `f`. As a result,
-- calling `f(...)` will result to `f(v,...)`.
-- @name bind
-- @tparam function f a function
-- @tparam arg v an argument
-- @treturn function a function, prototyped as `f(v,...)`
function _.bind(f,v)
  return function (...)
      return f(v,...)
    end
end

--- Binds `...` to be the N-first arguments to function `f`. As a result,
-- calling `f(a1,a2,...,aN)` will result to `f(...,a1,a2,...,aN)`.
-- @name bindn
-- @tparam function f a function
-- @tparam var_arg ... a variable numer of arguments
-- @treturn function a function, prototyped as `f(v,...)`
function _.bindn(f,...)
  local iArg = {...}
  return function (...)
      return f(unpack(_.append(iArg,{...})))
    end
end

--- Generates a unique Id (unique for the current session). If given a sring `template`
-- will use this template for output formatting. Otherwise, if `template` is a function,
-- will compute an output running `template(id,...)`.
-- <br/><em>Aliased as @{uId}</em>.
-- @name uniqueId
-- @tparam[opt] string|function template either a string or a function
-- @tparam[optchain] var_arg ... a variable numer of arguments to be passed to `template`, in case it is a function.
-- @treturn id a formatted Id
-- @see uId
function _.uniqueId(template,...)
    unique_id_counter = unique_id_counter + 1
    if template then
        if _.isString(template) then
            return template:format(unique_id_counter)
        elseif _.isFunction(template) then
            return template(unique_id_counter,...)
        end
    end
    return unique_id_counter
end

--- Alias for @{uniqueId}.
-- @function uId
-- @param[opt] template
-- @param[optchain] ...
_.uId = _.uniqueId

-- ========= Object functions

--- Returns the names of the object properties.
-- @name keys
-- @tparam table obj an object
-- @treturn table an array
function _.keys(obj)
  local _oKeys = {}
  _.each(obj,function(key,_) _oKeys[#_oKeys+1]=key end)
  return _oKeys
end

--- Returns the values of the object properties.
-- @name values
-- @tparam table obj an object
-- @treturn table an array
function _.values(obj)
  local _oValues = {}
  _.each(obj,function(_,value) _oValues[#_oValues+1]=value end)
  return _oValues
end

--- Returns an array of `obj` key-values pairs
-- @name pairs
-- @tparam table obj an object
-- @treturn table an array
function _.pairs(obj)
  local paired= {}
  _.each(obj,function(k,v)
        paired[#paired+1] = {k,v}
    end)
    return paired
end

--- Extends an object properties. It copies all of the properties of extra passed-in objects
-- over to the destination object, and returns the destination object.
-- The last object in `...` will override properties of the same name in the previous one
-- @name extend
-- @tparam table destObj a destination object
-- @tparam var_arg ... a variable number of array arguments
-- @treturn table the destination object extended
function _.extend(destObj,...)
    local sources = {...}
    _.each(sources,function(__,source)
        if _.isObject(source) then
            _.each(source,function(key,value)
                destObj[key] = value
            end)
        end
    end)
    return destObj
end

--- Returns a sorted list of all methods names found in an object. If the given object
-- has a metatable implementing an `__index` field pointing to another table, will also recurse on this
-- table. If `output` is provided, will export results in this table.
-- <br/><em>Aliased as @{methods}</em>.
-- @name functions
-- @tparam table obj an object
-- @tparam[opt] table output Optional table to collect the results
-- @treturn table an array of methods names
-- @see methods
function _.functions(obj,output)
  if not obj then return _.sort(_.keys(_)) end
  local _methods = output or {}
  _.each(obj,function(key,value)
      if _.isFunction(value) then
        _methods[#_methods+1]=key
      end
    end)
    local mt = getmetatable(obj)
    if mt and mt.__index then
        _.functions(mt.__index,_methods)
    end
   return _.sort(_methods)
end

--- Alias for @{functions}.
-- @function methods
-- @param obj
-- @param[opt] output
_.methods = _.functions

--- Clones a given object properties. If `shallow` is passed
-- will also clone nested array properties.
-- @name clone
-- @tparam table obj an object
-- @tparam[opt] boolean shallow whether or not nested array-properties should be cloned, defaults to false.
-- @treturn table a clone of the passed-in object
function _.clone(obj,shallow)
    if not _.isObject(obj) then return obj end
  local _obj = {}
  _.each(obj,function(i,v)
    if _.isObject(v) then
      if not shallow then
        _obj[i] = _.clone(v,shallow)
      else _obj[i] = v
      end
    else
        _obj[i] = v
    end
  end)
  return _obj
end

--- Checks if a given object implements a property.
-- @name has
-- @tparam table obj an object
-- @tparam key key a key property to be checked
-- @treturn boolean __true__ or __false__
function _.has(obj, key)
  return obj[key]~=nil
end

--- Return a filtered copy of the object. The returned object will only have
-- the whitelisted properties. <br/><em>Aliased as @{choose}</em>.
-- @name pick
-- @tparam table obj an object
-- @tparam var_arg ... a variable number of string keys
-- @treturn table the filtered object
-- @see choose
function _.pick(obj, ...)
    local whitelist = _.flatten {...}
    local _picked = {}
    _.each(whitelist,function(key,property)
            if obj[property] then
                _picked[property] = obj[property]
            end
        end)
    return _picked
end

--- Alias for @{pick}.
-- @function choose
-- @param obj
-- @param ...
_.choose = _.pick

--- Return a filtered copy of the object. The returned object will not have
-- the blacklisted properties. <br/><em>Aliased as @{drop}</em>.
-- @name omit
-- @tparam table obj an object
-- @tparam var_arg ... a variable number of string keys
-- @treturn table the filtered object
-- @see drop
function _.omit(obj,...)
    local blacklist = _.flatten {...}
    local _picked = {}
    _.each(obj,function(key,value)
            if not _.include(blacklist,key) then
                _picked[key] = value
            end
        end)
    return _picked
end

--- Alias for @{omit}.
-- @function drop
-- @param obj
-- @param ...
_.drop = _.omit

--- Fills nil properties in an object with the given `template` object. Pre-existing
-- properties will be preserved. <br/><em>Aliased as @{defaults}</em>.
-- @name template
-- @tparam table obj an object
-- @tparam table template a template object
-- @treturn table the passed-in object filled
-- @see defaults
function _.template(obj,template)
  _.each(template,function(i,v)
    if not obj[i] then
        obj[i] = v
    end
  end)
  return obj
end

--- Alias for @{template}.
-- @function defaults
-- @param obj
-- @param template
_.defaults = _.template

--- Performs an equality test between two objects.
-- Can compare strings, functions (by reference), nil, booleans. Compares tables by reference or by component-values.
-- Comparing objects, if `useMt` is passed, the equality operator `==` will be used if one of
-- the given objects has a metatable implementing `mt.__eq`
-- @name isEqual
-- @tparam table objA an object
-- @tparam table objB another object
-- @tparam[opt] boolean useMt whether or not `mt.__eq` should be used, defaults to false.
-- @treturn boolean __true__ or __false__
function _.isEqual(objA,objB,useMt)
    local typeObjA = type(objA)
    local typeObjB = type(objB)
  if typeObjA~=typeObjB then return false end
  if typeObjA~='table' then return (objA==objB) end

  local mtA = getmetatable(objA)
  local mtB = getmetatable(objB)

  if useMt then
    if mtA or mtB and mtA.__eq or mtB.__eq then
        return (objA==objB)
    end
  end

  if _.size(objA)~=_.size(objB) then return false end

  for i,v1 in pairs(objA) do
    local v2 = objB[i]
    if _.isNil(v2) or not _.isEqual(v1,v2,useMt) then return false end
  end

  for i,v1 in pairs(objB) do
    local v2 = objA[i]
    if _.isNil(v2) then return false end
  end

  return true
end

--- Invokes an object method. It passes the object itself as the first argument. if `method` is not
-- callable, will return `obj[method]`.
-- @name result
-- @tparam table obj an object
-- @tparam string method a string key to index in object `obj`.
-- @tparam[opt] var_arg ... Optional extra-args to be passed to `method`
-- @treturn value the returned value of `method(obj,...)` call
function _.result(obj,method,...)
  if obj[method] then
    if _.isCallable(obj[method]) then
      return obj[method](obj,...)
    else return obj[method]
    end
  end
  if _.isCallable(method) then
    return method(obj,...)
  end
end

--- Checks if the given arg is an object (i.e a Lua table).
-- @name isObject
-- @tparam object obj an object
-- @treturn boolean __true__ or __false__
function _.isObject(obj)
  return type(obj) == 'table'
end

--- Checks if the given arg is an callable. Assumes `obj` is callable if
-- it is either a function or a table having a metatable implementing `__call` metamethod.
-- @name isCallable
-- @tparam object obj an object
-- @treturn boolean __true__ or __false__
function _.isCallable(obj)
  return (_.isFunction(obj) or
         (_.isObject(obj) and getmetatable(obj)
                             and getmetatable(obj).__call~=nil) or false)
end

--- Checks if the given arg is an array. Assumes `obj` is an array
-- if is a table with integer numbers as indexes.
-- @name isArray
-- @tparam object obj an object
-- @treturn boolean __true__ or __false__
function _.isArray(obj)
    if not _.isObject(obj) then return false end
    return _.all(_.keys(obj),function(i,v)
            return _.isNumber(v) and (floor(v)==v)
        end)
end

--- Checks if the given is empty. If `obj` is a @{string}, will return __true__
-- if `#obj==0`. Otherwise, if `obj` is a table, will return whether or not this table
-- is empty.
-- @name isEmpty
-- @tparam object obj an object
-- @treturn boolean __true__ or __false__
function _.isEmpty(obj)
    if _.isString(obj) then return #obj==0 end
    if _.isObject(obj) then return next(obj)==nil end
    return true
end

--- Checks if the given arg is a @{string}.
-- @name isString
-- @tparam object obj an object
-- @treturn boolean __true__ or __false__
function _.isString(obj)
  return type(obj) == 'string'
end

--- Checks if the given arg is a function.
-- @name isFunction
-- @tparam object obj an object
-- @treturn boolean __true__ or __false__
function _.isFunction(obj)
   return type(obj) == 'function'
end

--- Checks if the given arg is nil.
-- @name isNil
-- @tparam object obj an object
-- @treturn boolean __true__ or __false__
function _.isNil(obj)
    return obj==nil
end

--- Checks if the given arg is a finite number.
-- @name isFinite
-- @tparam object obj a number
-- @treturn boolean __true__ or __false__
function _.isFinite(obj)
    if not _.isNumber(obj) then return false end
    return obj > -huge and obj < huge
end

--- Checks if the given arg is a number.
-- @name isNumber
-- @tparam object obj a number
-- @treturn boolean __true__ or __false__
function _.isNumber(obj)
    return type(obj) == 'number'
end

--- Checks if the given arg is NaN (see [Not-A-Number](http://en.wikipedia.org/wiki/NaN)).
-- @name isNaN
-- @tparam object obj a number
-- @treturn boolean __true__ or __false__
function _.isNaN(obj)
  return _.isNumber(obj) and obj~=obj
end

--- Checks if the given arg is a boolean.
-- @name isBoolean
-- @tparam object obj a boolean
-- @treturn boolean __true__ or __false__
function _.isBoolean(obj)
  return type(obj) == 'boolean'
end

--- Imports all library functions in the global environment. <br/><em>Aliased as @{mixin}</em>
-- @name import
-- @see mixin
local function import()
  local fn = _.functions()
  local env = getfenv()
  _.each(fn,function(i,fName)
    env[fName] = _[fName]
  end)
end

--- Alias for @{import}.
-- @function mixin
local mixin = import

local _mt = {import = import, mixin = mixin}
_mt.__index = _mt
return setmetatable (_, _mt)]===================],"CoolisOS/bin/kernel/checker",true,"CoolisOS/bin/kernel/checker/init.lua",[===================[local classname=require'kernel.class'.classname
custom={}

function conforms(t,a)
    local k=t:sub(1, 1)
    return t == "?"
    or (k == "?" and (a==nil or conforms(t:sub(2, -1),a)))
    or (k == "!" and not (conforms(t:sub(2, -1),a)))
    or type(a)==t
    or classname(a) == t
    or (custom[t] and custom[t](a))
end

function check_one(d,a)
    for t in d:gmatch('|?([^|]+)|?') do
        if conforms(t,a) then return true end
    end
    return false
end
function check(s,...)
    if type(s)~='string' then error('arg1 is not of type string',2) end
    local i=0
    for typ in s:gmatch(',?([^,]+),?') do
        i=i+1
        if not check_one(typ,select(i,...)) then
            local msg=string.format(
            'arg%d:(%s) is not of type (%s);\n args=%s',
            i,tostring((debug and debug.getinfo or type)((select(i,...)))),typ,
            (debug.args_tostring(...)))
            error(msg,3)
        end
    end
end]===================],"CoolisOS/bin/kernel/class",true,"CoolisOS/bin/kernel/class/Box.lua",[===================[include'kernel.class'
local Opt=require'kernel.class.Opt'
local compat=require'kernel.compat'
local check=require'kernel.checker'.check
local pipe=sched.pipe
class.Box()
Box.token={}
do
    local def=Opt{
    pin=Opt(pipe),
    pout=Opt(pipe),
    perr=Opt(pipe),
    cc=false,
    terminal=Opt(nil),
    env=Opt(function()
        local env=util.shcopy(_G)
        env._G=env
        return env
    end)
    }
    function Box:__init(opt)
        def:drop(self,opt)
        self.env[Box.token]=self
        self.env._BOX=self
        if self.terminal then
            self.env.write=function(...)
                return self.terminal:write(...)
            end
            self.env.read=function(...)
                return self.terminal:read(...)
            end
            self.env.printError=function(s)
                return debug.printError(s,self.terminal)
            end
            self.env.term=self.terminal.term
        else
            self.env.print=function(s)
                self.pout:send(tostring(s))
            end
            self.env.write=function(s)
                self.pout:send(s)
            end
            self.env.read=function()
                self.pin:receive()
            end
            self.env.printError=function(s)
                self.perr:send(s)
            end
        end
        self.env.os=util.shcopy(self.env.os)
        self.env.os.execute=function(s)
            if not self.env.shell then error'no shell' end
            return self.env.shell.execute(s)
        end
    end
    function Box:run(f,...)
        setfenv(f,self.env)
        return f(...)
    end
    Box.get_current=function(level)
        level=(level or 0)
        repeat
            level=level+1
            local env=getfenv(level)
            if env[Box.token] then
                return env[Box.token]
            end
        until env==_Gstore.base_env
    end

end

return Box]===================],"CoolisOS/bin/kernel/class/init.lua",[===================[-- classlib.lua 2.04.04
--
-- Changes from 2.03:
--
-- 1.   Included patches and ideas from Peter Schaefer
--      ([email protected]) considerably improving the efficiency of
--      build(), __init() and other parts of the code.
--
-- 2.   The former remove_ambiguous() function was removed, improving the
--      efficiency of both build() (instance creation) and mt:__call() (class
--      creation). Ambiguities are now processed using the ambiguous_keys
--      tables introduced by Peter.
--
-- 3.   Removed inheritance of class properties, which was inconsistent with
--      the way instance properties are handled (see pages 4-5 of the manual).
--      Mostly harmless, but confusing. Now only methods are inherited.
--

-- PRIVATE

--[[
    Define unique value for identifying ambiguous base objects and inherited
    attributes. Ambiguous values are normally removed from classes and objects,
    but if keep_ambiguous == true they are left there and the ambiguous value
    is made to behave in a way useful for debugging.
]]

--[[
Changes for OS:
-__root field of each self points to the deepest self table;
-methods matching '^_[^_]' are not copied into subclasses;

]]


local ambiguous

if keep_ambiguous then

    ambiguous = { _type = 'ambiguous' }

    local function invalid(operation)
        return function()
            error('Invalid ' .. operation .. ' on ambiguous')
        end
    end

    -- Make ambiguous complain about everything except tostring()
    local ambiguous_mt =
    {
        __add       = invalid('addition'),
        __sub       = invalid('substraction'),
        __mul       = invalid('multiplication'),
        __div       = invalid('division'),
        __mod       = invalid('modulus operation'),
        __pow       = invalid('exponentiation'),
        __unm       = invalid('unary minus'),
        __concat    = invalid('concatenation'),
        __len       = invalid('length operation'),
        __eq        = invalid('equality comparison'),
        __lt        = invalid('less than'),
        __le        = invalid('less or equal'),
        __index     = invalid('indexing'),
        __newindex  = invalid('new indexing'),
        __call      = invalid('call'),
        __tostring  = function() return 'ambiguous' end,
        __tonumber  = invalid('conversion to number')
    }
    setmetatable(ambiguous, ambiguous_mt)

end


--[[
    Reserved attribute names.
]]

local reserved =
{
    __index         = true,
    __newindex      = true,
    __type          = true,
    __class         = true,
    __bases         = true,
    __inherited     = true,
    __from          = true,
    __shared        = true,
    __user_init     = true,
    __name          = true,
    __initialized   = true,
    __root          = true,
}

--[[
    Some special user-set attributes are renamed.
]]

local rename =
{
    __init  = '__user_init',
    __set   = '__user_set',
    __get   = '__user_get'
}

--[[
    The metatable of all classes, containing:

    To be used by the classes:
    __call()        for creating instances
    __init()        default constructor
    is_a()          for checking object and class types
    implements()    for checking interface support

    For internal use:
    __newindex()    for controlling class population
]]

local class_mt = {}
class_mt.__index = class_mt

--[[
    This controls class population.
    Here 'self' is a class being populated by inheritance or by the user.
]]

function class_mt:__newindex(name, value)

    -- Rename special user-set attributes
    if rename[name] then name = rename[name] end

    -- __user_get() needs an __index() handler
    if name == '__user_get' then
        self.__index = value and function(obj, k)
            local v = self[k]
            if v == nil and not reserved[k] then v = value(obj, k) end
            return v
        end or self

    -- __user_set() needs a __newindex() handler
    elseif name == '__user_set' then
        self.__newindex = value and function(obj, k, v)
            if reserved[k] or not value(obj, k, v) then rawset(obj, k, v) end
        end or nil

    end

    -- Assign the attribute
    rawset(self, name, value)
end

--[[
    This function creates an object of a certain class and calls itself
    recursively to create one child object for each base class. Base objects
    of unnamed base classes are accessed by using the base class as an index
    into the object, base objects of named base classes are accessed as fields
    of the object with the names of their respective base classes.
    Classes derived in shared mode will create only a single base object.
    Unambiguous grandchildren are inherited by the parent if they do not
    collide with direct children.
]]

local function build(class, shared_objs, shared,__root)

    -- If shared, look in the repository of shared objects
    -- and return any previous instance of this class.
    if shared then
        local prev_instance = shared_objs[class]
        if prev_instance then return prev_instance end
    end

    -- Create new object
    local obj = { __type = 'object' }
    if __root==nil then
        __root=obj
    end
    obj.__root=__root
    obj[class.__name]=obj

    -- Build child objects if there are base classes
    local nbases = #class.__bases
    if nbases > 0 then

        -- Repository for storing inherited base objects
        local inherited = {}

        -- List of ambiguous keys
        local ambiguous_keys = {}

        -- Build child objects for each base class
        for i = 1, nbases do
            local base = class.__bases[i]
            local child = build(base, shared_objs, class.__shared[base],__root)
            obj[base.__name] = child

            -- Get inherited grandchildren from this child
            for c, grandchild in pairs(child) do

                -- We can only accept one inherited grandchild of each class,
                -- otherwise this is an ambiguous reference
                if not ambiguous_keys[c] then
                    if not inherited[c] then inherited[c] = grandchild
                    elseif inherited[c] ~= grandchild then
                        inherited[c] = ambiguous
                        table.insert(ambiguous_keys, c)
                    end
                end
            end
        end

        -- Accept inherited grandchildren if they don't collide with
        -- direct children
        for k, v in pairs(inherited) do
            if not obj[k] then obj[k] = v end
        end

    end

    -- Object is ready
    setmetatable(obj, class)

    -- If shared, add it to the repository of shared objects
    if shared then shared_objs[class] = obj end

    return obj

end

--[[
    The __call() operator creates an instance of the class and initializes it.
]]

function class_mt:__call(...)
    local obj = build(self, {}, false)
    obj:__init(...)
    return obj
end

--[[
    The implements() method checks that an object or class supports the
    interface of a target class. This means it can be passed as an argument to
    any function that expects the target class. We consider only functions
    and callable objects to be part of the interface of a class.
]]

function class_mt:implements(class)

    -- Auxiliary function to determine if something is callable
    local function is_callable(v)
        if v == ambiguous then return false end
        if type(v) == 'function' then return true end
        local mt = getmetatable(v)
        return mt and type(mt.__call) == 'function'
    end

    -- Check we have all the target's callables (except reserved names)
    for k, v in pairs(class) do
        if not reserved[k] and is_callable(v) and not is_callable(self[k]) then
            return false
        end
    end
    return true
end

--[[
    The is_a() method checks the type of an object or class starting from
    its class and following the derivation chain upwards looking for
    the target class. If the target class is found, it checks that its
    interface is supported (this may fail in multiple inheritance because
    of ambiguities).
]]

function class_mt:is_a(class)

    -- If our class is the target class this is trivially true
    if self.__class == class then return true end

    -- Auxiliary function to determine if a target class is one of a list of
    -- classes or one of their bases
    local function find(target, classlist)
        for i = 1, #classlist do
            local class = classlist[i]
            if class == target or find(target, class.__bases) then
                return true
            end
        end
        return false
    end

    -- Check that we derive from the target
    if not find(class, self.__bases) then return false end

    -- Check that we implement the target's interface.
    return self:implements(class)
end

--[[
    Factory-supplied constructor, calls the user-supplied constructor if any,
    then calls the constructors of the bases to initialize those that were
    not initialized before. Objects are initialized exactly once.
]]

function class_mt:__init(...)
    if self.__initialized then return end
    if self.__user_init then self:__user_init(...) end
    for i = 1, #self.__bases do
        local base = self.__bases[i]
        self[base.__name]:__init(...)
    end
    self.__initialized = true
end


-- PUBLIC

--[[
    Utility type and interface checking functions
]]

function ofType(value)
    local t = type(value)
    return t =='table' and classname(t) or t
end

function typeof(value)
    local t = type(value)
    return t =='table' and value.__type or t
end

function classof(value)
    local t = type(value)
    return t == 'table' and value.__class or nil
end

function classname(value)
    if not classof(value) then return nil end
    local name = value.__name
    return type(name) == 'string' and name or nil
end

function implements(value, class)
    return classof(value) and value:implements(class) or false
end

function is_a(value, class)
    return classof(value) and value:is_a(class) or false
end


--[[
    Use a table to control class creation and naming.
]]

class = {}
local mt = {}
setmetatable(class, mt)

--[[
    Create a named or unnamed class by calling class([name, ] ...).
    Arguments are an optional string to set the class name and the classes or
    shared classes to be derived from.
]]

function mt:__call(...)

    local arg = {...}

    -- Create a new class
    local c =
    {
        __type = 'class',
        __bases = {},
        __shared = {}
    }
    c.__class = c
    c.__index = c

    -- A first string argument sets the name of the class.
    if type(arg[1]) == 'string' then
        c.__name = arg[1]
        table.remove(arg, 1)
    else
        c.__name = c
    end

    -- Repository of inherited attributes
    local inherited = {}
    local from = {}

    -- List of ambiguous keys
    local ambiguous_keys = {}

    -- Inherit from the base classes
    for i = 1, #arg do
        local base = arg[i]

        -- Get the base and whether it is inherited in shared mode
        local basetype = typeof(base)
        local shared = basetype == 'share'
        assert(basetype == 'class' or shared,
                'Base ' .. i .. ' is not a class or shared class')
        if shared then base = base.__class end

        -- Just in case, check this base is not repeated
        assert(c.__shared[base] == nil, 'Base ' .. i .. ' is duplicated')

        -- Accept it
        c.__bases[i] = base
        c.__shared[base] = shared

        -- Get methods that could be inherited from this base
        for k, v in pairs(base) do

            -- Skip reserved and ambiguous methods
            if type(v) == 'function' and not reserved[k] and (type(k)=='string' and not k:match'^_[^_]')and
                not ambiguous_keys[k] then

                -- Where does this method come from?
                local new_from

                -- Check if the method was inherited by the base
                local base_inherited = base.__inherited[k]
                if base_inherited then

                    -- If it has been redefined, cancel this inheritance
                    if base_inherited ~= v then     -- (1)
                        base.__inherited[k] = nil
                        base.__from[k] = nil

                    -- It is still inherited, get it from the original
                    else
                        new_from = base.__from[k]
                    end
                end

                -- If it is not inherited by the base, it originates there
                new_from = new_from or { class = base, shared = shared }

                -- Accept a first-time inheritance
                local current_from = from[k]
                if not current_from then
                    from[k] = new_from
                    local origin = new_from.class

                    -- We assume this is an instance method (called with
                    -- self as first argument) and wrap it so that it will
                    -- receive the correct base object as self. For class
                    -- functions this code is unusable.
                    inherited[k] = function(self, ...)
                        return origin[k](self[origin.__name], ...)
                    end

                -- Methods inherited more than once are ambiguous unless
                -- they originate in the same shared class.
                elseif current_from.class ~= new_from.class or
                        not current_from.shared or not new_from.shared then
                    inherited[k] = ambiguous
                    table.insert(ambiguous_keys, k)
                    from[k] = nil
                end
            end
        end
    end

    -- Set the metatable now, it monitors attribute setting and does some
    -- special processing for some of them.
    setmetatable(c, class_mt)

    -- Set inherited attributes in the class, they may be redefined afterwards
    for k, v in pairs(inherited) do c[k] = v end    -- checked at (1)
    c.__inherited = inherited
    c.__from = from

    return c
end

--[[
    Create a named class and assign it to a global variable of the same name.
    Example: class.A(...) is equivalent to (global) A = class('A', ...).
]]

function mt:__index(name)
    return function(...)
        local c = class(name, ...)
        local cenv=getfenv(2)
        cenv[name] = c
        return c
    end
end

--[[
    Wrap a class for shared derivation.
]]

function shared(class)
    assert(typeof(class) == 'class', 'Argument is not a class')
    return { __type = 'share', __class = class }
end
]===================],"CoolisOS/bin/kernel/class/Opt.lua",[===================[class.Opt()
function Opt:__init(t,typ,...)
    self.typ=typ or (typeof(t))
    self.val=t
    self.args={...}
end
function Opt:drop(dst,src,name)
    local typ=self.typ
    if typ=='req' then
        if src==nil then error(string.format('parameter %s required',tostring(name)))
        else return src end
    elseif typ=='function' then if src==nil then return self.val(unpack(self.args)) else return src end
    elseif typ=='raw' or typ=='nil' then
        if src==nil then return self.val else return src end
    elseif typ=='object' then return src==nil and (self.val.clone and self.val:clone() or self.val.__class(self.val)) or src
    elseif typ=='class' then return src==nil and (self.val(unpack(self.args))) or src
    elseif typ=='table' then
        dst=dst or {}
        src=src or {}
        for i,v in pairs(self.val) do
            if classof(v)==Opt then
                dst[i]=v:drop(nil,src[i],i)
            else
                if src[i]~=nil then
                    v=src[i]
                end
                dst[i]=v
            end
        end
        return dst
    end
end
return Opt]===================],"CoolisOS/bin/kernel/class/Var.lua",[===================[include'kernel.class'
local check=require'kernel.checker'
local dump=require'utils.serpent'.dump
local util=require'kernel.util'
class.Var()
local p=setmetatable({},{__mode='k'})
function Var:__init(file,opt)
    p[self]={}
    p[self].file=file
    local dir=loadreq.getDir(p[self].file)
    if not fs.exists(dir) then fs.makeDir(dir) end
    if not fs.exists(file) then self:setAll{} end
end

function Var:getAll()
    local f=io.open(p[self].file,'r')
    local s=f:read'*a'
    f:close()
    local t=loadstring(s)()
    return t
end

function Var:setAll(t)
    local f=io.open(p[self].file,'w')
    local s=f:write(dump(t))
    f:close()
end

function Var:__get(k)
    local t=self:getAll()
    if not t then t={} self:setAll(t) end
    return t[k]
end
function Var:__set(k,v)
    local t=self:getAll()
    t[k]=v
    self:setAll(t)
    return true
end
return Var]===================],"CoolisOS/bin/kernel/gui",true,"CoolisOS/bin/kernel/gui/autocomplete.lua",[===================[
local list=require'utils.pl.List'
local pathutils={} --API
do
    local segments, get, concat, find

    local function pathconcat(pt, starti, endi)
        local t = {}
        local prev
        local empties = 0
        starti = starti or 1
        endi = endi or #pt

        for i = starti, endi do
            local v = pt[i]
            if not v then break
            elseif v == '' then
                empties = empties+1
            else
                table.insert(t, prev)
                prev = v
            end
        end
        table.insert(t, prev)
        --log('PATH', 'INFO', "pathconcat(%s, %d, %d) generates table %s, wants indexes %d->%d",
        --    sprint(pt), starti, endi, sprint(t), 1, endi-starti+1-empties)
        return table.concat(t, '.', 1, endi-starti+1-empties)
    end

    function get(t, path)
        local p = type(path)=='string' and segments(path) or path
        local k = table.remove(p)
        if not k then return t end
        local t = find(t, p)
        return t and t[k]
    end



    function segments(path)
        local t = {}
        local index, newindex, elt = 1
        repeat
            newindex = path:find(".", index, true) or #path+1 --last round
            elt = path:sub(index, newindex-1)
            elt = tonumber(elt) or elt
            if elt and elt ~= "" then table.insert(t, elt) end
            index = newindex+1
        until newindex==#path+1
        return t
    end

    function find(t, path, force)
        path = type(path)=="string" and segments(path) or path
        for i, n in ipairs(path) do
            local v  = t[n]
            if type(v) ~= "table" then
                if not force or (force=="noowr" and v~=nil) then return nil, pathconcat(path, 1, i)
                else v = {} t[n] = v end
            end
            t = v
        end
        return t
    end

    pathutils.get=get
end

function env_matcher(path,opts)
    local env=opts.env or _G

    local lpath,pa = path:match("^(.-)([%w_]?[%w_%.%:]*)$") -- get the significant end part of the path (non alphanum are spliters...)

    local p, s, l = pa:match("(.-)([%.%:]?)([^%.%:]*)$") -- separate into sub path and leaf, getting the separator
    local t = pathutils.get(env, p)
    local funconly =  s == ":"
    local tr = {}
    local function copykeys(src, dst)
        if type(src) ~= 'table' then return end
        for k, v in pairs(src) do
            local tv = type(v)
            if type(k)=='string' and k:match("^"..l) and (not funconly or tv=='function' or (tv=='table' and getmetatable(v) and getmetatable(v).__call)) then dst[k] = true end
        end
    end

    copykeys(t, tr)

    if s == ":" or s == "." then
        local m = getmetatable(t)
        if m then
            local i, n = m.__index, m.__newindex
            copykeys(i, tr)
            if n ~= i then copykeys(n, tr) end
            --if m~= i and m ~= n then copykeys(m, tr) end -- far from being perfect, but it happens that __index or __newindex are functions that uses the metatable as a object method holder
        end
    end
    local r = {}
    for k, v in pairs(tr) do table.insert(r, k) end

    -- sort the entries by lexical order
    table.sort(r)
    --when we have a complete match we can add a ".", ":" or "(" if the object is a table or a function
    if l == r[1] then
        local v=t[l]
        if type(v)=='function' then
            r[1]=r[1].."("
        elseif type(v)=='table' then
            if typeof(v)=='object' then
                r[1]=r[1]..":"
            else
                r[1]=r[1].."."
            end
        end
    end
    for i,v in pairs(r) do r[i]=lpath..p..s..v end
    return r
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,
}

function keyword_matcher(path,opts)
    local r={}
    if #path~=0 then
        for key in pairs(tKeywords) do
            if path==key:sub(1,#path) then
                table.insert(r,key)
            end
        end
    end
    return r
end

local function esc(x)
  return (x:gsub('%%', '%%%%')
           :gsub('%^', '%%%^')
           :gsub('%$', '%%%$')
           :gsub('%(', '%%%(')
           :gsub('%)', '%%%)')
           :gsub('%.', '%%%.')
           :gsub('%[', '%%%[')
           :gsub('%]', '%%%]')
           :gsub('%*', '%%%*')
           :gsub('%+', '%%%+')
           :gsub('%-', '%%%-')
           :gsub('%?', '%%%?'))
end

function fs_matcher(word,opts)
    local matches={}
    local p,s,l
    l=word:match("[^/\\]*$")
    local cwd=opts.cwd or '/'
    local absDir
    if not word:match("[/\\][^/\\]*$") then
        absDir=cwd
        p,s='',''
    else
        p,s=word:match("^(.-)([/\\])[^/\\]*$")
        absDir=(p=='' and '' or fs.combine(cwd,p))
    end

    if fs.isDir( absDir ) then
        -- Search for matches in the resolved folder.
        local ok, tFileList = pcall( fs.list, absDir )
        if ok then
            -- Populate table with all matches.
            local pat="^"..esc(l)..'.*'
            for k, v in ipairs(tFileList) do
                local match = string.match( v, pat)
                if match then
                    -- print(match)
                    table.insert( matches,match )
                end
            end
        end
    end
    table.sort(matches)
    if (l == matches[1]) and fs.isDir(fs.combine(absDir,l)) then
        matches[1]= matches[1]..'/'
    end
    for i,v in pairs(matches) do matches[i]=p..s..v end
    return matches
end

function getmatch(path,opts)
    local r=list()
    local matchers=opts.matchers
    for _,matcher in pairs(matchers) do
        r:extend(matcher(path,opts))
    end
    r:sort()
    return r
end
]===================],"CoolisOS/bin/kernel/gui/EvtH.lua",[===================[class.EvtH()
do
function EvtH:__init()

end

function EvtH:destroy()

end
function EvtH:queue()

end
wxEvtHandler::Connect
function EvtH:connect(src,event,f,...)
    local cast=src.EvtH
    local t=cast.dst[event] or setmetatable({},{__mode='k'})
    cast.dst[event][self]=true

    t=self.handlers[event] or {}
    self.handlers[event]=t
    t[f]={...}
end

wxEvtHandler::Disconnect
function EvtH:disconnect(src,event,f,this)
    srcs=src and {src=true} or self.src
    for src in pairs(srcs) do
        events=event and {event=src[event]} or src.dst
        for event,evth in pairs(events) do
            fs=f and {f}
        end
    end
end
wxEvtHandler::GetClientData
function EvtH:()

end
wxEvtHandler::GetClientObject
function EvtH:()

end
wxEvtHandler::GetEvtHandlerEnabled
function EvtH:isEnabled()

end
wxEvtHandler::GetNextHandler
function EvtH:next()

end
wxEvtHandler::GetPreviousHandler
function EvtH:previous()

end
wxEvtHandler::ProcessEvent
function EvtH:process()

end
wxEvtHandler::SearchEventTable
function EvtH:search()

end
wxEvtHandler::SetClientData
function EvtH:()

end
wxEvtHandler::SetClientObject
function EvtH:()

end
function EvtH:setEnabled()

end
function EvtH:setNext()

end
function EvtH:setPrevious()

end
end]===================],"CoolisOS/bin/kernel/gui/init.lua",[===================[include'kernel.class'
local sched=require'kernel.sched'
local checker=require'kernel.checker'
local check=checker.check
local list=require'utils.pl.List'
gui=getfenv()
Point=require'Point'
Rectangle=require'Rectangle'
Term=require'Term'

function read(pin,term,opts)
    pin=pin.Pipe
    term:setCursorBlink(true)
    local _sReplaceChar=opts._sReplaceChar
    local _tHistory=opts.history
    local sLine = ""
    local nHistoryPos = nil
    local nPos = 0
    if _sReplaceChar then
        _sReplaceChar = string.sub( _sReplaceChar, 1, 1 )
    end

    local auto
    if opts.auto then
        assert(#opts.auto>0)
        auto={}
        auto.mode=opts.auto.mode or 1
        auto.count=0
        auto.matches = { n = 0}
        function auto.reset()
            auto.matches = { n = 0}
        end
        local function split(s,n)
            local s=sLine
            local n=nPos+1
            local l,r=s:sub(1,n-1),s:sub(n)
            local pl,rl
            if l:sub(-1,-1):match'%s' then
                local sp=l:sub(-1,-1)
                l=l:sub(1,-2)
                r=sp..r
            end

            local ls,lp=l:match'^(.-)([^%s]+)$'
            rp,rs=r:match'^([^%s]+)(.-)$'
            if lp==nil then ls,lp=l,'','' end
            if rp==nil then rp,rs='',r end
            return ls,lp..rp,rs
        end

        function auto.update()
            local l,p,r=split(sLine,nPos+1)
            -- debug.log(l,p,r)
            local ok,m=pcall(opts.auto[auto.mode],p)
            if not ok then debug.log(m) end
            -- debug.log(pstring(m,1))
            m.l,m.r=l,r
            auto.matches=m
        end
        function auto.put()
            local matches=auto.matches
            local match=matches[matches.n]
            local l,r=matches.l,matches.r
            sLine = l..match..r
            nPos = #l+#match
        end
    end
    local w, h = term:getSize()
    local sx, sy = term:getCursorPos()


    local function redraw( _sCustomReplaceChar )
            local nScroll = 0
            local su=''

            if sx + nPos > w then
                    nScroll = (sx + nPos) - w
            end
            term:setCursorPos( sx, sy )

            local sReplace = _sCustomReplaceChar or _sReplaceChar
            local s
            if sReplace then
                s=string.rep(sReplace, string.len(sLine) - nScroll)
            else
                s=string.sub( sLine, nScroll + 1 )
            end

            if #s<(w-sx+1) then s=s..(' '):rep(w-sx+1) end
            term:write(s)
            term:setCursorPos( sx + nPos - nScroll, sy )
    end


    pin:reset()
    while true do
            local _,sEvent,param=unpack(pin:receive())
            if sEvent == "char" then
                if auto then auto.reset() end
                sLine = string.sub( sLine, 1, nPos ) .. param .. string.sub( sLine, nPos + 1 )
                nPos = nPos + 1
                redraw()
            elseif sEvent == "key" then
                if auto then
                    if not (param == keys.tab) then
                        auto.reset() -- Reset completion match-table.
                    else
                        if auto.matches[1] then   -- tab was pressed before.
                            local matches=auto.matches
                            -- Shift pointer to next match.
                            matches.n = (matches.n)%#matches +1  -- Wrap around if the pointer has gone past the end.

                            -- Assemble the new line.
                            auto.put()

                            redraw()
                        else
                            -- [[ No matches yet, look for some now. ]]
                            auto.update()
                            local matches=auto.matches
                            matches.n=0
                            if #matches==0 then
                                --nPos=nPos+4
                                --sLine=sLine..'\t'
                            else -- Show first match.
                                matches.n=1
                                auto.put()
                                if #matches==1 then auto.reset() end
                            end
                            redraw()
                        end
                    end
                    if not (param == keys.rightShift) then
                        auto.count=0
                    else
                        auto.count=(auto.count+1)%2
                        if auto.count==0 then
                            auto.mode=(auto.mode)%#opts.auto+1
                        end
                        auto.reset()
                    end
                end
                if param == keys.enter then
                    -- Enter
                    break
                elseif param == keys.left then
                        -- Left
                        if nPos > 0 then
                                nPos = nPos - 1
                                redraw()
                        end

                elseif param == keys.right then
                        -- Right
                        if nPos < string.len(sLine) then
                                nPos = nPos + 1
                                redraw()
                        end

                elseif param == keys.up or param == keys.down then
                    -- Up or down
                    if _tHistory then
                        redraw(" ");
                        if param == keys.up then
                                -- Up
                                if nHistoryPos == nil then
                                        if #_tHistory > 0 then
                                                nHistoryPos = #_tHistory
                                        end
                                elseif nHistoryPos > 1 then
                                        nHistoryPos = nHistoryPos - 1
                                end
                        else
                                -- Down
                                if nHistoryPos == #_tHistory then
                                        nHistoryPos = nil
                                elseif nHistoryPos ~= nil then
                                        nHistoryPos = nHistoryPos + 1
                                end
                        end

                        if nHistoryPos then
                            sLine = _tHistory[nHistoryPos]
                            nPos = string.len( sLine )
                        else
                            sLine = ""
                            nPos = 0
                        end
                        redraw()
                    end
                elseif param == keys.backspace then
                        -- Backspace
                        if nPos > 0 then
                            redraw(" ");
                            sLine = string.sub( sLine, 1, nPos - 1 ) .. string.sub( sLine, nPos + 1 )
                            nPos = nPos - 1
                            redraw()
                        end
                elseif param == keys.home then
                        -- Home
                        nPos = 0
                        redraw()
                elseif param == keys.delete then
                        if nPos < string.len(sLine) then
                            redraw(" ");
                            sLine = string.sub( sLine, 1, nPos ) .. string.sub( sLine, nPos + 2 )
                            redraw()
                        end
                elseif param == keys["end"] then
                        -- End
                        nPos = string.len(sLine)
                        redraw()
                -- elseif param == keys.leftAlt then
                        -- write('\n'..'..')
                        -- if auto then opts.auto.mode=auto.mode end
                        -- return sLine..'\n'..read(pin,term,opts)
                end
            end
    end

    term:setCursorBlink( false )
    term:setCursorPos( w + 1, sy )
    if opts.clear~=false then print() end
    return sLine
end
function write(term,sText)
    check('string',sText)
    local w,h = term:getSize()
    local x,y = term:getCursorPos()

    local nLinesPrinted = 0
    local function newLine()
        if y + 1 <= h then
            term:setCursorPos(1, y + 1)
        else
            term:setCursorPos(1, h)
            term:scroll(1)
        end
        x, y = term:getCursorPos()
        nLinesPrinted = nLinesPrinted + 1
    end

    -- Print the line with proper word wrapping
    while string.len(sText) > 0 do
        local whitespace = string.match( sText, "^[ \t]+" )
        if whitespace then
            -- Print whitespace
            term:write( whitespace )
            x,y = term:getCursorPos()
            sText = string.sub( sText, string.len(whitespace) + 1 )
        end

        local newline = string.match( sText, "^\n" )
        if newline then
            -- Print newlines
            newLine()
            sText = string.sub( sText, 2 )
        end

        local text = string.match( sText, "^[^ \t\n]+" )
        if text then
            sText = string.sub( sText, string.len(text) + 1 )
            if string.len(text) > w then
                -- Print a multiline word
                while string.len( text ) > 0 do
                    if x > w then
                        newLine()
                    end
                    term:write( text )
                    text = string.sub( text, (w-x) + 2 )
                    x,y = term:getCursorPos()
                end
            else
                -- Print a word normally
                if x + string.len(text) - 1 > w then
                    newLine()
                end
                term:write( text )
                x,y = term:getCursorPos()
            end
        end
    end

    return nLinesPrinted
end
function printError(term,s)
    if term:isColour() then
        term:setTextColour( colours.red )
    end
    gui.write(term,s)
    term:setTextColour( colours.white )
end

local function property(class, attribute,field,setter,getter)
    class['set'..attribute]=setter or function(self,val) self[field]=val end
    class['get'..attribute]=getter or function(self) return self[field] end
end

local cc_events={
mouse={
'mouse_click',
'mouse_scroll',
'mouse_drag',
},
touch={
'monitor_touch',
},
keyboard={
'key',
'char',
},
}

class.Terminal()
do
function Terminal:__init(term,pin,pout)
    check('Term,Pipe,Pipe',term,pin,pout)
    self.term=term
    debug.namefield(self,'term')
    self.pin=pin
    debug.namefield(self,'pin')
    self.pout=pout
    debug.namefield(self,'pout')
    sched.task(sched.pump):run(pout,function(r) self:write(tostring(r)) end)
end

function Terminal.from_native(term,emitter)
    check('native_terminal,!nil',term,emitter)
    local h=sched.sigpipe()
    if term.isColor() then
        h:link{[emitter]=cc_events.mouse}
    end
    if term.setTextScale then
        h:link{[emitter]=cc_events.touch}
    else
        h:link{[emitter]=cc_events.keyboard}
    end
    local t=Terminal(Term.from_native(term),h.Pipe,sched.pipe())
    t.renderer=sched.task(function()
        while true do
            t.term:blit_native(term)
            t.term:copyState(term)
            sched.wait(false)
        end
    end)
    t.renderer:link{[t.term]={'*'}}
    debug.namefield(t,'renderer')
    t.renderer:run()
    t.term:setSignals(true)
    t.term:clear()
    return t
end

function Terminal:write(...)
    return write(self.term,...)
end

function Terminal:read(...)
    return read(self.pin,self.term,...)
end

end
]===================],"CoolisOS/bin/kernel/gui/Point.lua",[===================[include'kernel.class'
local check=require'kernel.checker'.check
--[[-------------------------------------------------------
Members
    Point.x    -- number
    Point.y    -- number
Methods
    Point:Point(x, y)
    Point:Point(point)
    Point:assign(x, y)
    Point:assign(point)
    Point:clone()          -- return Point
    Point:add(x, y)
    Point:add(point)
    Point:sub(x, y)
    Point:sub(point)
    Point:equal(point)
--------------------------------------------------------------------------]]
class.Point()

function Point:__init(x, y)
    return self:assign(x, y)
end

function Point:assign(x, y)
    if (not y) then

        check('Point',x)

        self.x = x.x
        self.y = x.y
    else
        check('number,number',x,y)
        self.x = x
        self.y = y
    end
    return self
end

function Point:clone()
    return Point(self)
end

function Point:add(x, y)
    if (not y) then
        check('Point',x)
        self.x = self.x + x.x
        self.y = self.y + x.y
    else
        check('number,number',x,y)
        self.x = self.x + x
        self.y = self.y + y
    end
    return self
end

function Point:sub(x, y)
    if (not y) then
        check('Point',x)
        return self:add(-x.x, -x.y)
    else
        check('number,number',x,y)
        return self:add(-x, -y)
    end
end

function Point:equal(p)
    check('Point',p)
    return self.x == p.x and self.y == p.y
end
function Point:__tostring()
    return '(' .. self.x .. ',' .. self.y ..')'
end

return Point
]===================],"CoolisOS/bin/kernel/gui/Rectangle.lua",[===================[include'kernel.class'
local Point=require'kernel.gui.Point'
class.Rectangle()
--[[ -------------------------------------------------------
Members:
    Rectangle.s -- Point (start)
    Rectangle.e -- Point (end)
Methods:
    Rectangle:assign(x1, y1, x2, y2)
    Rectangle:assign(rect)
    Rectangle:size()    -- return Point
    Rectangle:clone()   -- return Rectangle
    Rectangle:move(deltax, deltay)
    Rectangle:grow(deltax, deltay)
    Rectangle:intersect(rect)
    Rectangle:union(rect)
    Rectangle:equal(rect)
    Rectangle:contains(point)
    Rectangle:empty()
    Rectangle:nempty()
--------------------------------------------------------------------------]]
function Rectangle:__init(x1, y1, x2, y2)
    self:assign(x1, y1, x2, y2)
end

function Rectangle:assign(x1, y1, x2, y2)
    if (not y1) then
        self.s = x1.s:clone()
        self.e = x1.e:clone()
    elseif (not x2) then
        self.s=x1:clone()
        self.e=y1:clone()
    else
        self.s = Point(x1, y1)
        self.e = Point(x2, y2)
    end
    return self
end

function Rectangle:size()
    return self.e:clone():sub(self.s)
end

function Rectangle:clone()
    return Rectangle(self)
end

function Rectangle:move(deltax, deltay)
    self.s:add(deltax, deltay)
    self.e:add(deltax, deltay)
    return self
end

function Rectangle:grow(deltax, deltay)
    self.s:sub(deltax, deltay)
    self.e:add(deltax, deltay)
    return self
end

function Rectangle:intersect(r)
    local s, e = self.s, self.e

    s.x = max(s.x, r.s.x)
    s.y = max(s.y, r.s.y)
    e.x = min(e.x, r.e.x)
    e.y = min(e.y, r.e.y)
    return self
end

function Rectangle:union(r)
    local s, e = self.s, self.e

    s.x = min(s.x, r.s.x)
    s.y = min(s.y, r.s.y)
    e.x = max(e.x, r.e.x)
    e.y = max(e.y, r.e.y)
    return self
end

function Rectangle:equal(r)
    return self.s:equal(r.s) and self.e:equal(r.e)
end

function Rectangle:contains(x, y)
    return x >= self.s.x and x < self.e.x and y >= self.s.y and y < self.e.y
end

function Rectangle:empty()
    return self.s.x >= self.e.x or self.s.y >= self.e.y
end

function Rectangle:nempty()
    return not self:empty()
end


function Rectangle:__tostring()
    if (self:empty()) then
        return 'rect (empty)'
    else
        return 'rect (' .. tostring(self.s) .. ',' .. tostring(self.e) .. ')'
    end
end
return Rectangle]===================],"CoolisOS/bin/kernel/gui/shell.lua",[===================[include'kernel.gui'
local check=require'kernel.checker'.check
local acpl=require'kernel.gui.autocomplete'
local Box=require'kernel.class.Box'
--[[
methods:
    loop
    execute string->command->stuff


    runFile
    runLua

    destroy
fields:
    cwd
    tasks
    env

    input history
    output history

    pin events
    pcmd commands
defaults:
    cwd
    path


Full craftos programs support:

    special option:

]]

function new()
local shell={}
shell.env=setmetatable({},{__index=_BOX.env})
shell.env.shell=shell
local prompts={
normal='>',
}

--[[
input
pout output
]]

--filesystem
shell.cwd='/'
shell.path=fs.combine(_INSTALL_PATH,'bin/programs')
function shell.resolve(sPath)
    check('string',sPath)
    local sStartChar = string.sub( sPath, 1, 1 )
    if sStartChar == "/" or sStartChar == "\\" then
        return fs.combine( "", sPath )
    else
        return fs.combine( shell.cwd, sPath )
    end
end
----intertask
shell.pin=sched.pipe()
--rendering
local w,h=term:getSize()
local up_term=Term{size=Point(w,1)}
local down_term=Term{size=Point(w,h-1)}
up_term:setSignals(true)
down_term:setSignals(true)
-- debug.name(up_term,'up_term')
-- debug.name(down_term,'down_term')
sched.task(function()
    sched.running:link{[up_term]={'*'},[down_term]={'*'}}
    repeat
        up_term:blit(term)
        down_term:blit(term,Point(1,2))
        sched.wait(false)
    until false
end):run()
--piping stuff to proper terms
local up_pin=_BOX.terminal.pin
local function _read()
    up_term:clear()
    up_term:setCursorPos(1,1)
    gui.write(up_term,shell.mode..shell.prompt)
    return gui.read(up_pin,up_term,{clear=false,history=shell.input,auto={
            function(s) return acpl.getmatch(s,{env=shell.env,
                                                matchers={
                                                        acpl.keyword_matcher,
                                                        acpl.env_matcher,
                                                        },
                                                }
                                            )
            end,
            function(s) return acpl.fs_matcher(s,{cwd=shell.cwd}) end,
            mode=shell.mode=='=' and 1 or 2,
            }
            }
    )
end
sched.task(function() sched.pump(nil,function() sched.wait() return _read() end,shell.pin) end):run()

sched.task(sched.pump):run(shell.pin,function(s)
    shell.execute(s)
end)
shell.pout=sched.pipe()
sched.task(sched.pump):run(shell.pout,function(s)
    gui.write(down_term,s..'\n')
end)

shell.perr=sched.pipe()
sched.task(sched.pump):run(shell.perr,function(s)
    log('shell','error',s)
    gui.printError(down_term,'perr:'..s..'\n')
end)

--keeping track of running tasks
shell.tasks=sched.Catalog()

shell.trace=false
function shell.runFunc(f,trace,stat,pp)
    -- local env=setmetatable({},{__index=shell.env})
    local box=Box{pout=shell.pout,perr=shell.perr,env=shell.env}
    local func=function() return box:run(f) end

    local t=sched.task(function()
        if trace==nil then trace=shell.trace end
        local debug=debug
        local t =trace and { xpcall(func,debug.traceback) } or { pcall(func) }
        if t[1] then
            table.remove(t,1)
            --if pp then t={pstring(t)} end
            table.insert(shell.output,t)
            shell.env._=t[1]
            local n=table.maxn(t)
            if n~=0 or stat then
                s=tostring(t[1])
                for i=2,n do
                    s=s..','..tostring(t[i])
                end
                shell.pout:send(s)
            end
        else
            shell.perr:send(t[2] or 'error(no msg)')
        end
    end)
    debug.name(t,'in'..#shell.input)
    shell.tasks:register(t,'in'..#shell.input)
    t:run()
end
function shell.runFile(path)
    local f,e=io.open(path,'r')
    if not f then shell.perr:send(e or 'could not open file')
    else
    local st=f:read'*a'
    f:close()
    local f,e=loadstring(st,path)
    if not f then shell.perr:send(e)
    else
    shell.runFunc(f,true,nil)
    end
    end
end

shell.input={}
shell.output=setmetatable({},{__index=function(t,k) return unpack(rawget(t,k)) end})
shell.env._in=shell.input
shell.env._out=shell.output
shell.prompt=prompts.normal
shell.mode='='
local modes={
['>']=function(s,name) --filesystem mode
    s=shell.resolve(s)
    shell.runFile(s)
end,
['=']=function(s,name)
    -- local pp=false
    -- if s:sub(1,1)=='?' then
        -- pp=true
        -- s=s:sub(2)
    -- end
    local proper_loadstring=function(s,n)
        check('string,string',s,n)
        local ok,f,e=pcall(loadstring,s,n)
        if e then e=e:match'(%d:[^:]-)$' end
        return f,e
    end

    local function get(s,name)
        --xpcall catches parsing errors which normally are returned as nil, error_msg.
        --so we pcall loadstring to avoid loosing the error
        --strangely, the xpcall lets execution continue at this level
        local func,e
        local f1,e1=proper_loadstring(s,name)
        local f2, e2 = proper_loadstring( "return "..s,name)
        if f1 then
            if f2 then
                func=f2
            else
                func=f1
            end
        else
            if f2 then
                func=f2
            else
                e=e1
            end
        end
        if e then e=name..':'..e end
        return func,e,(func==f2)
    end
    local func,e,stat=get(s,name)

    if func then
        shell.runFunc(func,nil,stat)--,pp)
    else
        shell.perr:send(e)
    end

end
}
--history

function shell.execute(s)
    table.insert(shell.input,s)
    local name='in['..#shell.input..']'
    shell.pout:send(name..':'..s)
    if modes[s:sub(1,1)] then--mode change
        shell.mode=s:sub(1,1)
        s=s:sub(2)
    end
    if #s>0 then modes[shell.mode](s,name) end
end

function shell.run_startups()
    local dir=fs.combine(_INSTALL_PATH,'ect/startups')
    if not fs.exists(dir) then fs.makeDir(dir) end
    local st=fs.list(dir)
    table.sort(st)
    for i,l in pairs(st) do
        shell.runFile(fs.combine(dir,l))
    end
end


_BOX.env.shell=shell
return shell
end
]===================],"CoolisOS/bin/kernel/gui/Term.lua",[===================[include'kernel.class'
local Opt=require'kernel.class.Opt'
local checker=require'kernel.checker'
local check=checker.check
local Point=require'Point'
local Rectangle=require'Rectangle'
-- local function nimpl() return error('Not implemented',3) end
-- class.DC()
-- function DC:blit(pos,section) nimpl() end
-- function DC:setCursorPos(pos,section) nimpl() end
-- function DC:write(txt) nimpl() end
-- function DC:setTextColor(pos,section) nimpl() end
-- function DC:setBackgroundColor(pos,section) nimpl() end

class.Term()
local term_opt=Opt{
size=Opt(Point(5,5)),
bcolor=colors.black,
tcolor=colors.white,
pos=Opt(Point(1,1)),
color=term.isColor(),
blink=false,
}
local function update(self) self:emit(UPDATE) end
checker.custom.color=function(n) return (type(n)=='number' and n>=0 or error('Invalid color, must be number >0',3)) end
checker.custom.char=function(s) return type(s)=='string' and #s==1 end
local native=util.shcopy(term.native)
checker.custom.native_terminal=function(t)
    for i,v in pairs(native) do
        if type(t[i])~=type(native[i]) then return false end
    end
    if typeof(t)~='table' then return false end
    return true
end
function Term.from_native(term)
    check('native_terminal',term)
    return Term{
        size=Point(term.getSize()),
        color=term.isColor(),
        blink=true,
    }
end
local function wrap_obj(self,tMethods)
    for i,v in pairs(tMethods or self) do
        if type(v)=='function' then
            local f=self[i]
            self[i]=function(s,...)
                if self==s then
                    return f(s,...)
                else
                    return f(self,s,...)
                end
            end
        end
    end
end
--[[process
e.g. shell
in out err
term
---in out in out
]]
local active={
'setBackgoundColour',
'setTextColour',
'setCursorPos',
'setCursorBlink',
'write',
'setSize',
'scroll',
'clear',
'setPixel',
}
function Term:setSignals(bool)
    for _,k in ipairs(active) do
        local f=self['_'..k] or self[k]
        self[k]=bool and function(...)
            sched.signal(self,k,...)
            return f(...)
        end or f
    end
end
function Term:__init(opt)
    term_opt:drop(self,opt)
    self:_allocate()
    wrap_obj(self,native)
end
function Term:setCursorPos(x,y)
    self.pos:assign(x,y)
end
function Term:getCursorPos() return self.pos.x,self.pos.y end
function Term:setBackgroundColor(color) check('color',color) self.bcolor=color end
Term.setBackgroundColour=Term.setBackgroundColor
function Term:getBackgroundColor() return self.bcolor end
Term.getBackgroundColour=Term.getBackgroundColor
function Term:setTextColor(color) check('color',color) self.tcolor=color end
Term.setTextColour=Term.setTextColor
function Term:getTextColor() return self.tcolor end
Term.getTextColour=Term.getTextColor
function Term:isColor() return self.color end
Term.isColour=Term.isColor
function Term:setCursorBlink(bool) check('boolean',bool) self.blink=bool end
function Term:getCursorBlink() return self.blink end
function Term:write(txt)
    check('string',txt)
    local n=#txt
    local pos=self.pos
    if pos.x+n<=1 or pos.x> self.size.x then
        pos.x=pos.x+n
        return
    end
    if pos.x < 1 then
        txt=txt:sub(math.abs(pos.x)+2)
        pos.x=1
    end
    local line=self.matrix[pos.y]
    if line then
        for j=pos.x,math.min(pos.x-1+n,self.size.x) do
            line[j]={tc=self.tcolor,bc=self.bcolor,c=txt:sub(j-pos.x+1,j-pos.x+1)}
        end
    end
    pos.x=pos.x+n
end
function Term:setSize(self,size)
    self.size=size
    self:_allocate()
end
function Term:getSize()
    return self.size.x,self.size.y
end

function Term:scroll(n)
    check('number',n)
    n=(n-n%1)
    local ind,nind=n>0 and 1 or nil,n>0 and self.size.y or 1
    local matrix=self.matrix
    for i=1,math.abs(n) do
        table.remove(matrix,ind)
        matrix[nind]=self:_newLine()
    end
end
function Term:clear() self:_allocate() end
function Term:clearLine()
    if self.matrix[self.pos.y] then
        self.matrix[self.pos.y]=self:_newLine()
    end
end
function Term:_newLine()
    local line={}
    for j=1,self.size.x do
        line[j]={tc=self.tcolor,bc=self.bcolor,c=' '}
    end
    return line
end
function Term:_allocate()
    local X,Y = self.size.x,self.size.y
    self.matrix=self.matrix or {}
    for i=1,Y do
        self.matrix[i]=self:_newLine()
    end
end
local def_pos=Point(1,1)
function Term:blit_native(term,pos,section)
    pos=pos or def_pos
    section=section or Rectangle(def_pos,self.size)
    term.setCursorBlink(false)
    if self.blink then
        local cell=self.matrix[self.pos.y] and self.matrix[self.pos.y][self.pos.x]
        if cell then
            self._bcell=cell
            cell.bc,cell.tc=cell.tc,cell.bc
        else
            self._bcell=nil
        end
    end
    for i=section.s.y,section.e.y do
        local line=self.matrix[i]
        local tc,bc=line[1].tc,line[1].bc
        local tTxt={}
        for j=section.s.x,section.e.x do
            local tl,bl=line[j].tc,line[j].bc
            if tc~=tl or bc~=bl then
                term.setCursorPos(j-#tTxt+pos.x-1,i+pos.y-1)
                term.setTextColor(tc==0 and self.tcolor or tc)
                term.setBackgroundColor(bc==0 and self.bcolor or bc)
                term.write(table.concat(tTxt))
                tc,bc=tl,bl
                tTxt={}
            end
            table.insert(tTxt,line[j].c)
        end
        if tTxt[1] then
            term.setCursorPos(section.e.x-#tTxt+pos.x,i+pos.y-1)
            term.setTextColor(tc==0 and self.tcolor or tc)
            term.setBackgroundColor(bc==0 and self.bcolor or bc)
            term.write(table.concat(tTxt))
        end
    end
    if self._bcell then
        local cell=self._bcell
        cell.bc,cell.tc=cell.tc,cell.bc
        self._bcell=nil
    end
end
function Term:blit(term,pos,section)
    return self:blit_native(term,pos,section) --temporary?
end

function Term:setPixel(char,tcolor,bcolor,x,y)
    check('char,?|color,?|color,?|Point|number|table,?|number',char,tcolor,bcolor,x,y)

    if type(x)=='table' then
        x,y=x.x,x.y
        check('number,number',x,y)
    else
        x,y=x or self.pos.x, y or self.pos.y
    end
    if self.matrix[y] and self.matrix[y][x] then
        self.matrix[y][x]={c=char or ' ',tc=tcolor or self.tcolor,bc=bcolor or self.bcolor}
    end
end
function Term:copyState(term)
    term.setTextColor(self:getTextColor())
    term.setBackgroundColor(self:getBackgroundColor())
    term.setCursorPos(self:getCursorPos())
end

-- function Term:from_npaint(file)
    -- -- pos=pos or def_pos
    -- -- section=section or Rectangle(pos,self.size)

    -- for line in file:lines() do
        -- if section.x<
    -- end
-- end

function Term:_dump_key(k)
  local s={}
  for i=1, self.size.y do
    local txt={}
    table.foreach(self.matrix[i],function(_,v) table.insert(txt,tostring(type(v[k])=='number' and string.char(97+math.ceil(math.log(v[k],2))) or v[k])) end)
    txt=table.concat(txt)
    table.insert(s,txt)
  end
  return table.concat(s,'\n')
end
function Term:dump()
  return self:_dump_key'c',self:_dump_key'tc',self:_dump_key'bc'
end
function Term:blit_all(term)
    for i=1,self.size.y do
        local line=self.matrix[i]
        for j=1,self.size.x do
            local p=line[j]
            term.setCursorPos(j,i)
            term.setTextColor(p.tc)
            term.setBackgroundColor(p.bc)
            term.write(p.c)
        end
    end
end
-- assert(Term:implements(DC))
Term.test=function()
  rawset(_G,'t',Term{size=Point(term.getSize())})
  for i=1,t.size.y do
    t:setPixel('a',2^i,2^i,i,i)
  end
  sleep(1)
  term.clear()
--  t:setCursorPos(2,2)
  t:blit_native(term)
  sleep(1)
end


return Term]===================],"CoolisOS/bin/kernel/loadreq",true,"CoolisOS/bin/kernel/loadreq/init.lua",[===================[---require implementation in pure Lua for a sandbox environment, with support for globs and full directory tree search.
--Licensed under the MIT license, whatever that is.


local fs=fs
local string=string
local loadfile=loadfile
local error=error
local function log(...)
    return (_G.log and _G.log(...))
end

function getNameExpansion(s) --returns name and expansion from a filepath @s; special cases: ''->'',nil; '.'-> '','';
    local _,_,name,expa=string.find(s, '([^%./\\]*)%.(.*)$')
    return name or s,expa
end

function getDir(s) --returns directory from filepath @s
    return string.match(s,'^(.*)/') or '/'
end

vars={} --to allow edition
--vars.loaded={}
--function loadFile(path,_reload) --@_reload forces reload
--  if (vars.loaded[path]==nil) or _reload then
--      local fnFile, err = loadfile( path )
--      if not fnFile then error('load:'..'path=:'..path..'| '..(err or 'nil'),2) end
--      vars.loaded[path]=fnFile
--  end
--  return vars.loaded[path]
--end
--
---iterator; replaces '?' in g by s and returns the resulting path if it is a file.
local function direct(g,s)
    g=string.gsub(g,'%?',s)
    if fs.exists(g) and not fs.isDir(g) then
        return g
    end
end
--add your finders here: must take (p,s) where p is where to search and s is what to search for.It must return a path.
vars.finders={direct}
vars.paths='?/init.lua;?.lua'

--helper vars for lua_requirer; other requirers may index theirs vars in loadreq.vars
vars.lua_requirer={
required={}, --to unrequire filepath s do require[s]=nil
required_envs={}, --to prevent garbage collection
requiring={}, --to throw error in case of recursive requiring;
}

--[[lua_requirer(path,cenv,env,renv,rerun,args)
Accepts empty or .lua extensions.
if the rerun flag is true, reloads the file even if it done it before;
if the file has been loaded already returns previous value;
if the file is being loaded returns nil, error_message
else:
loads file in @path;
sets it's env to @env, default {} with metatable with __index set to @renv, default _G;
calls the function with unpack(@args) and returns and saves either
    the function return
    a shallow copy of the functions environment
]]

function lua_requirer(path,cenv,t)
    local env,renv,rerun,args=t.env,t.renv,t.rerun,t.args

    local err_prefix='lua_requirer:'
    local vars=vars.lua_requirer
    local _,ext=getNameExpansion(path)
    if not (ext=='' or ext=='lua' or ext==nil) then
        return nil, err_prefix..'wrong extension:'..ext
    end

    if vars.requiring[path] then
        return nil, err_prefix..'file is being loaded'
    end
    if not rerun and vars.required[path] then
        return vars.required[path]
    end

    local f,e=loadfile(path,path)
    if not f then
        return nil,err_prefix..'loadfile:'..e
    end
    env=env or {}
    env._FILE_PATH=path
    vars.required_envs[path]=env
    setfenv(f,env)
    renv=renv or _G
    setmetatable(env,{__index=renv})
    vars.requiring[path]=true
    local ok,r=pcall(f,args)
    vars.requiring[path]=nil
    if not ok then
        return nil,err_prefix..'while calling module:\n'..r
    elseif r then
        vars.required[path]=r
        return r
    else
        local t={}
        for i,v in pairs(env) do
            t[i]=v
        end
        vars.required[path]=t
        return t
    end
end

--replacement for os_loadAPI that keeps APIS to the caller's env
--local old_os_loadAPI=os.loadAPI
--new_os_loadAPI=function(p)
--  local cenv=getfenv(2)
--  local r,e=loadreq.lua_requirer(p,cenv)
--  if r then
--      local name=getNameExpansion(p)
--      protect(r)
--      cenv[p]=r
--  else
--      error('os.loadAPI(loadreq version):'..e..'\n'..'path='..p,2)
--  end
--end

--[[add your requirers here;
each must
take as arguments (path,cenv,...) where
    path is the path to required file
    cenv is the environment of the caller of @require
    ... are extra arguments passed to @require
return
    one value to be returned by @require
    false|nil, error_message in case of failure
]]
vars.requirers={lua=lua_requirer}

function sufix(s)
    return string.gsub('@/?;@/?.lua;@/?/init.lua;@/?/?.lua;@/?/?;@','@',s)
end


local function _find(s,paths,caller_env)
    local err={'_find: finding '..tostring(s)}

    if paths then
    elseif caller_env.REQUIRE_PATH then
        paths=caller_env.REQUIRE_PATH
    elseif caller_env.PACKAGE_NAME and caller_env._FILE_PATH then
        paths=sufix(string.match(caller_env._FILE_PATH,'^(.-'..caller_env.PACKAGE_NAME..')'))..';'..vars.paths
    elseif  caller_env._FILE_PATH then
        paths=sufix(getDir(caller_env._FILE_PATH))..';'..vars.paths
    else
        paths=vars.paths
    end

    --replace . by / and .. by .
    s=string.gsub(s,'([^%.])%.([^%.])','%1/%2')
    s=string.gsub(s,'^%.([^%.])','/%1')
    s=string.gsub(s,'%.%.','.')

    local finders=vars.finders

    local finder,path
    for i=1,#finders do
        finder=finders[i]
        for search_path in string.gmatch(paths,';?([^;]+);?') do
            path=finder(search_path,s)
            if path then return path end

        end
    end
    table.insert(err,'_find:file not found:'..s..'\ncaller path='..(caller_env._FILE_PATH or 'not available'))
    local serr=table.concat(err,'\n')
    log('loadreq','ERROR','_find:%s',serr)
    return nil,serr
end
find=_find

local function _require(s,opt,caller_env)
    local err={}
    table.insert(err,'loadreq:require: while requiring '..tostring(s))
    local path,e=_find(s,opt.path,caller_env)
    if path==nil then
        table.insert(err,e)
        return nil, table.concat(err,'\n')
    end
    for req_name,requirer in pairs(vars.requirers) do
        local r,e=requirer(path,caller_env,opt)
        if r then
            return r,path
        else
            table.insert(err,e)
        end
    end
    return nil, table.concat(err,'\n')
end

--[[require(s,paths,...)
@paths is a string of paths separated by ';' where there can be '?'
-acquires @paths variable, by the following order;
    0-arg @paths
        Example (_FILE_PATH='myFolder/myFolder2/myAPI.lua'):
        myAPI=require('myFolder2.myAPI','myFolder/?.lua')
    1-REQUIRE_PATH in the caller's path, if existent
        Example (_FILE_PATH='myFolder/myFolder2/myAPI.lua'):
        REQUIRE_PATH='myFolder/?.lua'
        myAPI=require'myFolder2.myAPI'
    2-directory named PACKAGE_NAME in _FILE_PATH, if defined in the caller's environment
    with sufixes appended by @sufix and concatenated with @vars.paths.
    _FILE_PATH is set, for instance, by lua_loader in the files it loads.
        Example (_FILE_PATH='myFolder/myFolder3/myFolder/runningFile'):
        PACKAGE_NAME='myFolder'
        myAPI=require'myAPI' --@paths is 'myFolder/?;myFolder/?.lua;myFolder/?/init.lua;myFolder/?/?.lua;myFolder/?/?;myFolder'
    3-directory of _FILE_PATH, if defined
    with sufixes appended by @sufix and concatenated with @vars.paths.
        Example (_FILE_PATH='myFolder/runningFile'):
        myAPI=require'myAPI' --@paths is 'myFolder/?;myFolder/?.lua;myFolder/?/init.lua;myFolder/?/?.lua;myFolder/?/?;myFolder'
    [email protected] as set in loadreq.vars.paths
-replaces '.' in @s by '/' and '..' by '.'
--for all search_path in @paths
 -  for all iterators in vars.finders, iterates over the paths returned;
    default iterator:   see @direct
-for the first valid path, calls the loaders sequentially until one succeds,
in which case it returns the first value that the loader returns, else if it returns nil,e accumulates e as an error message
els, if all loaders fail, errors immediatly, printing all error messages
-in case of failure finding the path, errors with useful info
]]

function require(s,opt)
    opt=opt or {}
    local t,e=_require(s,opt,getfenv(2))
    if t==nil then
        log('loadreq','ERROR','require:%s',e)
        error(e,1)
    else
        log('loadreq','INFO','require: success in requiring [%s]',e)
        return t
    end
end

---same as require, but copies the returned API to the caller's environment
function include(s,opt)
    opt=opt or {}
    local caller_env=getfenv(2)
    local t,e=_require(s,opt,caller_env)
    if t then
        for i,v in pairs(t) do
            if type(i)=='string' and i:sub(1,1)~='_' then
                caller_env[i]=v
            end
        end
        return true
    else
        log('loadreq','ERROR','include:%s',e)
        error(e,1)
    end
end

function reload(s,opt)
    opt=opt or {}
    opt.rerun=true
    return require(s,opt)
end

--protection utilities; these are meant more as a warning than OS-grade protection
vars.bProtected=true
local function protected_access(t,k,v)
    if vars.bProtected then
        error( "Attempt to write to protected" )
    else
        rawset( t, k, v )
    end
end
function protect(_t)--shallow protection for tables (slows down access to the tables themselves, not to their values, e.g. local t.a=protected_table.a print(a) should do the trick)
    local meta = getmetatable( _t )
    if meta == "Protected" then
        -- already hard protected
        return
    end
    if meta then
        meta.__newindex = protected_access
    else
        setmetatable( _t, {__newindex = protected_access} )
    end
end
function unprotect(_t)--removes the shallow protection
    local meta = getmetatable( _t )
    if not meta then
        return
    end
    vars.bProtected=false
    meta.__newindex=nil
    vars.bProtected=true
end

function permaProtect(_t) --same as the os.loadAPI does
    local meta = getmetatable( _t )
    if meta == "Protected" then
        -- already hard protected
        return
    end
    setmetatable( _t, {
        __newindex = function( t, k, v )
            if vars.bProtected then
                error( "Attempt to write to protected" )
            else
                rawset( t, k, v )
            end
        end,
        __metatable = 'Protected',
    } )
end

env=getfenv()
return env
]===================],"CoolisOS/bin/kernel/log",true,"CoolisOS/bin/kernel/log/init.lua",[===================[------------------------------------------------------------------------------
-- Log library provides logging facilities.
-- The module exposes extension points. It is possible to provide both the custom printing function and the custom log saving function. <br />
-- The module is callable. Thus:
--    local log = require"log"
--    log("MODULE", "INFO", "message")
-- calls the @{#log.trace} function.
-- @module log
--
local assert,string,pcall,table,tostring,setmetatable,os,pairs,next,print,math,type,unpack=
assert,string,pcall,table,tostring,setmetatable,os,pairs,next,print,math,type,unpack
local base = _G

local util=require'kernel.util'
local check =require'kernel.checker'.check
local textutils=textutils
local string=string
--temporary
local pprint=pprint

--no more global access
local env=getfenv()
setmetatable(env,nil)

function s_to_real(t)
    local n_s=t%60
    local m=((t-n_s)/60)
    local n_m=m%60
    local h=((m-n_m)/60)
    return h,n_m,n_s
end
local os_time= function()
    local mc='Day '..os.day()..', '..textutils.formatTime(os.time())
    local t=os.clock()
    local h,n_m,n_s=s_to_real(t)
    local sec=tostring(n_s)
    local s,p,e=sec:match('^([^%.]*)(%.)([^%.]*)$')
    s=s or '0'
    p=p or '.'
    e=e or '0'
    s=string.rep('0',2-s:len())..s
    e=e..string.rep('0',2-e:len())
    sec=s..p..e
    local real=string.format('%sh%sm%ss',h,n_m,sec)
    return string.format('%s',sec)--string.format('%s;%s;%s',mc,real,sec)
end

-------------------------------------------------------------------------------
-- Log levels are strings used to filter logs.
-- Levels are to be used both in log filtering configuration (see @{#log.setLevel}) and each time
-- @{#log.trace} function is used to issue a new log.
--
-- Levels are ordered by verbosity/severity level.
--
-- While configuring log filtering, if you set a module log level to 'INFO' level for exemple, you
-- enable all logs *up to* 'INFO', that is to say that logs with 'WARNING' and 'ERROR' severities will
-- be displayed too.
--
-- Built-in values (in order from the least verbose to the most):
--    - 'NONE':    filtering only: when no log is wanted
--    - 'ERROR':   filtering or tracing level
--    - 'WARNING': filtering or tracing level
--    - 'INFO':    filtering or tracing level
--    - 'DETAIL':  filtering or tracing level
--    - 'DEBUG':   filtering or tracing level
--    - 'ALL':     filtering only: when all logs are to be displayed
-- @type levels
--
levels = {}
-- Severity name <-> Severity numeric value translation table (internal purpose only)
for k,v in pairs{ 'NONE', 'ERROR', 'WARNING', 'INFO', 'DETAIL', 'DEBUG', 'ALL' } do
    levels[k], levels[v] = v, k
end

-- -----------------------------------------------------------------------------
-- Default verbosity level.
-- Default value is `"WARNING"`.
-- @field [parent=#log] #levels defaultlevel
-- See @{#log} for a list of existing levels.

local defaultlevel = defaultlevel or levels.WARNING

-- -----------------------------------------------------------------------------
-- Per module verbosity levels.
-- @field [parent=#log] modules
-- See @{#levels} to see existing levels.

local modules = modules or { }


-- -----------------------------------------------------------------------------
-- The string format of the timestamp is the same as what os.date takes.
-- Example: "%F %T"
-- #field [parent=#log] #string timestampformat
timestampformat = nil

-- -----------------------------------------------------------------------------
-- logger functions, will be called if non nil
-- the loggers are called with following params (module, severity, logvalue)
-- -----------------------------------------------------------------------------

-------------------------------------------------------------------------------
-- Default logger for instant display.
-- This logger can be replaced by a custom function.
-- It is called only if the log needs to be traced.
--
-- @function [parent=#log] displaylogger
-- @param #string module string identifying the module that issues the log
-- @param severity string representing the log level, see @{log#levels}.
-- @param msg string containing the message to log.
--
displaylogger = function(_, _, ...)
   -- if base.print then base.print(...) end
end

-------------------------------------------------------------------------------
-- Logger function for log storage.
-- This logger can be replaced by a custom function.
-- There is no default store logger.
-- It is called only if the log needs to be traced (see @{#log.musttrace}) and after the log has been displayed using {displaylogger}.
--
-- @function [parent=#log] storelogger
-- @param module string identifying the module thats issues the log
-- @param severity string representing the log level, see @{log#levels}.
-- @param msg string containing the message to log.
--

storelogger = nil

-------------------------------------------------------------------------------
-- Format is a string used to apply specific formating before the log is outputted.
-- Within a format, the following tokens are available (in addition to standard text)
--
--- %l => the actual log (given in 3rd argument when calling log() function)
--- %t => the current date
--- %m => module name
--- %s => log level (severity), see @{log#levels}
--@field [parent=#log] #string format
format = nil

local function loggers(...)
    if displaylogger then displaylogger(...) end
    if storelogger then storelogger(...) end
end

-------------------------------------------------------------------------------
-- Determines whether a log must be traced depending on its severity and the
-- module issuing the log. This function is mostly useful to protect `log()`
-- calls which involve costly computations
--
-- @usage
--
--    if log.musttrace('SAMPLE', 'DEBUG') then
--        log('SAMPLE', 'DEBUG', "Here are some hard-to-compute info: %s",
--            computeAndReturnExpensiveDebugString())
--    end
--
-- @function [parent=#log] musttrace
-- @param modulename string identifying the module that issues the log.
-- @param severity string representing the log level, see @{log#levels}.
-- @return `nil' if the message of the given severity by the given module should
-- not be printed.
-- @return `true` if the message should be printed.
--
function musttrace(module, severity)
    -- get the log level for this module, or default log level
    local lev, sev = modules[module] or defaultlevel, levels[severity]
    return not sev or lev >= sev
end

local function debug_getinfo(...)
    return (base.debug and base.debug.getinfo or tostring)(...)
end
-------------------------------------------------------------------------------
-- Prints out a log entry according to the module and the severity of the log entry.
--
-- This function uses @{#log.format} and @{#log.timestampformat} to create the
-- final message string. It calls @{#log.displaylogger} and @{#log.storelogger}.
--
-- @function [parent=#log] trace
-- @param modulename string identifying the module that issues the log.
-- @param severity string representing the level in @{log#levels}.
-- @param fmt   string format that holds the log text the same way as string.format does.
--              function must return fmt (string) , vararg
-- @param varargs additional arguments can be provided (as with string.format).
-- @usage trace("MODULE", "INFO", "message=%s", "sometext").
--
function trace(module, severity, fmt, ...)
    local args
    if type(fmt)=='function' then
        local t={fmt(...)}
        fmt=table.remove(t,1)
        args=t
    else args={...} end
    check('string,string,string',module, severity, fmt)
    if not musttrace(module, severity) then return end
    local c, s = pcall(string.format,fmt, unpack(util.map_args(args,function(v) if (type(v)=='number' or type(v)=='string') then return v else return debug_getinfo(v) end end)))
    if c then
        local t
        local function sub(p)
            if     p=="l" then return s
            elseif p=="t" then t = t or tostring(os_time(timestampformat)) return t
            elseif p=="m" then return module
            elseif p=="s" then return severity
            else return p end
        end
        local out = (format or "%t %m-%s: %l"):gsub("%%(%a)", sub)
        loggers(module, severity, out)
    else -- fallback printing when the formating failed. The fallback printing allow to safely print what was given to the log function, without crashing the thread !
        --trace(module, severity, "\targs=("..table.concat(args, " ")..")" )
        loggers(module, severity, "Error in the log formating! ("..tostring(s)..") - Fallback to raw printing:" )
        loggers(module, severity, string.format("\tmodule=(%s), severity=(%s), format=(%q), args=(%s)", module, severity, fmt,table.concat(util.map_args(args,debug_getinfo),',') ))
    end
end


-------------------------------------------------------------------------------
-- Sets the log level for a list of module names.
-- If no module name is given, the default log level is affected
-- @function [parent=#log] setLevel
-- @param slevel level as in @{log#levels}
-- @param varargs Optional list of modules names (string) to apply the level to.
-- @return nothing.
--
function setLevel(slevel, ...)
    local mods = {...}
    local nlevel = levels[slevel] or levels['ALL']
    if not levels[slevel] then
        trace("LOG", "ERROR", "Unknown severity %q, reverting to 'ALL'", tostring(slevel))
    end
    if next(mods) then for _, m in pairs(mods) do modules[m] = nlevel end
    else defaultlevel = nlevel end
end

---
local wrapped=setmetatable({},{__mode='k'})
function wrap_class(k)
    assert(not wrapped[k])
    local old=k.__init
    rawset(k,'__init',function(...)
        old(...)
        env(tostring(k.__name),'DETAIL','initiated obj %s with args ',debug_getinfo(obj),args_tostring(...))
    end)
    wrapped[k]=old
end
function unwrapp_class(k)
    if wrapped[k] then
        rawset(k,'__init',wrapped[k])
        wrapped[k]=nil
    end
end
-- -----------------------------------------------------------------------------
-- Make the module callable, so the user can call log(x) instead of log.trace(x)
-- -----------------------------------------------------------------------------
setmetatable(env, {__call = function(_, ...) return trace(...) end })
return env

]===================],"CoolisOS/bin/kernel/log/store.lua",[===================[local store={}
local log_dir=fs.combine(_INSTALL_PATH,'ect/log')
if not fs.exists(log_dir) then
    fs.makeDir(log_dir)
end


local his={}

local function flush_file(s)
    local f=fs.open(s,'a')
    for i,v in pairs(his[s]) do
        f.writeLine(v)
    end
    f.close()
    his[s]=nil
end

function store.flush(module)
    if not module then
        for s,t in pairs(util.shcopy(his)) do
            flush_file(s)
        end
    else
        local s=fs.combine(log_dir,module..'.log')
        flush_file(s)
    end
end

store.instant=false
function store.append(module,msg)
    local s=fs.combine(log_dir,module..'.log')
    his[s]=his[s] or {}
    table.insert(his[s],msg)
    if store.instant==true then
        flush_file(s)
    end
end

function store.reset(module)
    if module then
        fs.open(fs.combine(log_dir,module..'.log'),'w').close()
    else
        fs.delete(log_dir)
        fs.makeDir(log_dir)
    end
end
log.storelogger=function(module,severity,msg)
    store.append(module,msg)
    store.append('log',msg)
end
return store]===================],"CoolisOS/bin/kernel/sched",true,"CoolisOS/bin/kernel/sched/barrier.lua",[===================[local check=require 'kernel.checker'.check

PACKAGE_NAME='sched'

local sched=require 'init'

--------------------------------------------------------------------------------
-- Object metatable/class
--------------------------------------------------------------------------------
local B={__type='barrier'};B.__index=B

--------------------------------------------------------------------------------
-- A registry of all currently active barriers. This is intended as a debug aid,
-- and can be safely commented out if not needed
--------------------------------------------------------------------------------
sched.barriers = setmetatable({}, {__mode='kv'})

function barrier(n)
    check ('integer',n)
    local instance={n=n}
    if sched.barriers then
        sched.barriers[tostring(instance):match(':.(.*)')]=instance
    end
    setmetatable(instance,B)
    return instance
end

B.reach=function(self)
    if self.n<=1 then
        self.n=0
        sched.signal(self,'zero')
    else
        self.n=self.n-1
        sched.wait(self,'zero')
    end
end

return barrier]===================],"CoolisOS/bin/kernel/sched/catalog.lua",[===================[--- A general purpose Catalog.
-- The catalog is used to give tasks well known names for sharing purposes.
-- It also allows synchronization, by blocking the requester until the object
-- is made available. Catalogs themselves are made available under a Well Known
-- name. Typical catalogs are "tasks", "mutexes" and "pipes".
-- The catalog does not check for multiple names per object.
-- @module catalog
-- @usage local tasks = require 'catalog'()
--...
--tasks:register('a task', sched.Task.running)
--...
--local a_task=tasks:waitFor('a task')
-- @alias M
include'kernel.class'
local log = require'kernel.log'
local check=require'kernel.checker'.check

local named=setmetatable({},{__mode='kv'})

class.Catalog()
local C=Catalog
C.named=named
function C:__init()
    self.objs=setmetatable({},{__mode='kv'})
end
function C:register(obj,name)
    if type(obj)~='table' then error('not a table',2) end
    if self.objs[name]~=nil and self.objs[name]~=obj then error('name taken',2) end
    self.objs[obj]=name
    self.objs[name]=obj
    sched.signal(self,'+'..name,obj)

    named[obj]=named[obj] or setmetatable({},{__mode='kv'})
    named[obj][self]=true
end
function C:unregister(id)
    local s = self.objs[id]
    local name=type(s)=='string' and s or id
    self.objs[s]=nil
    self.objs[id]=nil

    if named[obj] then
        named[obj][self]=nil
    end
    sched.signal(self,'-'..name,obj)
end
function C:waitFor(name,timeout)
    check('string',name)
    log('catalog', 'INFO', 'catalog %s queried for name "%s" by %s',self, name,sched.me())

    local obj
    if self[name] then return self[name] else
        local em,ev,o=sched.wait(self,'+'..name,timeout)
        if em==self then obj=o end
    end
    log('catalog', 'INFO', 'catalog %s queried for name "%s" by %s, found %s',self, name,sched.me(),obj)
    return obj
end
function C:__tostring()
    local t={}
    for i,v in pairs(self.objs) do
        if type(i)=='string' then t[i]=i..'->'..debug.getinfo(v) end
    end
    return debug.getinfo(self)..'\n'..pstring(t,1)
end

sched.Catalog=Catalog]===================],"CoolisOS/bin/kernel/sched/init.lua",[===================[include'kernel.class'
local log=require'kernel.log'
local check=require'kernel.checker'.check
local Linked=require 'utils.linked'
local table=table
local pairs=pairs

local sched,Obj,Sync,Task,timer,platform
local os_time

local fil
--[[
2D array of sets of objs, fil[emitter][event][obj]=true
wildcards for emitter, event are '*'; can only be used for listening
reserved values; do not use for custom signals:
    -emitters:
        'timer'     -timer module;
        'platform'  -events yielded to the scheduler by os.pullEventRaw
]]


---emits a signal with emitter @emitter, event @event and parameters @vararg (...)
--can be called recursively; be careful not to signal the same entry which is being run
--to use infinite loops of signals (e.g. A->B->A) blocking the scheduler, use @Task or @Call instances.
local signal = function (emitter,event,...)
    log('sched', 'DEBUG', "SIGNAL [%s].[%s]", emitter, event)
    local function walk_event(evl,emitter,event,...)
        local copy={}
        for obj,val in pairs(evl) do
            copy[obj]=val
        end
        for obj,val in pairs(copy) do
            -- if d then print(obj) end
            obj:handle(emitter,event,...)
        end
    end

    local function walk_emitter(eml,emitter,event,...)
        local evl=eml[event]
        if evl then
            walk_event(evl,emitter,event,...)
        end
        evl=eml['*']
        if evl then
            walk_event(evl,emitter,event,...)
        end
    end

    local eml=fil[emitter]
    if eml then
        walk_emitter(eml,emitter,event,...)
    end
    local eml=fil['*']
    if eml then
        walk_emitter(eml,emitter,event,...)
    end

    return true
end

--[[Class that Task,Sync implement and that describes what can be put into the waiting table @fil.
--Objs instances keep track of which signals call their @handle field in their @fil field;
--their @parent and @subs fields maintain a tree-like hierarchy used to destroy @subs from an object before destroying the object itself.
--Objs expect to have defined a handle field consisting of a function used to process signals received, syncronously:
--@handle is a function called with args (obj,emitter,event,...) everytime a signal (emitter,event,...) that obj is linked too is emitted.
]]
Obj=class('Obj')
do
local O=Obj
--@name is an optional parameter to set a debugging name
function O:__init()
    self.fil={}
    self.subs={}
    if sched.running then self:setParent(sched.running) end
end

---Takes a link descriptor and tranforms them into a a proper link table for Obj methods to consume
--supports emitter,ev1,ev2,...,timeout
--or {[emt1]={ev1,ev2,...},...},timeout
local function get_args(...)
    local args={...}
    local nargs=#args
    local t,timeout
    if type(args[nargs])=='number' then
        timeout=args[nargs]
        nargs=nargs-1
    end
    if nargs~=0 then
        if nargs==1 and typeof(args[1])=='table' then
            t=args[1]
        else
            t={[args[1]]={nargs==1 and '*' or unpack(args,2,nargs)}}
        end
    end
    return t,timeout
end

--helper
local add_timer=function(t,nd)
    t=t or {}
    if nd then
        if not t[timer] then
            t[timer]={nd}
        else
            table.insert(t[timer],nd)
        end
    end
    return t
end

function get_t(...)
    local t,timeout=get_args(...)
    if timeout then t=add_timer(t,timeout+os_time()) end
    return t
end

---Registers @obj in the waiting table @fil in the waiting sets described by the link table @t
function O:link(...)
    local t=get_t(...)
    if t==nil then return end
    local ofil=self.fil
    local root=self.__root
    local fil_tev,ofil_tev,fil_tobj
    for em,tev in pairs(t) do
        if type(tev)~='table' then error('Wrong struct for link',2) end
        fil_tev=fil[em]
        ofil_tev=ofil[em]
        if not ofil_tev then
            ofil[em]={}
            ofil_tev=ofil[em]
            if not fil_tev then fil[em]={} fil_tev=fil[em] end
        end
        local ev
        for i=1,#tev do
            ev=tev[i]
            ofil_tev[ev]=true
            fil_tobj=fil_tev[ev]
            if not fil_tobj then fil_tev[ev]={} fil_tobj=fil_tev[ev] end
            fil_tobj[root]=true
        end
    end
end

---Unregisters @obj in the waiting table @fil from the waiting sets described by the link table @t
function O:unlink(...)
    local r=self.__root
    local t=get_t(...)
    if t==nil then return end
    local ofil=self.fil
    local fil_tev,ofil_tev,fil_tobj
    for em,tev in pairs(t) do
        ofil_tev=ofil[em]
        if ofil_tev then
            fil_tev=fil[em]
            local ev
            for i=1,#tev do
                ev=tev[i]
                if ofil_tev[ev] then
                    ofil_tev[ev]=nil

                    fil_tobj=fil_tev[ev]
                    fil_tobj[r]=nil
                    if not next(fil_tobj) then fil_tev[ev]=nil end
                end
            end
            if not next(ofil_tev) then ofil[em]=nil end
            if not next(fil_tev) then fil[em]=nil end
        end
    end
end

---Unregisters @obj from all the waiting sets it is linked to.
function O:reset()
    local fil_tev
    local r=self.__root
    for em,tev in pairs(self.fil) do
        fil_tev=fil[em]
        if fil_tev then
            for ev in pairs(tev) do
                -- print(ev,'|',self,'|',fil_tev[ev],'|',fil_tev[ev][self])
                if fil_tev[ev] then
                    fil_tev[ev][r]=nil
                    if not next(fil_tev[ev]) then fil_tev[ev]=nil end
                end
            end
            if not next(fil_tev) then fil[em]=nil end
        end
    end
    self.fil={}
end

local ending={n=0}
--helper
---Kills @obj 's subs and removes it from the waiting sets.
function O:silent_destroy()
    local root=self.__root
    if ending[root] then
        error('Detected recursion in Obj.finalize: ending stack='..pstring(ending),2)
    else
        ending.n=ending.n+1
        ending[root]=ending.n
    end
    --handle subs
    while next(self.subs) do
        next(self.subs):destroy()
    end

    if self.parent then
        self.parent.Obj.subs[root]=nil
    end
    --remove self from the waiting sets
    self:reset()

    --remove self from the action queue
    sched.queue:remove(root)

    ending[root]=nil
    ending.n=ending.n-1
end

---same as @O:silent_destroy, but throws some useful warning signals.
function O:destroy(...)
    if not self.destroyed then
        local r=self.__root
        signal(r,'dying',...) --warns subs
        self:silent_destroy()
        signal(r,'dead',...)
        self.destroyed=true
    end
end

local function check_tree(self,new_parent,seen)
    if new_parent==nil then return true,seen end
    new_parent=new_parent.__root
    local r=self.__root
    seen=seen or {r,[r]=true}
    if seen[new_parent] then return false,seen end
    table.insert(seen,new_parent)
    seen[new_parent]=true
    return check_tree(new_parent,new_parent.Obj.parent,seen)
end
---Changes  an @obj parent field.
function O:setParent(parent)
    local rparent,oparent=parent.__root,parent.Obj
    local root=self.__root
    local ok, t=check_tree(self,self.parent)
    if not ok then error('Cycle detected in scheduler hierarchy;debug:'..pstring(t),2) end
    if rparent==root then error("A scheduler object cannot be it's own parent",2) end
    if self.parent then self.parent.Obj.subs[root]=nil end
    self.parent=rparent
    oparent.subs[root]=true
    log('sched','DETAIL','(%s) parent set to (%s) by (%s)',self.__root,(parent and parent.__root),sched.running or 'nil')
end

local TIMEOUT_TOKEN={}
---helpers for linking @obj to timer signals
function O:setTimeout(timeout)
    if type(timeout)~='number' then
        error('timeout must be number',2)
    else
        timeout=timer.norm(timeout)
    end
    self:cancelTimeout()
    self[TIMEOUT_TOKEN]={
    timeout=timeout,
    td={timer={timeout+os_time()}},
    }
    self:link(self[TIMEOUT_TOKEN].td)
    return self
end

---cancels the current timeout and sets a new one in @timeout seconds, where @timeout was set by @O:setTimeout
function O:resetTimeout()
    local td=self[TIMEOUT_TOKEN]
    if td then
        self:unlink(td.td)
        td.td[timer][1]=os_time()+td.timeout
        self:link(self.td.td)
    end
end

---cancels the current timeout
function O:cancelTimeout()
    local td=self[TIMEOUT_TOKEN]
    if td then
        self:unlink(td.td)
        self.td=nil
    end
end

function O:__debug()
    local fil={}
    for i,v in pairs(self.fil) do
        local k=debug.getinfo(i)
        fil[k]={}
        for j in pairs(v) do
            table.insert(fil[k],debug.getinfo(j))
        end
    end
    return string.format('%s;   \nWait descriptor:%s',debug.objinfo(self),pstring(fil))
end
end

 --[[syncronous calls; are called as soon as the signal is received, but can't block as tasks do
once are one-use,
on are permanent,
]]
Sync=class('Sync',Obj)
do
local S=Sync
local sync_once_handle = function(self,...)
    local sync=self.Sync
    local running=sched.running
    sched.running=self
    sync.f(...)
    self:destroy()
    sched.running = running
end
local sync_on_handle=function(self,...)
    local running=sched.running
    sched.running=self
    local sync=self.Sync
    sync.f(...)
    self:resetTimeout()
    sched.running=running
end
function S:__init(f,mode)
    check('function',f)
    mode=mode or 'on'
    Obj:__init(self)
    if mode=='once' then
    elseif mode=='on' then
    else error('mode?',2) end
    self.f=f
    self.mode=mode
    log('sched','INFO','(%s) created with mode %s by (%s)',self,mode,sched.running or 'nil')
end
function S:handle(...)
    if self.mode=='on' then
        sync_on_handle(self,...)
    else
        sync_once_handle(self,...)
    end
end
end
--asyncronous calls through coroutines
Task=class('Task',Obj)
do
local T=Task
---Creates a task object in paused mode;
---fields set by Task.new are
--co: matching coroutine
--args: table of args to unpack and pass to co
--parent: parent task
--subs: sub tasks (see @{Task.setSub} and @{Task.setParent}
--name: name used for logging and result of tostring(task)
--Can take either (f) or (name,f) as args
--@return task
function T:__init(f,...)
    check('function',f)
    Obj:__init(self)
    self.co=coroutine.create( f )
    self._resume=function(co)
        s,m=coroutine.resume(self.co,unpack(self.args))
        self._resume=coroutine.resume
        return s,m
    end
    self.args={...}
    log('sched', 'INFO', 'created (%s) from function (%s) by (%s)', self, f,sched.running or 'nil')
end

---Schedules a task for execution with args (...)
--If T:handle is called several times before resuming the task, task.args will be overwritten and the last args set will be the last ones.
function T:handle(...)
    self.args={...} --no point in catching args after nil, since self.args is unpacked before returning to the task.
    sched.queue:push(self)
    sched.ready=true

    log('sched', 'DETAIL', 'Task:handle rescheduling (%s) to receive SIGNAL [%s].[%s]',
    self,...)
    return self
end

---Runs a task with initial args ...
--@param vararg optional arguments to start the task with
--@return task
function T:run(...)
    self.args={...}
    sched.queue:push(self)
    log('sched', 'INFO', "Task.run scheduling (%s)", self)
    return self
end

--- Finishes a task and destroys it's subs.
-- @param self task to terminate (see @{Task.new})
-- @return  task
function T:destroy()
    if self.status~='dead' then
        log('sched', 'INFO', "Task.destroy destroying (%s) from (%s)",self,sched.running or 'nil')
        self.Obj:destroy()
        self.status='dead'
        if Task.running and Task.running.status=='dead' and Task.running.co==coroutine.running() then
            coroutine.yield()
        end
    end
    return self
end

function T:resume()
    sched.running = self

    local co=self.co
    Task.running=self

    log('sched', 'DETAIL', "Resuming (%s)", self)
    local success, msg = self._resume(co)
    log('sched', 'DETAIL', "Exited (%s)", self)
    Task.running=nil
    self.args={}
    sched.running = nil
    if not success then
        -- report the error msg
        log('sched', 'ERROR', "In (%s):%s",self,msg)
        signal(self, "error",success, msg)
        --preserve events/subs for error catchers to analize, and then finalize
        self:destroy(success,msg)
    elseif coroutine.status (co) == "dead" then --If the coroutine died, signal it for those who synchronize on its termination.
        log('sched', 'INFO', "(%s) is dead", self)
        self:destroy(success,msg)
    end
end

--- Waits for a signal
--Can only be called from a task
--If called with no arguments, yields and reschedules for execution
--If called with false as argument, yields without rescheduling for execution
-- @param vararg an entries descriptor for the signal (see @{get_args})
-- @return  emitter, event, parameters
function T:wait(...)
    local task = self
    if task.co~=coroutine.running() then error('calling Task.wait outside a task/inside a task but inside another coroutine',2) end
    if (...)==nil then
        sched.queue:push(task)
        log('sched', 'DETAIL', "Task.wait rescheduling (%s) for resuming ASAP", task)
    elseif ... then
        task:link(...)
        log('sched', 'DETAIL', "(%s) waiting", task)
    else
        log('sched', 'DETAIL', "(%s) waiting for pre-set signals", task)
    end
    coroutine.yield ()
    if ... then
        task:reset()
    end
    return unpack(task.args)
end

---resets the Task class vars
function Task._reset()
    Task.running=nil
end

---Some pre-built utilities for tasks
--- Create a task that listens for a signal.
-- @param f function to be called when the signal appears. The signal
-- is passed to f as parameter. The signal will be provided as
-- emitter, event, parameters, just as the result of a @{wait}
-- @param vararg a Wait Descriptor for the signal (see @{get_args})
-- @return task in the scheduler
Task.sigrun= function (f,...)
    local ff=function()
        while true do
            f(sched.wait(false))
        end
    end
    local t=Task(ff)
    t:link(...)
    return t
end
--- Create a task that listens for a signal, once.
-- @param f function to be called when the signal appears. The signal
-- is passed to f as parameter. The signal will be provided as
-- _emitter, event, parameters_, just as the result of a @{wait}
-- @param vararg a Wait Descriptor for the signal (see @{get_args})
-- @return task in the scheduler
Task.sigrunonce= function (f,...)
    local ff=function()
        f(sched.wait(false))
    end
    local t=Task(ff)
    t:link(...)
    return t
end
end


do
sched={
--modules and respective shortcuts
signal=signal,
emit=function(...)
    sched.signal(sched.me(),...)
end,

Obj=Obj,
ready=false,
me=function() return sched.running end,
Task=Task,
Sync=Sync,
-- Call=Call,
-- Wait=Wait,

sigonce=function(f) return Sync(f,'once') end,
sighook=function(f) return Sync(f,'on') end,
wait=function(...) return sched.running:wait(...) end,
sigrun=Task.sigrun,
sigrunonce=Task.sigrunonce,

--others
}
local _require=function(p,t)
    t=t or{}
    t.env={sched=sched}
    return require(p,t)
end
platform=_require'platform'

os_time=platform.time

timer=_require'timer'

_require'pipe'
_require'catalog'



local loop_state = 'stopped' -- stopped, running or stopping

function sched.step()
    local old = sched.queue
    sched.queue=Linked()
    --------------------------------------------------------------------
    -- going through `self.queue` until it's empty.
    --------------------------------------------------------------------
    while true do
        local obj = old:remove() --pops first from left->right
        if obj==nil then break end

        obj:resume()
    end
    if not sched.queue:isempty() then sched.ready=true end
end

---Exits the scheduler after the current cycle is completed.
function sched.stop()
    log('sched','INFO','(%s) toggling loop_state=%s to stopping',Task.running or 'scheduler',loop_state)
    if loop_state=='running' then loop_state = 'stopping' end
end

---resets internal vars
function sched.reset()
    fil={}
    sched.fil=fil
    sched.running=nil
    sched.queue=Linked()
    Task._reset()
    timer._reset()

    platform._reset() --after timer
    loop_state = 'stopped'
    log('sched','INFO','scheduler cleaned.')
end

---Loops over the scheduler cycle,
--returning to the caller function after sched.stop has been called
--calling platform.step for performing sleeps.
function sched.loop ()
    log('sched','INFO','Scheduler started')
    loop_state = 'running'
    local timeout
    while true do --this block is the scheduler step
        timer.step() -- Emit timer signals
        sched.step() -- Run all the ready tasks
        -- Find out when the next timer event is due
        timeout = nil
        local date = timer.nextevent()
        if date then
            local now=os_time()
            timeout = date<now and 0 or date-now
        end

        if loop_state~='running' then sched.reset() break end
        --debug.log(sched.debug())
        platform.step(timeout) -- Wait for platform events until the next timer is due
        sched.ready=false
    end
end

function sched.debug()
    local d={}
    local t={}
    for em,emt in pairs(fil) do
        local tt={}
        for ev,objt in pairs(emt) do
            local ttt={}
            for obj in pairs(objt) do
                table.insert(ttt,debug.getinfo(obj))
            end
            tt[debug.getinfo(ev)]=ttt
        end
        t[debug.getinfo(em)]=tt
    end
    d.fil=t
    return pstring(d)
end

local t={}
for i,v in pairs(sched) do
    if type(i)=='string' then t[i:lower()]=v end
end
for i,v in pairs(t) do sched[i]=v end

sched.reset()
end
return sched]===================],"CoolisOS/bin/kernel/sched/lock.lua",[===================[--------------------------------------------------------------------------------
-- Thread-bound lock objects
-- =========================
--
-- A lock allows to define atomic units of code execution:
-- a portion of code that is protected by a lock will never be executed by more
-- than one thread at a time.
-- Because of the use of coroutines for the threading in Lua, the use of locks
-- is only relevant when you want to protect a portion of code that contains
-- blocking APIs (i.e. network access, scheduling, etc...)
--
-- A lock must be acquired and released by the same thread: an error will be
-- triggered if a thread tries to release a lock acquired by another thread.
-- This behavior is enforced because it is almost always a concurrency mistake
-- to have a thread releasing another thread's locks; but you can circumvent
-- this by passing the owning thread as an extra parameter.
--
-- A lock is automatically released when its owning thread dies, if it failed
-- to do so explicitly.
--
-- API
-- ---
--
-- lock.new()
--      return a new instance of a lock.
--
-- LOCK :acquire ()
--      acquire the lock.
--
-- LOCK :release ([thread])
--      release the lock. The optional thread param is defaulted to the
--      current thread. A lock must be released by the thread that
--      acquired it (or use the thread params to release another thread's lock).
--
-- LOCK :destroy()
--      destroy the lock. Any waiting thread on that lock will trigger a
--      "destroyed" error
--
--------------------------------------------------------------------------------

--------------------------------------------------------------------------------
-- Associative lock objects
-- ------------------------
--
-- Function lock (object) allows to associate a lock to an arbitrary object.
-- This API creates a standard lock (as above). It removes the burden of
-- creating the lock and managing the association between the object
-- and the lock.
--
-- Locks associated to objects still have an owning thread, and the rule
-- "locks must be released by the thread which owns them" still applies.
--
-- API
--
-- lock.lock (object)
--      lock the object.
--
-- lock.unlock(object, thread)
--      unlock the object. thread is optional as in lock:acquire() function.
--
--------------------------------------------------------------------------------

--------------------------------------------------------------------------------
-- Synchronized functions
-- ----------------------
--
-- A common pattern is to have a function that must not be called more than once
-- at a given time: if the function is already running in another thread, one
-- must wait for this call to finish before calling it again.
--
-- API
--
-- lock.synchronized (f)
--      return a synchronized wrapper around f. A typical idiom is:
--
--      mysynchronizedfunction = lock.synchronized (function (...)
--          [code]
--      end)
--------------------------------------------------------------------------------
include'kernel.class'
local check = require 'kernel.checker'.check

local sched = require 'init'

local setmetatable = setmetatable
local tostring = tostring
local string = string
local error = error
local assert = assert
local table = table
local next = next
local pairs = pairs
local type = type
local unpack = unpack

env=getfenv()
setmetatable(env,nil)

--------------------------------------------------------------------------------
--
--------------------------------------------------------------------------------
class.LOCK()
LOCK.hooks={}
LOCK.objlocks=setmetatable({}, {__mode = "k"})
--------------------------------------------------------------------------------
-- Create a new lock object. It remains unlocked.
--------------------------------------------------------------------------------
setmetatable(env,{__call=function() return LOCK(...) end})
function LOCK:__init()
    self.waiting={}
end
--------------------------------------------------------------------------------
-- Destroy a lock object.
--------------------------------------------------------------------------------
function LOCK:destroy()
    self.owner = "destroyed" -- means that the lock is being destroyed !
    for t, _ in pairs(self.waiting) do
        sched.signal(self, t)
        self.waiting[t] = nil
    end
end

--------------------------------------------------------------------------------
-- Helper to release locks on dead threads.
--------------------------------------------------------------------------------
local function autorelease(thread)
    for l, _ in pairs(LOCK.hooks[thread]) do
        if l.owner == thread then l:release(thread)
        elseif l.waiting then l.waiting[thread] = nil end
    end
    LOCK.hooks[thread] = nil
end

--------------------------------------------------------------------------------
-- Helper to release locks on dead threads.
--------------------------------------------------------------------------------
local function protectdie(self, thread)
    if not LOCK.hooks[thread] then
        local h = sched.sigonce(function()
            autorelease(thread)
        end,thread, "dead")
        LOCK.hooks[thread] = {sighook = h}
    end
    (LOCK.hooks[thread])[self] = true
end

--------------------------------------------------------------------------------
-- Helper to release locks on dead threads.
--------------------------------------------------------------------------------
local function unprotectdie(self, thread)
    (LOCK.hooks[thread])[self] = nil
    if not next(LOCK.hooks[thread], next(LOCK.hooks[thread])) then -- if this was the last lock attached to that thread...
        (LOCK.hooks[thread].sighook):destroy()
        LOCK.hooks[thread] = nil
    end
end

--------------------------------------------------------------------------------
-- Attempt to take ownership of a lock; might block until the current owner
-- releases it.
--------------------------------------------------------------------------------
function LOCK:acquire()
    local t = sched.task.running
    assert(self.owner ~= t, "a lock cannot be acquired twice by the same thread")
    assert(self.owner ~= "destroyed", "cannot acquire a destroyed lock")
    protectdie(self, t) -- ensure that the lock will be unlocked if the thread dies before unlocking...

    while self.owner do
        self.waiting[t] = true
        sched.wait(self,t) -- wait on the current lock with the current thread
        if self.owner == "destroyed" then error("lock destroyed while waiting") end
    end
    self.waiting[t] = nil
    self.owner = t
end

--------------------------------------------------------------------------------
-- Release ownership of a lock.
--------------------------------------------------------------------------------
function LOCK:release(thread)
    thread = thread or sched.task.running
    assert(self.owner ~= "destroyed", "cannot release a destroyed lock")
    assert(self.owner == thread, "unlock must be done by the thread that locked")
    unprotectdie(self, thread)
    self.owner = nil

    -- wakeup a waiting thread, if any...
    local t = next(self.waiting)
    if t then
        sched.signal(self, t)
    end
end

--------------------------------------------------------------------------------
-- Create and acquire a new lock, associated to an arbitrary object.
--------------------------------------------------------------------------------
function lock(object)
    assert(object, "you must provide an object to lock on")
    assert(type(object) ~= "string" and type(object) ~= "number", "the object to lock on must be a collectable object (no string or number)")
    if not LOCK.objlocks[object] then LOCK.objlocks[object] = new() end
    LOCK.objlocks[object]:acquire()
end


--------------------------------------------------------------------------------
-- Release an object created with lock().
--------------------------------------------------------------------------------
function unlock(object, thread)
    assert(object, "you must provide an object to unlock on")
    assert(LOCK.objlocks[object], "this object was not locked")
    LOCK.objlocks[object]:release()
end

--------------------------------------------------------------------------------
-- Create a synchronized version of function f, i.e. a function that behaves
-- as f, except that no more than one instance of it will be running at a
-- given time.
--------------------------------------------------------------------------------
function synchronized(f)
    check(f,'function')
    local function sync_f(...)
        local k = lock (f)
        local r = {f(...)}
        unlock(f)
        return unpack (r, 1, r.n)
    end
    return sync_f
end

return env
]===================],"CoolisOS/bin/kernel/sched/pipe.lua",[===================[--------------------------------------------------------------------------------
-- FIFO PIPES
-- ==========
--
-- Purpose
-- -------
-- Tasks can't easily exchange messages with sighook() or wait():
--
-- Calling wait() in a loop might lose some messages, if a message arrives
-- before the loop had the time to go back to wait(). Example:
--
--     ----------------------------------------------------------
--     -- sender --
--     for i=1, 100 do signal('foo', 'tick', i); sched.wait (2) end
--
--     -- receiver --
--     while true do
--        local  _, n = sched.wait('foo', 'tick')
--        printf ("received %i", n)
--        sched.wait(3)
--     end
--     ----------------------------------------------------------
--
-- sighooks are guaranteed to be called everytime the event is triggered,
-- but they are executed as interruptions, they can't pause a task.
--
-- Pipes solve this issue: everything that is written in a pipe with :send()
-- will be read back, in order, with :receive(). If there's nothing to read yet,
-- the task calling :receive() will pause and wait for the next :send() to
-- provide data to read back.
--
-- :receive() can yield, and therefore must not be used in a sighook.
--
-- :send() can yield only if there is a maxlength and the pipe is already full.
--
--
-- API
-- ---
-- - create a new pipe with:
--    P = pipe()
-- - push data in it with:
--    P :send(x). x can't be nil.
-- - read data back with:
--    P :receive() or P :receive(timeout).
--   This call will block if necessary. It also supports an optional timeout
--   parameter. If there is a timeout and nothing can be read within the delay,
--   nil is returned.
-- - do a non-blocking, non-consumming peek at next value with:
--    P :peek()
--   This might return nil is the pipe is currently empty.
-- - return all of the pipe's current content and reset it as empty with:
--    P :reset()
-- - cancel a reading by pushing back an element in the pipe with:
--    P :pushback(x)
-- - retrieve the number of elements currently in a pipe with:
--    P :length()
-- - tune the recompaction parameters:
--    P :setwaste(absolute_waste_factor, proportional_waste_factor)
--
--
-- Algorithmic complexity
-- ----------------------
-- The amortized complexity for sending and receiving is o(log(N)), N
-- being the current number of elements in the pipe. Notice that with
-- the obvious/naive implentation based on table.insert() and
-- table.remove(), one of the operations is in o(log(N)) but the other
-- is in o(N); therefore, writing K elements then reading them back
-- would have a time complexity in o(K^2), compared to o(K*log(K)) here.
--
--------------------------------------------------------------------------------
include'kernel.class'

local check=require 'kernel.checker'.check

local sched=sched

--------------------------------------------------------------------------------
-- Object metatable/class
--------------------------------------------------------------------------------

sched.Pipe=class'Pipe'
do
local P=sched.Pipe

local insert, remove, os_time = table.insert, table.remove, os.clock

--------------------------------------------------------------------------------
-- A registry of all currently active pipes. This is intended as a debug aid,
-- and can be safely commented out if not needed
--------------------------------------------------------------------------------
sched.pipes = setmetatable({}, {__mode='kv'})

--------------------------------------------------------------------------------
-- Create a new pipe
--------------------------------------------------------------------------------

function P:__init(maxlength)
    check ('?number',maxlength)
    util.shcopy({
        sndidx     = 1;
        rcvidx     = 1;
        content    = { };
        maxlength  = maxlength;
        state      = 'empty';
        wasteabs   = 32 ;
        wasteprop  = 2 },
        self)
    if sched.pipes then
        sched.pipes[debug.getinfo(self)]=self
    end
end

--------------------------------------------------------------------------------
-- Check whether the 'state' field is consistent with the pipe's content
-- and maxlength, produce a signal and change it if needed.
-- Helper for methods which modify content or maxlength.
--------------------------------------------------------------------------------
local function updatestate (self)
    local length   = self.sndidx - self.rcvidx
    local oldstate = self.state
    local newstate = length==0 and 'empty' or self.maxlength==length and 'full' or 'ready'
    if oldstate ~= newstate then
        self.state=newstate
        sched.signal(self, 'state', newstate)
    end
end

--------------------------------------------------------------------------------
-- Move all entries to the beginning of content, if the following conditions
-- are both verified:
--  * there are more than self.wasteabs cells to collect;
--  * the number of wasted cells is at more than self.wasteprop times bigger
--    than the number of actually used cells.
--------------------------------------------------------------------------------
local function recompact (self)
    local rcvidx = self.rcvidx
    local wasted = rcvidx-1
    if wasted <= self.wasteabs then return end
    local sndidx = self.sndidx
    local used = sndidx - rcvidx
    if wasted <= self.wasteprop * used then return end
    -- Tests passed, proceed to recompaction
    local content
    if sndidx<2000 then content = { select (rcvidx, unpack (self.content)) } else
        -- avoid stack overflows: stacks can't grow beyond LUAI_MAXCSTACK,
        -- which is set to 8000 by default. Our choice of 2000 is just as
        -- arbitrary as 8000.
        local oldcontent
        oldcontent, content = self.content, { }
        for i=1,used do content[i]=oldcontent[i+wasted] end
    end
    self.content, self.rcvidx, self.sndidx = content, 1, used+1
end

--------------------------------------------------------------------------------
-- Read a value, yield the current task if necessary
--------------------------------------------------------------------------------
function P :receive (timeout)
    check('?number',timeout)
    local due_date
    while true do
        if self.rcvidx==self.sndidx then
            log('pipe', 'DEBUG', "(%s) empty,(%s) :receive() waits for data", self,sched.running)
            due_date = due_date or timeout and os_time() + timeout
            local timeout = due_date and due_date - os_time()
            if timeout and timeout<=0 or sched.wait(self,'state',timeout)==sched.timer then
                return nil, 'timeout'
            end
        else
            local content, rcvidx = self.content, self.rcvidx
            local x = content[rcvidx]
            content[rcvidx] = false
            self.rcvidx = rcvidx+1
            recompact (self)
            updatestate (self)
            if x~=nil then return x end
        end
    end
end

--------------------------------------------------------------------------------
-- Push a value to read
--------------------------------------------------------------------------------
function P :send (x, timeout)
    check ('!nil,?number',x,timeout)
    local maxlength = self.maxlength
    local due_date
    while self.state == 'full' do
        log('pipe', 'DEBUG', "Pipe %s full, :send() blocks until some data is pulled from pipe", self)
        due_date = due_date or timeout and os_time() + timeout
        local timeout = due_date and due_date - os_time()
        if timeout and timeout<=0 or sched.wait(self,'state', timeout)=='timer' then
            log('pipe', 'DEBUG', "Pipe %s :send() timeout", self)
            return nil, 'timeout'
        else
            log('pipe', 'DEBUG', "Pipe %s state changed, retrying to :send()", self)
        end
    end
    local sndidx = self.sndidx
    self.content[sndidx] = x
    self.sndidx = sndidx+1
    updatestate(self)
    return self
end

--------------------------------------------------------------------------------
-- Pushback the last read value
--------------------------------------------------------------------------------
function P :pushback (x)
    assert (x~=nil, "Don't :pushback(nil) in a pipe")
    if self.state=='full' then
        return nil, 'length would exceed maxlength'
    end
    local rcvidx = self.rcvidx-1
    if rcvidx==0 then
        table.insert(self.content, 1, x)
        self.sndidx = self.sndidx+1
    else
        self.content[rcvidx] = x
        self.rcvidx = rcvidx
    end
    updatestate (self)
    return self
end

--------------------------------------------------------------------------------
-- Empty the pipe, return what it contained in a list
--------------------------------------------------------------------------------
function P :reset()
    local r = self.content
    self.content = { }
    updatestate(self)
    return r
end

--------------------------------------------------------------------------------
-- Try to read without yielding nor removing from internal queue
--------------------------------------------------------------------------------
function P :peek()
    return self.content[self.rcvidx]
end

--------------------------------------------------------------------------------
-- Return the number of elements currently in the pipe.
--------------------------------------------------------------------------------
function P :length()
    return self.sndidx - self.rcvidx
end

--------------------------------------------------------------------------------
-- Change or remove (by passing nil) the curent pipe length limitation.
--------------------------------------------------------------------------------
function P :setmaxlength(maxlength)
    check ('?number',maxlength)
    if self :length() > maxlength then return nil, 'length exceeds new maxlength' end
    if maxlength and maxlength<1 then return nil, 'invalid maxlength' end
    self.maxlength = maxlength
    updatestate (self)
    return self
end

--------------------------------------------------------------------------------
-- Change waste parameters, hence the memory/speed performance compromize.
--------------------------------------------------------------------------------
function P :setwaste(abs, prop)
    self.wasteabs, self.wasteprop = abs, prop
    return self
end
end
sched.SigPipe=class('SigPipe',sched.Pipe,sched.Obj)
do
local S=sched.SigPipe
function S:handle(...)
    self:send{...}
end
end

sched.pump=function(pin,f,pout)
    check('?Pipe,?function,?Pipe',pin,f,pout)
    if not (pin or f or pout) then error'No pipes or function' end
    repeat
        local r=pin and pin:receive()
        r=f==nil and r or f(r)
        if r~=nil and pout then pout:send(r) end
    until false
end

sched.to=function(pin,pouts)
    repeat
        local x=pin:receive()
        if x~=nil then
            for i,pout in ipairs(pouts) do
                pout:send(x)
            end
        end
    until false
end

sched.from=function(pins,pout)
    sched.running:reset()
    for _,pin in ipairs(pins) do
        sched.running:link(pin,'*')
    end
    repeat
        local redo=true
        while redo do
            redo=false
            for _,pin in ipairs(pins) do
                if pin:peek()~=nil then
                    pout:send(pin:receive())
                    redo=true
                end
            end
        end
        sched.wait(false)
    until false
end

]===================],"CoolisOS/bin/kernel/sched/platform.lua",[===================[local log=require'kernel.log'
local sched,pairs,string,term,_G,fs,os,print,unpack,select,pprint,next=sched,pairs,string,term,_G,fs,os,print,unpack,select,pprint,next
local coroutine=coroutine
local tostring,math=tostring,math
local debug,util=debug,util
local plat={}

local sched=sched
local fil
env=getfenv()
setmetatable(env,nil)

---Whether or not the coroutine running will yield to the scheduler
plat.is_running=function()
    return sched and sched.Task.running and sched.Task.running.co==coroutine.running()
end

plat.time = os.clock
local time=plat.time
local wake_ev=tostring({})
local Task=sched.Task

local cc,CC,load=0,1,0
last_yield,last_return=-math.huge,-math.huge
plat.info=function()
    return string.format('load: %f;last yield: %f;last return:%f',util.format_number(load,2),util.format_number(last_yield,2),util.format_number(last_return,2))
end

local yield=function(...)
    log('platform','DETAIL','yielding to platform')
    last_yield=time()
    cc=last_yield-last_return
    local x={coroutine.yield(...)}
    last_return=time()
    CC=last_return-last_yield
    load=cc/(CC+cc)
    log('platform','DETAIL',plat.info())
    return x
end

function plat.step(timeout)
    if sched.ready then timeout=0 end
    if timeout then
        local ev,id
        if timeout==0 then
            if time()-last_return>=0.05 then --retain control for at most (as far as the scheduler can control) one tick if necessary; set to math.huge in case there is too much of a delay between computers;

                ev=wake_ev
                os.queueEvent(ev)
            else
                return
            end
        else
            ev,id='timer',os.startTimer(timeout)
        end
        local x
        repeat
            x=yield()
            if (ev==nil or x[1]==ev) and (id==nil or id==x[2]) then
                break
            else
                sched.signal(plat,unpack(x))
                if sched.ready then break end
            end
        until false
        return
    else
        if not fil[plat] then
            log('platform','ERROR','no timers or platform listeners, so exiting.')
            sched.stop()
            return
        end
        local filter
        if not next(fil[plat],next(fil[plat])) then
            filter=next(fil[plat])
        end
        sched.signal(plat,unpack(yield(filter)))
        return
    end
end

function plat._reset()
    fil=sched.fil
end
debug.name(plat,'platform')
sched.platform=plat
return plat]===================],"CoolisOS/bin/kernel/sched/timer.lua",[===================[------------------------------------------------------------------------------
-- timer module
--      supports one time timer timer.new(positive number)
--      supports periodic timer timer.new(negative number)
--      cron-compatible syntax (string conforming to cron syntax)
--      support simple timers
------------------------------------------------------------------------------
include'kernel.class'
local linked=require'utils.linked'
local check=require'kernel.checker'.check
local shcopy=require'kernel.util'.shcopy
local error=error
local read=read
PACKAGE_NAME='sched'


local sched=sched
local fil
local Obj=sched.Obj
local os = os
local math = math
local tonumber = tonumber
local assert = assert
local table = table
local pairs = pairs
local next = next
local type = type
local _G=_G
local os_time=os.clock
local setmetatable=setmetatable
local rawset=rawset
local unpack=unpack
local debug=debug

env=getfenv()
setmetatable(env,nil)

local timer={}

timer.norm=function(t) --the CC clock moves in steps of 0.05
    t=t-t%0.05
    -- if t<=0 then
        -- error('time values must be non-negative and multiples of 0.05',3)--to be used internally inside timer functions
    -- end
    return t
end
local norm=timer.norm
-------------------------------------------------------------------------------------
-- Common scheduling code
-------------------------------------------------------------------------------------

-------------------------------------------------------------------------------------
-- These functions must be attached as method :nextevent() to timer objects,
-- and return the timer's next due date.
-------------------------------------------------------------------------------------
local function stimer_nextevent (timer) return nil end

local events
local link,link_r
local n
-------------------------------------------------------------------------------------
-- Take a timer, reference it
-------------------------------------------------------------------------------------

timer.add = function(t)
    if not link_r[t] then
        local ind
        for val in linked.next_r,link,val do
            if val>t then
                ind=val
                break
            end
        end
        -- print(ind)
        if ind==nil then sched.ready=true end--if the next due date changed, signal the platform to break it's step
        link:insert_r(t,ind)
    end
end

-------------------------------------------------------------------------------------
-- Take a timer, dereference it
-------------------------------------------------------------------------------------
timer.remove = function(t)
    link:remove(t)
end

-------------------------------------------------------------------------------------
-- Signal all elapsed timer events.
-- This must be called by the scheduler every time a due date elapses.
-------------------------------------------------------------------------------------
function timer.step()
    if link_r[0]==-1 then return end -- if no timer is set just return and prevent further processing
    local now = os_time()
    while link_r[0]~=-1 and now >= link_r[0] do --about the above redundancy, maybe while loops are heavy?
        local nd = link:remove()
        sched.signal(timer,nd)
    end
end

timer.meta={__index=timer}
setmetatable(timer,{__index=Obj,__tostring=function() return 'Class timer' end})
-------------------------------------------------------------------------------------
-- returns the next expiration date
-------------------------------------------------------------------------------------
function timer.nextevent()
    -- print(link)
    if link_r[0]~=-1 then return link_r[0] end
end

local meta={
    __newindex=function(t,k,v)
        if type(k)~='number' then
            error(tostring(k)..'timer events must be numbers',2)
        end
        -- k=k-k%0.05 --math.ceil(t/0.05)*0.05 --maybe round up for user comfort? this way it's 1.5 time faster
        -- if k<=0 then
            -- error(k..'time values must be positive',2)
        -- end
        if v==nil then
            timer.remove(k)
        else--could move it here...
            timer.add(k)
        end
        rawset(t,k,v)
    end,

}
---resets the timer module
timer._reset=function()
    local holder=sched.task(function() end)
    debug.name(holder,'placeholder')
    events=setmetatable({[{}]={[holder]=true}},meta)
    sched.fil[timer]=events
    link=linked()
    link_r=link.r
    timer.link=link
end

class.CyclicTimer(sched.Obj)
do
local C=CyclicTimer
local O=sched.Obj
function C:__init(delta,...)
    O:__init(self)
    check('number,function',delta,f)
    self.delta=norm(delta)
    self.f=f
    self.args={...}
end
function C:handle(_,ev)
    ev=ev+self.delta
    self:link{timer={ev}}
    self.f(unpack(self.args))
end
end
timer.cyclic=CyclicTimer
debug.name(timer,'timer')
sched.timer=timer
return timer]===================],"CoolisOS/bin/programs",true,"CoolisOS/bin/programs/bt.lua",[===================[print(1)]===================],"CoolisOS/bin/programs/help.lua",[===================[--By CoolisTheName007
--CoolisOS/dev/help.lua

local mon=peripheral.wrap'back'
mon.setTextScale(1)
local delay=1
local textPath='CoolisOS/dev/text'

local function getText()
    local f=fs.open(textPath,'r')
    local text=f.readAll()
    f.close()
    return text
end

local function parse_text(text)
    for line in text:gmatch("([^\n]*)\n?") do
        local t,b=line:match'^#([^#- ]+)-?([^#- ]*)#'
    end
end

local function write( sText)
    local term=mon
    local w,h = term.getSize()
    local x,y = term.getCursorPos()

    local nLinesPrinted = 0
    local function newLine()
        if y + 1 <= h then
            term.setCursorPos(1, y + 1)
        else
            term.setCursorPos(1, h)
            term.scroll(1)
        end
        x, y = term.getCursorPos()
        nLinesPrinted = nLinesPrinted + 1
    end

    -- Print the line with proper word wrapping
    while string.len(sText) > 0 do
        local whitespace = string.match( sText, "^[ \t]+" )
        if whitespace then
            -- Print whitespace
            term.write( whitespace )
            x,y = term.getCursorPos()
            sText = string.sub( sText, string.len(whitespace) + 1 )
        end

        local newline = string.match( sText, "^\n" )
        if newline then
            -- Print newlines
            newLine()
            sText = string.sub( sText, 2 )
        end

        local text = string.match( sText, "^[^ \t\n]+" )
        if text then
            sText = string.sub( sText, string.len(text) + 1 )
            if string.len(text) > w then
                -- Print a multiline word
                while string.len( text ) > 0 do
                    if x > w then
                        newLine()
                    end
                    term.write( text )
                    text = string.sub( text, (w-x) + 2 )
                    x,y = term.getCursorPos()
                end
            else
                -- Print a word normally
                if x + string.len(text) - 1 > w then
                    newLine()
                end
                term.write( text )
                x,y = term.getCursorPos()
            end
        end
    end

    return nLinesPrinted
end

local function wrap(text, limit) --from Kingdaroo
        local lines = {''}
        for word, space in text:gmatch('(%S+)(%s*)') do
                local temp = lines[#lines] .. word .. space:gsub('\n','')
                if #temp > limit then
                        table.insert(lines, '')
                end
                if space:find('\n') then
                        lines[#lines] = lines[#lines] .. word

                        space = space:gsub('\n', function()
                                table.insert(lines, '')
                                return ''
                        end)
                else
                        lines[#lines] = lines[#lines] .. word .. space
                end
        end
        return lines
end

local function extract(t,s,l)
    local c={}
    for k=s,s+l-1 do
        c[k-s+1]=t[k%(#t)+1]
    end
    return c
end

local function print_screen(t)
    mon.clear()
    mon.setCursorPos(1,1)
    local x,y=mon.getSize()


    for i,line in ipairs(t) do
        if (line:sub(1,1)=='#') then
            local tc=colors[line:match'^#([^-#]+)']
            mon.setTextColor(tc or colors.white)
            local bc=colors[line:match'^#[^-#]+%-([^#]+)#']
            mon.setBackgroundColor(bc or colors.black)
            local l=line:match'^#[^#]+#'
            line=line:sub(l:len()+1)
        end
        c=' '
        if (line:sub(-2,-2)=='&') then
            c=line:sub(-1,-1)
            line=line:sub(1,-3)
        end
        line=line..string.rep(c,math.max(x-#line,0))
        write(line..(i~=#t and '\n' or ''))
    end
end

local function main()
    local x,y=mon.getSize()
    local text
    local c=-1
    repeat

        local ok,r=pcall(getText)
        if ok then text=r else error(r) end
        local tText=wrap(text,x)
        c=(c+1)%(#tText)
        mon.setTextColor(colors.white)
        mon.setBackgroundColor(colors.black)
        local t=tText
        for i=1,(c+1) do
            local line=t[i]
            if (line:sub(1,1)=='#') then
                local tc=colors[line:match'^#([^-#]+)']
                mon.setTextColor(tc or colors.white)
                local bc=colors[line:match'^#[^-#]+%-([^#]+)#']
                mon.setBackgroundColor(bc or colors.black)
            end
        end
        print_screen(extract(tText,c,y))

        sleep(delay)
    until false
end
parallel.waitForAny(main,function() shell.run'shell' end)
]===================],"CoolisOS/bin/programs/master.lua",[===================[rednet.open'right'

function slave()
    local t={
    1=true
    }
    local send=function(id,n) turtle.select(id) turtle.drop(n) end
    while true do
        local _id,msg=rednet.receive()
        local id,n=msg:match'([^:]):([^:])'
        if id and n then
            n=tonumber(n)
            send(id,n)
        end
    end
end

function master()

delay=5
function _request(id,n)
    repeat
        rednet.broadcast(id..':'..n)
        t=0
        repeat
            if turtle.getItemCount(1)==n then break end
            sleep(dt)
            t=t+dt
        until t>delay
    until turtle.getItemCount(1)==n
    turtle.drop()
end


function request(id,n)
    local r=n%64
    local q=(n-r)/64
    for i=1,q do _request(id,64) end
    _request(id,r)
end

end]===================],"CoolisOS/bin/programs/quarry.lua",[===================[--CoolisOS/dev/quarry.lua
include'kernel.class'

class.Machine()
local function link(t)
    if t[1] then t[1].start=true end
    for i,v in ipairs(t) do
        v.next=t[i+1]
        v.index=i
    end
end
function Machine:__init(t)
    link(t)
    self.states=t
end
function Machine:find()
    for i,v in ipairs(self.states) do
        if v.is() then
            return v
        end
    end
    error'no match for state'
end
function Machine:run(state)
    state=state or self.states[1]
    while state do
        state.action()
        state=state.next
    end
end

Vec3=require'utils.Vec3'


Var=require'kernel.class.Var'
var=Var(fs.combine(_INSTALL_PATH,'ect/quarry.var'))

winding=require'programs.winding'

ut=require'utils.turtle'
for n,mov in pairs(ut) do getfenv()[n]=mov end
goto=ut.goto
turn=ut.turn
clear=function(...)
    select(Tr)
    local _,_,dc=ut.clear(...)
    if dc~=0 then
        clear_inv()
    end
end
force=function(...)
    select(Tr)
    local _,_,dc=ut.force(...)
    if dc~=0 then
        clear_inv()
    end
end

place=function(dir,n)
    clear(dir)
    select(n)
    if not has(n) then error('missing '..n) end
    return ut.place(dir)
end
drop=turtle.drop
refuel=function()
    return turtle.refuel(64) or error'not fuel'
end
clear_inv=function()
    for i=1,8 do
        if getCount(i)==0 then
            break
        end
        select(i)
        drop()
    end
end
local fuel
api.ensureFuel=function()
    if turtle.getFuelLevel()<10 then
        if fuel then
            refuel_machine:run()
        else
            print'Out of fuel'
            repeat
                sleep(5)
            until turtle.getFuelLevel()>10
        end
    end
end

inv={
R=9,
C=10,
M=11,
T=12,
I=13,
F=14,
Fu=15,
Tr=1,
}
local env=getfenv()
for i,n in pairs(inv) do env[i]=n end

function isInv(a,b,c,d)
    local function is(s)
        local c=turtle.getItemCount(s)
        if c==0 or c==1 then return c
        else error('inv not match') end
    end
    return is(R)==a and is(C)==b and is(M)==c and is(T)==d
end

select=turtle.select
has=function(n)
    local c=turtle.getItemCount(n)
    if c~=1 and c~=0 then error'no inv match'
    else return c==1 end
end
getPart=function(n,dir)
    select(n)
    repeat dir.dig() until (has(n) or sleep(1))
end
getCount=turtle.getItemCount
dof=function(f,g,delay)
    return function()
        if f() then return
        else
            g()
            while not f() do
                g()
                if delay then sleep(delay) end
            end
        end
    end
end

refuel_states={
{
is=function()
    return has(F)
end,
action=function()
    place(up,F)
end,
},
{
is=function() return not has(F) end,
action=function()
    local fill=dof(function() return getCount(Fu)~=0 end,up.suck,1)
    select(Fu)
    repeat
        fill()
        refuel()
    until turtle.getFuelLevel()>10 or sleep(1)
    getPart(F,up)
end,
},
}

well_states={
{is=function()
    return isInv(1,1,1,1)
end,
action=function()
    clear(bottom)
    force(forward)
    place(down,M)
    force(back)
    place(down,C)
end,
},
{is=function()
    return isInv(1,0,0,1)
end,
action=function()
    place(front,R)
    sleep(delay)
end,
},
{is=function()
    return isInv(0,0,0,1) and front.detect()
end,
action=function()
    force(back)
    clear_inv()
end},
{is=function()
    return isInv(0,0,0,1) and not front.detect()
end,
action=function()
    place(front,T)
end,
},
{is=function()
    return isInv(0,0,0,0)
end,
action=function()
    local p=peripheral.wrap('front')
    assert(p)
    p.shutdown()
    p.turnOn()
    select(R)
    repeat
        front.suck()
    until has(R)
    p.shutdown()
end,
},
{is=function()
    return isInv(1,0,0,0)
end,
action=function()
    getPart(T,front)
end,
},
{is=function()
    return isInv(1,0,0,1) and not down.detect()
end,
action=function()
    select(16)
    force(front)
end,
},
{is=function()
    return isInv(1,0,0,1)
end,
action=function()
    getPart(C,down)
end,
},
{is=function()
    return isInv(1,1,0,1) and not down.detect()
end,
action=function()
    force(front)
end,
},
{is=function()
    return isInv(1,1,0,1) and down.detect()
end,
action=function()
    getPart(M,down)
end,
},
}

recharge_states={
{
is=function()
    return has(I)
end,
action=function()
    place(up,I)
end,
},
{
is=function() return ((not has(I)) and has(R)) end,
action=function()
    select(R)
    repeat
        up.drop()
    until (not has(R))
end,
},
{
is=function() return not (has(I) or has(R)) end,
action=function()
    sleep(2)
    select(R)
    repeat
        up.suck()
    until (has(R))
    var.count=0
    select(I)
    up.dig()
end,
},
}

refuel_machine=Machine(refuel_states)
recharge_machine=Machine(recharge_states)
well_machine=Machine(well_states)

wind_machine={
run=function(self,center)
    function project(v)
        return {v.x,v.z}
    end
    local p=project((get())-center)
    var.count=var.count or 0
    repeat
        if var.count>max_count then
            recharge_machine:run()
        end

        -- print('actual:',p[1],p[2])
        local n=winding{p[1],p[2]}
        -- print('winding:',n[1],n[2])
        -- print('turning:',n[1]-p[1],0,n[2]-p[2])
        turn{n[1]-p[1],0,n[2]-p[2]}
        -- print('pos,dir:',get())
        local x,z=p[1],p[2]
        local d=math.max(math.abs(x),math.abs(z))
        if (not(x==d and z==(d-1))) and ((not(d==math.abs(x) and d==math.abs(z))) or (d==x and d==-z)) then
            well_machine:run()
        end
        local nex=center+Vec3{n[1],0,n[2]}
        -- print('to:',nex)
        select(Tr)
        goto(nex)
        clear_inv()
        p=n
    until false
end,
}

function resume()
    order={
    refuel_machine,
    recharge_machine,
    well_machine,
    }
    if not fuel then table.remove(order,1) end
    for _,machine in ipairs(order) do
        local s=machine:find()
        if not s.start then
            machine:run(s)
        end
    end
end

function main(opts)
    delay=assert(opts.delay)
    max_count=assert(opts.count)
    fuel=assert(opts.fuel~=nil) and opts.fuel
    resume()
    var.center=var.center or (get())
    wind_machine:run(Vec3(var.center))
end
]===================],"CoolisOS/bin/programs/question.lua",[===================[--CoolisOS/dev/question.lua

local questions=loadfile'CoolisOS/dev/questions'()

local set=rs.setOutput
local setDoor=function(...) return set('back',...) end
local setFire=function(...) return set('bottom',...) end
for i,v in pairs(rs.getSides()) do
    set(v,false)
end

local right=function()
    reset_term()
    print'Right Answer! Pass throught the door!'
    setDoor(true)
    sleep(2)
    setDoor(false)
end
local function pulse(f,delay)
    f(true)
    sleep(delay)
    f(false)
    sleep(delay)
end

local wrong=function()
    reset_term()
    print'Wrong answer! Burn in hell!'
    local t=os.clock()
    while (os.clock()-t)<20 do
        pulse(setFire,1)
    end
end

function reset_term()
    term.clear()
    term.setCursorPos(1,1)
end

function copy(t)
    local c={}
    for i,v in pairs(t) do
        c[i]=v
    end
    return c
end

local get_permut
do
local permgen
permgen = function (a, n, fn)
if n == 0 then
fn(a)
else
for i=1,n do
-- put i-th element as the last one
a[n], a[i] = a[i], a[n]

-- generate all permutations of the other elements
permgen(a, n - 1, fn)

-- restore i-th element
a[n], a[i] = a[i], a[n]

end
end
end

--- an iterator over all permutations of the elements of a list.
-- Please note that the same list is returned each time, so do not keep references!
-- @param a list-like table
-- @return an iterator which provides the next permutation as a list
function permute_iter (a)
local n = #a
local co = coroutine.create(function () permgen(a, n, coroutine.yield) end)
return function ()   -- iterator
local code, res = coroutine.resume(co)
return res
end
end

local function factorial(n)
    if n==0 then return 1 end
    return n*factorial(n-1)
end

function get_permut(t)
    local n=math.random()*(factorial(#t))
    local iter=permute_iter(t)
    for i=1,n-1 do iter() end
    local perm=iter()
    return perm
end
end

function test()
    for i,question in pairs(questions) do
        reset_term()
        print(question[1])
        if type(question[2])=='string' then
            print'Type answer.'
            if question[2]~=read() then
                return false
            end
        else
            local permut=get_permut(copy(question[2]))
            for i,answer in pairs(permut) do
                print(i..')'..answer)
            end
            print'Press the number key matching the right answer'
            local id,ev,ok
            repeat
                local t={os.pullEvent()}
                ev,id=t[1],t[2]
                ok,id=pcall(tonumber,id)
            until (ev=='char' and type(id)=='number' and 1<=id and id<=#permut)
            if permut[id]~=question[2][1] then
                return false
            end
        end
    end
    return true
end

os.pullEvent=os.pullEventRaw
wrong()
repeat
    if test() then
        right()
    else
        wrong()
    end
until false]===================],"CoolisOS/bin/programs/questions",[===================[local questions={
        {
        [[When was LG Founded??]],
        [[2000]],
        },
        {
                [[Who of the following is NOT a member of LG?]],
                {
                'DarkRaven',
                'FatherAbel',
                'Tuglowz',
                'Sanitty',
                },
        },
        {
        [[What is Legacy Gaming's website address minus the www]],
        [[legacygaming.com]],
        },
        {
                [[How Does LG Staff handle griefing?]],
                {
                'All of these',
                'With a Ban',
                'With Jail',
                'With Smite',
                'None of these (except this one)',
                },
        },
        {
                [[What are you supposed to do if you see someone breaking the rules?]],
                {
                [[Message an Admin AND Email [email protected]]],
                [[Message an Admin]],
                [[Call the police]],
                [[Email [email protected]]],
                [[Message an Admin AND Call the police]],
                [[All of these]],
                },
        },
        {
                [[What is the Owner of LG's Minecraft Name?]],
                [[RoseD83]],
        },
}
return questions]===================],"CoolisOS/bin/programs/recharge.lua",[===================[--Recharger
--log.setLevel('INFO','recharge')
_log=log
log=function(...) return _log('recharge',...) end
args={...}
tmax=args[1] and tonumber(args[1]) or 1800
local Var=require'kernel.class.Var'
var=Var('ect/recharger.var')
local t=require'utils.turtle'
local pdir=t.moves.forward
local tdir=t.moves.down
g1=pdir.detect
g2=function() return turtle.getItemCount(1)==1 end
g3=function() return turtle.getItemCount(2)==1 end
select=turtle.select
function out()
    log('INFO','outputing cell')
    select(2)
    repeat
        tdir.drop()
        if not(g3() and g2()) then break else sleep(1) end
    until false
    log('INFO','done')
end
function place()
    log('INFO','placing cell')
    select(1)
    repeat
        pdir.place()
        if (not g2()) and g1() then break else sleep(1) end
    until g1()
    log('INFO','done')
end
function remove()
    log('INFO','removing cell')
    select(2)
    t.clear(pdir)
    log('INFO','done')
end
local BREAK
function main()
sleep(5)
repeat
log('INFO','starting')
if g1() and g2() then
    remove()
end
if g2() and g3() then
    out()
    sleep(5)
end
if g2() and not g3() then
    place()
    var.count=0
end
if g1() and not (g2() and g3())then
    log('INFO','recharging')
    var.count=var.count or 0
    tc=var.count
    ti=os.clock()
    select(1)
    repeat
        var.count=(os.clock()-ti)+tc
        print('now:'..var.count..';max='..tmax)
        sleep(1)
        tdir.suck()
        if g2() or BREAK then break end
    until var.count>tmax
    log('INFO','done')
    remove()
end
if g3() and not(g1() and g2()) then
    log('INFO','waiting for input')
    select(1)
    repeat
        tdir.suck()
        if not g2() then
            sleep(1)
        else
            break
        end
    until false
    log('INFO','done')
end
sleep(1)
log('INFO','done')
until false
end]===================],"CoolisOS/bin/programs/test.lua",[===================[--CoolisOS/dev/test.lua

-- r()
-- function r()
-- v=loadreq.reload'utils.Vec3'
-- t=loadreq.reload'utils.turtle'
-- end
-- r()
-- function g()
-- shell.run('CoolisOS/dev/quarry.lua')
-- m=recharge_machine
-- end
-- g()

-- function r()
    -- w=loadreq.reload'dev.winding'
    -- iter=function(_,p) return w(p) end
    -- for p in iter,nil,{0,0} do
        -- print(p[1],',',p[2])
        -- os.pullEvent'key'
    -- end
-- end
-- sched.wait(sched.platform,'*')
function b()
    printError(debug.traceback())
end

function a()
    b()
end
a()]===================],"CoolisOS/bin/programs/text",[===================[#white-black#&-
Hello!
#green-white#Green!
]===================],"CoolisOS/bin/programs/transpose.lua",[===================[while true do
  turtle.suckUp()
  while turtle.getItemCount(1)~=0 do
    turtle.drop()
  end
  sleep(1)
end]===================],"CoolisOS/bin/programs/winding.lua",[===================[local max=math.max
local abs=math.abs

function winding(p)
    local x,y=p[1],p[2]
    local ax,ay=abs(x),abs(y)
    local d=max(ax,ay)

    if x==d and ay~=d then
        return {x,y+1}
    elseif y==d and x~=-d then
        return {x-1,y}
    elseif x==-d and y~=-d then
        return {x,y-1}
    elseif y==-d then
        return {x+1,y}
    elseif y==-d and x==d then
        return {x+1,y}
    else print(p[1],p[2]) _error'not a valid state' end
end

return winding

]===================],"CoolisOS/bin/utils",true,"CoolisOS/bin/utils/git.lua",[===================[local tArgs, gUser, gRepo, gPath, gBranch = {...}, nil, nil, "", "master"
local usage = [[
 github <user> <repo> [path] [remote path] [branch]
 Remote path defaults to the root of the repo.
 Path defaults to the download folder.
 Branch defaults to master.
 If you want to leave an option empty use a dot.
 Example: github johnsmith hello-world . foo
 Everything inside the directory foo will be
 downloaded to downloads/hello-world/.
  ]]
local blackList = [[
@blacklistedfile
]]

local title = "Github Repo Downloader"
local fileList = {dirs={},files={}}
local x , y = term.getSize()

-- GUI
function printTitle()
    local line = 2
    term.setCursorPos(1,line)
    for i = 2, x, 1 do write("-") end
    term.setCursorPos((x-title:len())/2,line+1)
    print(title)
    for i = 2, x, 1 do write("-") end
end

function writeCenter( str )
    term.clear()
    printTitle()
    term.setCursorPos((x-str:len())/2-1,y/2-1)
    for i = -1, str:len(), 1 do write("-") end
    term.setCursorPos((x-str:len())/2-1,y/2)
    print("|"..str.."|")
    term.setCursorPos((x-str:len())/2-1,y/2+1)
    for i = -1, str:len(), 1 do write("-") end
end

function printUsage()
    local str = "Press space key to continue"
    term.clear()
    printTitle()
    term.setCursorPos(1,y/2-4)
    print(usage)
    term.setCursorPos((x-str:len())/2,y/2+7)
    print(str)
    while true do
        local event, param1 = os.pullEvent("key")
        if param1 == 57 then
            sleep(0)
            break
        end
    end
    term.clear()
    term.setCursorPos(1,1)
end

-- Download File
function downloadFile( path, url, name )
    writeCenter("Downloading File: "..name)
    dirPath = path:gmatch('([%w%_%.% %-%+%,%;%:%*%#%=%/]+)/'..name..'$')()
    if dirPath ~= nil and not fs.isDir(dirPath) then fs.makeDir(dirPath) end
    local content = http.get(url)
    local file = fs.open(path,"w")
    file.write(content.readAll())
    file.close()
end

-- Get Directory Contents
function getGithubContents( path )
    local pType, pPath, pName, checkPath = {}, {}, {}, {}
    local response = http.get("https://api.github.com/repos/"..gUser.."/"..gRepo.."/contents/"..path.."/?ref="..gBranch)
    if response then
        response = response.readAll()
        if response ~= nil then
            for str in response:gmatch('"type":"(%w+)"') do table.insert(pType, str) end
            for str in response:gmatch('"path":"([^\"]+)"') do table.insert(pPath, str) end
            for str in response:gmatch('"name":"([^\"]+)"') do table.insert(pName, str) end
        end
    else
        writeCenter( "Error: Can't resolve URL" )
        sleep(2)
        term.clear()
        term.setCursorPos(1,1)
        error()
    end
    return pType, pPath, pName
end

-- Blacklist Function
function isBlackListed( path )
    if blackList:gmatch("@"..path)() ~= nil then
        return true
    end
end

-- Download Manager
function downloadManager( path )
    local fType, fPath, fName = getGithubContents( path )
    for i,data in pairs(fType) do
        if data == "file" then
            checkPath = http.get("https://raw.github.com/"..gUser.."/"..gRepo.."/"..gBranch.."/"..fPath[i])
            if checkPath == nil then

                fPath[i] = fPath[i].."/"..fName[i]
            end
            local path = "downloads/"..gRepo.."/"..fPath[i]
            if gPath ~= "" then path = gPath.."/"..gRepo.."/"..fPath[i] end
            if not fileList.files[path] and not isBlackListed(fPath[i]) then
                fileList.files[path] = {"https://raw.github.com/"..gUser.."/"..gRepo.."/"..gBranch.."/"..fPath[i],fName[i]}
            end
        end
    end
    for i, data in pairs(fType) do
        if data == "dir" then
            local path = "downloads/"..gRepo.."/"..fPath[i]
            if gPath ~= "" then path = gPath.."/"..gRepo.."/"..fPath[i] end
            if not fileList.dirs[path] then
                writeCenter("Listing directory: "..fName[i])
                fileList.dirs[path] = {"https://raw.github.com/"..gUser.."/"..gRepo.."/"..gBranch.."/"..fPath[i],fName[i]}
                downloadManager( fPath[i] )
            end
        end
    end
end

-- Main Function
function main( path )
    writeCenter("Connecting to Github")
    downloadManager(path)
    for i, data in pairs(fileList.files) do
        downloadFile( i, data[1], data[2] )
    end
    writeCenter("Download completed")
    sleep(2,5)
    term.clear()
    term.setCursorPos(1,1)
end

-- Parse User Input
function parseInput( user, repo , dldir, path, branch )
    if path == nil then path = "" end
    if branch ~= nil then gBranch = branch end
    if repo == nil then printUsage()
    else
        gUser = user
        gRepo = repo
        if dldir ~= nil then gPath = dldir end
        main( path )
    end
end

if not http then
    writeCenter("You need to enable the HTTP API!")
    sleep(3)
    term.clear()
    term.setCursorPos(1,1)
else
    for i=1, 5, 1 do
        if tArgs[i] == "." then tArgs[i] = nil end
    end
    parseInput( tArgs[1], tArgs[2], tArgs[3], tArgs[4], tArgs[5] )
end]===================],"CoolisOS/bin/utils/linked.lua",[===================[include'kernel.class'
local pairs=pairs
local print=print

class.Linked()

function Linked:__init(t)
    self.r,self.l={[0]=-1},{[-1]=0}
    if t then self:append_r(t) end
end

function Linked._insert(t,val,i_l,i_r)
    if t.r[val] then return end
    i_l,i_r=i_l or 0,i_r or -1
    --handle left               right
    t.r[i_l],   t.l[val],   t.r[val],   t.l[i_r]
    =   val,            i_l,        i_r,        val
end

function Linked.insert_l(t,val,i_l)
    return Linked._insert(t,val,i_l,t.r[i_l or 0])
end

function Linked.insert_r(t,val,i_r)
    return Linked._insert(t,val,t.l[i_r or -1],i_r)
end

function Linked.remove(t,val)
    val=val or t.r[0]
    if t.r[val] then t.r[t.l[val]],t.l[t.r[val]],t.r[val],t.l[val]=t.r[val],t.l[val],nil,nil end
    if val==-1 then val=nil end
    return val,t.r[val]
end

function Linked.next_r(t,ind)
    local _=t.r[ind or 0]
    if _~=-1 then return _ end
end

function Linked.next_l(t,ind)
    local _=t.r[ind or -1]
    if _~=0 then return _ end
end

function Linked.__tostring(t)
    s={}
    for i in self.next_r,t,nil do
        table.insert(s,tostring(i))
    end
    return 'Linked instance:'..table.concat(s,'<>')
end

function Linked:append_r(t)
    local old
    for i,v in ipairs(t) do
        self:insert_r(v,old)
        -- print(v,old)
        -- read()
        old=v
    end
end

function Linked:has(val)
    return self.r[val]~=nil
end
function Linked:isempty()
    return self.r[0]==-1
end
Linked.append=Linked.append_r
Linked.push=Linked.insert_r
Linked.pop=Linked.remove

function Linked.test()
    t={'a',3,4}
    l=Linked(t)
    print(l)
    l:remove(3)
    print(l)
    print(l:has(4),l:has(3))
    return l
end



return Linked]===================],"CoolisOS/bin/utils/luau.lua",[===================[-- luau: Lua-upgraded

-- Since we're sharing our scope with the user, make a table to keep
-- all our stuff in, so we pollute the namespace as little as possible:
luau_={}
luau_.n = 0         -- current line number
luau_.opt = {}      -- options data
luau_.mac = {}      -- macros
-- A default macro:
luau_.mac.la = {['def']='os.loadAPI("%1")',['pnum']=1}

-- Default option settings:
luau_.opt.skip_lines={
    ['type'] = 'number',
    ['value'] = 0,
    ['default'] = 0,
    ['desc']='Number of blank lines to skip between input/output pairs.'
}
luau_.opt.use_color={
    ['type'] = 'boolean',
    ['value'] = true,
    ['default'] = true,
    ['desc']='Whether to use color, if available.'
}

-- Some variables we do want to expose:
in_ = {}      -- input history
out_ = {}     -- output history


-- Help topics:
luau_.help = {}

luau_.help.summary = 'The following topics are available, and can be abbreviated--for instance, "/help sub" for "/help substitution".'

luau_.help.substitution = 'Typing "s/find-expr/replace-expr/" will repeat the previously entered line, but with all occurrences of find-expr replaced by replace-expr. Lua\'s string-matching patterns may be used in find-expr. This is often quicker than using up-arrow to recall the command and editing it manually.'

luau_.help.history = 'The tables in_ and out_ hold the input and output histories, and can be referenced, for example: "result=out_[9]".'

luau_.help['repeat-command'] = 'To repeat a previous input, use the "!<n>" command. For example, typing !23 will re-evaluate the 23rd command in the history.'

luau_.help['question-mark'] = 'The "?" character is a shortcut for print: "?foo" is short for "print(foo)". If foo is a table, then its keys and values will be displayed.'

luau_.help['macros'] = 'You can define macros to shorten frequently-typed strings. For example, if you type "/macro %la=os.loadAPI", then in the future any occurence of "%la" in commands you type will be changed to "os.loadAPI" before processing by Lua.\n\nMacros can also accept parameters. For example, "/macro %rs=rednet.send(%1,%2)" will tell luau to expand "%rs[23][\'hi!\']" into "rednet.send(23,\'hi!\')".\n\nParameters may appear more than once and out of order--a silly example is "/macro %palindrome=%3%2%1%2%3", which expands "%palindrome[A][B][C]" into "CBABC".'

luau_.help['commands'] = 'Luau has some built-in commands which are invoked by starting a line with the slash "/" character. Type "/commands" for a list.'

-- Build a sorted list of help topics:
luau_.helpkeys = {}
for k in pairs(luau_.help) do
    if k~='summary' then
        table.insert(luau_.helpkeys, k)
    end
end
table.sort(luau_.helpkeys)

-- Define the appropriate color function:
if term.isColor() then
    term.setTextColor(colors.gray)
    luau_.setColor = function(c)
        if luau_.opt.use_color.value then
            term.setTextColor(c)
        else
            term.setTextColor(gray)
        end
    end
else
    luau_.setColor = function(c) return end
end

luau_.terminated = false
-- End of initialization code.

function luau_.terminate()
    -- Goodbye, cruel world:
    luau_.terminated = true
end

function luau_.separator()
    -- A line of dashes, of the appropriate length:
    return(string.rep('-', term.getSize()))
end

function luau_.loadData()
    -- Load config options and macros:
    local h
    if fs.exists('luau.conf') then
        h = fs.open('luau.conf','r')
        local opt, mac
        opt = textutils.unserialize(h.readLine())
        mac = textutils.unserialize(h.readLine())
        h.close()
        if type(opt)=='table' and type(mac)=='table' then
            luau_.opt = opt
            luau_.mac = mac
            return true
        else
            luau_.showError('Unable to load configuration; /luau.conf is corrupt. Exiting. (Delete or rename /luau.conf to start fresh)')
            return false
        end
    else
        luau_.setColor(colors.blue)
        print('Configuration file /luau.conf does not exist; creating with default values.')
        luau_.saveData()
        return true
    end
end

function luau_.saveData()
    -- Save config options and macros:
    h = fs.open('luau.conf','w')
    h.writeLine(textutils.serialize(luau_.opt))
    h.writeLine(textutils.serialize(luau_.mac))
    h.close()
end

function luau_.firstMatch(s, t)
    for i, k in ipairs(t) do
        if string.find(k, s) == 1 then
            return k
        end
    end
    return nil
end

function luau_.showError(errorText)
    -- Report errors to the user
    luau_.setColor(colors.red)
    print(errorText)
    luau_.setColor(colors.gray)
end

function luau_.trim(s)
    -- Trim leading/trailing spaces from string s:
    return (s:gsub("^%s*(.-)%s*$", "%1"))
end

function luau_.macro(s)
    -- !<n> to re-evaluate n-th input:
    local a, b, n
    a, b, n = s:find('!(%d+)')
    n = tonumber(n)
    if a == 1 then
        if in_[n] then
            s = in_[n]
        else
            luau_.showError("History entry "..tostring(n).." not found.")
            s = ''
        end
        return s
    end
    -- s/foo/bar/ substitutions
    a, b, find, replace, flags = s:find('s/(.+)/(.*)/(.*)')
    if find and in_[luau_.n] then
        s = in_[luau_.n-1]:gsub(find, replace)
        return s
    end
    -- Macro expansion:
    local lMark, rMark = '>tboss>', '<tboss<'
    -- This lMark/rMark business is an ugly hack that wouldn't be
    -- necessary if I knew how to directly capture the stuff INSIDE a
    -- balanced expression captured with %b[], i.e. without the brackets.
    for name, macro in pairs(luau_.mac) do
        local pattern = '%%'..name..string.rep('(%b[])',macro.pnum)
        -- This is a workaround for a bug in the string library:
        local s_ = s..string.rep('[ ]',macro.pnum)
        local a, b = s_:find(pattern)
        if b and b<=s:len() then
            if s_:find(pattern) then
                local def = macro.def:gsub('(%%%d)',lMark..'%1'..rMark)
                s_ = s_:gsub(pattern, def)
                s_ = s_:gsub(lMark..'%[', '')
                s_ = s_:gsub('%]'..rMark, '')
                s = s_:sub(1, s_:len()-3*macro.pnum)
            end
        end
    end
    return s
end

function luau_.columnList(t)
    -- Print the elements of t in columns:
    -- Compute the max length of the names so we can decide
    -- how many columns to print them in:
    local maxLen = 0
    for i,k in ipairs(t) do
        if string.len(k) > maxLen then maxLen = string.len(k) end
    end
    local spacing = 2   -- Spacing between columns
    local w, h = term.getSize()
    local nCols = math.floor((w+spacing)/(maxLen+spacing))
    -- Print all the names in columns:
    for i, k in ipairs(t) do
        if (i%nCols == 0) or (i == #t) then
            print(k)
        else
            write(k..string.rep(' ', maxLen+spacing-string.len(k)))
        end
    end
end

function luau_.showHelp(topic)
    luau_.setColor(colors.blue)
    topic = tostring(topic)
    if topic ~= '' then
        -- Do partial matching:
        local mtopic = luau_.firstMatch(topic, luau_.helpkeys)
        if luau_.help[mtopic] then
            local m, n = term.getSize()
            textutils.pagedPrint('('..mtopic..') '..luau_.help[mtopic],n-3)
        else
            print('No help found for "'..topic..'". Type "help" for a list of topics.')
        end
    else
        -- Print help summary and list of topics:
        print(luau_.help.summary)
        print(luau_.separator())
        --luau_.setColor(colors.lightBlue)
        luau_.columnList(luau_.helpkeys)
    end
end

function luau_.searchHistory(s)
    -- Print a list of history entries matching s.
    -- Should refactor this into a search and a print.
    local nFound = 0
    for i,v in ipairs(in_) do
        if string.find(v,s) then
            print(i..': '..v)
            nFound = nFound+1
        end
    end
    return nFound
end

function luau_.keySort(a, b)
    -- Order function for table keys, returns true if a<b:
    if type(a)=='number' and type(b)=='number' then
        return a<b
    elseif type(a)=='number' then
        return true
    elseif type(b)=='number' then
        return false
    elseif type(a)=='string' and type(b)=='string' then
        return a<b
    elseif type(a)=='string' then
        return true
    elseif type(b)=='string' then
        return false
    else
        return (type(a)<type(b))
    end
end

function luau_.serial(v)
    -- Wrapper for textutils.serialize, to work with all types
    if string.find("nil boolean number string table", type(v)) then
        local err, str = pcall(function() textutils.serialize(v) end)
        if err then str=tostring(v) end
        return str
    else
        return tostring(v)
    end
end

function luau_.setMacro(p, overwrite)
    -- Define or redefine a macro:
    luau_.setColor(colors.yellow)
    if p=='' then
        -- Display currently defined macros:
        print("The following macros are currently defined:")
        print(luau_.separator())
        for k in pairs(luau_.mac) do
            print("%"..k.."="..luau_.mac[k].def)
        end
    else
        -- Should be in the form "%name=def":
        local a, b, name, def = p:find('%%([%w_]+)=(.*)')
        if name then
            -- See if it's already defined:
            if luau_.mac[name] and not overwrite then
                print('Macro %'..name..' is already defined. Use /Macro to overwrite it.')
                return false
            end
            -- See how many params:
            local n = 0
            def:gsub('%%(%d+)', function(s) n=tonumber(s) end)
            luau_.mac[name] = {['def']=def, ['pnum']=n}
            -- Save it right away. We could wait until we exit, but
            -- during development crashes are likely so let's not
            -- lose people's work.
            luau_.saveData()
        else
            luau_.showError('Invalid macro definition (see /help macro).')
            return false
        end
    end
    return true
end

function luau_.setOpt(p)
    luau_.setColor(colors.yellow)
    if p=='' then
        print('The following options are available. Type "/option <option_name>=<value>" to change, or "/option <option_name>" to get a description.')
        local keys = {}
        for k in pairs(luau_.opt) do keys[#keys+1]=k end
        table.sort(keys, luau_.keySort)
        print(luau_.separator())
        for i, k in ipairs(keys) do
            print(k..'='..tostring(luau_.opt[k].value))
        end
    elseif p:find('=') then
        local a, b, opt, val = p:find("([%w_]+)%s*=%s*(.*)")
        if luau_.opt[opt] then
            -- Make sure the types are right:
            local t = luau_.opt[opt].type
            local ok = false
            if t=='boolean' then
                local v = val:lower()
                if v=='true' or v=='1' or v=='yes' or v=='y' then
                    luau_.opt[opt].value = true
                    ok = true
                elseif v=='false' or v=='0' or v=='no' or v=='n' then
                    luau_.opt[opt].value = false
                    ok = true
                end
            elseif t=='number' then
                local v = tonumber(val)
                if v then
                    luau_.opt[opt].value = v
                    ok = true
                end
            elseif t=='string' then
                luau_.opt[opt].value = val
                ok = true
            end
            if ok then
                luau_.saveData()
            else
                print('Value for '..opt..' must be of type '..t..'.')
            end
        else
            print('Option "'..p..'" not found. Type "/option" for a list.')
        end
    else
        if luau_.opt[p] then
            print(luau_.opt[p].desc..' [type='..luau_.opt[p].type..', value='..tostring(luau_.opt[p].value)..', default='..tostring(luau_.opt[p].default)..']')
        else
            print('Option "'..p..'" not found. Type "/option" for a list.')
        end
    end
end

function luau_.showCommands(p)
    luau_.setColor(colors.blue)
    if p=='' then
        print('The following commands are available. Type "/command <command-name>" for details.')
        print(luau_.separator())
        luau_.columnList(luau_.cmdNames)
    else
        local cmd = luau_.firstMatch(p, luau_.cmdNames)
        if cmd then
            print('/'..cmd..': '..luau_.cmd[cmd].desc)
        else
            print('Command "'..p..'" not found. Type "/commands" for a list.')
        end
    end
end

-- Now that we've defined all our handler functions, we can set up the command list:
luau_.cmd = {}
luau_.cmd.help = {
    ['handler'] = luau_.showHelp,
    ['desc'] = 'Online help. Type "/help <topic>", or "/help" for a list of topics.',
}
luau_.cmd.exit = {
    ['handler'] = luau_.terminate,
    ['desc'] = 'Exits Luau and returns you to the shell or wherever else you launched it from.',
}
luau_.cmd.history = {
    ['handler'] = luau_.searchHistory,
    ['desc'] = 'Typing "/history" will simply print the entire history buffer, while "/history <pattern>" will only show entries matching <pattern>.',
}
luau_.cmd.macro = {
    ['handler'] = function(p) luau_.setMacro(p, false) end,
    ['desc'] = 'Define a text-expansion macro with "/macro %<name>=<output>", or type "/macro" for a list of existing macros. Type "/help macros" for more details.',
}
luau_.cmd.Macro = {
    ['handler'] = function(p) luau_.setMacro(p, true) end,
    ['desc'] = 'Same as "/macro", but able to overwrite existing definitions.',
}
luau_.cmd.options = {
    ['handler'] = luau_.setOpt,
    ['desc'] = 'Type "/options" for a list of all options, "/option <name>" for an option\'s description, or "/option <name>=<value>" to change it.',
}
luau_.cmd.commands = {
    ['handler'] = luau_.showCommands,
    ['desc'] = 'Type "/commands" for a list of commands, or "/command <command-name>" to view a description of a particular one.',
}
luau_.cmdNames = {}
for k in pairs(luau_.cmd) do table.insert(luau_.cmdNames, k) end
table.sort(luau_.cmdNames)


function luau_.go()
    -- Load config options and macros:
    if not luau_.loadData() then return false end
    luau_.setColor(colors.blue)
    print()
    print('LUAU--LUA Upgraded v0.1 by Tinyboss\nType "/exit" to exit, "/help" for help.')
    while not luau_.terminated do
        luau_.setColor(colors.gray)
        for i=1,luau_.opt.skip_lines.value do print() end
        luau_.n = luau_.n+1
        -- Get the next input, passing the input history for recall by up-arrow:
        local input = ''
        while luau_.trim(input)=='' do
            luau_.setColor(colors.lime)
            write(' in_['..luau_.n..']: ')
            luau_.setColor(colors.lightGray)
            input = luau_.trim(read(false, in_,getfenv(1)))
        end
        in_[luau_.n] = input
        luau_.handled = false
        -- ? is a shortcut for print, with benefits:
        if in_[luau_.n]:sub(1,1) == "?" then
            rest_ = luau_.trim(in_[luau_.n]:sub(2))
            if rest_ == "" then
                -- If they just typed "?", they probably wanted help:
                luau_.setColor(colors.blue)
                print('"?foo" is a synonym for "print(foo)". Use "/help" for help.')
                luau_.handled = true
            elseif type(getfenv(1)[rest_])=="table" then
                -- If it's a table, display it:
                local keys = {}
                for k in pairs(getfenv(1)[rest_]) do
                    keys[#keys+1]=k
                end
                table.sort(keys, luau_.keySort)
                local kv = {}
                for i,k in ipairs(keys) do
                    kv[i] = luau_.serial(k)..'='
                        ..luau_.serial(getfenv(1)[rest_][k])
                end
                print('{',table.concat(kv, ', '),'}')
                luau_.handled = true
            else
                in_[luau_.n] = 'print('..in_[luau_.n]:sub(2)..')'
            end
        end
        if not luau_.handled then
            -- See if it's a slash command:
            local a_, b_, cmd_, rest_ = in_[luau_.n]:find('/(%a+)%s*(.*)')
            if a_==1 then
                cmd_ = luau_.firstMatch(cmd_, luau_.cmdNames)
                if cmd_ then
                    luau_.cmd[cmd_].handler(rest_)
                else
                    luau_.setColor(colors.yellow)
                    print('Invalid command. (Try "/help".)')
                end
            else
                -- Do macro substitution before passing it to Lua:
                in_[luau_.n] = luau_.macro(in_[luau_.n])
                luau_.setColor(colors.gray)
                is_print_ = string.sub(in_[luau_.n], 1, 6)=='print('
                -- Try it as an expression first:
                func_, err_ = loadstring('out_[luau_.n]='..in_[luau_.n])
                if err_ then
                    -- Try it as a statement (e.g. "pi=3"):
                    func_, err_ = loadstring(in_[luau_.n])
                    if err_ then
                        luau_.showError('(loadstring)'..err_)
                    else
                        setfenv(func_, getfenv(1))
                        success_, err_ = pcall(func_)
                        if not success_ then
                            luau_.showError(err_)
                        end
                    end
                else
                    -- It worked as an expression, so store and show the result:
                    setfenv(func_, getfenv(1))
                    success_, err_ = pcall(func_)
                    if success_ then
                        if out_[luau_.n] and not is_print_ then
                            luau_.setColor(colors.green)
                            write('out_['..luau_.n..']: ')
                            luau_.setColor(colors.gray)
                            print(out_[luau_.n])
                        end
                    else
                        luau_.showError(err_)
                    end
                end
            end
        end
    end
    -- Save config and macro data:
    luau_.saveData()
end

luau_.go()]===================],"CoolisOS/bin/utils/path.lua",[===================[---
-- Path utils.
--
-- **Definition of path** used by this file:
--
-- - it is **not Lua path**, Lua path meaning the way Lua provide table indexing.
--     - especially, **'table[ ]'** notation is not supported
-- - **element separator is  '.'** (dot)
-- - provided **path is always cleaned** before being processed:
--     - if the path starts and/or ends with one or several dots, there are automatically removed.<br />
--       e.g.: `'...toto.tutu....'` means `'toto.tutu'`
--     - internal repetitions of successives dots are replaced by a single dot.<br />
--       e.g.: `'toto...tutu.tata..foo.bar'` means `'toto.tutu.tata.foo.bar'`
-- - if a path element can be **converted to a number**, then it is returned as a number,
--   otherwise all elements or paths are returned as strings.<br />
--   e.g.: `split('a.2', 1)` -> `('a', 2)`   (where 2 is returned as a number) <br />
--   e.g.: `split('a.b.2e3.c', 1)` -> `('a', 'b.2000.c')`
--
-- @module utils.path
--
local check = require"kernel.checker".check

local M = { }
--public API
local split,clean,segments, get, set, gsplit, concat, find

local function pathconcat(pt, starti, endi)
    local t = {}
    local prev
    local empties = 0
    starti = starti or 1
    endi = endi or #pt

    for i = starti, endi do
        local v = pt[i]
        if not v then break
        elseif v == '' then
            empties = empties+1
        else
            table.insert(t, prev)
            prev = v
        end
    end
    table.insert(t, prev)
    --log('PATH', 'INFO', "pathconcat(%s, %d, %d) generates table %s, wants indexes %d->%d",
    --    sprint(pt), starti, endi, sprint(t), 1, endi-starti+1-empties)
    return table.concat(t, '.', 1, endi-starti+1-empties)
end

--------------------------------------------------------------------------------
-- Concatenates a sequence of path strings together.
--
-- @function [parent=#utils.path] concat
-- @param varargs list of strings to concatenate into a valid path
-- @return resulting path as a string
--

function concat(...)
    return pathconcat({...})
end

--------------------------------------------------------------------------------
-- Cleans a path.
--
-- Removes trailing/preceding/doubling '.'.
--
-- @function [parent=#utils.path] clean
-- @param path string containing the path to clean.
-- @return cleaned path as a string.
--

function clean(path)
    check('string',path)
    local p = segments(path)
    return pathconcat(p)
end

--------------------------------------------------------------------------------
-- Sets a value in a tree-like table structure.
--
-- The value to set is indicated by the path relative to the table.
-- This function creates the table structure to store the value, unless the value to set is nil.
-- If the value to set is nil and the table structure already exists then the value is set to nil.
-- If the value is not nil, then the table structure is always created/overwritten and the value set.
--
-- @function [parent=#utils.path] set
-- @param t table where to set the value.
-- @param path can be either a string (see @{#(utils.path).split})
--  or an array where path[1] is the root and path[n] is the leaf.
-- @param value the value to set.
--

function set(t, path, value)
    check('table,string|table',t, path)
    local p = type(path)=='string' and segments(path) or path
    local k = table.remove(p)
    local t = find(t, p, value~=nil) -- only create the table structure if the value to set is non nil!
--    local t = findtable(t, p, true) -- for the creation of the table structure, even if the value to set is non nil!
    if t then t[k] = value end
end

--------------------------------------------------------------------------------
-- Gets the value of a table field. The field can be in a sub table.
--
-- The field to get is indicated by a path relative to the table.
--
-- @function [parent=#utils.path] get
-- @param t table where to set the value.
-- @param path can be eiher a string (see @{split}) or an array where path[1] is the root and path[n] is the leaf.
-- @return value if the field is found.
-- @return nil otherthise.
--
function get(t, path)
    check('table,string|table',t,path)
    local p = type(path)=='string' and segments(path) or path
    local k = table.remove(p)
    if not k then return t end
    local t = find(t, p)
    return t and t[k]
end


--------------------------------------------------------------------------------
-- Enumerates path partitions in a for-loop generator, starting from the right.
--
-- For instance, `gsplit "a.b.c"` will generate successively
-- `("a.b.c", ""), ("a.b", "c"), ("a", "b.c"), ("", "a.b.c")`.
--
-- @function [parent=#utils.path] gsplit
-- @param path the path as a string
-- @return the for-loop iterator function
--

function gsplit (path)
    check ('string',path)
    local segs  = segments(path)
    local nsegs = #segs
    local limit = nsegs
    local function f()
        if limit == -1 then return nil, nil end
        local a, b = pathconcat(segs, 1, limit), pathconcat(segs, limit+1, nsegs)
        limit = limit - 1
        return a, b
    end
    return f
end

--------------------------------------------------------------------------------
-- Splits a path into two halves, can be used to get path root, tail etc.
--
-- The content of the two halves depends on 'n' param: there will be `n` segments in the first half if `n>0`,
-- `-n` segments in the second half if `n<0`.
--
-- If there are less then `n` segments, returns the path argument followed by
-- an empty path.
--
-- If there are less then `-n` segments, returns an empty path followed by the
-- path argument.
--
-- Note that if a half is a single element and that this element can be converted into a number,
-- it is returned as a number.
--
-- @function [parent=#utils.path] split
-- @param path the path as a string
-- @param n number defining how the path is splitted (see above description).
-- @return the two halves
-- @usage local root, tail = split('a.b.c', 1)
-- ->root contains 'a', tail contains 'b.c'
--

function split(path, n)
    check('string,number',path,n)
    local segments = segments(path)
    if      n>#segments then return path, ''
    elseif -n>#segments then return '', path
    else
        if n<0 then n=#segments+n end
        return pathconcat(segments, 1, n), pathconcat(segments, n+1, #segments)
    end
end

--------------------------------------------------------------------------------
-- Splits a path into segments.
--
-- Each segment is delimited by '.' pattern.
--
-- @function [parent=#utils.path] segments
-- @param path string containing the path to split.
-- @return list of split path elements.
--

function segments(path)
    check('string',path)
    local t = {}
    local index, newindex, elt = 1
    repeat
        newindex = path:find(".", index, true) or #path+1 --last round
        elt = path:sub(index, newindex-1)
        elt = tonumber(elt) or elt
        if elt and elt ~= "" then table.insert(t, elt) end
        index = newindex+1
    until newindex==#path+1
    return t
end

--------------------------------------------------------------------------------
-- Retrieves the element in a sub-table corresponding to the path.
--
-- @function [parent=#utils.path] find
-- @param t is the table to look into.
-- @param path can be either a string (see @{segments}) or an array where
-- `path[1]` is the root and `path[n]` is the leaf.
-- @param force parameter allows to create intermediate tables as specified
--  by the path, if necessary.
-- @return returned values depend on force value:
--
-- * if force is false (or nil), find returns the table if it finds one,
--   or it returns nil followed by the subpath that points to non table value
--
-- * if force is true, find overwrites or create tables as necessary so
--   it always returns a table.
--
-- * if force is 'noowr', find creates tables as necessary but does not
--   overwrite non-table values. So as with `force=false`, it only returns a
--   table if possible, and nil followed by the path that points to the first
--   neither-table-nor-nil value otherwise.
--
-- @usage config = {toto={titi={tutu = 5}}}
--     find(config, "toto.titi") -- will return the table titi
--
function find(t, path, force)
    check('table,string|table', t,path)
    path = type(path)=="string" and segments(path) or path
    for i, n in ipairs(path) do
        local v  = t[n]
        if type(v) ~= "table" then
            if not force or (force=="noowr" and v~=nil) then return nil, pathconcat(path, 1, i)
            else v = {} t[n] = v end
        end
        t = v
    end
    return t
end

--public API
M.split=split; M.clean=clean; M.segments=segments; M.get=get; M.set=set;
M.gsplit=gsplit; M.concat=concat; M.find=find

return M
]===================],"CoolisOS/bin/utils/print.lua",[===================[
local io=io
local string=string
local table=table
local type=type
local tostring=tostring
local pairs=pairs
local print=print
local getmetatable=getmetatable
local select=select

env=getfenv()
setmetatable(env,nil)

mtostring=function(...)
    local t={}
    for i=1,select('#',...) do
        table.insert(t,tostring(select(i,...)))
    end
    return table.concat(t,';')
end

-- Make sure stdout is actually flushed every line
if io and io.stdout then
    io.stdout:setvbuf("line")
end

local function quotestring(x)
    local function q(k) return
        k=='"'  and '\\"'  or
        k=='\\' and '\\\\' or
        string.format('\\%03d', k :byte())
    end
    return '"' .. x :gsub ('[%z\1-\9\11\12\14-\31\128-\255"\\]', q) .. '"'
end

------------------------------------------------------------------------------
-- virtual printer: print a textual description of the objects in `...', using
-- function `write()' as a writer. By providing the appropriate writer, one
-- can make this function write on a TCP channel, in a string,... anywhere.
-- print_indent is the number of indentation characters used to render
-- tables. If nil/false, tables are rendered without carriage returns.
------------------------------------------------------------------------------
function vprint (write, print_indent, ...)
   local in_progress = { }
   local indent_level = 0
   local tinsert = table.insert
   local function aux(x)
      local  t=type(x)
      if     t=="string"  then write(quotestring(x))
      elseif t=="boolean" then write(x and "true" or "false")
      elseif t=="number"  then write(tostring(x))
      elseif t=="nil"     then write("nil")
      elseif t=="table"   then
        if getmetatable(x) and getmetatable(x).__tostring then write(tostring(x))
        elseif in_progress[x] then write(tostring(table)) else
            in_progress[x] = true
            indent_level = indent_level+1

            local function print_separator()
                if print_indent then write(",\r\n" .. (" "):rep(print_indent * indent_level))
                else write(", ") end
            end

            -- number of elements according to pairs(): zero, one, many
            local at_least_one, more_than_one = false, false
            for _ in pairs(x) do
                if at_least_one then more_than_one=true; break
                else at_least_one=true end
            end

            if not at_least_one then write "{ }"; return
            elseif not more_than_one or not print_indent then write "{ "
            else write("{\r\n" .. (" "):rep(print_indent * indent_level)) end

            local list_keys = { }
            local last_list_key = 0
            repeat
                local i = last_list_key + 1
                local occupied = x[i]~=nil
                if occupied then list_keys[i]=true; last_list_key=i end
            until not occupied

            for i=1, last_list_key do
                if i>1 then print_separator() end
                aux(x[i])
            end

            local first_hash_pair = true
            for k, v in pairs(x) do
                if not list_keys[k] then -- don't reprint the list-part
                    -- separator
                    if not first_hash_pair or last_list_key~=0 then print_separator() end
                    first_hash_pair = false
                    -- key
                    if type(k)=="string" and k:match"^[%a_][%w_]*$" then write(k .. " = ")
                    else write("["); aux(k); write("] = ") end
                    -- value
                    aux(v)
                end
            end
            write (" }")

            indent_level = indent_level-1
            in_progress[x] = nil
         end
      else write(tostring(x)) end
   end
   local args = {...}
   local nb = table.getn(args)
   for k = 1, nb do aux(args[k]); if k<nb then write "\t" end end
end

------------------------------------------------------------------------------
-- A more precise print (on stdout)
------------------------------------------------------------------------------
function p (...)
   local out = {}
   local function write(s)
      table.insert(out, s)
   end
   vprint(write, 3, ...)
   print(table.concat(out))
end

------------------------------------------------------------------------------
-- Build up and return a string instead of printing in some channel.
------------------------------------------------------------------------------
function siprint(indent, ...)
   local ins, acc = table.insert, { }
   vprint(function(x) return ins(acc, x) end, indent, ...)
   return table.concat(acc)
end

function sprint(...)
    return siprint(false, ...)
end

function printf(...) return print(string.format(...)) end

return env]===================],"CoolisOS/bin/utils/serpent.lua",[===================[local n, v = "serpent", 0.224 -- (C) 2012-13 Paul Kulchenko; MIT License
local c, d = "Paul Kulchenko", "Lua serializer and pretty printer"
local snum = {[tostring(1/0)]='1/0 --[[math.huge]]',[tostring(-1/0)]='-1/0 --[[-math.huge]]',[tostring(0/0)]='0/0'}
local badtype = {thread = true, userdata = true}
local keyword, globals, G = {}, {}, (_G or _ENV)
for _,k in ipairs({'and', 'break', 'do', 'else', 'elseif', 'end', 'false',
  'for', 'function', 'goto', 'if', 'in', 'local', 'nil', 'not', 'or', 'repeat',
  'return', 'then', 'true', 'until', 'while'}) do keyword[k] = true end
for k,v in pairs(G) do globals[v] = k end -- build func to name mapping
for _,g in ipairs({'coroutine', 'io', 'math', 'string', 'table', 'os'}) do
  for k,v in pairs(G[g]) do globals[v] = g..'.'..k end end

local function s(t, opts)
  local name, indent, fatal,dname = opts.name, opts.indent, opts.fatal,opts.debug
  local sparse, custom, huge,dbg = opts.sparse, opts.custom, not opts.nohuge,opts.debug
  local space, maxl = (opts.compact and '' or ' '), (opts.maxlevel or math.huge)
  local iname, comm = '_'..(name or ''), opts.comment and (tonumber(opts.comment) or math.huge)
  local seen, sref, syms, symn = {}, {'local '..iname..'={}'}, {}, 0
  local function gensym(val) return '_'..(tostring(tostring(val)):gsub("[^%w]",""):gsub("(%d%w+)",
    -- tostring(val) is needed because __tostring may return a non-string value
    function(s) if not syms[s] then symn = symn+1; syms[s] = symn end return syms[s] end)) end
  local function safestr(s) return type(s) == "number" and (huge and snum[tostring(s)] or s)
    or type(s) ~= "string" and tostring(s) -- escape NEWLINE/010 and EOF/026
    or ("%q"):format(s):gsub("\010","n"):gsub("\026","\\026") end
  local function comment(s,l)
    return comm and (l or 0) < comm and ' --[['..(dbg and type(s)~='string' and debug.getinfo(s) or tostring(s))..']]' or '' end
  local function globerr(s,l) return globals[s] and globals[s]..comment(s,l) or not fatal
    and safestr(select(2, pcall(tostring, s))) or error("Can't serialize "..tostring(s)) end
  local function safename(path, name) -- generates foo.bar, foo[3], or foo['b a r']
    local n = name == nil and '' or name
    local plain = type(n) == "string" and n:match("^[%l%u_][%w_]*$") and not keyword[n]
    local safe = plain and n or '['..safestr(n)..']'
    return (path or '')..(plain and path and '.' or '')..safe, safe end
  local alphanumsort = type(opts.sortkeys) == 'function' and opts.sortkeys or function(k, o, n)  -- k=keys, o=originaltable, n=padding
    local maxn, to = tonumber(n) or 12, {number = 'a', string = 'b'}
    local function padnum(d) return ("%0"..maxn.."d"):format(d) end
    table.sort(k, function(a,b)
      -- sort numeric keys first: k[key] is non-nil for numeric keys
      return (k[a] and 0 or to[type(a)] or 'z')..(tostring(a):gsub("%d+",padnum))
           < (k[b] and 0 or to[type(b)] or 'z')..(tostring(b):gsub("%d+",padnum)) end) end
  local function val2str(t, name, indent, insref, path, plainindex, level,pass)
    local ttype, level, mt = type(t), (level or 0), getmetatable(t)
    local spath, sname = safename(path, name)
    local tag = plainindex and
      ((type(name) == "number") and '' or name..space..'='..space) or
      (name ~= nil and sname..space..'='..space or '')
    if seen[t] then -- already seen this element
      if dbg then return tag..comment(t,level) end
      table.insert(sref, spath..space..'='..space..seen[t])
      return tag..'nil'..comment('ref'..tostring(t), level) end
    if mt and not dbg then
      if mt.__serialize or mt.__tostring then -- knows how to serialize itself
        seen[t] = insref or spath
        if rawget(mt,'__serialize') then t = mt.__serialize(t) else t = tostring(t) end
        ttype = type(t) -- new value falls through to be serialized
      end
    end
    if ttype == "table" then
      if level >= maxl then return tag..'{}'..comment('max', level) end
      seen[t] = insref or spath
      if next(t) == nil then return tag..'{}'..comment(t, level) end -- table empty
      local maxn, o, out = #t, {}, {}
      for key = 1, maxn do table.insert(o, key) end
      for key in pairs(t) do if not o[key] then table.insert(o, key) end end
      if opts.sortkeys then alphanumsort(o, t, opts.sortkeys) end
      for n, key in ipairs(o) do
        local value, ktype, plainindex = t[key], type(key), n <= maxn and not sparse
        if opts.valignore and opts.valignore[value] -- skip ignored values; do nothing
        or opts.keyallow and not opts.keyallow[key]
        or opts.valtypeignore and opts.valtypeignore[type(value)] -- skipping ignored value types
        or sparse and value == nil then -- skipping nils; do nothing
        elseif ktype == 'table' or ktype == 'function' or badtype[ktype] then
          if dbg then
              local s
              if not (seen[key] or globals[key]) then
                seen[key]=debug.getinfo(key)
                s = '['..(val2str(key,nil,indent,nil,nil,false,level+1))..']'..comment(key,level)

              end
              table.insert(out,val2str(value,s or (seen[key] or globals[key]),indent,insref,nil,true,level+1))
          else
              if not seen[key] and not globals[key] then
                local sname = safename(iname, gensym(key)) -- iname is table for local variables
                sref[#sref] = val2str(key,sname,indent,sname,iname,true)
              end
              table.insert(sref, 'placeholder')
              local path = seen[t]..'['..(seen[key] or globals[key] or gensym(key))..']'
              sref[#sref] = path..space..'='..space..(seen[value] or val2str(value,nil,indent,path))
          end
        else
          table.insert(out,val2str(value,key,indent,insref,seen[t],plainindex,level+1))
        end
      end
      local prefix = string.rep(indent or '', level)
      local head = indent and '{\n'..prefix..indent or '{'
      local body = table.concat(out, ','..(indent and '\n'..prefix..indent or space))
      local tail = indent and "\n"..prefix..'}' or '}'
      return (custom and custom(tag,head,body,tail) or tag..head..body..tail)..comment(t, level)
    elseif badtype[ttype] then
      seen[t] = insref or spath
      return tag..globerr(t, level)
    elseif ttype == 'function' and not dbg then
      seen[t] = insref or spath
      local ok, res = pcall(string.dump, t)
      local func = ok and ((opts.nocode and "function() --[[..skipped..]] end" or
        "loadstring("..safestr(res)..",'@serialized')")..comment(t, level))
      return tag..(func or globerr(t, level))
    else return tag..safestr(t) end -- handle all other types
  end
  local sepr = indent and "\n" or ";"..space
  local body = val2str(t, name, indent) -- this call also populates sref
  local tail = #sref>1 and table.concat(sref, sepr)..sepr or ''
  return not name and body or "do local "..body..sepr..tail.."return "..name..sepr.."end"
end

local function merge(a, b) if b then for k,v in pairs(b) do a[k] = (a[k]==nil and v or a[k]) end end; return a; end
return { _NAME = n, _COPYRIGHT = c, _DESCRIPTION = d, _VERSION = v, serialize = s,
  dump = function(a, opts) return s(a, merge({name = '_', compact = true, sparse = true}, opts)) end,
  line = function(a, opts) return s(a, merge({sortkeys = true, comment = true}, opts)) end,
  block = function(a, opts) return s(a, merge({indent = '  ', sortkeys = true, comment = true}, opts)) end }]===================],"CoolisOS/bin/utils/turtle.lua",[===================[

--[[
process:
-state
-state handler
--interrupts
-state machines?
-complex for generalism
-simple for dig queues: <- are generally stateless
    are kept separately, dig queues are just vector coords
    position and orientation->state
    turtle api overwritten to catch movement
    interpreter command to set position, world-wide
    implies keepig initial referencial
    simple wrap-up of goto
(need stack like state machines for pausing, and then returning)
-general pathfinding
    djikstra algorithm
    maintainig map
    - imprredictable movement
    + can contornate obstacles
]]
--state_stack={}
--
--
--
--function get_move_queue()
--  local q={}
--  for i=1,10 do
--      table.insert(function() goto(Vec3(i,0,0)) end)
--  end
--  return q
--end
--
--[[doing queue implies
--getting state/resuming state
--executing and saving <- open new, save current, delete old
--goto needs some context
--turtle movement is single -coroutined; means that mode can be global
--]]
--function get_coords()
--  f=fs.open('ect/pos','r')
--  pos=Vec3(textutils.deserialize(f.readAll()))
--  f.close()
--  return pos
--end
--function save_pos(pos)
--  f=fs.open('ect/pos','w')
--  f.writeLine(pos:serialize())
--  f.close()
--end
--
--
--function get_state_for(queue)
--  local coords=get_coords()
--  for i,v in pairs(queue) do
--      if v==coords then return i end
--  end
--end
--function do_queue(queue)
--  cur=get_state_for(queue)
--  for i=cur,#queue do
--      goto(queue[i])
--  end
--end
--
--function main()
--  mov_queue=get_move_queue()
--  do_queue(queue)
--end

if not turtle then error('not a turtle',2) end

if turtle._old then
    turtle=util.shcopy(turtle._old)
else
    turtle._old=util.shcopy(turtle)
end

local _log=log
local log=function(...) return _log('turtle',...) end

include'kernel.class'
local Vec3=require'utils.Vec3'

local util=require'kernel.util'
local Var=require'kernel.class.Var'

---forward declaration
local api

--persistence
local pos,dir
local saveDir=fs.combine(_INSTALL_PATH,'ect/turtle')
if not fs.exists(saveDir) then fs.makeDir(saveDir) end

local dump=require'utils.serpent'.dump
local var=Var(fs.combine(saveDir,'pos-dir.var'))
local mode=Var(fs.combine(saveDir,'mode.var'))

local function merge(dst,src)
    for i,v in pairs(src) do
        if dst[i]==nil then
            dst[i]=src[i]
        end
    end
end
merge(mode,{
dig=true,
attack=true,
count=20,
delay=0.5,
gps=false,
})

local function save()
   var.pos=pos
   var.dir=dir
end
local function load()
    local p,d=var.pos,var.dir
    pos,dir=p and Vec3(p) or nil,d and Vec3(d) or nil
end
local zero=Vec3()
function set(_pos,_dir)
    check('?Vec3,?Vec3',_pos,_dir)
    assert(_dir~=zero)
    pos,dir=(_pos or pos):clone(),(_dir or dir):clone()
    save()
end
function get() return pos:clone(),dir:clone() end

local function sign(num)
    return (num==nil or num==0) and 0 or (num>0 and 1 or -1)
end
--fuel handling
function ensureFuel()
    if api.ensureFuel then api.ensureFuel() end
end
---
--atomic overrides of the turtle api and moves def
moves={}
do
    local s_dirs={
    up={
    vec=function() return Vec3(0,1,0) end,
    at=function(at)
        at.y=at.y+1
    end,
    raw_name="up",
        attack=turtle.attackUp,
        suck=turtle.suckUp,dig=turtle.digUp, raw_move=turtle.up, detect=turtle.detectUp, place=turtle.placeUp,compare=turtle.compareUp, drop=turtle.dropUp,},
    forward={
    vec=function() return Vec3(dir.x,0,dir.z) end,
    at=function(at,dir)
        at.x=at.x+dir.x
        at.z=at.z+dir.z
    end,
    attack=turtle.attack,
    raw_name="forward",suck=turtle.suck, dig=turtle.dig, raw_move=turtle.forward, detect=turtle.detect, place=turtle.place,compare=turtle.compare, drop=turtle.drop,},
    down={
    vec=function() return Vec3(0,-1,0) end,
    at=function(at)
        at.y=at.y-1
    end,
    attack=turtle.attackDown,
    raw_name="down",suck=turtle.suckDown,dig=turtle.digDown, raw_move=turtle.down, detect=turtle.detectDown, place=turtle.placeDown,compare=turtle.compareDown, drop=turtle.dropDown,},
    back={
    vec=function() return Vec3(-dir.x,0,-dir.z) end,
    at=function(at,dir)
        at.x=at.x-dir.x
        at.z=at.z-dir.z
    end,
    raw_name='back',raw_move=turtle.back},
    }
    local t_dirs={
    left={
    vec=function() return Vec3(dir.z,0,-dir.x) end,
    raw_name='turnLeft',raw_move=turtle.turnLeft,at=function(at,dir)  dir.x, dir.z = dir.z, -dir.x end },
    right={
    vec=function() return Vec3(-dir.z,0,dir.x) end,
    raw_name='turnRight',raw_move=turtle.turnRight,at=function(at,dir) dir.x, dir.z = -dir.z, dir.x end},
    }
    local opp={
    up='down',
    forward='back',
    right='left',
    }
    for i,v in pairs(opp) do opp[v]=i end

    local function helpMove(doF,moveF,undoF,fuel)
        if fuel then ensureFuel() end
        doF(pos,dir)
        save()
        local r=moveF()
        if not r then undoF(pos,dir) save() end
        return r
    end

    for mv,t in pairs(s_dirs) do
        local args={t.at,t.raw_move,s_dirs[opp[mv]].at,true}
        turtle[t.raw_name]=function() return helpMove(unpack(args)) end
        t.move=turtle[t.raw_name]
        moves[mv]=t
    end
    for mv,t in pairs(t_dirs) do
        local args={t.at,t.raw_move,t_dirs[opp[mv]].at}
        turtle[t.raw_name]=function() return helpMove(unpack(args)) end
        t.move=turtle[t.raw_name]
        moves[mv]=t
    end

    --aliases
    -- local function tdo(turnF,doF) return function(...) turnF() return doF(...) end end

    -- moves.around={}
    -- util.shcopy({
    -- suck=tdo(moves.around,forward.suck),
    -- attack=tdo(moves.around,forward.attack),
    -- drop=tdo(moves.around,forward.drop),
    -- move=function() turtle.turnLeft() turtle.turnLeft() end,
    -- at=function(at,dir) moves.left.at(at,dir) moves.left.at(at,dir) end,
    -- },moves.around)



    for i,v in pairs(moves) do
        setmetatable(v,
            {__call=function(t,...)
                return v.move(...)
            end,
            })
    end
    moves.top=moves.up
    moves.bottom=moves.down
    moves.front=moves.forward



end
for i,v in pairs(moves) do
    local env=(getfenv())
    env[i]=v
end
---

--world pos related
compass={
    {name='north',n=0,vec=function() return Vec3( 0, 0,-1) end},
    {name='east',n=1,vec=function() return Vec3( 1, 0, 0) end},
    {name='south',n=2,vec=function() return Vec3( 0, 0, 1) end},
    {name='west',n=3,vec=function() return Vec3(-1, 0, 0) end},
    }
for i,v in pairs(compass) do compass[v.name]=v end

--vec, mov, string, or nil
function getFacing(mv)
    local vec
    if mv==nil then vec=dir
    elseif classof(mv)==Vec3 then vec=mv
    elseif type(mv)=='string' then vec=moves[mv].vec()
    else error() end
    for i,c in ipairs(compass) do
        if vec==c.vec() then return c.name end
    end
end
function getChunk(v)
    v=v or pos
  return math.floor(v.x/16), math.floor(v.z/16)
end
function getChunkPosition(v)
    v=v or pos
  return v.x%16, v.z%16
end
---

--[[input patterns:
x,y,z ->vector
string->move or compass
move or compas->vec

drop
suck
place

]]
--arg transformer
local function trf(...)
    if classof(...)==Vec3 then
        return ...
    elseif type(...)=='string' then
        if moves[...] then
            return moves[...].vec()
        elseif compass[...] then
            return compass[...].vec()
        end
    else return Vec3(...) end
end
--public api
--mv based
local lastMoveNeededDig=false

function clear(mv)
    mv=type(mv)=='string' and moves[mv] or mv
    local maxCount=mode.count
    local delay=mode.delay

    local dig_count=0
    local count=0
    while (mv.detect()) and (count < maxCount) do
        if(count == 0) then
          -- Am about to dig a block - check that it is not a chest if necessary
          -- If we are looking for chests, then check that this isn't a chest before moving
            if not mode.dig then
                return false,'dig'
            end
        end
        dig_count = (mv.dig() and 1 or 0)+count
        count=count+1
        sleep(delay)
    end
    if dig_count~=0 then lastMoveNeededDig=true end
    return (count~=maxCount),count,dig_count
end
function force_back()
    if not moves.back() then
        local a,b,c=move'back'
        turn'back'
        return a,b,c
    end
    return true,0,0
end

local function _force(mv,key)
    mv=type(mv)=='string' and moves[mv] or mv
    if mv==moves.back then return force_back(mv,key) end
    local suc
    if not lastMoveNeededDig then
        suc=mv[key]()
        if suc then return true,0,0 end
    end
    local maxCount=mode.count
    local delay=mode.delay

    local dig_count=0
    local count=0
    while (not suc) and (count < maxCount) do
        if mv.detect() then
            if(count == 0) then
              -- Am about to dig a block - check that it is not a chest if necessary
              -- If we are looking for chests, then check that this isn't a chest before moving
                if not mode.dig then
                    return false,'dig'
                end
            end
            dig_count = (mv.dig() and 1 or 0)+count
        else
            if not mode.attack then
                return false,'attack'
            end
            mv.attack()
        end
        sleep(delay)
        suc=mv[key]()
        count=count+1
    end
    if dig_count~=0 then lastMoveNeededDig=true end
    return suc,count,dig_count
end
function force(mv)
    return _force(mv,'move')
end
function place(mv)
    return _force(mv,'place')
end
function advance(mv, steps)
    mv=type(mv)=='string' and moves[mv] or mv
    steps = steps or 1
    for step = 1,steps do
        force(mv)
    end
end

--vector based
function turn(...)
    local to=trf(...)
    local x,z = sign(to.x), sign(to.z)
    if x == dir.x and z == dir.z then
        return
    elseif (x == -dir.x and x~=0) or (z == -dir.z and z~=0) then --or?
        left()
        left()
    elseif x ~= 0 then
        if x == -dir.z then right() else left() end
    elseif z ~= 0 then
        if z == dir.x then right() else left() end
    end
end

function goto(...)
    local to=trf(...)
    if to.y>pos.y then
        advance(up, to.y-pos.y)
    elseif to.y<pos.y then
        advance(down, pos.y-to.y)
    end
    if to.x ~= pos.x then
        turn({x=to.x-pos.x})
        advance(forward, math.abs(to.x-pos.x))
    end
    if to.z ~= pos.z then
        turn({z=to.z-pos.z})
        advance(forward, math.abs(to.z-pos.z))
    end
end

function move(...)
    local to=trf(...)
    return goto(to+pos)
end
---
--init code
local function update()
    load()
    pos=(pos or Vec3())
    dir=(dir or compass.south.vec())
    save()
    if mode.gps then
        local ok, pos_,dir_=pcall(getGps)
        if ok then set(pos_,dir_)
        else log('WARNING','Could not use gps:',pos_) end
    end
end

function getGps()
    rednet.open'right'
    local x,y,z=gps.locate(5)
    if x then
        gps_pos=Vec3(x,y,z)
        local org=(get())
        for _,c in ipairs(compass) do
            if goto(c.vec()+org) then
                local x,y,z=gps.locate(5)
                if x then
                    local gps_pos2=Vec3(x,y,z)
                    local dir=gps_pos2-gps_pos
                    if dir~=Vec3(0,0,0) then
                        return true,gps_pos2,dir
                    end
                end
            end
        end
        error'blocked'
    else
        error'no gps signal'
    end
end


api={

set=set,
get=get,

moves=moves,
front=moves.forward,
bottom=moves.down,
top=moves.up,

clear=clear,
force=force,
place=place,
advance=advance,

mode=mode,

getFacing=getFacing,
getChunk=getChunk,
getChunkPos=getChunkPos,
compass=compass,

getGps=getGps,

turn=turn,
move=move,
goto=goto,
}
for i,v in pairs(moves) do api[i]=v end
api.api=api


update()




return api]===================],"CoolisOS/bin/utils/Vec3.lua",[===================[--[[
Advanced Vector API by Tomass1996

Vector 'Object' Functions And Fields:
  vector.x                              -- Vectors X component
  vector.y                              -- Vectors Y component
  vector.z                              -- Vectors Z component
  vector:add(otherVector)               -- Component-wise addition
  vector:scalarAdd(n)                   -- Scalar addition
  vector:subtract(otherVector)          -- Component-wise subtraction
  vector:scalarSubtract(n)              -- Scalar subtraction
  vector:eldot(otherVector)          -- Component-wise multiplication
  vector:scalarMultiply(n)              -- Scalar multiplication
  vector:divide(otherVector)            -- Component-wise division
  vector:scalarDivide(n)                -- Scalar division
  vector:length()                       -- Get the length of the vector
  vector:lengthSq()                     -- Get the length ^ 2 of the vector
  vector:distance(otherVector)          -- Get the distance away from a vector
  vector:distanceSq(otherVector)        -- Get the distance away from a vector, squared
  vector:normalize()                    -- Get the normalized vector
  vector:dot(otherVector)               -- Get the dot product of vector and otherVector
  vector:cross(otherVector)             -- Get the cross product of vector and otherVector
  vector:containedWithin(minVec, maxVec)-- Check to see if vector is contained within minVec and maxVec
  vector:clampX(min, max)               -- Clamp the X component
  vector:clampY(min, max)               -- Clamp the Y component
  vector:clampZ(min, max)               -- Clamp the Z component
  vector:floor()                        -- Rounds all components down
  vector:ceil()                         -- Rounds all components up
  vector:round()                        -- Rounds all components to the closest integer
  vector:absolute()                     -- Vector with absolute values of components
  vector:isCollinearWith(otherVector)   -- Checks to see if vector is collinear with otherVector
  vector:getIntermediateWithX(other, x) -- New vector with given x value along the line between vector and other, or nil if not possible
  vector:getIntermediateWithY(other, y) -- New vector with given y value along the line between vector and other, or nil if not possible
  vector:getIntermediateWithZ(other, z) -- New vector with given z value along the line between vector and other, or nil if not possible
  vector:rotateAroundX(angle)           -- Rotates vector around the x axis by the specified angle(radians)
  vector:rotateAroundY(angle)           -- Rotates vector around the y axis by the specified angle(radians)
  vector:rotateAroundZ(angle)           -- Rotates vector around the z axis by the specified angle(radians)
  vector:clone()                        -- Returns a new vector with same component values as vector
  vector:equals(otherVector)            -- Checks to see if vector and otherVector are equal
  vector:tostring()                     -- Returns the string representation of vector "(x, y, z)"

Vector 'Object' Metatable Overrides:    -- [x, y, z] represents a vector object in these examples, not irl
  To String             -- tostring will get the string representation
                            ie. tostring([1, 2, 3])     -->     "(1, 2, 3)"
  Unary Minus           -- Using unary minus on a vector will result in the negative of vector
                            ie. -[1, -2, 3]             -->     [-1, 2, -3]
  Addition              -- Can add two vectors or vector and number with +
                            ie. [1, 2, 3] + [4, 5, 6]   -->     [5, 7, 9]
                                [1, 2, 3] + 3           -->     [4, 5, 6]
  Subtraction           -- Can subtract two vectors or vector and number with -
                            ie. [4, 5, 6] - [1, 2, 3]   -->     [3, 3, 3]
                                [4, 5, 6] - 3           -->     [1, 2, 3]
  Multiplication        -- Can dot two vectors or vector and number with *
                            ie. [1, 2, 3] * [4, 5, 6]   -->     [4, 10, 18]
                                [1, 2, 3] * 3           -->     [3, 6, 9]
  Division              -- Can divide two vectors or vector and number with /
                            ie. [4, 10, 18] / [1, 2, 3] -->     [4, 5, 6]
                                [3, 6, 9] / 3           -->     [1, 2, 3]
  Equality              -- Can check if two vectors are the same with ==
                            ie. [4, 5, 6] == [4, 5, 6]  -->     true
                                [4, 5, 6] == [4, 99, 6] -->     false

Vector API functions:
  Vector.getMinimum(v1, v2)             -- Gets the minimum components of two vectors
  Vector.getMaximum(v1, v2)             -- Gets the maximum components of two vectors
  Vector.getMidpoint(v1, v2)            -- Gets the midpoint of two vectors
  Vector.isVector(v)                    -- Checks whether v is a vector created by this api
  Vector(x, y, z)                   -- Creates a new vector object with the component values
--]]

include'kernel.class'
class.Vec3()
function Vec3:__init(t,y,z)
    if type(t)=='table' then
        self.x = t.x or t[1] or 0
        self.y = t.y or t[2] or 0
        self.z = t.z or t[3] or 0
    else
        self.x = t or 0
        self.y = y or 0
        self.z = z or 0
    end
end
local vector=Vec3
local new=Vec3
local isVector=function(v) return classof(v)==Vec3 end
local getType=ofType
local vector = {
  add = function(self, v)
      self.x=self.x + v.x
      self.y=self.y + v.y
      self.z=self.z + v.z
      return self
  end,
  scalarAdd = function(self, n)
    self.x=self.x + n
    self.y=self.y + n
    self.z=self.z + n
    return self
  end,
  subtract = function(self, v)
    self.x=self.x - v.x
    self.y=self.y - v.y
    self.z=self.z - v.z
    return self
  end,
  scalarSubtract = function(self, n)
    return self:scalarAdd(-n)
  end,
  eldot = function(self, v)
    self.x=self.x * v.x
    self.y=self.y * v.y
    self.z=self.z * v.z
    return self
  end,
  scalarMultiply = function(self, n)
    self.x=self.x * n
    self.y=self.y * n
    self.z=self.z * n
    return self
  end,
  divide = function(self, o)
    return new(
      self.x / o.x,
      self.y / o.y,
      self.z / o.z
    )
  end,
  scalarDivide = function(self, n)
    return new(
      self.x / n,
      self.y / n,
      self.z / n
    )
  end,
  length = function(self)
    return math.sqrt(
      self.x * self.x
      + self.y * self.y
      + self.z * self.z
    )
  end,
  lengthSq = function(self)
    return (
      self.x * self.x
      + self.y * self.y
      + self.z * self.z
    )
  end,
  distance = function(self, o)
    return math.sqrt(
      math.pow(o.x - self.x, 2)
      + math.pow(o.y - self.y, 2)
      + math.pow(o.z - self.z, 2)
    )
  end,
  distanceSq = function(self, o)
    return (
      math.pow(o.x - self.x, 2)
      + math.pow(o.y - self.y, 2)
      + math.pow(o.z - self.z, 2)
    )
  end,
  normalize = function(self)
    return self:scalarDivide(self:length())
  end,
  dot = function(self, o)
    return (
      self.x * o.x
      + self.y * o.y
      + self.z * o.z
    )
  end,
  cross = function(self, o)
    return 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,
  containedWithin = function(self, min, max)
    return (
      self.x >= min.x and self.x <= max.x
      and self.y >= min.y and self.y <= max.y
      and self.z >= min.z and self.z <= max.z
    )
  end,
  clampX = function(self, min, max)
    return new(
      math.max(min, math.min(max, self.x)),
      self.y,
      self.z
    )
  end,
  clampY = function(self, min, max)
    return new(
      self.x,
      math.max(min, math.min(max, self.y)),
      self.z
    )
  end,
  clampZ = function(self, min, max)
    return new(
      self.x,
      self.y,
      math.max(min, math.min(max, self.z))
    )
  end,
  floor = function(self)
    return new(
      math.floor(self.x),
      math.floor(self.y),
      math.floor(self.z)
    )
  end,
  ceil = function(self)
    return new(
      math.ceil(self.x),
      math.ceil(self.y),
      math.ceil(self.z)
    )
  end,
  round = function(self)
    return new(
      math.floor(self.x + 0.5),
      math.floor(self.y + 0.5),
      math.floor(self.z + 0.5)
    )
  end,
  absolute = function(self)
    return new(
      math.abs(self.x),
      math.abs(self.y),
      math.abs(self.z)
    )
  end,
  isCollinearWith = function(self, o)
    if self.x == 0 and self.y == 0 and self.z == 0 then
      return true
    end
    local otherX, otherY, otherZ = o.x, o.y, o.z
    if otherX == 0 and otherY == 0 and otherZ == 0 then
      return true
    end
    if (self.x == 0) ~= (otherX == 0) then return false end
    if (self.y == 0) ~= (otherY == 0) then return false end
    if (self.z == 0) ~= (otherZ == 0) then return false end
    local quotientX = otherX / self.x
    if quotientX == quotientX then
      return o:equals(self:scalarMultiply(quotientX))
    end
    local quotientY = otherY / self.y
    if quotientY == quotientY then
      return o:equals(self:scalarMultiply(quotientY))
    end
    local quotientZ = otherZ / self.z
    if quotientZ == quotientZ then
      return o:equals(self:scalarMultiply(quotientZ))
    end
  end,
  getIntermediateWithX = function(self, o, v)
    local vX = o.x - self.x
    local vY = o.y - self.y
    local vZ = o.z - self.z
    if vX * vX < 1.0000000116860974e-7 then
      return nil
    else
      local nMul = (v - self.x) / vX
      return (
        (nMul >= 0 and nMul <= 1)
        and new(
          self.x + vX * nMul,
          self.y + vY * nMul,
          self.z + vZ * nMul
        )
        or nil
      )
    end
  end,
  getIntermediateWithY = function(self, o, v)
    local vX = o.x - self.x
    local vY = o.y - self.y
    local vZ = o.z - self.z
    if vY * vY < 1.0000000116860974e-7 then
      return nil
    else
      local nMul = (v - self.y) / vY
      return (
        (nMul >= 0 and nMul <= 1)
        and new(
          self.x + vX * nMul,
          self.y + vY * nMul,
          self.z + vZ * nMul
        )
        or nil
      )
    end
  end,
  getIntermediateWithZ = function(self, o, v)
    local vX = o.x - self.x
    local vY = o.y - self.y
    local vZ = o.z - self.z
    if vZ * vZ < 1.0000000116860974e-7 then
      return nil
    else
      local nMul = (v - self.z) / vZ
      return (
        (nMul >= 0 and nMul <= 1)
        and new(
          self.x + vX * nMul,
          self.y + vY * nMul,
          self.z + vZ * nMul
        )
        or nil
      )
    end
  end,
  rotateAroundX = function(self, n)
    local c, s = math.cos(n), math.sin(n)
    return new(
      self.x,
      self.y * c + self.z * s,
      self.z * c - self.y * s
    )
  end,
  rotateAroundY = function(self, n)
    local c, s = math.cos(n), math.sin(n)
    return new(
      self.x * c + self.z * s,
      self.y,
      self.z * c - self.x * s
    )
  end,
  rotateAroundZ = function(self, n)
    local c, s = math.cos(n), math.sin(n)
    return new(
      self.x * c + self.y * s,
      self.y * c - self.x * s,
      self.z
    )
  end,
  clone = function(self)
    return Vec3(self)
  end,
  equals = function(self, o)
    if not isVector(self) or not isVector(o) then return false end
    return (
      o.x == self.x
      and o.y == self.y
      and o.z == self.z
    )
  end,
  tostring = function(self)
    return "("..self.x..", "..self.y..", "..self.z..")"
  end,
  getMinimum=function(v1, v2)
      return new(
        math.min(v1.x, v2.x),
        math.min(v1.y, v2.y),
        math.min(v1.z, v2.z)
      )
    end,
    getMidpoint= function(v1, v2)
  return new(
    (v1.x + v2.x) / 2,
    (v1.y + v2.y) / 2,
    (v1.z + v2.z) / 2
  )
end,
    __serialize=function(self)
        return {self.x,self.y,self.z}
    end
}

local vmetatable = {
  __tostring = vector.tostring,
  __unm = function(v) return v:scalarMultiply(-1) end,
  __add = function(a, b)
    if type(b) == "number" and isVector(a) then
      return a:clone():scalarAdd(b)
    elseif type(a) == "number" and isVector(b) then
      return b:clone():scalarAdd(a)
    elseif isVector(a) and isVector(b) then
      return a:clone():add(b)
    else
      error("Attempt to perform vector addition on <"..getType(a).."> and <"..getType(b)..">")
    end
  end,
  __sub = function(a, b)
    if type(b) == "number" and isVector(a) then
      return a:clone():scalarSubtract(b)
    elseif type(a) == "number" and isVector(b) then
      return b:clone():scalarSubtract(a)
    elseif isVector(a) and isVector(b) then
      return a:clone():subtract(b)
    else
      error("Attempt to perform vector subtraction on <"..getType(a).."> and <"..getType(b)..">")
    end
  end,
  __mul = function(a, b)
    if type(b) == "number" and isVector(a) then
      return a:scalarMultiply(b)
    elseif type(a) == "number" and isVector(b) then
      return b:scalarMultiply(a)
    elseif isVector(a) and isVector(b) then
      return a:dot(b)
    else
      error("Attempt to perform vector multiplication on <"..getType(a).."> and <"..getType(b)..">")
    end
  end,
  __div = function(a, b)
    if type(b) == "number" and isVector(a) then
      return a:scalarDivide(b)
    elseif type(a) == "number" and isVector(b) then
      return b:scalarDivide(a)
    elseif isVector(a) and isVector(b) then
      return a:divide(b)
    else
      error("Attempt to perform vector division on <"..getType(a).."> and <"..getType(b)..">")
    end
  end,
  __eq = vector.equals,
  __pow = vector.cross,
}



util.shcopy(vector,Vec3)
util.shcopy(vmetatable,Vec3)

--[[test
v=require'bin.utils.Vec3'


]]

return Vec3]===================],"CoolisOS/bin/utils/pl",true,"CoolisOS/bin/utils/pl/List.lua",[===================[--- Python-style list class.
--
-- **Please Note**: methods that change the list will return the list.
-- This is to allow for method chaining, but please note that `ls = ls:sort()`
-- does not mean that a new copy of the list is made. In-place (mutable) methods
-- are marked as returning 'the list' in this documentation.
--
-- See the Guide for further @{02-arrays.md.Python_style_Lists|discussion}
--
-- See <a href="http://www.python.org/doc/current/tut/tut.html">http://www.python.org/doc/current/tut/tut.html</a>, section 5.1
--
-- **Note**: The comments before some of the functions are from the Python docs
-- and contain Python code.
--
-- Written for Lua version Nick Trout 4.0; Redone for Lua 5.1, Steve Donovan.
--
-- Dependencies: `pl.utils`, `pl.tablex`
-- @module pl.List
-- @pragma nostrip

local tinsert,tremove,concat,tsort = table.insert,table.remove,table.concat,table.sort
local setmetatable, getmetatable,type,tostring,assert,string,next = setmetatable,getmetatable,type,tostring,assert,string,next
local write = io.write
local tablex = require 'tablex'
local filter,imap,imap2,reduce,transform,tremovevalues = tablex.filter,tablex.imap,tablex.imap2,tablex.reduce,tablex.transform,tablex.removevalues
local tablex = tablex
local tsub = tablex.sub
local utils = require 'utils'
local array_tostring,split,is_type,assert_arg,function_arg = utils.array_tostring,utils.split,utils.is_type,utils.assert_arg,utils.function_arg
local normalize_slice = tablex._normalize_slice

--[[
module ('pl.List',utils._module)
]]

local Multimap = utils.stdmt.MultiMap
-- metatable for our list objects
local List = utils.stdmt.List
List.__index = List
List._class = List

local iter

-- we give the metatable its own metatable so that we can call it like a function!
setmetatable(List,{
    __call = function (tbl,arg)
        return List.new(arg)
    end,
})

local function makelist (t,obj)
    local klass = List
    if obj then
        klass = getmetatable(obj)
    end
    return setmetatable(t,klass)
end

local function is_list(t)
    return getmetatable(t) == List
end

local function simple_table(t)
  return type(t) == 'table' and not is_list(t) and #t > 0
end

function List:_init (src)
    if src then
        for v in iter(src) do
            tinsert(self,v)
        end
    end
end

--- Create a new list. Can optionally pass a table;
-- passing another instance of List will cause a copy to be created
-- we pass anything which isn't a simple table to iterate() to work out
-- an appropriate iterator  @see List.iterate
-- @param t An optional list-like table
-- @return a new List
-- @usage ls = List();  ls = List {1,2,3,4}
function List.new(t)
    local ls
    if not simple_table(t) then
        ls = {}
        List._init(ls,t)
    else
        ls = t
    end
    makelist(ls)
    return ls
end

function List:clone()
    local ls = makelist({},self)
    List._init(ls,self)
    return ls
end

function List.default_map_with(T)
    return function(self,name)
       local f = T[name]
       if f then
          return function(self,...)
             return self:map(f,...)
          end
       else
          error("method not found: "..name,2)
       end
    end
end


---Add an item to the end of the list.
-- @param i An item
-- @return the list
function List:append(i)
  tinsert(self,i)
  return self
end

List.push = tinsert

--- Extend the list by appending all the items in the given list.
-- equivalent to 'a[len(a):] = L'.
-- @param L Another List
-- @return the list
function List:extend(L)
  assert_arg(1,L,'table')
  for i = 1,#L do tinsert(self,L[i]) end
  return self
end

--- Insert an item at a given position. i is the index of the
-- element before which to insert.
-- @param i index of element before whichh to insert
-- @param x A data item
-- @return the list
function List:insert(i, x)
  assert_arg(1,i,'number')
  tinsert(self,i,x)
  return self
end

--- Insert an item at the begining of the list.
-- @param x a data item
-- @return the list
function List:put (x)
    return self:insert(1,x)
end

--- Remove an element given its index.
-- (equivalent of Python's del s[i])
-- @param i the index
-- @return the list
function List:remove (i)
    assert_arg(1,i,'number')
    tremove(self,i)
    return self
end

--- Remove the first item from the list whose value is given.
-- (This is called 'remove' in Python; renamed to avoid confusion
-- with table.remove)
-- Return nil if there is no such item.
-- @param x A data value
-- @return the list
function List:remove_value(x)
    for i=1,#self do
        if self[i]==x then tremove(self,i) return self end
    end
    return self
 end

--- Remove the item at the given position in the list, and return it.
-- If no index is specified, a:pop() returns the last item in the list.
-- The item is also removed from the list.
-- @param i An index
-- @return the item
function List:pop(i)
    if not i then i = #self end
    assert_arg(1,i,'number')
    return tremove(self,i)
end

List.get = List.pop

--- Return the index in the list of the first item whose value is given.
-- Return nil if there is no such item.
-- @class function
-- @name List:index
-- @param x A data value
-- @param idx where to start search (default 1)
-- @return the index, or nil if not found.

local tfind = tablex.find
List.index = tfind

--- does this list contain the value?.
-- @param x A data value
-- @return true or false
function List:contains(x)
    return tfind(self,x) and true or false
end

--- Return the number of times value appears in the list.
-- @param x A data value
-- @return number of times x appears
function List:count(x)
    local cnt=0
    for i=1,#self do
        if self[i]==x then cnt=cnt+1 end
    end
    return cnt
end

--- Sort the items of the list, in place.
-- @param cmp an optional comparison function, default '<'
-- @return the list
function List:sort(cmp)
    if cmp then cmp = function_arg(1,cmp) end
    tsort(self,cmp)
    return self
end

--- return a sorted copy of this list.
-- @param cmp an optional comparison function, default '<'
-- @return a new list
function List:sorted(cmp)
    return List(self):sort(cmp)
end

--- Reverse the elements of the list, in place.
-- @return the list
function List:reverse()
    local t = self
    local n = #t
    local n2 = n/2
    for i = 1,n2 do
        local k = n-i+1
        t[i],t[k] = t[k],t[i]
    end
    return self
end

--- return the minimum and the maximum value of the list.
-- @return minimum value
-- @return maximum value
function List:minmax()
    local vmin,vmax = 1e70,-1e70
    for i = 1,#self do
        local v = self[i]
        if v < vmin then vmin = v end
        if v > vmax then vmax = v end
    end
    return vmin,vmax
end

--- Emulate list slicing.  like  'list[first:last]' in Python.
-- If first or last are negative then they are relative to the end of the list
-- eg. slice(-2) gives last 2 entries in a list, and
-- slice(-4,-2) gives from -4th to -2nd
-- @param first An index
-- @param last An index
-- @return a new List
function List:slice(first,last)
    return tsub(self,first,last)
end

--- empty the list.
-- @return the list
function List:clear()
    for i=1,#self do tremove(self) end
    return self
end

local eps = 1.0e-10

--- Emulate Python's range(x) function.
-- Include it in List table for tidiness
-- @param start A number
-- @param finish A number greater than start; if absent,
-- then start is 1 and finish is start
-- @param incr an optional increment (may be less than 1)
-- @return a List from start .. finish
-- @usage List.range(0,3) == List{0,1,2,3}
-- @usage List.range(4) = List{1,2,3,4}
-- @usage List.range(5,1,-1) == List{5,4,3,2,1}
function List.range(start,finish,incr)
  if not finish then
    finish = start
    start = 1
  end
  if incr then
    assert_arg(3,incr,'number')
    if not utils.is_integer(incr) then finish = finish + eps end
  else
    incr = 1
  end
  assert_arg(1,start,'number')
  assert_arg(2,finish,'number')
  local t = List.new()
  for i=start,finish,incr do tinsert(t,i) end
  return t
end

--- list:len() is the same as #list.
function List:len()
  return #self
end

-- Extended operations --

--- Remove a subrange of elements.
-- equivalent to 'del s[i1:i2]' in Python.
-- @param i1 start of range
-- @param i2 end of range
-- @return the list
function List:chop(i1,i2)
    return tremovevalues(self,i1,i2)
end

--- Insert a sublist into a list
-- equivalent to 's[idx:idx] = list' in Python
-- @param idx index
-- @param list list to insert
-- @return the list
-- @usage  l = List{10,20}; l:splice(2,{21,22});  assert(l == List{10,21,22,20})
function List:splice(idx,list)
    assert_arg(1,idx,'number')
    idx = idx - 1
    local i = 1
    for v in iter(list) do
        tinsert(self,i+idx,v)
        i = i + 1
    end
    return self
end

--- general slice assignment s[i1:i2] = seq.
-- @param i1  start index
-- @param i2  end index
-- @param seq a list
-- @return the list
function List:slice_assign(i1,i2,seq)
    assert_arg(1,i1,'number')
    assert_arg(1,i2,'number')
    i1,i2 = normalize_slice(self,i1,i2)
    if i2 >= i1 then self:chop(i1,i2) end
    self:splice(i1,seq)
    return self
end

--- concatenation operator.
-- @param L another List
-- @return a new list consisting of the list with the elements of the new list appended
function List:__concat(L)
    assert_arg(1,L,'table')
    local ls = self:clone()
    ls:extend(L)
    return ls
end

--- equality operator ==.  True iff all elements of two lists are equal.
-- @param L another List
-- @return true or false
function List:__eq(L)
    if #self ~= #L then return false end
    for i = 1,#self do
        if self[i] ~= L[i] then return false end
    end
    return true
end

--- join the elements of a list using a delimiter. <br>
-- This method uses tostring on all elements.
-- @param delim a delimiter string, can be empty.
-- @return a string
function List:join (delim)
    delim = delim or ''
    assert_arg(1,delim,'string')
    return concat(array_tostring(self),delim)
end

--- join a list of strings. <br>
-- Uses table.concat directly.
-- @class function
-- @name List:concat
-- @param delim a delimiter
-- @return a string
List.concat = concat

local function tostring_q(val)
    local s = tostring(val)
    if type(val) == 'string' then
        s = '"'..s..'"'
    end
    return s
end

--- how our list should be rendered as a string. Uses join().
-- @see List:join
function List:__tostring()
    return '{'..self:join(',',tostring_q)..'}'
end

--[[
-- NOTE: this works, but is unreliable. If you leave the loop before finishing,
-- then the iterator is not reset.
--- can iterate over a list directly.
-- @usage for v in ls do print(v) end
function List:__call()
    if not self.key then self.key = 1 end
    local value = self[self.key]
    self.key = self.key + 1
    if not value then self.key = nil end
    return value
end
--]]

--[[
function List.__call(t,v,i)
    i = (i or 0) + 1
    v = t[i]
    if v then return i, v end
end
--]]

local MethodIter = {}

function MethodIter:__index (name)
    return function(mm,...)
        return self.list:foreachm(name,...)
    end
end

--- call the function for each element of the list.
-- @param fun a function or callable object
-- @param ... optional values to pass to function
function List:foreach (fun,...)
    if fun==nil then
        return setmetatable({list=self},MethodIter)
    end
    fun = function_arg(1,fun)
    for i = 1,#self do
        fun(self[i],...)
    end
end

function List:foreachm (name,...)
    for i = 1,#self do
        local obj = self[i]
        local f = assert(obj[name],"method not found on object")
        f(obj,...)
    end
end

--- create a list of all elements which match a function.
-- @param fun a boolean function
-- @param arg optional argument to be passed as second argument of the predicate
-- @return a new filtered list.
function List:filter (fun,arg)
    return makelist(filter(self,fun,arg),self)
end

--- split a string using a delimiter.
-- @param s the string
-- @param delim the delimiter (default spaces)
-- @return a List of strings
-- @see pl.utils.split
function List.split (s,delim)
    assert_arg(1,s,'string')
    return makelist(split(s,delim))
end

local MethodMapper = {}

function MethodMapper:__index (name)
    return function(mm,...)
        return self.list:mapm(name,...)
    end
end

--- apply a function to all elements.
-- Any extra arguments will be passed to the function; if the function
-- is `nil` then `map` returns a mapper object that maps over a method
-- of the items
-- @param fun a function of at least one argument
-- @param ... arbitrary extra arguments.
-- @return a new list: {f(x) for x in self}
-- @usage List{'one','two'}:map(string.upper) == {'ONE','TWO'}
-- @usage List{'one','two'}:map():sub(1,2) == {'on','tw'}
-- @see pl.tablex.imap
function List:map (fun,...)
    if fun==nil then
        return setmetatable({list=self},MethodMapper)
    end
    return makelist(imap(fun,self,...),self)
end

--- apply a function to all elements, in-place.
-- Any extra arguments are passed to the function.
-- @param fun A function that takes at least one argument
-- @param ... arbitrary extra arguments.
-- @return the list.
function List:transform (fun,...)
    transform(fun,self,...)
    return self
end

--- apply a function to elements of two lists.
-- Any extra arguments will be passed to the function
-- @param fun a function of at least two arguments
-- @param ls another list
-- @param ... arbitrary extra arguments.
-- @return a new list: {f(x,y) for x in self, for x in arg1}
-- @see pl.tablex.imap2
function List:map2 (fun,ls,...)
    return makelist(imap2(fun,self,ls,...),self)
end

--- apply a named method to all elements.
-- Any extra arguments will be passed to the method.
-- @param name name of method
-- @param ... extra arguments
-- @return a new list of the results
-- @see pl.seq.mapmethod
function List:mapm (name,...)
    local res = {}
    local t = self
    for i = 1,#t do
      local val = t[i]
      local fn = val[name]
      if not fn then error(type(val).." does not have method "..name,2) end
      res[i] = fn(val,...)
    end
    return makelist(res,self)
end

--- 'reduce' a list using a binary function.
-- @param fun a function of two arguments
-- @return result of the function
-- @see pl.tablex.reduce
function List:reduce (fun)
    return reduce(fun,self)
end

--- partition a list using a classifier function.
-- The function may return nil, but this will be converted to the string key '<nil>'.
-- @param fun a function of at least one argument
-- @param ... will also be passed to the function
-- @return a table where the keys are the returned values, and the values are Lists
-- of values where the function returned that key. It is given the type of Multimap.
-- @see pl.MultiMap
function List:partition (fun,...)
    fun = function_arg(1,fun)
    local res = {}
    for i = 1,#self do
        local val = self[i]
        local klass = fun(val,...)
        if klass == nil then klass = '<nil>' end
        if not res[klass] then res[klass] = List() end
        res[klass]:append(val)
    end
    return setmetatable(res,Multimap)
end

--- return an iterator over all values.
function List:iter ()
    return iter(self)
end

--- Create an iterator over a seqence.
-- This captures the Python concept of 'sequence'.
-- For tables, iterates over all values with integer indices.
-- @param seq a sequence; a string (over characters), a table, a file object (over lines) or an iterator function
-- @usage for x in iterate {1,10,22,55} do io.write(x,',') end ==> 1,10,22,55
-- @usage for ch in iterate 'help' do do io.write(ch,' ') end ==> h e l p
function List.iterate(seq)
    if type(seq) == 'string' then
        local idx = 0
        local n = #seq
        local sub = string.sub
        return function ()
            idx = idx + 1
            if idx > n then return nil
            else
                return sub(seq,idx,idx)
            end
        end
    elseif type(seq) == 'table' then
        local idx = 0
        local n = #seq
        return function()
            idx = idx + 1
            if idx > n then return nil
            else
                return seq[idx]
            end
        end
    elseif type(seq) == 'function' then
        return seq
    elseif type(seq) == 'userdata' and io.type(seq) == 'file' then
        return seq:lines()
    end
end
iter = List.iterate

return List

]===================],"CoolisOS/bin/utils/pl/tablex.lua",[===================[--- Extended operations on Lua tables.
--
-- See @{02-arrays.md.Useful_Operations_on_Tables|the Guide}
--
-- Dependencies: `pl.utils`
-- @module pl.tablex
local utils = require'utils'
local getmetatable,setmetatable,require = getmetatable,setmetatable,require
local append,remove = table.insert,table.remove
local min,max = math.min,math.max
local pairs,type,unpack,next,select,tostring = pairs,type,unpack,next,select,tostring
local function_arg = utils.function_arg
local Set = utils.stdmt.Set
local List = utils.stdmt.List
local Map = utils.stdmt.Map
local assert_arg = utils.assert_arg

local tablex = {}

-- generally, functions that make copies of tables try to preserve the metatable.
-- However, when the source has no obvious type, then we attach appropriate metatables
-- like List, Map, etc to the result.
local function setmeta (res,tbl,def)
    local mt = getmetatable(tbl) or def
    return setmetatable(res, mt)
end

local function makelist (res)
    return setmetatable(res,List)
end

local function check_meta (val)
    if type(val) == 'table' then return true end
    return getmetatable(val)
end

local function complain (idx,msg)
    error(('argument %d is not %s'):format(idx,msg),3)
end

local function assert_arg_indexable (idx,val)
    local mt = check_meta(val)
    if mt == true then return end
    if not(mt and mt.__len and mt.__index) then
        complain(idx,"indexable")
    end
end

local function assert_arg_iterable (idx,val)
    local mt = check_meta(val)
    if mt == true then return end
    if not(mt and mt.__pairs) then
        complain(idx,"iterable")
    end
end

local function assert_arg_writeable (idx,val)
    local mt = check_meta(val)
    if mt == true then return end
    if not(mt and mt.__newindex) then
        complain(idx,"writeable")
    end
end


--- copy a table into another, in-place.
-- @param t1 destination table
-- @param t2 source (any iterable object)
-- @return first table
function tablex.update (t1,t2)
    assert_arg_writeable(1,t1)
    assert_arg_iterable(2,t2)
    for k,v in pairs(t2) do
        t1[k] = v
    end
    return t1
end

--- total number of elements in this table.
-- Note that this is distinct from `#t`, which is the number
-- of values in the array part; this value will always
-- be greater or equal. The difference gives the size of
-- the hash part, for practical purposes. Works for any
-- object with a __pairs metamethod.
-- @param t a table
-- @return the size
function tablex.size (t)
    assert_arg_iterable(1,t)
    local i = 0
    for k in pairs(t) do i = i + 1 end
    return i
end

--- make a shallow copy of a table
-- @param t an iterable source
-- @return new table
function tablex.copy (t)
    assert_arg_iterable(1,t)
    local res = {}
    for k,v in pairs(t) do
        res[k] = v
    end
    return res
end

--- make a deep copy of a table, recursively copying all the keys and fields.
-- This will also set the copied table's metatable to that of the original.
--  @param t A table
-- @return new table
function tablex.deepcopy(t)
    if type(t) ~= 'table' then return t end
    assert_arg_iterable(1,t)
    local mt = getmetatable(t)
    local res = {}
    for k,v in pairs(t) do
        if type(v) == 'table' then
            v = tablex.deepcopy(v)
        end
        res[k] = v
    end
    setmetatable(res,mt)
    return res
end

local abs, deepcompare = math.abs

--- compare two values.
-- if they are tables, then compare their keys and fields recursively.
-- @param t1 A value
-- @param t2 A value
-- @param ignore_mt if true, ignore __eq metamethod (default false)
-- @param eps if defined, then used for any number comparisons
-- @return true or false
function tablex.deepcompare(t1,t2,ignore_mt,eps)
    local ty1 = type(t1)
    local ty2 = type(t2)
    if ty1 ~= ty2 then return false end
    -- non-table types can be directly compared
    if ty1 ~= 'table' then
        if ty1 == 'number' and eps then return abs(t1-t2) < eps end
        return t1 == t2
    end
    -- as well as tables which have the metamethod __eq
    local mt = getmetatable(t1)
    if not ignore_mt and mt and mt.__eq then return t1 == t2 end
    for k1 in pairs(t1) do
        if t2[k1]==nil then return false end
    end
    for k2 in pairs(t2) do
        if t1[k2]==nil then return false end
    end
    for k1,v1 in pairs(t1) do
        local v2 = t2[k1]
        if not deepcompare(v1,v2,ignore_mt,eps) then return false end
    end

    return true
end

deepcompare = tablex.deepcompare

--- compare two arrays using a predicate.
-- @param t1 an array
-- @param t2 an array
-- @param cmp A comparison function
function tablex.compare (t1,t2,cmp)
    assert_arg_indexable(1,t1)
    assert_arg_indexable(2,t2)
    if #t1 ~= #t2 then return false end
    cmp = function_arg(3,cmp)
    for k = 1,#t1 do
        if not cmp(t1[k],t2[k]) then return false end
    end
    return true
end

--- compare two list-like tables using an optional predicate, without regard for element order.
-- @param t1 a list-like table
-- @param t2 a list-like table
-- @param cmp A comparison function (may be nil)
function tablex.compare_no_order (t1,t2,cmp)
    assert_arg_indexable(1,t1)
    assert_arg_indexable(2,t2)
    if cmp then cmp = function_arg(3,cmp) end
    if #t1 ~= #t2 then return false end
    local visited = {}
    for i = 1,#t1 do
        local val = t1[i]
        local gotcha
        for j = 1,#t2 do if not visited[j] then
            local match
            if cmp then match = cmp(val,t2[j]) else match = val == t2[j] end
            if match then
                gotcha = j
                break
            end
        end end
        if not gotcha then return false end
        visited[gotcha] = true
    end
    return true
end


--- return the index of a value in a list.
-- Like string.find, there is an optional index to start searching,
-- which can be negative.
-- @param t A list-like table (i.e. with numerical indices)
-- @param val A value
-- @param idx index to start; -1 means last element,etc (default 1)
-- @return index of value or nil if not found
-- @usage find({10,20,30},20) == 2
-- @usage find({'a','b','a','c'},'a',2) == 3
function tablex.find(t,val,idx)
    assert_arg_indexable(1,t)
    idx = idx or 1
    if idx < 0 then idx = #t + idx + 1 end
    for i = idx,#t do
        if t[i] == val then return i end
    end
    return nil
end

--- return the index of a value in a list, searching from the end.
-- Like string.find, there is an optional index to start searching,
-- which can be negative.
-- @param t A list-like table (i.e. with numerical indices)
-- @param val A value
-- @param idx index to start; -1 means last element,etc (default 1)
-- @return index of value or nil if not found
-- @usage rfind({10,10,10},10) == 3
function tablex.rfind(t,val,idx)
    assert_arg_indexable(1,t)
    idx = idx or #t
    if idx < 0 then idx = #t + idx + 1 end
    for i = idx,1,-1 do
        if t[i] == val then return i end
    end
    return nil
end


--- return the index (or key) of a value in a table using a comparison function.
-- @param t A table
-- @param cmp A comparison function
-- @param arg an optional second argument to the function
-- @return index of value, or nil if not found
-- @return value returned by comparison function
function tablex.find_if(t,cmp,arg)
    assert_arg_iterable(1,t)
    cmp = function_arg(2,cmp)
    for k,v in pairs(t) do
        local c = cmp(v,arg)
        if c then return k,c end
    end
    return nil
end

--- return a list of all values in a table indexed by another list.
-- @param tbl a table
-- @param idx an index table (a list of keys)
-- @return a list-like table
-- @usage index_by({10,20,30,40},{2,4}) == {20,40}
-- @usage index_by({one=1,two=2,three=3},{'one','three'}) == {1,3}
function tablex.index_by(tbl,idx)
    assert_arg_indexable(1,tbl)
    assert_arg_indexable(2,idx)
    local res = {}
    for i = 1,#idx do
        res[i] = tbl[idx[i]]
    end
    return setmeta(res,tbl,List)
end

--- apply a function to all values of a table.
-- This returns a table of the results.
-- Any extra arguments are passed to the function.
-- @param fun A function that takes at least one argument
-- @param t A table
-- @param ... optional arguments
-- @usage map(function(v) return v*v end, {10,20,30,fred=2}) is {100,400,900,fred=4}
function tablex.map(fun,t,...)
    assert_arg_iterable(1,t)
    fun = function_arg(1,fun)
    local res = {}
    for k,v in pairs(t) do
        res[k] = fun(v,...)
    end
    return setmeta(res,t)
end

--- apply a function to all values of a list.
-- This returns a table of the results.
-- Any extra arguments are passed to the function.
-- @param fun A function that takes at least one argument
-- @param t a table (applies to array part)
-- @param ... optional arguments
-- @return a list-like table
-- @usage imap(function(v) return v*v end, {10,20,30,fred=2}) is {100,400,900}
function tablex.imap(fun,t,...)
    assert_arg_indexable(1,t)
    fun = function_arg(1,fun)
    local res = {}
    for i = 1,#t do
        res[i] = fun(t[i],...) or false
    end
    return setmeta(res,t,List)
end

--- apply a named method to values from a table.
-- @param name the method name
-- @param t a list-like table
-- @param ... any extra arguments to the method
function tablex.map_named_method (name,t,...)
    utils.assert_string(1,name)
    assert_arg_indexable(2,t)
    local res = {}
    for i = 1,#t do
        local val = t[i]
        local fun = val[name]
        res[i] = fun(val,...)
    end
    return setmeta(res,t,List)
end


--- apply a function to all values of a table, in-place.
-- Any extra arguments are passed to the function.
-- @param fun A function that takes at least one argument
-- @param t a table
-- @param ... extra arguments
function tablex.transform (fun,t,...)
    assert_arg_iterable(1,t)
    fun = function_arg(1,fun)
    for k,v in pairs(t) do
        t[k] = fun(v,...)
    end
end

--- generate a table of all numbers in a range
-- @param start  number
-- @param finish number
-- @param step optional increment (default 1 for increasing, -1 for decreasing)
function tablex.range (start,finish,step)
    if start == finish then return {start}
    elseif start > finish then return {}
    end
    local res = {}
    local k = 1
    if not step then
        if finish > start then step = finish > start and 1 or -1 end
    end
    for i=start,finish,step do res[k]=i; k=k+1 end
    return res
end

--- apply a function to values from two tables.
-- @param fun a function of at least two arguments
-- @param t1 a table
-- @param t2 a table
-- @param ... extra arguments
-- @return a table
-- @usage map2('+',{1,2,3,m=4},{10,20,30,m=40}) is {11,22,23,m=44}
function tablex.map2 (fun,t1,t2,...)
    assert_arg_iterable(1,t1)
    assert_arg_iterable(2,t2)
    fun = function_arg(1,fun)
    local res = {}
    for k,v in pairs(t1) do
        res[k] = fun(v,t2[k],...)
    end
    return setmeta(res,t1,List)
end

--- apply a function to values from two arrays.
-- The result will be the length of the shortest array.
-- @param fun a function of at least two arguments
-- @param t1 a list-like table
-- @param t2 a list-like table
-- @param ... extra arguments
-- @usage imap2('+',{1,2,3,m=4},{10,20,30,m=40}) is {11,22,23}
function tablex.imap2 (fun,t1,t2,...)
    assert_arg_indexable(2,t1)
    assert_arg_indexable(3,t2)
    fun = function_arg(1,fun)
    local res,n = {},math.min(#t1,#t2)
    for i = 1,n do
        res[i] = fun(t1[i],t2[i],...)
    end
    return res
end

--- 'reduce' a list using a binary function.
-- @param fun a function of two arguments
-- @param t a list-like table
-- @return the result of the function
-- @usage reduce('+',{1,2,3,4}) == 10
function tablex.reduce (fun,t)
    assert_arg_indexable(2,t)
    fun = function_arg(1,fun)
    local n = #t
    local res = t[1]
    for i = 2,n do
        res = fun(res,t[i])
    end
    return res
end

--- apply a function to all elements of a table.
-- The arguments to the function will be the value,
-- the key and <i>finally</i> any extra arguments passed to this function.
-- Note that the Lua 5.0 function table.foreach passed the <i>key</i> first.
-- @param t a table
-- @param fun a function with at least one argument
-- @param ... extra arguments
function tablex.foreach(t,fun,...)
    assert_arg_iterable(1,t)
    fun = function_arg(2,fun)
    for k,v in pairs(t) do
        fun(v,k,...)
    end
end

--- apply a function to all elements of a list-like table in order.
-- The arguments to the function will be the value,
-- the index and <i>finally</i> any extra arguments passed to this function
-- @param t a table
-- @param fun a function with at least one argument
-- @param ... optional arguments
function tablex.foreachi(t,fun,...)
    assert_arg_indexable(1,t)
    fun = function_arg(2,fun)
    for i = 1,#t do
        fun(t[i],i,...)
    end
end


--- Apply a function to a number of tables.
-- A more general version of map
-- The result is a table containing the result of applying that function to the
-- ith value of each table. Length of output list is the minimum length of all the lists
-- @param fun a function of n arguments
-- @param ... n tables
-- @usage mapn(function(x,y,z) return x+y+z end, {1,2,3},{10,20,30},{100,200,300}) is {111,222,333}
-- @usage mapn(math.max, {1,20,300},{10,2,3},{100,200,100}) is  {100,200,300}
-- @param fun A function that takes as many arguments as there are tables
function tablex.mapn(fun,...)
    fun = function_arg(1,fun)
    local res = {}
    local lists = {...}
    local minn = 1e40
    for i = 1,#lists do
        minn = min(minn,#(lists[i]))
    end
    for i = 1,minn do
        local args,k = {},1
        for j = 1,#lists do
            args[k] = lists[j][i]
            k = k + 1
        end
        res[#res+1] = fun(unpack(args))
    end
    return res
end

--- call the function with the key and value pairs from a table.
-- The function can return a value and a key (note the order!). If both
-- are not nil, then this pair is inserted into the result. If only value is not nil, then
-- it is appended to the result.
-- @param fun A function which will be passed each key and value as arguments, plus any extra arguments to pairmap.
-- @param t A table
-- @param ... optional arguments
-- @usage pairmap(function(k,v) return v end,{fred=10,bonzo=20}) is {10,20} _or_ {20,10}
-- @usage pairmap(function(k,v) return {k,v},k end,{one=1,two=2}) is {one={'one',1},two={'two',2}}
function tablex.pairmap(fun,t,...)
    assert_arg_iterable(1,t)
    fun = function_arg(1,fun)
    local res = {}
    for k,v in pairs(t) do
        local rv,rk = fun(k,v,...)
        if rk then
            res[rk] = rv
        else
            res[#res+1] = rv
        end
    end
    return res
end

local function keys_op(i,v) return i end

--- return all the keys of a table in arbitrary order.
--  @param t A table
function tablex.keys(t)
    assert_arg_iterable(1,t)
    return makelist(tablex.pairmap(keys_op,t))
end

local function values_op(i,v) return v end

--- return all the values of the table in arbitrary order
--  @param t A table
function tablex.values(t)
    assert_arg_iterable(1,t)
    return makelist(tablex.pairmap(values_op,t))
end

local function index_map_op (i,v) return i,v end

--- create an index map from a list-like table. The original values become keys,
-- and the associated values are the indices into the original list.
-- @param t a list-like table
-- @return a map-like table
function tablex.index_map (t)
    assert_arg_indexable(1,t)
    return setmetatable(tablex.pairmap(index_map_op,t),Map)
end

local function set_op(i,v) return true,v end

--- create a set from a list-like table. A set is a table where the original values
-- become keys, and the associated values are all true.
-- @param t a list-like table
-- @return a set (a map-like table)
function tablex.makeset (t)
    assert_arg_indexable(1,t)
    return setmetatable(tablex.pairmap(set_op,t),Set)
end


--- combine two tables, either as union or intersection. Corresponds to
-- set operations for sets () but more general. Not particularly
-- useful for list-like tables.
-- @param t1 a table
-- @param t2 a table
-- @param dup true for a union, false for an intersection.
-- @usage merge({alice=23,fred=34},{bob=25,fred=34}) is {fred=34}
-- @usage merge({alice=23,fred=34},{bob=25,fred=34},true) is {bob=25,fred=34,alice=23}
-- @see tablex.index_map
function tablex.merge (t1,t2,dup)
    assert_arg_iterable(1,t1)
    assert_arg_iterable(2,t2)
    local res = {}
    for k,v in pairs(t1) do
        if dup or t2[k] then res[k] = v end
    end
    if dup then
      for k,v in pairs(t2) do
        res[k] = v
      end
    end
    return setmeta(res,t1,Map)
end

--- a new table which is the difference of two tables.
-- With sets (where the values are all true) this is set difference and
-- symmetric difference depending on the third parameter.
-- @param s1 a map-like table or set
-- @param s2 a map-like table or set
-- @param symm symmetric difference (default false)
-- @return a map-like table or set
function tablex.difference (s1,s2,symm)
    assert_arg_iterable(1,s1)
    assert_arg_iterable(2,s2)
    local res = {}
    for k,v in pairs(s1) do
        if not s2[k] then res[k] = v end
    end
    if symm then
        for k,v in pairs(s2) do
            if not s1[k] then res[k] = v end
        end
    end
    return setmeta(res,s1,Map)
end

--- A table where the key/values are the values and value counts of the table.
-- @param t a list-like table
-- @param cmp a function that defines equality (otherwise uses ==)
-- @return a map-like table
-- @see seq.count_map
function tablex.count_map (t,cmp)
    assert_arg_indexable(1,t)
    local res,mask = {},{}
    cmp = function_arg(2,cmp)
    local n = #t
    for i = 1,#t do
        local v = t[i]
        if not mask[v] then
            mask[v] = true
            -- check this value against all other values
            res[v] = 1  -- there's at least one instance
            for j = i+1,n do
                local w = t[j]
                if cmp and cmp(v,w) or v == w then
                    res[v] = res[v] + 1
                    mask[w] = true
                end
            end
        end
    end
    return setmetatable(res,Map)
end

--- filter a table's values using a predicate function
-- @param t a list-like table
-- @param pred a boolean function
-- @param arg optional argument to be passed as second argument of the predicate
function tablex.filter (t,pred,arg)
    assert_arg_indexable(1,t)
    pred = function_arg(2,pred)
    local res,k = {},1
    for i = 1,#t do
        local v = t[i]
        if pred(v,arg) then
            res[k] = v
            k = k + 1
        end
    end
    return setmeta(res,t,List)
end

--- return a table where each element is a table of the ith values of an arbitrary
-- number of tables. It is equivalent to a matrix transpose.
-- @usage zip({10,20,30},{100,200,300}) is {{10,100},{20,200},{30,300}}
function tablex.zip(...)
    return tablex.mapn(function(...) return {...} end,...)
end

local _copy
function _copy (dest,src,idest,isrc,nsrc,clean_tail)
    idest = idest or 1
    isrc = isrc or 1
    local iend
    if not nsrc then
        nsrc = #src
        iend = #src
    else
        iend = isrc + min(nsrc-1,#src-isrc)
    end
    if dest == src then -- special case
        if idest > isrc and iend >= idest then -- overlapping ranges
            src = tablex.sub(src,isrc,nsrc)
            isrc = 1; iend = #src
        end
    end
    for i = isrc,iend do
        dest[idest] = src[i]
        idest = idest + 1
    end
    if clean_tail then
        tablex.clear(dest,idest)
    end
    return dest
end

--- copy an array into another one, resizing the destination if necessary. <br>
-- @param dest a list-like table
-- @param src a list-like table
-- @param idest where to start copying values from source (default 1)
-- @param isrc where to start copying values into destination (default 1)
-- @param nsrc number of elements to copy from source (default source size)
function tablex.icopy (dest,src,idest,isrc,nsrc)
    assert_arg_indexable(1,dest)
    assert_arg_indexable(2,src)
    return _copy(dest,src,idest,isrc,nsrc,true)
end

--- copy an array into another one. <br>
-- @param dest a list-like table
-- @param src a list-like table
-- @param idest where to start copying values from source (default 1)
-- @param isrc where to start copying values into destination (default 1)
-- @param nsrc number of elements to copy from source (default source size)
function tablex.move (dest,src,idest,isrc,nsrc)
    assert_arg_indexable(1,dest)
    assert_arg_indexable(2,src)
    return _copy(dest,src,idest,isrc,nsrc,false)
end

function tablex._normalize_slice(self,first,last)
  local sz = #self
  if not first then first=1 end
  if first<0 then first=sz+first+1 end
  -- make the range _inclusive_!
  if not last then last=sz end
  if last < 0 then last=sz+1+last end
  return first,last
end

--- Extract a range from a table, like  'string.sub'.
-- If first or last are negative then they are relative to the end of the list
-- eg. sub(t,-2) gives last 2 entries in a list, and
-- sub(t,-4,-2) gives from -4th to -2nd
-- @param t a list-like table
-- @param first An index
-- @param last An index
-- @return a new List
function tablex.sub(t,first,last)
    assert_arg_indexable(1,t)
    first,last = tablex._normalize_slice(t,first,last)
    local res={}
    for i=first,last do append(res,t[i]) end
    return setmeta(res,t,List)
end

--- set an array range to a value. If it's a function we use the result
-- of applying it to the indices.
-- @param t a list-like table
-- @param val a value
-- @param i1 start range (default 1)
-- @param i2 end range (default table size)
function tablex.set (t,val,i1,i2)
    assert_arg_indexable(1,t)
    i1,i2 = i1 or 1,i2 or #t
    if utils.is_callable(val) then
        for i = i1,i2 do
            t[i] = val(i)
        end
    else
        for i = i1,i2 do
            t[i] = val
        end
    end
end

--- create a new array of specified size with initial value.
-- @param n size
-- @param val initial value (can be nil, but don't expect # to work!)
-- @return the table
function tablex.new (n,val)
    local res = {}
    tablex.set(res,val,1,n)
    return res
end

--- clear out the contents of a table.
-- @param t a table
-- @param istart optional start position
function tablex.clear(t,istart)
    istart = istart or 1
    for i = istart,#t do remove(t) end
end

--- insert values into a table. <br>
-- insertvalues(t, [pos,] values) <br>
-- similar to table.insert but inserts values from given table "values",
-- not the object itself, into table "t" at position "pos".
function tablex.insertvalues(t, ...)
    assert_arg(1,t,'table')
    local pos, values
    if select('#', ...) == 1 then
        pos,values = #t+1, ...
    else
        pos,values = ...
    end
    if #values > 0 then
        for i=#t,pos,-1 do
            t[i+#values] = t[i]
        end
        local offset = 1 - pos
        for i=pos,pos+#values-1 do
            t[i] = values[i + offset]
        end
    end
    return t
end

--- remove a range of values from a table.
-- @param t a list-like table
-- @param i1 start index
-- @param i2 end index
-- @return the table
function tablex.removevalues (t,i1,i2)
    assert_arg(1,t,'table')
    i1,i2 = tablex._normalize_slice(t,i1,i2)
    for i = i1,i2 do
        remove(t,i1)
    end
    return t
end

local _find
_find = function (t,value,tables)
    for k,v in pairs(t) do
        if v == value then return k end
    end
    for k,v in pairs(t) do
        if not tables[v] and type(v) == 'table' then
            tables[v] = true
            local res = _find(v,value,tables)
            if res then
                res = tostring(res)
                if type(k) ~= 'string' then
                    return '['..k..']'..res
                else
                    return k..'.'..res
                end
            end
        end
    end
end

--- find a value in a table by recursive search.
-- @param t the table
-- @param value the value
-- @param exclude any tables to avoid searching
-- @usage search(_G,math.sin,{package.path}) == 'math.sin'
-- @return a fieldspec, e.g. 'a.b' or 'math.sin'
function tablex.search (t,value,exclude)
    assert_arg_iterable(1,t)
    local tables = {[t]=true}
    if exclude then
        for _,v in pairs(exclude) do tables[v] = true end
    end
    return _find(t,value,tables)
end

return tablex
]===================],"CoolisOS/bin/utils/pl/utils.lua",[===================[--- Generally useful routines.
-- See  @{01-introduction.md.Generally_useful_functions|the Guide}.
-- @module pl.utils
local format,gsub,byte = string.format,string.gsub,string.byte
local clock = os.clock
local stdout = io.stdout
local append = table.insert

local collisions = {}

local utils = {}

utils._VERSION = "1.1.0"

local lua51 = rawget(_G,'setfenv')

utils.lua51 = lua51
if not lua51 then -- Lua 5.2 compatibility
    unpack = table.unpack
    loadstring = load
end

utils.dir_separator = '/'

--- end this program gracefully.
-- @param code The exit code or a message to be printed
-- @param ... extra arguments for message's format'
-- @see utils.fprintf
function utils.quit(code,...)
    if type(code) == 'string' then
        utils.fprintf(io.stderr,code,...)
        code = -1
    else
        utils.fprintf(io.stderr,...)
    end
    io.stderr:write('\n')
    os.exit(code)
end

--- print an arbitrary number of arguments using a format.
-- @param fmt The format (see string.format)
-- @param ... Extra arguments for format
function utils.printf(fmt,...)
    utils.assert_string(1,fmt)
    utils.fprintf(stdout,fmt,...)
end

--- write an arbitrary number of arguments to a file using a format.
-- @param f File handle to write to.
-- @param fmt The format (see string.format).
-- @param ... Extra arguments for format
function utils.fprintf(f,fmt,...)
    utils.assert_string(2,fmt)
    f:write(format(fmt,...))
end

local function import_symbol(T,k,v,libname)
    local key = rawget(T,k)
    -- warn about collisions!
    if key and k ~= '_M' and k ~= '_NAME' and k ~= '_PACKAGE' and k ~= '_VERSION' then
        utils.printf("warning: '%s.%s' overrides existing symbol\n",libname,k)
    end
    rawset(T,k,v)
end

local function lookup_lib(T,t)
    for k,v in pairs(T) do
        if v == t then return k end
    end
    return '?'
end

local already_imported = {}

--- take a table and 'inject' it into the local namespace.
-- @param t The Table
-- @param T An optional destination table (defaults to callers environment)
function utils.import(t,T)
    T = T or _G
    t = t or utils
    if type(t) == 'string' then
        t = require (t)
    end
    local libname = lookup_lib(T,t)
    if already_imported[t] then return end
    already_imported[t] = libname
    for k,v in pairs(t) do
        import_symbol(T,k,v,libname)
    end
end

utils.patterns = {
    FLOAT = '[%+%-%d]%d*%.?%d*[eE]?[%+%-]?%d*',
    INTEGER = '[+%-%d]%d*',
    IDEN = '[%a_][%w_]*',
    FILE = '[%a%.\\][:%][%w%._%-\\]*'
}

--- escape any 'magic' characters in a string
-- @param s The input string
function utils.escape(s)
    utils.assert_string(1,s)
    return (s:gsub('[%-%.%+%[%]%(%)%$%^%%%?%*]','%%%1'))
end

--- return either of two values, depending on a condition.
-- @param cond A condition
-- @param value1 Value returned if cond is true
-- @param value2 Value returned if cond is false (can be optional)
function utils.choose(cond,value1,value2)
    if cond then return value1
    else return value2
    end
end

local raise

--- return the contents of a file as a string
-- @param filename The file path
-- @param is_bin open in binary mode
-- @return file contents
function utils.readfile(filename,is_bin)
    local mode = is_bin and 'b' or ''
    utils.assert_string(1,filename)
    local f,err = io.open(filename,'r'..mode)
    if not f then return utils.raise (err) end
    local res,err = f:read('*a')
    f:close()
    if not res then return raise (err) end
    return res
end

--- write a string to a file
-- @param filename The file path
-- @param str The string
-- @return true or nil
-- @return error message
-- @raise error if filename or str aren't strings
function utils.writefile(filename,str)
    utils.assert_string(1,filename)
    utils.assert_string(2,str)
    local f,err = io.open(filename,'w')
    if not f then return raise(err) end
    f:write(str)
    f:close()
    return true
end

--- return the contents of a file as a list of lines
-- @param filename The file path
-- @return file contents as a table
-- @raise errror if filename is not a string
function utils.readlines(filename)
    utils.assert_string(1,filename)
    local f,err = io.open(filename,'r')
    if not f then return raise(err) end
    local res = {}
    for line in f:lines() do
        append(res,line)
    end
    f:close()
    return res
end

--- split a string into a list of strings separated by a delimiter.
-- @param s The input string
-- @param re A Lua string pattern; defaults to '%s+'
-- @param plain don't use Lua patterns
-- @param n optional maximum number of splits
-- @return a list-like table
-- @raise error if s is not a string
function utils.split(s,re,plain,n)
    utils.assert_string(1,s)
    local find,sub,append = string.find, string.sub, table.insert
    local i1,ls = 1,{}
    if not re then re = '%s+' end
    if re == '' then return {s} end
    while true do
        local i2,i3 = find(s,re,i1,plain)
        if not i2 then
            local last = sub(s,i1)
            if last ~= '' then append(ls,last) end
            if #ls == 1 and ls[1] == '' then
                return {}
            else
                return ls
            end
        end
        append(ls,sub(s,i1,i2-1))
        if n and #ls == n then
            ls[#ls] = sub(s,i1)
            return ls
        end
        i1 = i3+1
    end
end

--- split a string into a number of values.
-- @param s the string
-- @param re the delimiter, default space
-- @return n values
-- @usage first,next = splitv('jane:doe',':')
-- @see split
function utils.splitv (s,re)
    return unpack(utils.split(s,re))
end

--- convert an array of values to strings.
-- @param t a list-like table
-- @param temp buffer to use, otherwise allocate
-- @param tostr custom tostring function, called with (value,index).
-- Otherwise use `tostring`
-- @return the converted buffer
function utils.array_tostring (t,temp,tostr)
    temp, tostr = temp or {}, tostr or tostring
    for i = 1,#t do
        temp[i] = tostr(t[i],i)
    end
    return temp
end

local lua51_load = load

if utils.lua51 then -- define Lua 5.2 style load()
    function utils.load(str,src,mode,env)
        local chunk,err
        if type(str) == 'string' then
            chunk,err = loadstring(str,src)
        else
            chunk,err = lua51_load(str,src)
        end
        if chunk and env then setfenv(chunk,env) end
        return chunk,err
    end
end


--- execute a shell command.
-- This is a compatibility function that returns the same for Lua 5.1 and Lua 5.2
-- @param cmd a shell command
-- @return true if successful
-- @return actual return code
function utils.execute (cmd)
    local res1,res2,res2 = os.execute(cmd)
    if lua51 then
        return res1==0,res1
    else
        return res1,res2
    end
end

if lua51 then
    function table.pack (...)
        local n = select('#',...)
        return {n=n; ...}
    end
    local sep = '/'
    function utils.searchpath (mod,path)
        mod = mod:gsub('%.',sep)
        for m in path:gmatch('[^;]+') do
            local nm = m:gsub('?',mod)
            local f = io.open(nm,'r')
            if f then f:close(); return nm end
        end
    end
end

if not table.pack then table.pack = _G.pack end
if not rawget(_G,"pack") then _G.pack = table.pack end

--- take an arbitrary set of arguments and make into a table.
-- This returns the table and the size; works fine for nil arguments
-- @param ... arguments
-- @return table
-- @return table size
-- @usage local t,n = utils.args(...)

--- 'memoize' a function (cache returned value for next call).
-- This is useful if you have a function which is relatively expensive,
-- but you don't know in advance what values will be required, so
-- building a table upfront is wasteful/impossible.
-- @param func a function of at least one argument
-- @return a function with at least one argument, which is used as the key.
function utils.memoize(func)
    return setmetatable({}, {
        __index = function(self, k, ...)
            local v = func(k,...)
            self[k] = v
            return v
        end,
        __call = function(self, k) return self[k] end
    })
end

--- is the object either a function or a callable object?.
-- @param obj Object to check.
function utils.is_callable (obj)
    return type(obj) == 'function' or getmetatable(obj) and getmetatable(obj).__call
end

--- is the object of the specified type?.
-- If the type is a string, then use type, otherwise compare with metatable
-- @param obj An object to check
-- @param tp String of what type it should be
function utils.is_type (obj,tp)
    if type(tp) == 'string' then return type(obj) == tp end
    local mt = getmetatable(obj)
    return tp == mt
end

local fileMT = getmetatable(io.stdout)

--- a string representation of a type.
-- For tables with metatables, we assume that the metatable has a `_name`
-- field. Knows about Lua file objects.
-- @param obj an object
-- @return a string like 'number', 'table' or 'List'
function utils.type (obj)
    local t = type(obj)
    if t == 'table' or t == 'userdata' then
        local mt = getmetatable(obj)
        if mt == fileMT then
            return 'file'
        else
            return mt._name or "unknown "..t
        end
    else
        return t
    end
end

--- is this number an integer?
-- @param x a number
-- @raise error if x is not a number
function utils.is_integer (x)
    return math.ceil(x)==x
end

utils.stdmt = {
    List = {_name='List'}, Map = {_name='Map'},
    Set = {_name='Set'}, MultiMap = {_name='MultiMap'}
}

local _function_factories = {}

--- associate a function factory with a type.
-- A function factory takes an object of the given type and
-- returns a function for evaluating it
-- @param mt metatable
-- @param fun a callable that returns a function
function utils.add_function_factory (mt,fun)
    _function_factories[mt] = fun
end

local function _string_lambda(f)
    local raise = utils.raise
    if f:find '^|' or f:find '_' then
        local args,body = f:match '|([^|]*)|(.+)'
        if f:find '_' then
            args = '_'
            body = f
        else
            if not args then return raise 'bad string lambda' end
        end
        local fstr = 'return function('..args..') return '..body..' end'
        local fn,err = loadstring(fstr)
        if not fn then return raise(err) end
        fn = fn()
        return fn
    else return raise 'not a string lambda'
    end
end

--- an anonymous function as a string. This string is either of the form
-- '|args| expression' or is a function of one argument, '_'
-- @param lf function as a string
-- @return a function
-- @usage string_lambda '|x|x+1' (2) == 3
-- @usage string_lambda '_+1 (2) == 3
-- @function utils.string_lambda
utils.string_lambda = utils.memoize(_string_lambda)

local ops

--- process a function argument.
-- This is used throughout Penlight and defines what is meant by a function:
-- Something that is callable, or an operator string as defined by <code>pl.operator</code>,
-- such as '>' or '#'. If a function factory has been registered for the type, it will
-- be called to get the function.
-- @param idx argument index
-- @param f a function, operator string, or callable object
-- @param msg optional error message
-- @return a callable
-- @raise if idx is not a number or if f is not callable
-- @see utils.is_callable
function utils.function_arg (idx,f,msg)
    utils.assert_arg(1,idx,'number')
    local tp = type(f)
    if tp == 'function' then return f end  -- no worries!
    -- ok, a string can correspond to an operator (like '==')
    if tp == 'string' then
        if not ops then ops = require 'pl.operator'.optable end
        local fn = ops[f]
        if fn then return fn end
        local fn, err = utils.string_lambda(f)
        if not fn then error(err..': '..f) end
        return fn
    elseif tp == 'table' or tp == 'userdata' then
        local mt = getmetatable(f)
        if not mt then error('not a callable object',2) end
        local ff = _function_factories[mt]
        if not ff then
            if not mt.__call then error('not a callable object',2) end
            return f
        else
            return ff(f) -- we have a function factory for this type!
        end
    end
    if not msg then msg = " must be callable" end
    if idx > 0 then
        error("argument "..idx..": "..msg,2)
    else
        error(msg,2)
    end
end

--- bind the first argument of the function to a value.
-- @param fn a function of at least two values (may be an operator string)
-- @param p a value
-- @return a function such that f(x) is fn(p,x)
-- @raise same as @{function_arg}
-- @see pl.func.curry
function utils.bind1 (fn,p)
    fn = utils.function_arg(1,fn)
    return function(...) return fn(p,...) end
end

--- bind the second argument of the function to a value.
-- @param fn a function of at least two values (may be an operator string)
-- @param p a value
-- @return a function such that f(x) is fn(x,p)
-- @raise same as @{function_arg}
function utils.bind2 (fn,p)
    fn = utils.function_arg(1,fn)
    return function(x,...) return fn(x,p,...) end
end


--- assert that the given argument is in fact of the correct type.
-- @param n argument index
-- @param val the value
-- @param tp the type
-- @param verify an optional verfication function
-- @param msg an optional custom message
-- @param lev optional stack position for trace, default 2
-- @raise if the argument n is not the correct type
-- @usage assert_arg(1,t,'table')
-- @usage assert_arg(n,val,'string',path.isdir,'not a directory')
function utils.assert_arg (n,val,tp,verify,msg,lev)
    if type(val) ~= tp then
        error(("argument %d expected a '%s', got a '%s'"):format(n,tp,type(val)),lev or 2)
    end
    if verify and not verify(val) then
        error(("argument %d: '%s' %s"):format(n,val,msg),lev or 2)
    end
end

--- assert the common case that the argument is a string.
-- @param n argument index
-- @param val a value that must be a string
-- @raise val must be a string
function utils.assert_string (n,val)
    utils.assert_arg(n,val,'string',nil,nil,3)
end

local err_mode = 'default'

--- control the error strategy used by Penlight.
-- Controls how <code>utils.raise</code> works; the default is for it
-- to return nil and the error string, but if the mode is 'error' then
-- it will throw an error. If mode is 'quit' it will immediately terminate
-- the program.
-- @param mode - either 'default', 'quit'  or 'error'
-- @see utils.raise
function utils.on_error (mode)
    if ({['default'] = 1, ['quit'] = 2, ['error'] = 3})[mode] then
      err_mode = mode
    else
      -- fail loudly
      if err_mode == 'default' then err_mode = 'error' end
      utils.raise("Bad argument expected string; 'default', 'quit', or 'error'. Got '"..tostring(mode).."'")
    end
end

--- used by Penlight functions to return errors.  Its global behaviour is controlled
-- by <code>utils.on_error</code>
-- @param err the error string.
-- @see utils.on_error
function utils.raise (err)
    if err_mode == 'default' then return nil,err
    elseif err_mode == 'quit' then utils.quit(err)
    else error(err,2)
    end
end

raise = utils.raise

--- load a code string or bytecode chunk.
-- @param code Lua code as a string or bytecode
-- @param name for source errors
-- @param mode kind of chunk, 't' for text, 'b' for bytecode, 'bt' for all (default)
-- @param env  the environment for the new chunk (default nil)
-- @return compiled chunk
-- @return error message (chunk is nil)
-- @function utils.load


--- Lua 5.2 Compatible Functions
-- @section lua52

--- pack an argument list into a table.
-- @param ... any arguments
-- @return a table with field n set to the length
-- @return the length
-- @function table.pack

------
-- return the full path where a Lua module name would be matched.
-- @param mod module name, possibly dotted
-- @param path a path in the same form as package.path or package.cpath
-- @see path.package_path
-- @function package.searchpath

return utils


]===================],"CoolisOS/bin/utils/search",true,"CoolisOS/bin/utils/search/init.lua",[===================[---filesystem search API by CoolisTheName007
local fs=fs
local string=string
local env=getfenv()
setmetatable(env,nil)
--The hard work here was writing the iterators to be efficient; for instance they don't use coroutines or recursion.

----DIRECTORY TREE-LIKE SEARCH

---iterator over files/dirs in directory dir and with maximum depth of search depth, default is infinite
--following refer to the iterator returned, not the iterator created.
--@treturn string path
function iterTree(dir,depth)
    dir=dir or ''
    if dir=='/' then dir='' end
    local index={0}
    local dir_index={0}
    local ts={{dir,fs.list(dir),{}}}
    local level=1
    local t_dir
    return function()
        repeat
            index[level]=index[level]+1
            name=ts[level][2][index[level]]
            -- pprint(index,name)
            -- read()
            if name==nil then
                if (not ts[level][4]) and ts[level][3][1] then
                    ts[level][4]=true
                    ts[level][2],ts[level][3]=ts[level][3],ts[level][2]
                    index[level]=0
                else
                    level=level-1
                    if level==0 then return end
                    dir=ts[level][1]
                end
            else
                t_dir=ts[level][1]..'/'..name
                if fs.isDir(t_dir) then
                    if ts[level][4] then
                        if depth~=level then
                            level=level+1
                            dir=t_dir
                            ts[level]={dir,fs.list(dir),{}}
                            index[level]=0
                            dir_index[level]=0
                        end
                    else
                        dir_index[level]=dir_index[level]+1
                        ts[level][3][dir_index[level]]=name
                        break --send dir path
                    end
                else
                    break
                end
            end
        until false
        return dir..'/'..name
    end
end

---iterator over files in directory dir and with maximum depth of search depth, default is infinite
--following refer to the iterator returned, not the iterator created.
--@treturn string path
function iterFiles(dir,depth)
    local iter=iterTree(dir,depth)
    local path
    return function()
        repeat
            path=iter()
            if path then
                if not fs.isDir(path) then
                    return path
                end
            else
                return
            end
        until false
    end
end

---iterator over dirs in directory dir and with maximum depth of search depth, default is infinite
--following refer to the iterator returned, not the iterator created.
--@treturn string path
function iterDir(dir,depth)
    local iter=iterTree(dir,depth)
    local path
    return function()
        repeat
            path=iter()
            if path then
                if fs.isDir(path) then
                    return path
                end
            else
                return
            end
        until false
    end
end

------GLOBS

--WARNING: for compatibility with Lua ?, ? was replaced by # in globs; taken from https://github.com/davidm/lua-glob-pattern , by davidm
--only needed for filename conversion, slashes are dealt with directly for iteration purposes.
local function globtopattern(g)

  local p = "^"  -- pattern being built
  local i = 0    -- index in g
  local c        -- char at index i in g.


    -- unescape glob char
  local function unescape()
    if c == '\\' then
      i = i + 1; c = string.sub(g,i,i)
      if c == '' then
        p = '[^]'
        return false
      end
    end
    return true
  end

  -- escape pattern char
  local function escape(c)
    return c:match("^%w$") and c or '%' .. c
  end
  -- Convert tokens at end of charset.
  local function charset_end()
    while 1 do
      if c == '' then
        p = '[^]'
        return false
      elseif c == ']' then
        p = p .. ']'
        break
      else
        if not unescape() then break end
        local c1 = c
        i = i + 1; c = string.sub(g,i,i)
        if c == '' then
          p = '[^]'
          return false
        elseif c == '-' then
          i = i + 1; c = string.sub(g,i,i)
          if c == '' then
            p = '[^]'
            return false
          elseif c == ']' then
            p = p .. escape(c1) .. '%-]'
            break
          else
            if not unescape() then break end
            p = p .. escape(c1) .. '-' .. escape(c)
          end
        elseif c == ']' then
          p = p .. escape(c1) .. ']'
          break
        else
          p = p .. escape(c1)
          i = i - 1 -- put back
        end
      end
      i = i + 1; c = string.sub(g,i,i)
    end
    return true
  end

  -- Convert tokens in charset.
  local function charset()
    i = i + 1; c = string.sub(g,i,i)
    if c == '' or c == ']' then
      p = '[^]'
      return false
    elseif c == '^' or c == '!' then
      i = i + 1; c = string.sub(g,i,i)
      if c == ']' then
        -- ignored
      else
        p = p .. '[^'
        if not charset_end() then return false end
      end
    else
      p = p .. '['
      if not charset_end() then return false end
    end
    return true
  end
 --Convert tokens.
  while 1 do
    i = i + 1; c = string.sub(g,i,i)
    if c == '' then
      p = p .. '$'
      break
    elseif c == '#' then --?->#
      p = p .. '.'
    elseif c == '*' then
      p = p .. '.*'
    elseif c == '[' then
      if not charset() then break end
    elseif c == '\\' then
      i = i + 1; c = string.sub(g,i,i)
      if c == '' then
        p = p .. '\\$'
        break
      end
      p = p .. escape(c)
    else
      p = p .. escape(c)
    end
  end
  return p
end

---turns a glob into a table structure proper for iterPatterns.
local function compact(g)

    local nl={}
    local s1
    local n=0
    for c in string.gmatch(g,'[\\/]*([^/\\]+)[\\/]*') do
        if c:match('^[%w%s%.]*$') then
            s1=s1 and s1..'/'..c or c
        else
            n=n+1
            nl[n]={s1,globtopattern(c)}
            s1=nil
        end
    end

    if s1 then
        if n==0 then
            n=n+1
            nl[n]={s1}
        else
            nl[n][3]=s1
        end
    end
    return nl
end

---iterator creator over valid paths defined by a table with the structure: {t1,...,tn}, where ti is:
--for i<n: {dir,pat} - dir is the directory where to look for names matching the pattern pat
--for i=n: {dir,pat,ending} -same but will combine the name (after successful match with pat) with the optional ending (can be nil) and check the resulting path
--e.g., g={{'APIS','*'},{nil,'A'},{'B/C','#','aq/qwerty'}} will search in all subfolders of APIS for subfolders named A, and in each of those for a folder B
--containing a folder C, and for all one-lettered folders in that folder for a folder aq containing a  folder/file named qwerty.
local function iterPatterns(l)
    local n=#l
    if n==0 then return function () return  end end
    if n==1 and not l[1][2] and fs.exists(l[1][1]) then
        local done=false
        return function ()
                if not done then
                    done=true
                    return l[1][1]
                else
                    return
                end
            end
    end
    local dir=l[1][1]
    local index={0}
    local ts
    ts={{dir,fs.isDir(dir) and fs.list(dir) or {}}}
    local level=1
    local t_dir
    local _
    return function()
        repeat
            index[level]=index[level]+1
            name=ts[level][2][index[level]]
            if name==nil then
                    index[level]=nil
                    level=level-1
                    if level==0 then return end
                    dir=ts[level][1]
            else
                if string.match(name,l[level][2]) then
                    t_dir=dir..'/'..name
                    if level==n then
                        _=l[level][3]
                        if _ then
                            t_dir=t_dir..'/'.._
                            if fs.exists(t_dir) then
                                path=t_dir
                                break
                            end
                        else
                            path=t_dir
                            break
                        end
                    elseif fs.isDir(t_dir) then
                        level=level+1
                        _=l[level][1]
                        if _ then
                            t_dir=t_dir..'/'.._
                            if fs.exists(t_dir) then
                                dir=t_dir
                                ts[level]={dir,fs.list(dir)}
                                index[level]=0
                            else
                                level=level-1
                            end
                        else
                            dir=t_dir
                            ts[level]={dir,fs.list(dir)}
                            index[level]=0
                        end
                    end
                end
            end
        until false
        return path, index
    end
end

---iterator creator, over the valid paths defined by glob @g, e.g */filenumber?to
-- see the unix part of the table at http://en.wikipedia.org/wiki/Glob_(programming) .
--@treturn string path to matching of the dir
--@usage
--for path in search.iterGlob('*/stuff?/a*') do
--  print(path)
--end
--APIS/stuff1/a.lua
--var/stuff2/a.var
function iterGlob(g)
    return iterPatterns(compact(g))
end


--iterator over glob @g with ? replaced by @s
searchGlob = function (g,s)
    g=string.gsub(g,'%?',s)
    local iter=iterGlob(g)
    local path
    return function ()
        repeat
            path=iter()
            if path then
                if not fs.isDir(path) then
                    return path
                end
            else
                break
            end
        until false
    end
end

function getNameExpansion(s) --returns name and expansion from a filepath @s; special cases: ''->'',nil; '.'-> '','';
    --s string = filename
    --returns: name, expansion
    --Example
    --print(getNameExpansion('filename.lua.kl'))
    --filename
    --lua.kl
    local _,_,name,expa=string.find(s, '([^%./\\]*)%.(.*)$')
    return name or s,expa
end
function getDir(s) --returns directory from filepath @s
    return string.match(s,'^(.*)/') or '/'
end

--iterator over directory @p searching for @p...@s, where @s is a glob.
searchTree = function (p,s)
    if not p:match('%?') and fs.isDir(p) then
        if p=='/' then p='' end
        local iter=iterFiles(p)
        local path
        return function ()
            repeat
                path=iter()
                if path then
                    if string.match(path,s..'$') and not string.match(path,'[^/]'..s..'$') then
                        return path
                    end
                else
                    break
                end
            until false
        end
    else
        return function() end
    end
end

return env]===================],
    }
    args={...}
    if args[1]=='help' or args[1]=='-help' or args[1]=='--help' then

    else
        local loc=shell.getRunningProgram()
        local llen=loc:len()
        local nlen=fs.getName(loc):len()
        loc=loc:sub(1,(llen==nlen and 0 or llen-nlen-1))
        print(args[1])
        print(loc)
        local r=args[1] or loc
        for i=1,#t,2 do
            p,v=t[i],t[i+1]
            p=fs.combine(r,p)
            if i~=1 then
                fs.delete(p)
            end
            if type(v)=='boolean' then
                fs.makeDir(p)
            else
                local f=fs.open(p,'w')
                f.write(v)
                f.close()
            end
        end
        local r_s=args[2] and r or ''
        if not fs.exists('startup') then
            fs.delete(fs.combine(r_s,'startup'))
            local f=fs.open(fs.combine(r_s,'startup'),'w')
            f.write(string.format("shell.run('%s')",fs.combine(loc,'CoolisOS/bin/kernel/init.lua')))
            f.close()
            print('Running startup')
            dofile(fs.combine(r_s,'startup'))
        end
    end