local hookInterval = 10000
local function calcHookInterval()
	local bogomipsDivider = 0.05
	local bogomipsDeadline = computer.realTime() + bogomipsDivider
	local ipsCount = 0
	local bogomipsBusy = true
	local function calcBogoMips()
		ipsCount = ipsCount + hookInterval
		if computer.realTime() > bogomipsDeadline then
			bogomipsBusy = false
		end
	end
	-- The following is a bit of nonsensical-seeming code attempting
	-- to cover Lua's VM sufficiently for the IPS calculation.
	local bogomipsTmpA = {{["b"]=3, ["d"]=9}}
	local function c(k)
		if k <= 2 then
			bogomipsTmpA[1].d = k / 2.0
		end
	end
	debug.sethook(calcBogoMips, "", hookInterval)
	while bogomipsBusy do
		local st = ""
		for k=2,4 do
			st = st .. "a" .. k
			c(k)
			if k >= 3 then
				bogomipsTmpA[1].b = bogomipsTmpA[1].b * (k ^ k)
			end
		end
	end
	debug.sethook()
	return ipsCount / bogomipsDivider
end

local ipsCount = calcHookInterval()
-- Since our IPS might still be too generous (hookInterval needs to run at most
-- every 0.05 seconds), we divide it further by 10 relative to that.
hookInterval = (ipsCount * 0.005)
if hookInterval < 1000 then hookInterval = 1000 end

local deadline = math.huge
local hitDeadline = false
local tooLongWithoutYielding = setmetatable({},  { __tostring = function() return "too long without yielding" end})
local function checkDeadline()
  if computer.realTime() > deadline then
    debug.sethook(coroutine.running(), checkDeadline, "", 1)
    if not hitDeadline then
      deadline = deadline + 0.5
    end
    hitDeadline = true
    error(tooLongWithoutYielding)
  end
end
local function pcallTimeoutCheck(...)
  local ok, timeout = ...
  if rawequal(timeout, tooLongWithoutYielding) then
    return ok, tostring(tooLongWithoutYielding)
  end
  return ...
end

-------------------------------------------------------------------------------

local isLuaOver54 = _VERSION:match("5.4")
local isLuaOver53 = isLuaOver54 or _VERSION:match("5.3")

local function checkArg(n, have, ...)
  have = type(have)
  local function check(want, ...)
    if not want then
      return false
    else
      return have == want or check(...)
    end
  end
  if not check(...) then
    local msg = string.format("bad argument #%d (%s expected, got %s)",
                              n, table.concat({...}, " or "), have)
    error(msg, 3)
  end
end

-------------------------------------------------------------------------------

--[[ This is pretty much a straight port of Lua's pattern matching code from
     the standard PUC-Rio C implementation. We want to have this in plain Lua
     for the sandbox, so that timeouts also apply while matching stuff, which
     can take a looong time for certain "evil" patterns.
     It passes the pattern matching unit tests from Lua 5.2's test suite, so
     that should be good enough. ]]
do
  local CAP_UNFINISHED = -1
  local CAP_POSITION = -2
  local L_ESC = '%'
  local SPECIALS = "^$*+?.([%-"
  local SHORT_STRING = 500 -- use native implementations for short strings

  local string_find, string_lower, string_match, string_gmatch, string_gsub =
        string.find, string.lower, string.match, string.gmatch, string.gsub

  local match -- forward declaration

  local strptr
  local strptr_mt = {__index={
    step = function(self, count)
      self.pos = self.pos + (count or 1)
      return self
    end,
    head = function(self, len)
      return string.sub(self.data, self.pos, self.pos + (len or self:len()) - 1)
    end,
    len = function(self)
      return #self.data - (self.pos - 1)
    end,
    char = function(self, offset)
      local pos = self.pos + (offset or 0)
      if pos == #self.data + 1 then
        return "\0"
      end
      return string.sub(self.data, pos, pos)
    end,
    copy = function(self, offset)
      return strptr(self.data, self.pos + (offset or 0))
    end
    },
    __add = function(a, b)
      if type(b) == "table" then
        return a.pos + b.pos
      else
        return a:copy(b)
      end
    end,
    __sub = function(a, b)
      if type(b) == "table" then
        return a.pos - b.pos
      else
        return a:copy(-b)
      end
    end,
    __eq = function(a, b)
      return a.data == b.data and a.pos == b.pos
    end,
    __lt = function(a, b)
      assert(a.data == b.data)
      return a.pos < b.pos
    end,
    __le = function(a, b)
      assert(a.data == b.data)
      return a.pos <= b.pos
    end
  }
  function strptr(s, pos)
    return setmetatable({
      data = s,
      pos = pos or 1
    }, strptr_mt)
  end

  local function islower(b) return b >= 'a' and b <= 'z' end
  local function isupper(b) return b >= 'A' and b <= 'Z' end
  local function isalpha(b) return islower(b) or isupper(b) end
  local function iscntrl(b) return b <= '\007' or (b >= '\010' and b <= '\017') or (b >= '\020' and b <= '\027') or (b >= '\030' and b <= '\037' and b ~= ' ') or b == '\177' end
  local function isdigit(b) return b >= '0' and b <= '9' end
  local function ispunct(b) return (b >= '{' and b <= '~') or (b == '`') or (b >= '[' and b <= '_') or (b == '@') or (b >= ':' and b <= '?') or (b >= '(' and b <= '/') or (b >= '!' and b <= '\'') end
  local function isspace(b) return b == '\t' or b == '\n' or b == '\v' or b == '\f' or b == '\r' or b == ' ' end
  local function isalnum(b) return isalpha(b) or isdigit(b) end
  local function isxdigit(b) return isdigit(b) or (b >= 'a' and b <= 'f') or (b >= 'A' and b <= 'F') end
  local function isgraph(b) return not iscntrl(b) and not isspace(b) end

  -- translate a relative string position: negative means back from end
  local function posrelat(pos, len)
    if pos >= 0 then return pos
    elseif -pos > len then return 0
    else return len + pos + 1
    end
  end

  local function check_capture(ms, l)
    l = l - '1'
    if l < 0 or l >= ms.level or ms.capture[l].len == CAP_UNFINISHED then
      error("invalid capture index %" .. (l + 1))
    end
    return l
  end

  local function capture_to_close(ms)
    local level = ms.level
    while level > 0 do
      level = level - 1
      if ms.capture[level].len == CAP_UNFINISHED then
        return level
      end
    end
    return error("invalid pattern capture")
  end

  local function classend(ms, p)
    local p0 = p:char() p = p:copy(1)
    if p0 == L_ESC then
      if p == ms.p_end then
        error("malformed pattern (ends with %)")
      end
      return p:step(1)
    elseif p0 == '[' then
      if p:char() == '^' then
        p:step()
      end
      repeat  -- look for a `]'
        if p == ms.p_end then
          error("malformed pattern (missing ])")
        end
        p:step()
        if p:char(-1) == L_ESC then
          if p < ms.p_end then
            p:step()  -- skip escapes (e.g. `%]')
          end
        end
      until p:char() == ']'
      return p:step()
    else
      return p
    end
  end

  local function match_class(c, cl)
    local res
    local cll = string_lower(cl)
    if cll == 'a' then res = isalpha(c)
    elseif cll == 'c' then res = iscntrl(c)
    elseif cll == 'd' then res = isdigit(c)
    elseif cll == 'g' then res = isgraph(c)
    elseif cll == 'l' then res = islower(c)
    elseif cll == 'p' then res = ispunct(c)
    elseif cll == 's' then res = isspace(c)
    elseif cll == 'u' then res = isupper(c)
    elseif cll == 'w' then res = isalnum(c)
    elseif cll == 'x' then res = isxdigit(c)
    elseif cll == 'z' then res = c == '\0'  -- deprecated option
    else return cl == c
    end
    if islower(cl) then return res
    else return not res
    end
  end

  local function matchbracketclass(c, p, ec)
    local sig = true
    p = p:copy(1)
    if p:char() == '^' then
      sig = false
      p:step()  -- skip the `^'
    end
    while p < ec do
      if p:char() == L_ESC then
        p:step()
        if match_class(c, p:char()) then
          return sig
        end
      elseif p:char(1) == '-' and p + 2 < ec then
        p:step(2)
        if p:char(-2) <= c and c <= p:char() then
          return sig
        end
      elseif p:char() == c then
        return sig
      end
      p:step()
    end
    return not sig
  end

  local function singlematch(ms, s, p, ep)
    if s >= ms.src_end then
      return false
    end
    local p0 = p:char()
    if p0 == '.' then return true -- matches any char
    elseif p0 == L_ESC then return match_class(s:char(), p:char(1))
    elseif p0 == '[' then return matchbracketclass(s:char(), p, ep:copy(-1))
    else return p:char() == s:char()
    end
  end

  local function matchbalance(ms, s, p)
    if p >= ms.p_end - 1 then
      error("malformed pattern (missing arguments to %b)")
    end
    if s:char() ~= p:char() then return nil end
    local b = p:char()
    local e = p:char(1)
    local cont = 1
    s = s:copy()
    while s:step() < ms.src_end do
      if s:char() == e then
        cont = cont - 1
        if cont == 0 then return s:step() end
      elseif s:char() == b then
        cont = cont + 1
      end
    end
    return nil  -- string ends out of balance
  end

  local function max_expand(ms, s, p, ep)
    local i = 0  -- counts maximum expand for item
    while singlematch(ms, s:copy(i), p, ep) do
      i = i + 1
    end
    -- keeps trying to match with the maximum repetitions
    while i >= 0 do
      local res = match(ms, s:copy(i), ep:copy(1))
      if res then return res end
      i = i - 1  -- else didn't match; reduce 1 repetition to try again
    end
    return nil
  end

  local function min_expand(ms, s, p, ep)
    s = s:copy()
    while true do
      local res = match(ms, s, ep:copy(1))
      if res ~= nil then
        return res
      elseif singlematch(ms, s, p, ep) then
        s:step()  -- try with one more repetition
      else return nil
      end
    end
  end

  local function start_capture(ms, s, p, what)
    local level = ms.level
    ms.capture[level] = ms.capture[level] or {}
    ms.capture[level].init = s:copy()
    ms.capture[level].len = what
    ms.level = level + 1
    local res = match(ms, s, p)
    if res == nil then  -- match failed?
      ms.level = ms.level - 1  -- undo capture
    end
    return res
  end

  local function end_capture(ms, s, p)
    local l = capture_to_close(ms)
    ms.capture[l].len = s - ms.capture[l].init  -- close capture
    local res = match(ms, s, p)
    if res == nil then  -- match failed?
      ms.capture[l].len = CAP_UNFINISHED  -- undo capture
    end
    return res
  end

  local function match_capture(ms, s, l)
    l = check_capture(ms, l)
    local len = ms.capture[l].len
    if ms.src_end - s >= len and
       ms.capture[l].init:head(len) == s:head(len)
    then
      return s:copy(len)
    else return nil
    end
  end

  function match(ms, s, p)
    s = s:copy()
    p = p:copy()
    ::init:: -- using goto's to optimize tail recursion
    if p ~= ms.p_end then
      local p0 = p:char()
      if p0 == '(' then  -- start capture
        if p:char(1) == ')' then  -- position capture?
          s = start_capture(ms, s, p:copy(2), CAP_POSITION)
        else
          s = start_capture(ms, s, p:copy(1), CAP_UNFINISHED)
        end
        goto brk
      elseif p0 == ')' then  -- end capture
        s = end_capture(ms, s, p:copy(1))
        goto brk
      elseif p0 == '$' then
        if p + 1 ~= ms.p_end then  -- is the `$' the last char in pattern?
          goto dflt  -- no; go to default
        end
        s = (s == ms.src_end) and s or nil  -- check end of string
        goto brk
      elseif p0 == L_ESC then  -- escaped sequences not in the format class[*+?-]?
        local p1 = p:char(1)
        if p1 == 'b' then  -- balanced string?
          s = matchbalance(ms, s, p:copy(2))
          if s ~= nil then
            p:step(4)
            goto init  -- return match(ms, s, p + 4)
          end
          -- else fail (s == nil)
        elseif p1 == 'f' then  -- frontier?
          p:step(2)
          if p:char() ~= '[' then
            error("missing [ after %f in pattern")
          end
          local ep = classend(ms, p)  -- points to what is next
          local previous = (s == ms.src_init) and '\0' or s:char(-1)
          if not matchbracketclass(previous, p, ep:copy(-1)) and
             matchbracketclass(s:char(), p, ep:copy(-1))
          then
            p = ep
            goto init  -- return match(ms, s, ep)
          end
          s = nil  -- match failed
        elseif isdigit(p:char(1)) then  -- capture results (%0-%9)?
          s = match_capture(ms, s, p:char(1))
          if s ~= nil then
            p:step(2)
            goto init  -- return match(ms, s, p + 2)
          end
        else
          goto dflt
        end
        goto brk
      end
      ::dflt:: do
        local ep = classend(ms, p)  -- points to what is next
        local ep0 = ep:char()
        if not singlematch(ms, s, p, ep) then
          if ep0 == '*' or ep0 == '?' or ep0 == '-' then  -- accept empty?
            p = ep:copy(1)
            goto init  -- return match(ms, s, ep + 1)
          else  -- '+' or no suffix
            s = nil  -- fail
          end
        else  -- matched once
          if ep0 == '?' then  -- optional
            local res = match(ms, s:copy(1), ep:copy(1))
            if res ~= nil then
              s = res
            else
              p = ep:copy(1)
              goto init  -- else return match(ms, s, ep + 1)
            end
          elseif ep0 == '+' then  -- 1 or more repetitions
            s = max_expand(ms, s:copy(1), p, ep)  -- 1 match already done
          elseif ep0 == '*' then  -- 0 or more repetitions
            s = max_expand(ms, s, p, ep)
          elseif ep0 == '-' then  -- 0 or more repetitions (minimum)
            s = min_expand(ms, s, p, ep)
          else
            s:step()
            p = ep
            goto init  -- else return match(ms, s+1, ep);
          end
        end
      end
      ::brk::
    end
    return s
  end

  local function push_onecapture(ms, i, s, e)
    if i >= ms.level then
      if i == 0 then  -- ms->level == 0, too
        return s:head(e - s)  -- add whole match
      else
        error("invalid capture index")
      end
    else
      local l = ms.capture[i].len;
      if l == CAP_UNFINISHED then error("unfinished capture") end
      if l == CAP_POSITION then
        return ms.capture[i].init - ms.src_init + 1
      else
        return ms.capture[i].init:head(l)
      end
    end
  end

  local function push_captures(ms, s, e)
    local nlevels = (ms.level == 0 and s) and 1 or ms.level
    local captures = {}
    for i = 0, nlevels - 1 do
      table.insert(captures, push_onecapture(ms, i, s, e))
    end
    return table.unpack(captures)
  end

  -- check whether pattern has no special characters
  local function nospecials(p)
    for i = 1, #p do
      for j = 1, #SPECIALS do
        if p:sub(i, i) == SPECIALS:sub(j, j) then
          return false
        end
      end
    end
    return true
  end

  local function str_find_aux(str, pattern, init, plain, find)
    checkArg(1, str, "string")
    checkArg(2, pattern, "string")
    checkArg(3, init, "number", "nil")

    if #str < SHORT_STRING then
      return (find and string_find or string_match)(str, pattern, init, plain)
    end

    local s = strptr(str)
    local p = strptr(pattern)
    local init = posrelat(init or 1, #str)
    if init < 1 then init = 1
    elseif init > #str + 1 then  -- start after string's end?
      return nil  -- cannot find anything
    end
    -- explicit request or no special characters?
    if find and (plain or nospecials(pattern)) then
      -- do a plain search
      local s2 = string_find(str, pattern, init, true)
      if s2 then
        return s2-s.pos + 1, s2 - s.pos + p:len()
      end
    else
      local s1 = s:copy(init - 1)
      local anchor = p:char() == '^'
      if anchor then p:step() end
      local ms = {
        src_init = s,
        src_end = s:copy(s:len()),
        p_end = p:copy(p:len()),
        capture = {}
      }
      repeat
        ms.level = 0
        local res = match(ms, s1, p)
        if res ~= nil then
          if find then
            return s1.pos - s.pos + 1, res.pos - s.pos, push_captures(ms, nil, nil)
          else
            return push_captures(ms, s1, res)
          end
        end
      until s1:step() > ms.src_end or anchor
    end
    return nil  -- not found
  end

  local function str_find(s, pattern, init, plain)
    return str_find_aux(s, pattern, init, plain, true)
  end

  local function str_match(s, pattern, init)
    return str_find_aux(s, pattern, init, false, false)
  end

  local function str_gmatch(s, pattern, init)
    checkArg(1, s, "string")
    checkArg(2, pattern, "string")

    if #s < SHORT_STRING then
      return string_gmatch(s, pattern, init)
    end

    local start = 0
    if isLuaOver54 then
      checkArg(3, init, "number", "nil")
      if init ~= nil then
        start = posrelat(init, #s)
        if start < 1 then start = 0
        elseif start > #s + 1 then start = #s + 1
        else start = start - 1 end
      end
    end

    local s = strptr(s)
    local p = strptr(pattern)
    return function()
      ms = {
        src_init = s,
        src_end = s:copy(s:len()),
        p_end = p:copy(p:len()),
        capture = {}
      }
      for offset = start, ms.src_end.pos - 1 do
        local src = s:copy(offset)
        ms.level = 0
        local e = match(ms, src, p)
        if e ~= nil then
          local newstart = e - s
          if e == src then newstart = newstart + 1 end -- empty match? go at least one position
          start = newstart
          return push_captures(ms, src, e)
        end
      end
      return nil  -- not found
    end
  end

  local function add_s(ms, b, s, e, r)
    local news = tostring(r)
    local i = 1
    while i <= #news do
      if news:sub(i, i) ~= L_ESC then
        b = b .. news:sub(i, i)
      else
        i = i + 1  -- skip ESC
        if not isdigit(news:sub(i, i)) then
          b = b .. news:sub(i, i)
        elseif news:sub(i, i) == '0' then
          b = b .. s:head(e - s)
        else
          b = b .. push_onecapture(ms, news:sub(i, i) - '1', s, e)  -- add capture to accumulated result
        end
      end
      i = i + 1
    end
    return b
  end

  local function add_value(ms, b, s, e, r, tr)
    local res
    if tr == "function" then
      res = r(push_captures(ms, s, e))
    elseif tr == "table" then
      res = r[push_onecapture(ms, 0, s, e)]
    else  -- LUA_TNUMBER or LUA_TSTRING
      return add_s(ms, b, s, e, r)
    end
    if not res then  -- nil or false?
      res = s:head(e - s)  -- keep original text
    elseif type(res) ~= "string" and type(res) ~= "number" then
      error("invalid replacement value (a "..type(res)..")")
    end
    return b .. res  -- add result to accumulator
  end

  local function str_gsub(s, pattern, repl, n)
    checkArg(1, s, "string")
    checkArg(2, pattern, "string", "number")
    checkArg(3, repl, "number", "string", "function", "table")
    checkArg(4, n, "number", "nil")

    if #s < SHORT_STRING then
      return string_gsub(s, pattern, repl, n)
    end

    pattern = tostring(pattern)
    local src = strptr(s);
    local p = strptr(pattern)
    local tr = type(repl)
    local max_s = n or (#s + 1)
    local anchor = p:char() == '^'
    if anchor then
      p:step()  -- skip anchor character
    end
    n = 0
    local b = ""
    local ms = {
      src_init = src:copy(),
      src_end = src:copy(src:len()),
      p_end = p:copy(p:len()),
      capture = {}
    }
    while n < max_s do
      ms.level = 0
      local e = match(ms, src, p)
      if e then
        n = n + 1
        b = add_value(ms, b, src, e, repl, tr)
      end
      if e and e > src then  -- non empty match?
        src = e  -- skip it
      elseif src < ms.src_end then
        b = b .. src:char()
        src:step()
      else break
      end
      if anchor then break end
    end
    b = b .. src:head()
    return b, n  -- number of substitutions
  end

  string.find = str_find
  string.match = str_match
  string.gmatch = str_gmatch
  string.gsub = str_gsub
end

-------------------------------------------------------------------------------

local function spcall(...)
  local result = table.pack(pcall(...))
  if not result[1] then
    error(tostring(result[2]), 0)
  else
    return table.unpack(result, 2, result.n)
  end
end

local sgcco

local function sgcf(self, gc)
  while true do
    self, gc = coroutine.yield(pcall(gc, self))
  end
end

local function sgc(self)
  local oldDeadline, oldHitDeadline = deadline, hitDeadline
  local mt = debug.getmetatable(self)
  mt = rawget(mt, "mt")
  local gc = rawget(mt, "__gc")
  if type(gc) ~= "function" then
    return
  end
  if not sgcco then
    sgcco = coroutine.create(sgcf)
  end
  debug.sethook(sgcco, checkDeadline, "", hookInterval)
  deadline, hitDeadline = math.min(oldDeadline, computer.realTime() + 0.5), true
  local _, result, reason = coroutine.resume(sgcco, self, gc)
  debug.sethook(sgcco)
  if coroutine.status(sgcco) == "dead" then
    sgcco = nil
  end
  deadline, hitDeadline = oldDeadline, oldHitDeadline
  if not result then
    error(reason, 0)
  end
end

--[[ This is the global environment we make available to userland programs. ]]
-- You'll notice that we do a lot of wrapping of native functions and adding
-- parameter checks in those wrappers. This is to avoid errors from the host
-- side that would push error objects - which are userdata and cannot be
-- persisted.
local sandbox, libprocess
sandbox = {
  assert = assert,
  dofile = nil, -- in boot/*_base.lua
  error = error,
  _G = nil, -- see below
  getmetatable = function(t)
    if type(t) == "string" then -- don't allow messing with the string mt
      return nil
    end
    local result = getmetatable(t)
    -- check if we have a wrapped __gc using mt
    if type(result) == "table" and system.allowGC() and rawget(result, "__gc") == sgc then
      result = rawget(result, "mt")
    end
    return result
  end,
  ipairs = ipairs,
  load = function(ld, source, mode, env)
    if not system.allowBytecode() then
      mode = "t"
    end
    return load(ld, source, mode, env or sandbox)
  end,
  loadfile = nil, -- in boot/*_base.lua
  next = next,
  pairs = pairs,
  pcall = function(...)
    -- prevent infinite pcall() loops by checking deadline before pcall()
    local status, err = pcall(checkDeadline)
    if not status then return false, err end

    return pcallTimeoutCheck(pcall(...))
  end,
  print = nil, -- in boot/*_base.lua
  rawequal = rawequal,
  rawget = rawget,
  rawlen = rawlen,
  rawset = rawset,
  select = select,
  setmetatable = function(t, mt)
    if type(mt) ~= "table" then
      return setmetatable(t, mt)
    end
    if rawget(mt, "__gc") ~= nil then -- If __gc is set to ANYTHING not `nil`, we're gonna have issues
      -- Garbage collector callbacks apparently can't be sandboxed after
      -- all, because hooks are disabled while they're running. So we just
      -- disable them altogether by default.
      if system.allowGC() then
        -- For all user __gc functions we enforce a much tighter deadline.
        -- This is because these functions may be called from the main
        -- thread under certain circumstanced (such as when saving the world),
        -- which can lead to noticeable lag if the __gc function behaves badly.
        local sbmt = {} -- sandboxed metatable. only for __gc stuff, so it's
                        -- kinda ok to have a shallow copy instead... meh.
        for k, v in next, mt do
          sbmt[k] = v
        end
        sbmt.__gc = sgc
        sbmt.mt = mt
        mt = sbmt
      else
        -- Don't allow marking for finalization, but use the raw metatable.
        local gc = rawget(mt, "__gc")
        rawset(mt, "__gc", nil) -- remove __gc
        local ret = table.pack(pcall(setmetatable, t, mt))
        rawset(mt, "__gc", gc) -- restore __gc
        if not ret[1] then error(ret[2], 0) end
        return table.unpack(ret, 2, ret.n)
      end
    end
    return setmetatable(t, mt)
  end,
  tonumber = tonumber,
  tostring = tostring,
  type = type,
  _VERSION = _VERSION:match("Luaj") and "Luaj" or _VERSION:match("5.4") and "Lua 5.4" or _VERSION:match("5.3") and "Lua 5.3" or "Lua 5.2",
  xpcall = function(f, msgh, ...)
    -- allow xpcall() to call the message handler recursively, per manual 2.3
    -- Lua itself promises to break the infinite loop; failing that, the timeout
    -- check will take care of this.
    local errorCapture
    errorCapture = function(ff, ...)
      -- prevent infinite xpcall() loops by checking deadline before xpcall()
      local status, err = pcall(checkDeadline)
      if not status then return false, err end

      return xpcall(ff, function(...)
        if rawequal((...), tooLongWithoutYielding) then
          return tooLongWithoutYielding
        else
          return select(2, errorCapture(msgh, ...))
        end
      end, ...)
    end

    checkArg(2, msgh, "function")
    local result = table.pack(errorCapture(f, ...))
    -- if the final returned error is due to timeout, run handler one last time
    if rawequal(result[2], tooLongWithoutYielding) then
      result = table.pack(result[1], select(2, pcallTimeoutCheck(pcall(msgh, tostring(tooLongWithoutYielding)))))
    end
    return table.unpack(result, 1, result.n)
  end,

  coroutine = {
    create = coroutine.create,
    resume = function(co, ...) -- custom resume part for bubbling sysyields
      checkArg(1, co, "thread")
      local args = table.pack(...)
      while true do -- for consecutive sysyields
        debug.sethook(co, checkDeadline, "", hookInterval)
        local result = table.pack(
          coroutine.resume(co, table.unpack(args, 1, args.n)))
        debug.sethook(co) -- avoid gc issues
        checkDeadline()
        if result[1] then -- success: (true, sysval?, ...?)
          if coroutine.status(co) == "dead" then -- return: (true, ...)
            return true, table.unpack(result, 2, result.n)
          elseif result[2] ~= nil then -- yield: (true, sysval)
            args = table.pack(coroutine.yield(result[2]))
          else -- yield: (true, nil, ...)
            return true, table.unpack(result, 3, result.n)
          end
        else -- error: result = (false, string)
          return false, result[2]
        end
      end
    end,
    running = coroutine.running,
    status = coroutine.status,
    wrap = function(f) -- for bubbling coroutine.resume
      local co = coroutine.create(f)
      return function(...)
        local result = table.pack(sandbox.coroutine.resume(co, ...))
        if result[1] then
          return table.unpack(result, 2, result.n)
        else
          error(result[2], 0)
        end
      end
    end,
    yield = function(...) -- custom yield part for bubbling sysyields
      return coroutine.yield(nil, ...)
    end,
    -- Lua 5.3.
    isyieldable = coroutine.isyieldable
  },

  string = {
    byte = string.byte,
    char = string.char,
    dump = string.dump,
    find = string.find,
    format = string.format,
    gmatch = string.gmatch,
    gsub = string.gsub,
    len = string.len,
    lower = string.lower,
    match = string.match,
    rep = string.rep,
    reverse = string.reverse,
    sub = string.sub,
    upper = string.upper,
    -- Lua 5.3.
    pack = string.pack,
    unpack = string.unpack,
    packsize = string.packsize
  },

  table = {
    concat = table.concat,
    insert = table.insert,
    pack = table.pack,
    remove = table.remove,
    sort = table.sort,
    unpack = table.unpack,
    -- Lua 5.3.
    move = table.move
  },

  math = {
    abs = math.abs,
    acos = math.acos,
    asin = math.asin,
    atan = math.atan,
    atan2 = math.atan2 or math.atan, -- Deprecated in Lua 5.3
    ceil = math.ceil,
    cos = math.cos,
    cosh = math.cosh, -- Deprecated in Lua 5.3
    deg = math.deg,
    exp = math.exp,
    floor = math.floor,
    fmod = math.fmod,
    frexp = math.frexp, -- Deprecated in Lua 5.3
    huge = math.huge,
    ldexp = math.ldexp or function(a, e) -- Deprecated in Lua 5.3
        return a*(2.0^e)
    end,
    log = math.log,
    max = math.max,
    min = math.min,
    modf = math.modf,
    pi = math.pi,
    pow = math.pow or function(a, b) -- Deprecated in Lua 5.3
      return a^b
    end,
    rad = math.rad,
    random = function(...)
      return spcall(math.random, ...)
    end,
    randomseed = function(seed)
      -- math.floor(seed) emulates pre-OC 1.8.0 behaviour
      spcall(math.randomseed, math.floor(seed))
    end,
    sin = math.sin,
    sinh = math.sinh, -- Deprecated in Lua 5.3
    sqrt = math.sqrt,
    tan = math.tan,
    tanh = math.tanh, -- Deprecated in Lua 5.3
    -- Lua 5.3.
    maxinteger = math.maxinteger,
    mininteger = math.mininteger,
    tointeger = math.tointeger,
    type = math.type,
    ult = math.ult
  },

  -- Deprecated in Lua 5.3.
  bit32 = bit32 and {
    arshift = bit32.arshift,
    band = bit32.band,
    bnot = bit32.bnot,
    bor = bit32.bor,
    btest = bit32.btest,
    bxor = bit32.bxor,
    extract = bit32.extract,
    replace = bit32.replace,
    lrotate = bit32.lrotate,
    lshift = bit32.lshift,
    rrotate = bit32.rrotate,
    rshift = bit32.rshift
  },

  io = nil, -- in lib/io.lua

  os = {
    clock = os.clock,
    date = function(format, time)
      return spcall(os.date, format, time)
    end,
    difftime = function(t2, t1)
      return t2 - t1
    end,
    execute = nil, -- in boot/*_os.lua
    exit = nil, -- in boot/*_os.lua
    remove = nil, -- in boot/*_os.lua
    rename = nil, -- in boot/*_os.lua
    time = function(table)
      checkArg(1, table, "table", "nil")
      return os.time(table)
    end,
    tmpname = nil, -- in boot/*_os.lua
  },

  debug = {
    getinfo = function(...)
      local result = debug.getinfo(...)
      if result then
        -- Only make primitive information available in the sandbox.
        return {
          source = result.source,
          short_src = result.short_src,
          linedefined = result.linedefined,
          lastlinedefined = result.lastlinedefined,
          what = result.what,
          currentline = result.currentline,
          nups = result.nups,
          nparams = result.nparams,
          isvararg = result.isvararg,
          name = result.name,
          namewhat = result.namewhat,
          istailcall = result.istailcall
        }
      end
    end,
    traceback = debug.traceback,
    -- using () to wrap the return of debug methods because in Lua doing this
    -- causes only the first return value to be selected
    -- e.g. (1, 2) is only (1), the 2 is not returned
    -- this is critically important here because the 2nd return value from these
    -- debug methods is the value itself, which opens a door to exploit the sandbox
    getlocal = function(...) return (debug.getlocal(...)) end,
    getupvalue = function(...) return (debug.getupvalue(...)) end,
  },

  -- Lua 5.3.
  utf8 = utf8 and {
    char = utf8.char,
    charpattern = utf8.charpattern,
    codes = utf8.codes,
    codepoint = utf8.codepoint,
    len = utf8.len,
    offset = utf8.offset
  },

  checkArg = checkArg
}
sandbox._G = sandbox

-------------------------------------------------------------------------------
-- Start of non-standard stuff.

-- JNLua derps when the metatable of userdata is changed, so we have to
-- wrap and isolate it, to make sure it can't be touched by user code.
-- These functions provide the logic for wrapping and unwrapping (when
-- pushed to user code and when pushed back to the host, respectively).
local wrapUserdata, wrapSingleUserdata, unwrapUserdata, wrappedUserdataMeta

wrappedUserdataMeta = {
  -- Weak keys, clean up once a proxy is no longer referenced anywhere.
  __mode="k",
  -- We need custom persist logic here to avoid ERIS trying to save the
  -- userdata referenced in this table directly. It will be repopulated
  -- in the load methods of the persisted userdata wrappers (see below).
  [persistKey and persistKey() or "LuaJ"] = function()
    return function()
      -- When using special persistence we have to manually reassign the
      -- metatable of the persisted value.
      return setmetatable({}, wrappedUserdataMeta)
    end
  end
}
local wrappedUserdata = setmetatable({}, wrappedUserdataMeta)

local function processResult(result)
  result = wrapUserdata(result) -- needed for metamethods.
  if not result[1] then -- error that should be re-thrown.
    error(result[2], 0)
  else -- success or already processed error.
    return table.unpack(result, 2, result.n)
  end
end

local function invoke(target, direct, ...)
  local result
  if direct then
    local args = table.pack(...) -- for unwrapping
    args = unwrapUserdata(args)
    result = table.pack(target.invoke(table.unpack(args, 1, args.n)))
    args = nil -- clear upvalue, avoids trying to persist it
    if result.n == 0 then -- limit for direct calls reached
      result = nil
    end
    -- no need to wrap here, will be wrapped in processResult
  end
  if not result then
    local args = table.pack(...) -- for access in closure
    result = select(1, coroutine.yield(function()
      args = unwrapUserdata(args)
      local result = table.pack(target.invoke(table.unpack(args, 1, args.n)))
      args = nil -- clear upvalue, avoids trying to persist it
      result = wrapUserdata(result)
      return result
    end))
  end
  return processResult(result)
end

local function udinvoke(f, data, ...)
  local args = table.pack(...)
  args = unwrapUserdata(args)
  local result = table.pack(f(data, table.unpack(args)))
  args = nil -- clear upvalue, avoids trying to persist it
  return processResult(result)
end

-- Metatable for additional functionality on userdata.
local userdataWrapper = {
  __index = function(self, ...)
    return udinvoke(userdata.apply, wrappedUserdata[self], ...)
  end,
  __newindex = function(self, ...)
    return udinvoke(userdata.unapply, wrappedUserdata[self], ...)
  end,
  __call = function(self, ...)
    return udinvoke(userdata.call, wrappedUserdata[self], ...)
  end,
  __gc = function(self)
    local data = wrappedUserdata[self]
    wrappedUserdata[self] = nil
    userdata.dispose(data)
  end,
  -- This is the persistence protocol for userdata. Userdata is considered
  -- to be 'owned' by Lua, and is saved to an NBT tag. We also get the name
  -- of the actual class when saving, so we can create a new instance via
  -- reflection when loading again (and then immediately wrap it again).
  -- Collect wrapped callback methods.
  [persistKey and persistKey() or "LuaJ"] = function(self)
    local className, nbt = userdata.save(wrappedUserdata[self])
    -- The returned closure is what actually gets persisted, including the
    -- upvalues, that being the classname and a byte array representing the
    -- nbt data of the userdata value.
    return function()
      return wrapSingleUserdata(userdata.load(className, nbt))
    end
  end,
  -- Do not allow changing the metatable to avoid the gc callback being
  -- unset, leading to potential resource leakage on the host side.
  __metatable = "userdata",
  __tostring = function(self)
    local data = wrappedUserdata[self]
    return tostring(select(2, pcall(tostring, data)))
  end
}

local userdataCallback = {
  __call = function(self, ...)
    local methods = spcall(userdata.methods, wrappedUserdata[self.proxy])
    for name, direct in pairs(methods) do
      if name == self.name then
        return invoke(userdata, direct, self.proxy, name, ...)
      end
    end
    error("no such method", 1)
  end,
  __tostring = function(self)
    return userdata.doc(wrappedUserdata[self.proxy], self.name) or "function"
  end
}

function wrapSingleUserdata(data)
  -- Reuse proxies for lower memory consumption and more logical behavior
  -- without the need of metamethods like __eq, as well as proper reference
  -- behavior after saving and loading again.
  for k, v in pairs(wrappedUserdata) do
    -- We need a custom 'equals' check for userdata because metamethods on
    -- userdata introduced by JNLua tend to crash the game for some reason.
    if v == data then
      return k
    end
  end
  local proxy = {type = "userdata"}
  local methods = spcall(userdata.methods, data)
  for method in pairs(methods) do
    proxy[method] = setmetatable({name=method, proxy=proxy}, userdataCallback)
  end
  wrappedUserdata[proxy] = data
  return setmetatable(proxy, userdataWrapper)
end

function wrapUserdata(values)
  local processed = {}
  local function wrapRecursively(value)
    if type(value) == "table" then
      if not processed[value] then
        processed[value] = true
        for k, v in pairs(value) do
          value[k] = wrapRecursively(v)
        end
      end
    elseif type(value) == "userdata" then
      return wrapSingleUserdata(value)
    end
    return value
  end
  return wrapRecursively(values)
end

function unwrapUserdata(values)
  local processed = {}
  local function unwrapRecursively(value)
    if wrappedUserdata[value] then
      return wrappedUserdata[value]
    end
    if type(value) == "table" then
      if not processed[value] then
        processed[value] = true
        for k, v in pairs(value) do
          value[k] = unwrapRecursively(v)
        end
      end
    end
    return value
  end
  return unwrapRecursively(values)
end

-------------------------------------------------------------------------------

local libcomponent

-- Caching proxy objects for lower memory use.
local proxyCache = setmetatable({}, {__mode="v"})

-- Short-term caching of callback directness for improved performance.
local directCache = setmetatable({}, {__mode="k"})
local function isDirect(address, method)
  local cacheKey = address..":"..method
  local cachedValue = directCache[cacheKey]
  if cachedValue ~= nil then
    return cachedValue
  end
  local methods, reason = spcall(component.methods, address)
  if not methods then
    return false
  end
  for name, info in pairs(methods) do
    if name == method then
      directCache[cacheKey] = info.direct
      return info.direct
    end
  end
  error("no such method: " .. method, 1)
end

local componentProxy = {
  __index = function(self, key)
    if self.fields[key] and self.fields[key].getter then
      return libcomponent.invoke(self.address, key)
    else
      rawget(self, key)
    end
  end,
  __newindex = function(self, key, value)
    if self.fields[key] and self.fields[key].setter then
      return libcomponent.invoke(self.address, key, value)
    elseif self.fields[key] and self.fields[key].getter then
      error("field is read-only")
    else
      rawset(self, key, value)
    end
  end,
  __pairs = function(self)
    local keyProxy, keyField, value
    return function()
      if not keyField then
        repeat
          keyProxy, value = next(self, keyProxy)
        until not keyProxy or keyProxy ~= "fields"
      end
      if not keyProxy then
        keyField, value = next(self.fields, keyField)
      end
      return keyProxy or keyField, value
    end
  end
}

local componentCallback = {
  __call = function(self, ...)
    return libcomponent.invoke(self.address, self.name, ...)
  end,
  __tostring = function(self)
    return libcomponent.doc(self.address, self.name) or "function"
  end
}

libcomponent = {
  doc = function(address, method)
    checkArg(1, address, "string")
    checkArg(2, method, "string")
    local result, reason = spcall(component.doc, address, method)
    if not result and reason then
      error(reason, 2)
    end
    return result
  end,
  invoke = function(address, method, ...)
    checkArg(1, address, "string")
    checkArg(2, method, "string")
    return invoke(component, isDirect(address, method), address, method, ...)
  end,
  list = function(filter, exact)
    checkArg(1, filter, "string", "nil")
    local list = spcall(component.list, filter, not not exact)
    local key = nil
    return setmetatable(list, {__call=function()
      key = next(list, key)
      if key then
        return key, list[key]
      end
    end})
  end,
  methods = function(address)
    local result, reason = spcall(component.methods, address)
    -- Transform to pre 1.4 format to avoid breaking scripts.
    if type(result) == "table" then
      for k, v in pairs(result) do
        if not v.getter and not v.setter then
          result[k] = v.direct
        else
          result[k] = nil
        end
      end
      return result
    end
    return result, reason
  end,
  fields = function(address)
    local result, reason = spcall(component.methods, address)
    if type(result) == "table" then
      for k, v in pairs(result) do
        if not v.getter and not v.setter then
          result[k] = nil
        end
      end
      return result
    end
    return result, reason
  end,
  proxy = function(address)
    local type, reason = spcall(component.type, address)
    if not type then
      return nil, reason
    end
    local slot, reason = spcall(component.slot, address)
    if not slot then
      return nil, reason
    end
    if proxyCache[address] then
      return proxyCache[address]
    end
    local proxy = {address = address, type = type, slot = slot, fields = {}}
    local methods, reason = spcall(component.methods, address)
    if not methods then
      return nil, reason
    end
    for method, info in pairs(methods) do
      if not info.getter and not info.setter then
        proxy[method] = setmetatable({address=address,name=method}, componentCallback)
      else
        proxy.fields[method] = info
      end
    end
    setmetatable(proxy, componentProxy)
    proxyCache[address] = proxy
    return proxy
  end,
  type = function(address)
    return spcall(component.type, address)
  end,
  slot = function(address)
    return spcall(component.slot, address)
  end
}
sandbox.component = libcomponent

local libcomputer = {
  isRobot = computer.isRobot,
  address = computer.address,
  tmpAddress = computer.tmpAddress,
  freeMemory = computer.freeMemory,
  totalMemory = computer.totalMemory,
  uptime = computer.uptime,
  energy = computer.energy,
  maxEnergy = computer.maxEnergy,

  getBootAddress = computer.getBootAddress,
  setBootAddress = function(...)
    return spcall(computer.setBootAddress, ...)
  end,

  users = computer.users,
  addUser = function(...)
    return spcall(computer.addUser, ...)
  end,
  removeUser = function(...)
    return spcall(computer.removeUser, ...)
  end,

  shutdown = function(reboot)
    coroutine.yield(not not reboot)
  end,
  pushSignal = function(...)
    return spcall(computer.pushSignal, ...)
  end,
  pullSignal = function(timeout)
    local deadline = computer.uptime() +
      (type(timeout) == "number" and timeout or math.huge)
    repeat
      local signal = table.pack(coroutine.yield(deadline - computer.uptime()))
      if signal.n > 0 then
        return table.unpack(signal, 1, signal.n)
      end
    until computer.uptime() >= deadline
  end,

  beep = function(...)
    return libcomponent.invoke(computer.address(), "beep", ...)
  end,
  getDeviceInfo = function()
    return libcomponent.invoke(computer.address(), "getDeviceInfo")
  end,
  getProgramLocations = function()
    return libcomponent.invoke(computer.address(), "getProgramLocations")
  end,

  getArchitectures = function(...)
    return spcall(computer.getArchitectures, ...)
  end,
  getArchitecture = function(...)
    return spcall(computer.getArchitecture, ...)
  end,
  setArchitecture = function(...)
    local result, reason = spcall(computer.setArchitecture, ...)
    if not result then
      if reason then
        return result, reason
      end
    else
      coroutine.yield(true) -- reboot
    end
  end
}
sandbox.computer = libcomputer

local libunicode = {
  char = function(...)
    return spcall(unicode.char, ...)
  end,
  len = function(s)
    return spcall(unicode.len, s)
  end,
  lower = function(s)
    return spcall(unicode.lower, s)
  end,
  reverse = function(s)
    return spcall(unicode.reverse, s)
  end,
  sub = function(s, i, j)
    if j then
      return spcall(unicode.sub, s, i, j)
    end
    return spcall(unicode.sub, s, i)
  end,
  upper = function(s)
    return spcall(unicode.upper, s)
  end,
  isWide = function(s)
    return spcall(unicode.isWide, s)
  end,
  charWidth = function(s)
    return spcall(unicode.charWidth, s)
  end,
  wlen = function(s)
    return spcall(unicode.wlen, s)
  end,
  wtrunc = function(s, n)
    return spcall(unicode.wtrunc, s, n)
  end
}
sandbox.unicode = libunicode

-------------------------------------------------------------------------------

local function bootstrap()
  local eeprom = libcomponent.list("eeprom")()
  if eeprom then
    local code = libcomponent.invoke(eeprom, "get")
    if code and #code > 0 then
      local bios, reason = load(code, "=bios", "t", sandbox)
      if bios then
        return coroutine.create(bios), {n=0}
      end
      error("failed loading bios: " .. reason, 0)
    end
  end
  error("no bios found; install a configured EEPROM", 0)
end

-------------------------------------------------------------------------------

local function main()
  -- Yield once to get a memory baseline.
  coroutine.yield()

  -- After memory footprint to avoid init.lua bumping the baseline.
  local co, args = bootstrap()
  local forceGC = 10

  while true do
    deadline = computer.realTime() + system.timeout()
    hitDeadline = false

    -- NOTE: since this is run in an executor thread and we enforce timeouts
    -- in user-defined garbage collector callbacks this should be safe.
    if persistKey then -- otherwise we're in LuaJ
      forceGC = forceGC - 1
      if forceGC < 1 then
        collectgarbage("collect")
        forceGC = 10
      end
    end

    debug.sethook(co, checkDeadline, "", hookInterval)
    local result = table.pack(coroutine.resume(co, table.unpack(args, 1, args.n)))
    args = nil -- clear upvalue, avoids trying to persist it
    if not result[1] then
      error(tostring(result[2]), 0)
    elseif coroutine.status(co) == "dead" then
      error("computer halted", 0)
    else
      args = table.pack(coroutine.yield(result[2])) -- system yielded value
      args = wrapUserdata(args)
    end
  end
end

-- JNLua converts the coroutine to a string immediately, so we can't get the
-- traceback later. Because of that we have to do the error handling here.
return pcallTimeoutCheck(pcall(main))
