function struct(tbl)
	local pat = tbl.endian or "="
	local args = {}
	for i=1, do
		local a, b = pairs(tbl[i])
		local k, v = a(b)
		args[i] = k
		pat = pat .. v
	end
	return setmetatable({}, {__call=function(_, arg)
		checkArg(1, arg, "string", "table")
		if (type(arg) == "string") then
			local sval = {string.unpack(pat, arg)}
			local rtn = {}
			for i=1, #args do
				rtn[args[i]] = sval[i]
			end
			return rtn, sval[#sval]
		elseif (type(arg) == "table") then
			local sval = {}
			for i=1, #args do
				sval[i] = arg[args[i]]
			end
			return string.pack(pat, unpack(sval))
		end
	end, __len=function()
		return string.packsize(pat)
	end})
end

function string.trim(self)
	return self:gsub("^%s+", ""):gsub("%s+$", "")
end

function string.explode(self, pat)
	local t, ll
	t={}
	ll=0
	if(#p == 1) then
		return {p}
	end
	while true do
		l = string.find(self, pat, ll, true) -- find the next d in the string
		if l ~= nil then -- if "not not" found then..
			table.insert(t, string.sub(self,ll,l-1)) -- Save it in our array.
			ll = l + 1 -- save just after where we found it for searching next time.
		else
			table.insert(t, string.sub(self,ll)) -- Save what's left in our array.
			break -- Break at end, as it should be, according to the lua manual.
		end
	end
	return t
end



---@module security Security
local security = {}

---@func checkacl
---@arg permission string "The permission to check."
---@return boolean "True if the current process has this permission."
function security.checkacl(permission)
	local perms = acl.get("group", thread.info().egid, {})
end

---@func getmode
---@return string "The current security mode."
function security.getmode()

end

function security.init()
	klog("security", 1, "Security init started.")

end



local velx = (function()


local velx_spec = struct {
	endian = "<",
	{magic="c5"},
	{fver="B"},
	{compression="B"},
	{lver="B"},
	{os="B"},
	{psize="I3"},
	{lsize="I3"},
	{ssize="I3"},
	{rsize="I4"}
}

local velx = {}

local exec = {}

function velx.identify(path)
	local h = io.open(path, "rb")
	local header = velx_spec(h:read(#velx_spec))
	h:close()
	return header.magic == "\27VelX"
end

function velx.load(path)
	
end

function velx.verify(path)
	local h = io.open(path, "rb")
	local header = velx_spec(h:read(#velx_spec))
	local code = h:read(header.psize)
	h:seek("cur", lsize)
	local sig = h:read(header.ssize)
	h:close()
	return security.verify(code, sig)
end

function exec:link()
	self.file:seek("set", #velx_spec+self.header.psize)
	local linkinfo = self.file:read(self.header.lsize)
	local linker = {}
	local pos = 1
	while true do
		local size = string.unpack("<H", linkinfo:sub(pos))
		pos = pos + 2
		local name = linkinfo:sub(pos, pos+size-1)
		pos = pos + size
		size = string.unpack("<H", linkinfo:sub(pos))
		pos = pos + 2
		local library = linkinfo:sub(pos, pos+size-1)
		pos = pos + size
		if (name == "" or library == "") then
			break
		end
		linker[#linker+1] = {name, library}
	end
	local linkscript = ""
	for i=1, #linker do
		linkscript = linkscript .. "local " .. linker[i][1] .. "=require(\"" .. linker[i][2] .. "\")\n"
	end
	self.code = linkscript .. self.code
	return true
end

function exec:load()
	self.file:seek("set", #velx_spec)
	local code = self.file:read(self.header.psize)
	if (self.header.compression == 0) then
		self.code = code
	elseif (self.header.compression == 1) then
		self.code = lzss.decompress(self.code)
	else
		return nil, "invalid compression method"
	end
	return true
end

function exec:run(args, evar)
	system.load(self.code, args, system.getglobalenv({_ARCHIVE=self.arc}), system.getevars(evar))
end

end)()

local zlua = (function()

local zlua = {}

return {}
end)

-- Executable loading process:
-- - Link
-- - Load
-- - Execute

if ()

local fox = {}
do

local struct_inode = struct {
	endian = "<",
	{mode="H"},
	{uid="H"},
	{fsize="I6"},
	{atime="I6"},
	{ctime="I6"},
	{mtime="I6"},
	{dtime="I6"},
	{gid="H"},
	{sec_count="I4"},
	{flags="I4"},
	{osval="I4"},
	{dbp0="I4"},
	{dbp1="I4"},
	{dbp2="I4"},
	{dbp3="I4"},
	{dbp4="I4"},
	{dbp5="I4"},
	{dbp6="I4"},
	{dbp7="I4"},
	{dbp8="I4"},
	{dbp9="I4"},
	{dbp10="I4"},
	{dbp11="I4"},
	{sibp="I4"},
	{dibp="I4"},
	{tibp="I4"},
	{gen="H"},
	{acl="I4"},
	{fragaddr="I4"},
	{osval2="c10"}
}

local dirent = struct {
	endian="<",
	{inode="I4"},
	{name_size="H"},
	{etype="B"}
}

local superblock = struct {
	endian = "<",
	{sig="H"},
	{ver_maj="H"},
	{ver_min="H"},
	{state="H"},
	{total_inodes="I4"},
	{total_blocks="I4"},
	{reserved_blocks="I4"},
	{total_unalloc_blocks="I4"},
	{total_unalloc_inodes="I4"},
	{total_unalloc_inodes="I4"},
}

local blkstr = {}

	function fox.proxy(blkdev)
		-- Read the superblock
	end
end

local tty = {}
do
	local _tty = {}
	function _tty:getgpu()
		return self.gpu.address
	end

	function _tty:getkb()
		return self.kb.address
	end

	function _tty:getscreen()
		return self.screen.address
	end
end

---@section biosfixes "BIOS fixes"

local _biossupport = {}




---@page zorya_legacy "Zorya 1.x (Zorya Legacy)"
---@doc "Zorya 1.x puts a few things in the global space that need to be removed. These include:"
---@doc "- The OEFI library"
---@doc "- The Zorya library"
---@doc ""
---@doc "Note: This *should* also apply to any forks of Zorya Legacy."
_biossupport["zoryalegacy"] = {
	quirks = function()

zorya = nil
	end,
	info = function()

return {
	name = "Zorya",
	version = {_ZVER//1, tonumber(tostring(_ZVER):match("%.(%d+)")), _ZPAT, string = _ZVER..".".._ZPAT},
	oefiver = oefi.getAPIVersion()
}
	end,
	detect = function()

return _LOAD == "Zorya"
	end,
	name = "zoryalegacy"
}



---@page zorya_neo "Zorya NEO (Zorya 2.0)"
---@doc "There's not much to be done for Zorya NEO as the included Zorya module starts Tsuki with a nice enviroment."
_biossupport["zoryaneo"] = {
	quirks = function()


	end,
	info = function()

return {
	name = "Zorya NEO",
	version = {_ZVER//1, tonumber(tostring(_ZVER):match("%.(%d+)")), _ZPAT, git = _ZGIT, string = _ZVSTR},
	loader = _ZLOADER
}
	end,
	detect = function()

return _BIOS == "Zorya NEO"
	end,
	name = "zoryaneo"
}




-- Mount the rootfs
vfs.mount()