cluaupp 1.3.0 → 1.4.1

package/examples/game/libs/DataService/Packages/quicknet/Serialize.luau

@@ -1,2020 +0,0 @@
---!optimize 2
-local Players = game:GetService("Players")
-
-local Types = require(script.Parent.Types)
-local Enums = require(script.Parent.Enums)
-
-type SchemaArg = Types.SchemaArg
-type Literal = Types.Literal
-
-local FX8_SCALE = 10
-local FX8_ROT_SCALE = 40.42
-local FX16_SCALE = 100
-local FX16_ROT_SCALE = 10430
-local DYNAMIC_DEFAULTS = {
-	number = Enums.NumberF64,
-	CFrame = Enums.CFrameF32,
-	Vector3 = Enums.Vector3F32,
-	Vector2 = Enums.Vector2F32,
-	["nil"] = Enums.Nil,
-	string = Enums.String,
-	Color3 = Enums.Color3,
-	BrickColor = Enums.BrickColor,
-	boolean = Enums.Boolean,
-	table = Enums.DictDynamic,
-	buffer = Enums.Buffer,
-	Instance = Enums.Instance,
-	DateTime = Enums.DateTime64,
-	TweenInfo = Enums.TweenInfo,
-	ColorSequence = Enums.ColorSequence,
-	NumberSequence = Enums.NumberSequence,
-	NumberRange = Enums.NumberRange,
-	UDim = Enums.UDim,
-	UDim2 = Enums.UDim2,
-	Region3 = Enums.Region3,
-	PhysicalProperties = Enums.PhysicalProperties,
-	Rect = Enums.Rect,
-}
-
-local TBL_POOL_SIZE = 100
-
-local writeu8 = buffer.writeu8 
-local writeu16 = buffer.writeu16 
-local writeu32 = buffer.writeu32 
-local writei8 = buffer.writei8 
-local writei16 = buffer.writei16 
-local writei32 = buffer.writei32 
-local writef32 = buffer.writef32 
-local writef64 = buffer.writef64 
-local writestring = buffer.writestring 
-local readu8 = buffer.readu8 
-local readu16 = buffer.readu16 
-local readu32 = buffer.readu32 
-local readi8 = buffer.readi8 
-local readi16 = buffer.readi16 
-local readi32 = buffer.readi32 
-local readf32 = buffer.readf32 
-local readf64 = buffer.readf64 
-local readstring = buffer.readstring
-local bufferCopy = buffer.copy
-local stringLen = string.len
-local stringSub = string.sub
-local mathFrexp = math.frexp 
-local mathFloor = math.floor 
-local mathHuge = math.huge 
-
-local tablePool = table.create(TBL_POOL_SIZE)
-
-for i = 1, TBL_POOL_SIZE do
-	tablePool[i] = {}
-end
-
-@native local function getTable(): {any}
-	local poolIdx = #tablePool
-	local tbl = tablePool[poolIdx]
-	tablePool[poolIdx] = nil
-	return tbl or {}
-end
-
-@native local function recycleTable(tbl: {any})
-	local poolIdx = #tablePool
-	if poolIdx > TBL_POOL_SIZE then
-		return
-	end
-	table.clear(tbl)
-	tablePool[poolIdx + 1] = tbl
-end
-
-@native local function isArray(tbl: {any}): boolean
-	local count = 1
-	for i, val in tbl do
-		if i ~= count then
-			return false
-		end
-		count += 1
-	end
-	return true
-end
-
-@native local function getDataType(value: any): number?
-	local generalType = typeof(value)
-	local dataType = DYNAMIC_DEFAULTS[generalType] or Enums.Nil
-
-	if generalType == "table" then
-		if isArray(value) then
-			dataType = Enums.ArrayDynamic
-		end
-	end
-	return dataType
-end
-
-@native local function encodeFloat16(value: number): number
-	if value == 0 then
-		return value
-	end
-	local sign = 0
-	if value < 0 then
-		sign = 1
-		value = -value
-	end
-
-	local mantissa, exponent = mathFrexp(value)
-	local expNum = exponent + 14
-	if expNum <= 0 then
-		return 0
-	elseif expNum >= 31 then
-		return sign * 32768 + 31744
-	end
-	local mant = mantissa * 2048 - 1024
-	mant = mathFloor(mant + .5)
-	return sign * 32768 + expNum * 1024 + mant
-end
-
-@native local function decodeFloat16(value: number): number
-	if value == 0 then
-		return 0
-	end
-
-	local sign = (value >= 0x8000) and -1 or 1
-	if sign == -1 then
-		value -= 0x8000
-	end
-
-	local exponent = mathFloor(value / 1024)
-	local mantissa = value - exponent * 1024
-
-	if exponent == 0 then
-		return 0
-	elseif exponent == 31 then
-		return sign * mathHuge
-	end
-
-	local normalized = 1 + mantissa / 1024
-	return sign * normalized * 2^(exponent - 15)
-end
-
---number
-@native local function encodeNumberU8(buff: buffer, offset: number, arg: SchemaArg, value: number): number
-	writeu8(buff, offset, value)
-	return 1
-end
-
-@native local function encodeNumberU16(buff: buffer, offset: number, arg: SchemaArg, value: number): number
-	writeu16(buff, offset, value)
-	return 2
-end
-
-@native local function encodeNumberU32(buff: buffer, offset: number, arg: SchemaArg, value: number): number
-	writeu32(buff, offset, value)
-	return 4
-end
-
-@native local function encodeNumberI8(buff: buffer, offset: number, arg: SchemaArg, value: number): number
-	writei8(buff, offset, value)
-	return 1
-end
-
-@native local function encodeNumberI16(buff: buffer, offset: number, arg: SchemaArg, value: number): number
-	writei16(buff, offset, value)
-	return 2
-end
-
-@native local function encodeNumberI32(buff: buffer, offset: number, arg: SchemaArg, value: number): number
-	writei32(buff, offset, value)
-	return 4
-end
-
-@native local function encodeNumberF16(buff: buffer, offset: number, arg: SchemaArg, value: number): number
-	writeu16(buff, offset, encodeFloat16(value))
-	return 2	
-end
-
-@native local function encodeNumberF32(buff: buffer, offset: number, arg: SchemaArg, value: number): number
-	writef32(buff, offset, value)
-	return 4
-end
-
-@native local function encodeNumberF64(buff: buffer, offset: number, arg: SchemaArg, value: number): number
-	writef64(buff, offset, value)
-	return 8
-end
-
-@native local function decodeNumberU8(buff: buffer, offset: number, arg: SchemaArg): (number, number)
-	return readu8(buff, offset), 1
-end
-
-@native local function decodeNumberU16(buff: buffer, offset: number, arg: SchemaArg): (number, number)
-	return readu16(buff, offset), 2
-end
-
-@native local function decodeNumberU32(buff: buffer, offset: number, arg: SchemaArg): (number, number)
-	return readu32(buff, offset), 4
-end
-
-@native local function decodeNumberI8(buff: buffer, offset: number, arg: SchemaArg): (number, number)
-	return readi8(buff, offset), 1
-end
-
-@native local function decodeNumberI16(buff: buffer, offset: number, arg: SchemaArg): (number, number)
-	return readi16(buff, offset), 2
-end
-
-@native local function decodeNumberI32(buff: buffer, offset: number, arg: SchemaArg): (number, number)
-	return readi32(buff, offset), 4
-end
-
-@native local function decodeNumberF16(buff: buffer, offset: number, arg: SchemaArg): (number, number)
-	return decodeFloat16(readu16(buff, offset)), 2
-end
-
-@native local function decodeNumberF32(buff: buffer, offset: number, arg: SchemaArg): (number, number)
-	return readf32(buff, offset), 4
-end
-
-@native local function decodeNumberF64(buff: buffer, offset: number, arg: SchemaArg): (number, number)
-	return readf64(buff, offset), 8
-end
-
---cframe
-@native local function encodeCFrameFX8(buff: buffer, offset: number, arg: SchemaArg, value: CFrame): number
-	local pos = value.Position
-	local x, y, z = value:ToEulerAnglesXYZ()
-	writei8(buff, offset, pos.X * FX8_SCALE)
-	writei8(buff, offset + 1, pos.Y * FX8_SCALE)
-	writei8(buff, offset + 2, pos.Z * FX8_SCALE)
-	writei8(buff, offset + 3, x * FX8_ROT_SCALE)
-	writei8(buff, offset + 4, y * FX8_ROT_SCALE)
-	writei8(buff, offset + 5, z * FX8_ROT_SCALE)
-	return 6
-end
-
-@native local function encodeCFrameI16FX16(buff: buffer, offset: number, arg: SchemaArg, value: CFrame): number
-	local pos = value.Position
-	local x, y, z = value:ToEulerAnglesXYZ()
-	writei16(buff, offset, pos.X)
-	writei16(buff, offset + 2, pos.Y)
-	writei16(buff, offset + 4, pos.Z)
-	writei16(buff, offset + 6, x * FX16_ROT_SCALE)
-	writei16(buff, offset + 8, y * FX16_ROT_SCALE)
-	writei16(buff, offset + 10, z * FX16_ROT_SCALE)
-	return 12
-end
-
-@native local function decodeCFrameI16FX16(buff: buffer, offset: number, arg: SchemaArg): (CFrame, number)
-	local pos = Vector3.new(
-		readi16(buff, offset),
-		readi16(buff, offset + 2),
-		readi16(buff, offset + 4)
-	)
-	local x = readi16(buff, offset + 6) / FX16_ROT_SCALE
-	local y = readi16(buff, offset + 8) / FX16_ROT_SCALE
-	local z = readi16(buff, offset + 10) / FX16_ROT_SCALE
-	return CFrame.Angles(x, y, z) + pos, 12
-end
-
-@native local function encodeCFrameFX16(buff: buffer, offset: number, arg: SchemaArg, value: CFrame): number
-	local pos = value.Position
-	local x, y, z = value:ToEulerAnglesXYZ()
-	writei16(buff, offset, pos.X * FX16_SCALE)
-	writei16(buff, offset + 2, pos.Y * FX16_SCALE)
-	writei16(buff, offset + 4, pos.Z * FX16_SCALE)
-	writei16(buff, offset + 6, x * FX16_ROT_SCALE)
-	writei16(buff, offset + 8, y * FX16_ROT_SCALE)
-	writei16(buff, offset + 10, z * FX16_ROT_SCALE)
-	return 12
-end
-
-@native local function encodeCFrameF16(buff: buffer, offset: number, arg: SchemaArg, value: CFrame): number
-	local pos = value.Position
-	local x, y, z = value:ToEulerAnglesXYZ()
-	writeu16(buff, offset, encodeFloat16(pos.X))
-	writeu16(buff, offset + 2, encodeFloat16(pos.Y))
-	writeu16(buff, offset + 4, encodeFloat16(pos.Z))
-	writeu16(buff, offset + 6, encodeFloat16(x))
-	writeu16(buff, offset + 8, encodeFloat16(y))
-	writeu16(buff, offset + 10, encodeFloat16(z))
-	return 12
-end
-
-@native local function axisId(x: number, y: number, z: number): number
-	local ax = math.abs(x)
-	local ay = math.abs(y)
-	local az = math.abs(z)
-
-	if ax >= ay and ax >= az then
-		return x > 0 and 0 or 1
-	elseif ay >= az then
-		return y > 0 and 2 or 3
-	else
-		return z > 0 and 4 or 5
-	end
-end
-
-local xAxis = Vector3.new(1, 0, 0)
-local yAxis = Vector3.new(0, 1, 0)
-local zAxis = Vector3.new(0, 0, 1)
-
-local alignIdsToCFrames = {
-	[0] = CFrame.identity,
-	[1] = CFrame.identity,
-	[2] = CFrame.fromMatrix(Vector3.zero, xAxis, yAxis),
-	[3] = CFrame.fromMatrix(Vector3.zero, xAxis, -yAxis),
-	[4] = CFrame.fromMatrix(Vector3.zero, xAxis, zAxis),
-	[5] = CFrame.fromMatrix(Vector3.zero, xAxis, -zAxis),
-	
-	[6] = CFrame.identity,
-	[7] = CFrame.identity,
-	[8] = CFrame.fromMatrix(Vector3.zero, -xAxis, yAxis),
-	[9] = CFrame.fromMatrix(Vector3.zero, -xAxis, -yAxis),
-	[10] = CFrame.fromMatrix(Vector3.zero, -xAxis, zAxis),
-	[11] = CFrame.fromMatrix(Vector3.zero, -xAxis, -zAxis),
-	
-	[12] = CFrame.fromMatrix(Vector3.zero, yAxis, xAxis),
-	[13] = CFrame.fromMatrix(Vector3.zero, yAxis, -xAxis),
-	[14] = CFrame.identity,
-	[15] = CFrame.identity,
-	[16] = CFrame.fromMatrix(Vector3.zero, yAxis, zAxis),
-	[17] = CFrame.fromMatrix(Vector3.zero, yAxis, -zAxis),
-	
-	[18] = CFrame.fromMatrix(Vector3.zero, -yAxis, xAxis),
-	[19] = CFrame.fromMatrix(Vector3.zero, -yAxis, -xAxis),
-	[20] = CFrame.identity,
-	[21] = CFrame.identity,
-	[22] = CFrame.fromMatrix(Vector3.zero, -yAxis, zAxis),
-	[23] = CFrame.fromMatrix(Vector3.zero, -yAxis, -zAxis),
-	
-	[24] = CFrame.fromMatrix(Vector3.zero, zAxis, xAxis),
-	[25] = CFrame.fromMatrix(Vector3.zero, zAxis, -xAxis),
-	[26] = CFrame.fromMatrix(Vector3.zero, zAxis, yAxis),
-	[27] = CFrame.fromMatrix(Vector3.zero, zAxis, -yAxis),
-	[28] = CFrame.identity,
-	[29] = CFrame.identity,
-	
-	[30] = CFrame.fromMatrix(Vector3.zero, -zAxis, xAxis),
-	[31] = CFrame.fromMatrix(Vector3.zero, -zAxis, -xAxis),
-	[32] = CFrame.fromMatrix(Vector3.zero, -zAxis, yAxis),
-	[33] = CFrame.fromMatrix(Vector3.zero, -zAxis, -yAxis),
-	[34] = CFrame.identity,
-	[35] = CFrame.identity,	
-}
-
-@native local function encodeCFrameF32Aligned(buff: buffer, offset: number, arg: SchemaArg, value: CFrame): number
-	local x, y, z,
-	r00, r01, r02,
-	r10, r11, r12,
-	r20, r21, r22 = value:GetComponents()
-	local right = axisId(r00, r10, r20)
-	local up = axisId(r01, r11, r21)
-	writef32(buff, offset, x)
-	writef32(buff, offset + 4, y)
-	writef32(buff, offset + 8, z)
-	writeu8(buff, offset + 12, right * 6 + up)
-	return 13
-end
-
-@native local function decodeCFrameF32Aligned(buff: buffer, offset: number, arg: SchemaArg): (CFrame, number)
-	local x = readf32(buff, offset)
-	local y = readf32(buff, offset + 4)
-	local z = readf32(buff, offset + 8)
-	local alignId = readu8(buff, offset + 12)
-	return alignIdsToCFrames[alignId] + Vector3.new(x, y, z), 13
-end
-
-@native local function encodeCFrameF32FX16(buff: buffer, offset: number, arg: SchemaArg, value: CFrame): number
-	local pos = value.Position
-	local x, y, z = value:ToEulerAnglesXYZ()
-	writef32(buff, offset, pos.X)
-	writef32(buff, offset + 4, pos.Y)
-	writef32(buff, offset + 8, pos.Z)
-	writei16(buff, offset + 12, x * FX16_ROT_SCALE)
-	writei16(buff, offset + 14, y * FX16_ROT_SCALE)
-	writei16(buff, offset + 16, z * FX16_ROT_SCALE)
-	return 18
-end
-
-@native local function encodeCFrameF32(buff: buffer, offset: number, arg: SchemaArg, value: CFrame): number
-	local pos = value.Position
-	local x, y, z = value:ToEulerAnglesXYZ()
-	writef32(buff, offset, pos.X)
-	writef32(buff, offset + 4, pos.Y)
-	writef32(buff, offset + 8, pos.Z)
-	writef32(buff, offset + 12, x)
-	writef32(buff, offset + 16, y)
-	writef32(buff, offset + 20, z)
-	return 24
-end
-
-@native local function decodeCFrameFX8(buff: buffer, offset: number, arg: SchemaArg): (CFrame, number)
-	local posX = readi8(buff, offset) / FX8_SCALE
-	local posY = readi8(buff, offset + 1) / FX8_SCALE
-	local posZ = readi8(buff, offset + 2) / FX8_SCALE
-	local x = readi8(buff, offset + 3) / FX8_ROT_SCALE
-	local y = readi8(buff, offset + 4) / FX8_ROT_SCALE
-	local z = readi8(buff, offset + 5) / FX8_ROT_SCALE
-	return CFrame.Angles(x, y, z) + Vector3.new(posX, posY, posZ), 6
-end
-
-@native local function decodeCFrameFX16(buff: buffer, offset: number, arg: SchemaArg): (CFrame, number)
-	local posX = readi16(buff, offset) / FX16_SCALE
-	local posY = readi16(buff, offset + 2) / FX16_SCALE
-	local posZ = readi16(buff, offset + 4) / FX16_SCALE
-	local x = readi16(buff, offset + 6) / FX16_ROT_SCALE
-	local y = readi16(buff, offset + 8) / FX16_ROT_SCALE
-	local z = readi16(buff, offset + 10) / FX16_ROT_SCALE
-	return CFrame.Angles(x, y, z) + Vector3.new(posX, posY, posZ), 12
-end
-
-@native local function decodeCFrameF16(buff: buffer, offset: number, arg: SchemaArg): (CFrame, number)
-	local posX = decodeFloat16(readu16(buff, offset))
-	local posY = decodeFloat16(readu16(buff, offset + 2))
-	local posZ = decodeFloat16(readu16(buff, offset + 4))
-	local x = decodeFloat16(readu16(buff, offset + 6))
-	local y = decodeFloat16(readu16(buff, offset + 8))
-	local z = decodeFloat16(readu16(buff, offset + 10))
-	return CFrame.Angles(x, y, z) + Vector3.new(posX, posY, posZ), 12
-end
-
-@native local function decodeCFrameF32FX16(buff: buffer, offset: number, arg: SchemaArg): (CFrame, number)
-	local posX = readf32(buff, offset)
-	local posY = readf32(buff, offset + 4)
-	local posZ = readf32(buff, offset + 8)
-	local x = readi16(buff, offset + 12) / FX16_ROT_SCALE
-	local y = readi16(buff, offset + 14) / FX16_ROT_SCALE
-	local z = readi16(buff, offset + 16) / FX16_ROT_SCALE
-	return CFrame.Angles(x, y, z) + Vector3.new(posX, posY, posZ), 18
-end
-
-@native local function decodeCFrameF32(buff: buffer, offset: number, arg: SchemaArg): (CFrame, number)
-	local posX = readf32(buff, offset)
-	local posY = readf32(buff, offset + 4)
-	local posZ = readf32(buff, offset + 8)
-	local x = readf32(buff, offset + 12)
-	local y = readf32(buff, offset + 16)
-	local z = readf32(buff, offset + 20)
-	return CFrame.Angles(x, y, z) + Vector3.new(posX, posY, posZ), 24
-end
-
---vector3
-@native local function encodeVector3FX8(buff: buffer, offset: number, arg: SchemaArg, value: Vector3): number
-	writei8(buff, offset, value.X * FX8_SCALE)
-	writei8(buff, offset + 1, value.Y * FX8_SCALE)
-	writei8(buff, offset + 2, value.Z * FX8_SCALE)
-	return 3
-end
-
-@native local function encodeVector3I16(buff: buffer, offset: number, arg: SchemaArg, value: Vector3): number
-	writei16(buff, offset, value.X)
-	writei16(buff, offset + 2, value.Y)
-	writei16(buff, offset + 4, value.Z)
-	return 6
-end
-
-@native local function decodeVector3I16(buff: buffer, offset: number, arg: SchemaArg): (Vector3, number)
-	return Vector3.new(
-		readi16(buff, offset),
-		readi16(buff, offset + 2),
-		readi16(buff, offset + 4)
-	), 6
-end
-
-@native local function encodeVector3FX16(buff: buffer, offset: number, arg: SchemaArg, value: Vector3): number
-	writei16(buff, offset, value.X * FX16_SCALE)
-	writei16(buff, offset + 2, value.Y * FX16_SCALE)
-	writei16(buff, offset + 4, value.Z * FX16_SCALE)
-	return 6
-end
-
-@native local function encodeVector3F16(buff: buffer, offset: number, arg: SchemaArg, value: Vector3): number	
-	writeu16(buff, offset, encodeFloat16(value.X))
-	writeu16(buff, offset + 2, encodeFloat16(value.Y))
-	writeu16(buff, offset + 4, encodeFloat16(value.Z))
-	return 6
-end
-
-@native local function encodeVector3F32(buff: buffer, offset: number, arg: SchemaArg, value: Vector3): number
-	writef32(buff, offset, value.X)
-	writef32(buff, offset + 4, value.Y)
-	writef32(buff, offset + 8, value.Z)
-	return 12
-end
-
-@native local function decodeVector3FX8(buff: buffer, offset: number, arg: SchemaArg): (Vector3, number)
-	local x = readi8(buff, offset) / FX8_SCALE
-	local y = readi8(buff, offset + 1) / FX8_SCALE
-	local z = readi8(buff, offset + 2) / FX8_SCALE
-	return Vector3.new(x, y, z), 3
-end
-
-@native local function decodeVector3FX16(buff: buffer, offset: number, arg: SchemaArg): (Vector3, number)
-	local x = readi16(buff, offset) / FX16_SCALE
-	local y = readi16(buff, offset + 2) / FX16_SCALE
-	local z = readi16(buff, offset + 4) / FX16_SCALE
-	return Vector3.new(x, y, z), 6
-end
-
-@native local function decodeVector3F16(buff: buffer, offset: number, arg: SchemaArg): (Vector3, number)
-	local x = decodeFloat16(readu16(buff, offset))
-	local y = decodeFloat16(readu16(buff, offset + 2))
-	local z = decodeFloat16(readu16(buff, offset + 4))
-	return Vector3.new(x, y, z), 6
-end
-
-@native local function decodeVector3F32(buff: buffer, offset: number, arg: SchemaArg): (Vector3, number)
-	return Vector3.new(
-		readf32(buff, offset),
-		readf32(buff, offset + 4),
-		readf32(buff, offset + 8)
-	), 12
-end
-
---vector2
-@native local function encodeVector2FX8(buff: buffer, offset: number, arg: SchemaArg, value: Vector2): number
-	writei8(buff, offset, value.X * FX8_SCALE)
-	writei8(buff, offset + 1, value.Y * FX8_SCALE)
-	return 2
-end
-
-@native local function encodeVector2I16(buff: buffer, offset: number, arg: SchemaArg, value: Vector2): number
-	writei16(buff, offset, value.X)
-	writei16(buff, offset + 2, value.Y)
-	return 4
-end
-
-@native local function decodeVector2I16(buff: buffer, offset: number, arg: SchemaArg): (Vector2, number)
-	return Vector2.new(readi16(buff, offset), readi16(buff, offset + 2)), 4
-end
-
-@native local function encodeVector2FX16(buff: buffer, offset: number, arg: SchemaArg, value: Vector2): number
-	writei16(buff, offset, value.X * FX16_SCALE)
-	writei16(buff, offset + 2, value.Y * FX16_SCALE)
-	return 4
-end
-
-@native local function encodeVector2F16(buff: buffer, offset: number, arg: SchemaArg, value: Vector2): number
-	writeu16(buff, offset, encodeFloat16(value.X))
-	writeu16(buff, offset + 2, encodeFloat16(value.Y))
-	return 4
-end
-
-@native local function encodeVector2F32(buff: buffer, offset: number, arg: SchemaArg, value: Vector2): number
-	writef32(buff, offset, value.X)
-	writef32(buff, offset + 4, value.Y)
-	return 8
-end
-
-@native local function decodeVector2FX8(buff: buffer, offset: number, arg: SchemaArg): (Vector2, number)
-	local x = readi8(buff, offset) / FX8_SCALE
-	local y = readi8(buff, offset + 1) / FX8_SCALE
-	return Vector2.new(x, y), 2
-end
-
-@native local function decodeVector2FX16(buff: buffer, offset: number, arg: SchemaArg): (Vector2, number)
-	local x = readi16(buff, offset) / FX16_SCALE
-	local y = readi16(buff, offset + 2) / FX16_SCALE
-	return Vector2.new(x, y), 4
-end
-
-@native local function decodeVector2F16(buff: buffer, offset: number, arg: SchemaArg): (Vector2, number)
-	local x = decodeFloat16(readu16(buff, offset))
-	local y = decodeFloat16(readu16(buff, offset + 2))
-	return Vector2.new(x, y), 4
-end
-
-@native local function decodeVector2F32(buff: buffer, offset: number, arg: SchemaArg): (Vector2, number)
-	local x = readf32(buff, offset)
-	local y = readf32(buff, offset + 4)
-	return Vector2.new(x, y), 8
-end
-
---misc
-@native local function encodeString(buff: buffer, offset: number, arg: SchemaArg, value: string): number
-	local bytes = stringLen(value)
-	writeu8(buff, offset, bytes)
-	writestring(buff, offset + 1, value, bytes)
-	return bytes + 1
-end
-
-@native local function decodeString(buff: buffer, offset: number, arg: SchemaArg): (string, number)
-	local bytes = readu8(buff, offset)
-	return readstring(buff, offset + 1, bytes), bytes + 1
-end
-
-@native local function encodeStringLong(buff: buffer, offset: number, arg: SchemaArg, value: string): number
-	local bytes = stringLen(value)
-	writeu32(buff, offset, bytes)
-	writestring(buff, offset + 4, value, bytes)
-	return bytes + 4
-end
-
-@native local function decodeStringLong(buff: buffer, offset: number, arg: SchemaArg, value: string): (string, number)
-	local bytes = readu32(buff, offset)
-	return readstring(buff, offset + 4, bytes), bytes + 4
-end
-
-@native local function encodeColor(buff: buffer, offset: number, arg: SchemaArg, value: Color3): number
-	writeu8(buff, offset, value.R * 255 + .5)
-	writeu8(buff, offset + 1, value.G * 255 + .5)
-	writeu8(buff, offset + 2, value.B * 255 + .5)
-	return 3
-end
-
-@native local function decodeColor(buff: buffer, offset: number, arg: SchemaArg): (Color3, number)
-	local r = readu8(buff, offset)
-	local g = readu8(buff, offset + 1)
-	local b = readu8(buff, offset + 2)
-	return Color3.fromRGB(r, g, b), 3
-end
-
-@native local function encodeBrickColor(buff: buffer, offset: number, arg: SchemaArg, value: BrickColor): number
-	writeu16(buff, offset, value.Number)
-	return 2
-end
-
-@native local function decodeBrickColor(buff: buffer, offset: number, arg: SchemaArg): (BrickColor, number)
-	return BrickColor.new(readu16(buff, offset)), 2
-end
-
-@native local function encodeBool(buff: buffer, offset: number, arg: SchemaArg, value: boolean): number
-	writeu8(buff, offset, value and 1 or 0)
-	return 1
-end
-
-@native local function decodeBool(buff: buffer, offset: number, arg: SchemaArg): (boolean, number)
-	local val = readu8(buff, offset)
-	return val == 1, 1
-end
-
-@native local function encodeNil(buff: buffer, offset: number, arg: SchemaArg, value: any): number
-	return 0
-end
-
-@native local function decodeNil(buff: buffer, offset: number, arg: SchemaArg): (any, number)
-	return nil, 0
-end
-
-@native local function encodeBuffer(buff: buffer, offset: number, arg: SchemaArg, value: buffer): number
-	local len = buffer.len(value)
-	writeu16(buff, offset, len)
-	bufferCopy(buff, offset + 2, value, 0, len)
-	return len + 2
-end
-
-@native local function decodeBuffer(buff: buffer, offset: number, arg: SchemaArg): (buffer?, number)
-	local len = readu16(buff, offset)
-	local newBuff = buffer.create(len)
-	bufferCopy(newBuff, 0, buff, offset + 2, len)
-	return newBuff, len + 2
-end
-
-@native local function encodeDateTime32(buff: buffer, offset: number, arg: SchemaArg, value: DateTime): number
-	writeu32(buff, offset, value.UnixTimestamp)
-	return 4
-end
-
-@native local function decodeDateTime32(buff: buffer, offset: number, arg: SchemaArg): (DateTime, number)
-	return DateTime.fromUnixTimestamp(readu32(buff, offset)), 4
-end
-
-@native local function encodeDateTime64(buff: buffer, offset: number, arg: SchemaArg, value: DateTime): number
-	writef64(buff, offset, value.UnixTimestampMillis)
-	return 8
-end
-
-@native local function decodeDateTime64(buff: buffer, offset: number, arg: SchemaArg): (DateTime, number)
-	return DateTime.fromUnixTimestampMillis(readf64(buff, offset)), 8
-end
-
-local tweenStyles = {
-	Enum.EasingStyle.Linear,
-	Enum.EasingStyle.Back,
-	Enum.EasingStyle.Quad,
-	Enum.EasingStyle.Bounce,
-	Enum.EasingStyle.Sine,
-	Enum.EasingStyle.Cubic,
-	Enum.EasingStyle.Quart,
-	Enum.EasingStyle.Quint,
-	Enum.EasingStyle.Elastic,
-	Enum.EasingStyle.Circular,
-	Enum.EasingStyle.Exponential,	
-}
-
-local tweenDirections = {
-	Enum.EasingDirection.In,
-	Enum.EasingDirection.Out,
-	Enum.EasingDirection.InOut,
-}
-
-local function keyValueSwap(tbl: {[any]: any}): {[any]: any}
-	local new = {}
-	for k, v in tbl do
-		new[v] = k
-	end
-	return new
-end
-
-local tweenStylesToId: {[EnumItem]: number} = keyValueSwap(tweenStyles)
-local tweenDirectionsToId: {[EnumItem]: number} = keyValueSwap(tweenDirections)
-
-@native local function encodeTweenInfo(buff: buffer, offset: number, arg: SchemaArg, value: TweenInfo): number
-	local style = tweenStylesToId[value.EasingStyle]
-	local dir = tweenDirectionsToId[value.EasingDirection]
-	local reverse = value.Reverses and 1 or 0
-	local packed = style + dir * 16 + reverse * 128
-	
-	writeu16(buff, offset, value.Time * FX16_SCALE)
-	writeu8(buff, offset + 2, packed)
-	writei8(buff, offset + 3, value.RepeatCount)
-	writeu16(buff, offset + 4, value.DelayTime * FX16_SCALE)
-	return 6
-end
-
-@native local function decodeTweenInfo(buff: buffer, offset: number, arg: SchemaArg): (TweenInfo, number)
-	local tweenTime = readu16(buff, offset) / FX16_SCALE
-	local packed = readu8(buff, offset + 2)
-	local repeatCount = readi8(buff, offset + 3)
-	local delayTime = readu16(buff, offset + 4) / FX16_SCALE
-	
-	local styleId = packed % 16
-	local dirId = (packed // 16) % 8
-	local reverse = (packed // 128) == 1
-	
-	local tweenInfo = TweenInfo.new(
-		tweenTime, 
-		tweenStyles[styleId], 
-		tweenDirections[dirId], 
-		repeatCount,
-		reverse,
-		delayTime
-	)
-	return tweenInfo, 6
-end
-
-@native local function encodeColorSequence(buff: buffer, offset: number, arg: SchemaArg, value: ColorSequence)
-	:number
-	local keypoints = value.Keypoints
-	writeu8(buff, offset, #keypoints)
-	local ptr = offset + 1
-	
-	for _, kp in keypoints do
-		local color = kp.Value
-		writeu8(buff, ptr, kp.Time * 255 + .5)
-		writeu8(buff, ptr + 1, color.R * 255 + .5)
-		writeu8(buff, ptr + 2, color.G * 255 + .5)
-		writeu8(buff, ptr + 3, color.B * 255 + .5)
-		ptr += 4
-	end
-	
-	return ptr - offset
-end
-
-@native local function decodeColorSequence(buff: buffer, offset: number, arg: SchemaArg): (ColorSequence, number)
-	local len = readu8(buff, offset)
-	local ptr = offset + 1
-	local keypoints = table.create(len)
-	
-	for i = 1, len do
-		keypoints[i] = ColorSequenceKeypoint.new(
-			readu8(buff, ptr) / 255,
-			Color3.fromRGB(
-				readu8(buff, ptr + 1),
-				readu8(buff, ptr + 2),
-				readu8(buff, ptr + 3)
-			)
-		)
-		ptr += 4
-	end
-	return ColorSequence.new(keypoints), ptr - offset
-end
-
-@native local function encodeNumberSequence(buff: buffer, offset: number, arg: SchemaArg, value: NumberSequence)
-	:number
-	local keypoints = value.Keypoints
-	writeu8(buff, offset, #keypoints)
-	local ptr = offset + 1
-	
-	for _, kp in keypoints do
-		writeu8(buff, ptr, kp.Time * 255 + .5)
-		writeu8(buff, ptr + 1, kp.Value * 255 + .5)
-		writeu8(buff, ptr + 2, kp.Envelope * 255 + .5)
-		ptr += 3
-	end
-	return ptr - offset
-end
-
-@native local function decodeNumberSequence(buff: buffer, offset: number, arg: SchemaArg)
-	: (NumberSequence, number)
-	local len = readu8(buff, offset)
-	local ptr = offset + 1
-	local keypoints = table.create(len)
-	
-	for i = 1, len do
-		keypoints[i] = NumberSequenceKeypoint.new(
-			readu8(buff, ptr) / 255,
-			readu8(buff, ptr + 1) / 255,
-			readu8(buff, ptr + 2) / 255
-		)
-		ptr += 3
-	end
-	return NumberSequence.new(keypoints), ptr - offset
-end
-
-@native local function encodeNumberRange(buff: buffer, offset: number, arg: SchemaArg, value: NumberRange)
-	:number
-	writef32(buff, offset, value.Min)
-	writef32(buff, offset + 4, value.Max)
-	return 8
-end
-
-@native local function decodeNumberRange(buff: buffer, offset: number, arg: SchemaArg): (NumberRange, number)
-	return NumberRange.new(readf32(buff, offset), readf32(buff, offset + 4)), 8
-end
-
-@native local function encodeUDim(buff: buffer, offset: number, arg: SchemaArg, value: UDim): number
-	writei16(buff, offset, value.Scale * 1000)
-	writei16(buff, offset + 2, value.Offset)
-	return 4
-end
-
-@native local function decodeUDim(buff: buffer, offset: number, arg: SchemaArg): (UDim, number)
-	return UDim.new(readi16(buff, offset) / 1000, readi16(buff, offset + 2)), 4
-end
-
-@native local function encodeUDim2(buff: buffer, offset: number, arg: SchemaArg, value: UDim2): number
-	local x, y = value.X, value.Y
-	writei16(buff, offset, x.Scale * 1000)
-	writei16(buff, offset + 2, x.Offset)
-	writei16(buff, offset + 4, y.Scale * 1000)
-	writei16(buff, offset + 6, y.Offset)
-	return 8
-end
-
-@native local function decodeUDim2(buff: buffer, offset: number, arg: SchemaArg): (UDim2, number)
-	return UDim2.new(
-		readi16(buff, offset) / 1000,
-		readi16(buff, offset + 2),
-		readi16(buff, offset + 4) / 1000,
-		readi16(buff, offset + 6)
-		), 8
-end
-
-@native local function encodeRegion3(buff: buffer, offset: number, arg: SchemaArg, value: Region3): number
-	local halfSize = value.Size / 2
-	local pos = value.CFrame.Position
-	local min, max = pos - halfSize, pos + halfSize
-	writef32(buff, offset, min.X)
-	writef32(buff, offset + 4, min.Y)
-	writef32(buff, offset + 8, min.Z)
-	writef32(buff, offset + 12, max.X)
-	writef32(buff, offset + 16, max.Y)
-	writef32(buff, offset + 20, max.Z)
-	return 24
-end
-
-@native local function decodeRegion3(buff: buffer, offset: number, arg: SchemaArg): (Region3, number)
-	return Region3.new(
-		Vector3.new(
-			readf32(buff, offset),
-			readf32(buff, offset + 4),
-			readf32(buff, offset + 8)
-		),
-		Vector3.new(
-			readf32(buff, offset + 12),
-			readf32(buff, offset + 16),
-			readf32(buff, offset + 20)
-		)
-	), 24
-end
-
-@native local function encodePhysicalProperties(buff: buffer, offset: number, arg: SchemaArg, value: PhysicalProperties)
-	:number
-	writeu16(buff, offset, value.Density * 655.35)
-	writeu8(buff, offset + 2, value.Friction * 127.5)
-	writeu8(buff, offset + 3, value.Elasticity * 255)
-	writeu16(buff, offset + 4, value.FrictionWeight * 655.35)
-	writeu16(buff, offset + 6, value.ElasticityWeight * 655.35)
-	writeu8(buff, offset + 8, value.AcousticAbsorption * 255)
-	return 9
-end
-
-@native local function decodePhysicalProperties(buff: buffer, offset: number, arg: SchemaArg)
-	:(PhysicalProperties, number)
-	return PhysicalProperties.new(
-		readu16(buff, offset) / 655.35,
-		readu8(buff, offset + 2) / 127.5,
-		readu8(buff, offset + 3) / 255,
-		readu16(buff, offset + 4) / 655.35,
-		readu16(buff, offset + 6) / 655.35,
-		readu8(buff, offset + 8) / 255
-	), 9
-end
-
-@native local function encodeRect(buff: buffer, offset: number, arg: SchemaArg, value: Rect): number
-	local min, max = value.Min, value.Max
-	writef32(buff, offset, min.X)
-	writef32(buff, offset + 4, min.Y)
-	writef32(buff, offset + 8, max.X)
-	writef32(buff, offset + 12, max.Y)
-	return 16
-end
-
-@native local function decodeRect(buff: buffer, offset: number, arg: SchemaArg): (Rect, number)
-	return Rect.new(
-		readf32(buff, offset),
-		readf32(buff, offset + 4),
-		readf32(buff, offset + 8),
-		readf32(buff, offset + 12)
-	), 16
-end
-
-@native local function encodeBulkNumberU4Array(buff: buffer, offset: number, array: {number}): number
-	local ptr = offset
-	local arrayLen = #array
-	local mod = arrayLen % 2
-	local iters = (arrayLen - mod) / 2
-	local nibPtr = 1
-
-	for i = 1, iters do
-		writeu8(buff, ptr, array[nibPtr] + array[nibPtr + 1] * 16)
-		ptr += 1
-		nibPtr += 2
-	end
-	
-	if mod ~= 0 then
-		writeu8(buff, ptr, array[arrayLen])
-	end
-	return ptr - offset
-end
-
-@native local function decodeBulkNumberU4Array(buff: buffer, offset: number, arrayLen: number, tbl: {any}?)
-	:({number}, number)
-	local ptr = offset
-	local array = tbl or table.create(arrayLen)
-	local mod = arrayLen % 2
-	local iters = (arrayLen - mod) / 2
-	local nibPtr = 1
-	
-	for i = 1, iters do
-		local b = readu8(buff, ptr)
-		local n2 = b // 16
-		local n1 = b - n2 * 16
-		array[nibPtr] = n1
-		array[nibPtr + 1] = n2
-		ptr += 1
-		nibPtr += 2	
-	end
-
-	if mod ~= 0 then
-		array[arrayLen] = readu8(buff, ptr)
-	end
-	return array, ptr - offset
-end
-
-@native local function encodeBulkNumberU8Array(buff: buffer, offset: number, array: {number}): number
-	local ptr = offset
-	for _, val in array do
-		writeu8(buff, ptr, val)
-		ptr += 1
-	end
-	return ptr - offset
-end
-
-@native local function decodeBulkNumberU8Array(buff: buffer, offset: number, arrayLen: number, tbl: {any}?)
-	: ({number}, number)
-	local ptr = offset
-	local array = tbl or table.create(arrayLen)
-	local mod = arrayLen % 4
-	local iters = (arrayLen - mod) / 4
-	local bytePtr = 1
-	
-	for i = 1, iters do
-		local b = readu32(buff, ptr)
-		local b1 = b // 256
-		local b2 = b1 // 256
-		local b3 = b2 // 256		
-		array[bytePtr] = b - b1 * 256
-		array[bytePtr + 1] = b1 - b2 * 256
-		array[bytePtr + 2] = b2 - b3 * 256
-		array[bytePtr + 3] = b3
-		ptr += 4
-		bytePtr += 4
-	end
-	
-	for i = arrayLen - mod + 1, arrayLen do
-		array[i] = readu8(buff, ptr)
-		ptr += 1
-	end
-	return array, ptr - offset
-end
-
-@native local function encodeBulkNumberI32Array(buff: buffer, offset: number, array: {number}): number
-	local ptr = offset
-	for _, val in array do
-		writei32(buff, ptr, val)
-		ptr += 4
-	end
-	return ptr - offset
-end
-
-@native local function decodeBulkNumberI32Array(buff: buffer, offset: number, arrayLen: number, tbl: {any}?)
-	: ({number}, number)
-	local ptr = offset
-	local array = tbl or table.create(arrayLen)
-	for i = 1, arrayLen do
-		array[i] = readi32(buff, ptr)
-		ptr += 4
-	end
-	return array, ptr - offset
-end
-
-@native local function encodeBulkNumberF32Array(buff: buffer, offset: number, array: {number}): number
-	local ptr = offset
-	for _, val in array do
-		writef32(buff, ptr, val)
-		ptr += 4
-	end
-	return ptr - offset
-end
-
-@native local function decodeBulkNumberF32Array(buff: buffer, offset: number, arrayLen: number, tbl: {any}?)
-	: ({number}, number)
-	local ptr = offset
-	local array = tbl or table.create(arrayLen)
-	for i = 1, arrayLen do
-		array[i] = readf32(buff, ptr)
-		ptr += 4
-	end
-	return array, ptr - offset
-end
-
-@native local function encodeBulkBoolArray(buff: buffer, offset: number, array: {boolean}): number
-	local ptr = offset
-	local arrayLen = #array
-	local mod = arrayLen % 8
-	local bitIters = (arrayLen - mod) / 8
-
-	local bitPtr = 1
-	for i = 1, bitIters do
-		writeu8(buff, ptr,
-				(array[bitPtr] and 1 or 0) +
-				(array[bitPtr + 1] and 2 or 0) + 
-				(array[bitPtr + 2] and 4 or 0) +
-				(array[bitPtr + 3] and 8 or 0) +
-				(array[bitPtr + 4] and 16 or 0) +
-				(array[bitPtr + 5] and 32 or 0) +
-				(array[bitPtr + 6] and 64 or 0) +
-				(array[bitPtr + 7] and 128 or 0)
-		)
-		bitPtr += 8
-		ptr += 1
-	end
-	
-	for i = arrayLen - mod + 1, arrayLen do
-		writeu8(buff, ptr, array[i] and 1 or 0)
-		ptr += 1
-	end
-	
-	return ptr - offset
-end
-
-local byteToBools = table.create(256)
-local function buildByteToBools()
-	for byte = 0, 255 do
-		local t = table.create(8)
-		local val = byte
-
-		for i = 1, 8 do
-			t[i] = (val % 2) == 1
-			val = val // 2
-		end
-		byteToBools[byte] = t
-	end
-end
-
-buildByteToBools()
-
-@native local function decodeBulkBoolArray(buff: buffer, offset: number, arrayLen: number, tbl: {any}?)
-	: ({boolean}, number)
-	local ptr = offset
-	local array = tbl or table.create(arrayLen)
-	local mod = arrayLen % 8
-	local bitIters = (arrayLen - mod) / 8
-	local bitPtr = 1
-
-	for i = 1, bitIters do
-		local byte = readu8(buff, ptr)
-		ptr += 1
-		
-		local bits = byteToBools[byte]
-		array[bitPtr]     = bits[1]
-		array[bitPtr + 1] = bits[2]
-		array[bitPtr + 2] = bits[3]
-		array[bitPtr + 3] = bits[4]
-		array[bitPtr + 4] = bits[5]
-		array[bitPtr + 5] = bits[6]
-		array[bitPtr + 6] = bits[7]
-		array[bitPtr + 7] = bits[8]
-		
-		bitPtr += 8
-	end
-	
-	for i = arrayLen - mod + 1, arrayLen do
-		array[i] = readu8(buff, ptr) == 1
-		ptr += 1
-	end
-	
-	return array, ptr - offset
-end
-
-@native local function encodeBulkStringArray(buff: buffer, offset: number, array: {string}): number
-	local totalLen = 0
-	local ptr = offset
-
-	for _, str in array do
-		local len = stringLen(str)
-		writeu8(buff, ptr, len)
-		ptr += 1
-		totalLen += len
-	end
-
-	local largeStr = table.concat(array)
-	writestring(buff, ptr, largeStr, totalLen)
-	return ptr + totalLen - offset
-end
-
-@native local function decodeBulkStringArray(buff: buffer, offset: number, arrayLen: number, tbl: {any}?)
-	: ({string}, number)
-	local ptr = offset
-	local lens = getTable()
-	local totalLen = 0
-	local array = tbl or table.create(arrayLen)
-	for i = 1, arrayLen do
-		local len = readu8(buff, ptr)
-		lens[i] = len
-		ptr += 1
-		totalLen += len
-	end
-	
-	local largeStr = readstring(buff, ptr, totalLen)
-	local largeStrPtr = 1
-	
-	for i, len in lens do
-		local start = largeStrPtr
-		largeStrPtr += len
-		array[i] = stringSub(largeStr, start, largeStrPtr - 1)
-	end	
-	recycleTable(lens)
-	return array, ptr + totalLen - offset
-end
-
-@native local function encodeBulkNumberU8DictStatic(buff: buffer, offset: number, dict: {[any]: number}, keysMap: {any})
-	: number
-	local ptr = offset
-	for _, key in keysMap do
-		writeu8(buff, ptr, dict[key])
-		ptr += 1
-	end
-	return ptr - offset
-end
-
-@native local function decodeBulkNumberU8DictStatic(buff: buffer, offset: number, keysMap: {any}, 
-	template: {[string | number]: any}): ({[any]: number}, number)
-	local ptr = offset
-	local dict = table.clone(template)
-	for _, key in keysMap do
-		dict[key] = readu8(buff, ptr)
-		ptr += 1
-	end
-	return dict, ptr - offset
-end
-
-@native local function encodeBulkNumberI32DictStatic(buff: buffer, offset: number, dict: {[any]: number}, keysMap: {any})
-	: number
-	local ptr = offset
-	for _, key in keysMap do
-		writei32(buff, ptr, dict[key])
-		ptr += 4
-	end
-	return ptr - offset
-end
-
-@native local function decodeBulkNumberI32DictStatic(buff: buffer, offset: number, keysMap: {any},
-	template: {[string | number]: any}): ({[any]: number}, number)
-	local ptr = offset
-	local dict = table.clone(template)
-	for _, key in keysMap do
-		dict[key] = readi32(buff, ptr)
-		ptr += 4
-	end
-	return dict, ptr - offset
-end
-
-@native local function encodeBulkNumberF32DictStatic(buff: buffer, offset: number, dict: {[any]: number}, keysMap: {any})
-	: number
-	local ptr = offset
-
-	for _, key in keysMap do
-		writef32(buff, ptr, dict[key])
-		ptr += 4
-	end
-	return ptr - offset
-end
-
-@native local function decodeBulkNumberF32DictStatic(buff: buffer, offset: number, keysMap: {any},
-	template: {[string | number]: any}): ({[any]: number}, number)
-	local ptr = offset
-	local dict = table.clone(template)
-	for _, key in keysMap do
-		dict[key] = readf32(buff, ptr)
-		ptr += 4
-	end
-	return dict, ptr - offset
-end
-
-@native local function encodeBulkBoolDictStatic(buff: buffer, offset: number, dict: {[any]: boolean}, keysMap: {any})
-	: number
-	local ptr = offset
-	for _, key in keysMap do
-		writeu8(buff, ptr, dict[key] and 1 or 0)
-		ptr += 1
-	end
-	return ptr - offset
-end
-
-@native local function decodeBulkBoolDictStatic(buff: buffer, offset: number, keysMap: {any},
-	template: {[string | number]: any}): ({[any]: boolean}, number)
-	local ptr = offset
-	local dict = table.clone(template)
-	for _, key in keysMap do
-		dict[key] = readu8(buff, ptr) == 1
-		ptr += 1
-	end
-	return dict, ptr - offset
-end
-
-@native local function encodeBulkStringDictStatic(buff: buffer, offset: number, dict: {[any]: string}, keysMap: {any})
-	: number
-	local ptr = offset
-	local str = getTable()
-	
-	for i, key in keysMap do
-		local val = dict[key]
-		local strLen = stringLen(val)
-		writeu8(buff, ptr, strLen)
-		ptr += 1
-		str[i] = val
-	end
-	
-	local largeStr = table.concat(str)
-	local totalStrLen = stringLen(largeStr)
-	writestring(buff, ptr, largeStr, totalStrLen)
-	ptr += totalStrLen
-	recycleTable(str)
-	return ptr - offset
-end
-
-@native local function decodeBulkStringDictStatic(buff: buffer, offset: number, keysMap: {any},
-	template: {[string | number]: any}): ({[any]: string}, number)
-	local ptr = offset
-	local dictLen = #keysMap
-	local strPtr = 1
-	local totalLen = 0
-	local dict = table.clone(template)
-	local lens = getTable()
-	
-	for i = 1, dictLen do
-		local len = readu8(buff, ptr)
-		lens[i] = len
-		totalLen += len
-		ptr += 1
-	end
-	
-	local largeStr = readstring(buff, offset + dictLen, totalLen)
-	for i, key in keysMap do
-		local start = strPtr
-		strPtr += lens[i]
-		dict[key] = stringSub(largeStr, start, strPtr - 1)
-	end
-	recycleTable(lens)
-	return dict, strPtr - offset
-end
-
-@native local function encodeBulkNumberU8Dict(buff: buffer, offset: number, dict: {[any]: number}, keys: boolean?)
-	: (number, number?)
-	local ptr = offset
-	local len
-	
-	if keys then
-		for key, val in dict do
-			writeu8(buff, ptr, key)
-			ptr += 1
-		end
-		len = ptr - offset
-	else
-		for key, val in dict do
-			writeu8(buff, ptr, val)
-			ptr += 1
-		end
-	end
-	return ptr - offset, len
-end
-
-@native local function encodeBulkNumberI32Dict(buff: buffer, offset: number, dict: {[any]: number}, keys: boolean?)
-	: (number, number?)
-	local ptr = offset
-	local len
-
-	if keys then
-		for key, val in dict do
-			writei32(buff, ptr, key)
-			ptr += 4
-		end
-		len = ptr - offset
-	else
-		for key, val in dict do
-			writei32(buff, ptr, val)
-			ptr += 4
-		end
-	end
-	return ptr - offset, len
-end
-
-@native local function encodeBulkNumberF32Dict(buff: buffer, offset: number, dict: {[any]: number}, keys: boolean)
-	: (number, number?)
-	local ptr = offset
-	local len
-	
-	if keys then
-		for key, val in dict do
-			writef32(buff, ptr, key)
-			ptr += 4
-		end
-		len = (ptr - offset) / 4
-	else
-		for key, val in dict do
-			writef32(buff, ptr, val)
-			ptr += 4
-		end
-	end
-	return ptr - offset, len
-end
-
-@native local function encodeBulkBoolDict(buff: buffer, offset: number, dict: {[any]: boolean}, keys: boolean?)
-	: (number, number?)
-	local ptr = offset
-	local len
-	
-	if keys then
-		for key, val in dict do
-			writeu8(buff, ptr, key and 1 or 0)
-			ptr += 1
-		end
-		len = ptr - offset
-	else
-		for key, val in dict do
-			writeu8(buff, ptr, val and 1 or 0)
-			ptr += 1
-		end
-	end
-	return ptr - offset, len
-end
-
-@native local function encodeBulkStringDict(buff: buffer, offset: number, dict: {[any]: string}, keys: boolean?)
-	: (number, number?)
-	local ptr = offset
-	local str = getTable()
-	
-	local len
-	if keys then
-		len = 0
-		for key, val in dict do
-			local strLen = stringLen(key)
-			writeu8(buff, ptr, strLen)
-			ptr += 1
-			len += 1
-			str[len] = key
-		end
-	else
-		local count = 0
-		for key, val in dict do
-			local strLen = stringLen(val)
-			writeu8(buff, ptr, strLen)
-			ptr += 1
-			count += 1
-			str[count] = val
-		end
-	end	
-	local largeStr = table.concat(str)
-	local totalStrLen = stringLen(largeStr)
-	writestring(buff, ptr, largeStr, totalStrLen)
-	ptr += totalStrLen
-	recycleTable(str)
-	return ptr - offset, len
-end
-
-local enumItems: {EnumItem} = {}
-local enumItemsByEnum: {[EnumItem]: number} = {}
-local encodeData: {[number]: (buffer, number, any, any?, any?) -> number}
-local decodeData: {[number]: (buffer, number, any?, any?) -> (any, number)}
-
-@native local function encodeEnumItem(buff: buffer, offset: number, arg: SchemaArg, value: EnumItem): number
-	writeu16(buff, offset, enumItemsByEnum[value] or 0)
-	return 2
-end
-
-@native local function decodeEnumItem(buff: buffer, offset: number, arg: SchemaArg): (EnumItem?, number)
-	local idx = readu16(buff, offset)
-	return enumItems[idx], 2
-end
-
-@native local function encodeInstance(buff: buffer, offset: number, arg: SchemaArg, value: Instance, inst: {Instance})
-	: number
-	inst[#inst + 1] = value
-	return 0
-end
-
-@native local function decodeInstance(buff: buffer, offset: number, arg: SchemaArg, inst: {Instance})
-	: (Instance, number)
-	local ptrIdx = #inst
-	local ptr = inst[ptrIdx]
-	inst[ptrIdx] += 1
-	return inst[ptr], 0
-end
-
-@native local function encodePlayer(buff: buffer, offset: number, arg: SchemaArg, value: Player): number
-	writef64(buff, offset, value.UserId or 0)
-	return 8
-end
-
-@native local function decodePlayer(buff: buffer, offset: number, arg: SchemaArg): (Player?, number)
-	local player = Players:GetPlayerByUserId(readf64(buff, offset))
-	return player, 8	
-end
-
-@native local function encodeAny(buff: buffer, offset: number, arg: SchemaArg, value: any, inst: {Instance}): number
-	local dataType = getDataType(value)
-	writeu8(buff, offset, dataType)
-	local bytes = 1
-	local encode = encodeData[dataType] :: ((buffer, number, SchemaArg, any, {Instance}?) -> number)?
-	bytes += encode(buff, offset + bytes, arg, value, inst)
-	return bytes
-end
-
-@native local function decodeAny(buff: buffer, offset: number, arg: SchemaArg, inst: {Instance}?): (any, number)
-	local dataType = readu8(buff, offset)
-	local bytes = 1
-	local decode = decodeData[dataType] :: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-	if not decode then
-		return nil, 1
-	end
-	local val, b = decode(buff, offset + bytes, arg, inst)
-	return val, bytes + b
-end
-
-@native local function encodeOptional(buff: buffer, offset: number, arg: SchemaArg, value: any, inst: {Instance}?)
-	: number
-	local isNil = value == nil
-	local tag = isNil and 0 or 1
-	writeu8(buff, offset, tag)
-	if isNil then
-		return 1
-	end
-	
-	local valArg = arg[2]
-	local encode = encodeData[valArg] or encodeData[valArg[1]] :: (buffer, number, SchemaArg, any, {Instance}?) -> number
-	local bytes = encode(buff, offset + 1, valArg, value, inst)
-	return bytes + 1
-end
-
-@native local function decodeOptional(buff: buffer, offset: number, arg: SchemaArg, inst: {Instance}?)
-	: (any, number)
-	local isNil = readu8(buff, offset) == 0
-	if isNil then return nil, 1 end
-	
-	local valArg = arg[2]
-	local decode = decodeData[valArg] or decodeData[valArg[1]] :: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-	local val, b = decode(buff, offset + 1, valArg, inst)
-	return val, b + 1
-end
-
-@native local function encodeUnion(buff: buffer, offset: number, arg: SchemaArg, value: any, inst: {Instance}?)
-	: number
-	local dt = typeof(value)
-	local valArg = arg[dt]
-	local tag = dt ~= "table" and valArg or valArg[1]
-	writeu8(buff, offset, tag)
-	
-	local encode = encodeData[tag] :: (buffer, number, SchemaArg, any, {Instance}?) -> number
-	local bytes = encode(buff, offset + 1, valArg, value, inst)
-	return bytes + 1
-end
-
-@native local function decodeUnion(buff: buffer, offset: number, arg: SchemaArg, inst: {Instance}?): (any, number)
-	local tag = readu8(buff, offset)
-	local valArg = arg[tag]
-	local decode = decodeData[tag] :: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-	local val, b = decode(buff, offset + 1, valArg, inst)
-	return val, b + 1
-end
-
-@native local function encodeLiteral(buff: buffer, offset: number, arg: SchemaArg, value: Literal)
-	:number
-	local reverseMap = arg[3]
-	writeu8(buff, offset, reverseMap[value])
-	return 1
-end
-
-@native local function decodeLiteral(buff: buffer, offset: number, arg: SchemaArg): (Literal, number)
-	local map = arg[2]
-	return map[readu8(buff, offset)], 1
-end
-
-@native local function encodeArrayStatic(buff: buffer, offset: number, schema: SchemaArg, array: {any}, inst: {Instance})
-	: number
-	local ptr = offset
-	local fastPath = schema[3]
-	
-	if fastPath then
-		ptr += encodeData[fastPath](buff, ptr, array)
-		return ptr - offset
-	end
-	
-	for idx, arg: SchemaArg in schema[2] do
-		local encode = encodeData[arg] or encodeData[arg[1]] 
-		:: (buffer, number, SchemaArg, any, {Instance}?) -> number
-		ptr += encode(buff, ptr, arg, array[idx], inst)
-	end
-	return ptr - offset
-end
-
-@native local function decodeArrayStatic(buff: buffer, offset: number, schema: {SchemaArg}, inst: {Instance}?)
-	: ({any}, number)
-	local ptr = offset
-	local data = schema[2]
-	local fastPath = schema[3]
-	
-	if fastPath then
-		local array, b = decodeData[fastPath](buff, ptr, #data)
-		return array, ptr + b - offset
-	end
-	
-	local array = {}
-	for i, arg: SchemaArg in data do
-		local decode = decodeData[arg] or decodeData[arg[1]] 
-		:: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-		local val, b = decode(buff, ptr, arg, inst)
-		ptr += b
-		array[i] = val
-	end
-	return array, ptr - offset
-end
-
-@native local function encodeArray(buff: buffer, offset: number, schema: SchemaArg, array: {any}, inst: {Instance})
-	: number
-	local len = #array
-	writeu16(buff, offset, len)
-	local ptr = offset + 2
-	
-	local fastPath = schema[3]
-	if fastPath then
-		ptr += encodeData[fastPath](buff, ptr, array)
-		return ptr - offset
-	end
-	
-	local arg = schema[2]
-	local encode = encodeData[arg] or encodeData[arg[1]] :: (buffer, number, SchemaArg, any, {Instance}?) -> number
-	for i, value in array do
-		ptr += encode(buff, ptr, arg, value, inst)
-	end
-	return ptr - offset
-end
-
-@native local function decodeArray(buff: buffer, offset: number, schema: SchemaArg, inst: {Instance}?): ({any}, number)
-	local len = readu16(buff, offset)
-	local ptr = offset + 2
-	
-	local fastPath = schema[3]
-	if fastPath then
-		local array, b = decodeData[fastPath](buff, ptr, len)
-		return array, ptr + b - offset
-	end
-	
-	local arg = schema[2]
-	local decode = decodeData[arg] or decodeData[arg[1]] 
-	:: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-	local array = table.create(len)
-
-	for i = 1, len do
-		local val, b = decode(buff, ptr, arg, inst)
-		ptr += b
-		array[i] = val
-	end
-	return array, ptr - offset
-end
-
-@native local function encodeArrayDynamic(buff: buffer, offset: number, schema: SchemaArg, array: {any}, inst: {Instance})
-	: number
-	local len = #array
-	writeu16(buff, offset, len)
-	local ptr = offset + 2
-
-	for i = 1, len do
-		local val = array[i]
-		local dataType = getDataType(val)
-		writeu8(buff, ptr, dataType)
-		ptr += 1
-		local encode = encodeData[dataType] :: (buffer, number, SchemaArg, any, {Instance}?) -> number
-		ptr += encode(buff, ptr, schema, val, inst)
-	end
-	return ptr - offset
-end
-
-@native local function decodeArrayDynamic(buff: buffer, offset: number, schema: SchemaArg, inst: {Instance}?)
-	: ({any}, number)
-	local len = readu16(buff, offset)
-	local ptr = offset + 2
-	local array = table.create(len)
-
-	for i = 1, len do
-		local dataType = readu8(buff, ptr)
-		ptr += 1
-		local decode = decodeData[dataType] or decodeData[Enums.Nil] 
-		:: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-		local val, b = decode(buff, ptr, schema, inst)
-		ptr += b
-		array[i] = val
-	end
-	return array, ptr - offset
-end
-
-@native local function encodeDictStatic(buff: buffer, offset: number, schema: SchemaArg, dict: {[string | number]: any},
-	inst: {Instance}): number
-	local ptr = offset
-	local data = schema[2]
-	local keysMap = schema[3]
-	local fastPath = schema[5]
-	
-	if fastPath then
-		ptr += encodeData[fastPath](buff, ptr, dict, keysMap)
-		return ptr - offset
-	end
-	
-	local idx = 0	
-	for i, key in keysMap do
-		idx += 1
-		local arg = data[idx]
-		local val = dict[key]
-		local encode = encodeData[arg] or encodeData[arg[1]] :: 
-		(buffer, number, SchemaArg, any, {Instance}?) -> number
-		ptr += encode(buff, ptr, arg, val, inst)
-	end
-	return ptr - offset
-end
-
-@native local function decodeDictStatic(buff: buffer, offset: number, schema: SchemaArg, inst: {Instance}?)
-	: ({[number | string]: any}, number)
-	local ptr = offset
-	local data = schema[2]
-	local keysMap = schema[3]
-	local template = schema[4]
-	local fastPath = schema[5]
-	
-	if fastPath then
-		local values, b = decodeData[fastPath](buff, ptr, keysMap, template)
-		ptr += b
-		return values, ptr - offset
-	end
-	
-	local dict = table.clone(template)	
-	for i, arg in data do
-		local decode = decodeData[arg] or decodeData[arg[1]] 
-		:: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-		local val, b = decode(buff, ptr, arg, inst)
-		ptr += b
-		local key = keysMap[i]
-		dict[key] = val
-	end
-	return dict, ptr - offset
-end
-
-@native local function encodeDict(buff: buffer, offset: number, schema: SchemaArg, dict: {[any]: any}, inst: {Instance})
-	: number
-	local len = 0
-	local ptr = offset + 2	
-	local keyFastPath = schema[4]
-	local valFastPath = schema[5]
-	
-	if keyFastPath then
-		local bytes
-		bytes, len = encodeData[keyFastPath](buff, ptr, dict, true)
-		ptr += bytes
-	else
-		local keyArg = schema[2]
-		local encodeKey = encodeData[keyArg] or encodeData[keyArg[1]] 
-		:: (buffer, number, SchemaArg, any, {Instance}?) -> number
-		for key, val in dict do
-			ptr += encodeKey(buff, ptr, keyArg, key, inst)
-			len += 1
-		end
-	end
-	
-	if valFastPath then
-		ptr += encodeData[valFastPath](buff, ptr, dict)
-	else
-		local valArg = schema[3]
-		local encodeVal = encodeData[valArg] or encodeData[valArg[1]] 
-		:: (buffer, number, SchemaArg, any, {Instance}?) -> number
-		for key, val in dict do
-			ptr += encodeVal(buff, ptr, valArg, val, inst)
-		end
-	end
-
-	writeu16(buff, offset, len)
-	return ptr - offset
-end
-
-local dictTempCache: {[number]: {[any]: any}} = {}
-
-@native local function decodeDict(buff: buffer, offset: number, schema: SchemaArg, inst: {Instance}?): ({[any]: any}, number)
-	local len = readu16(buff, offset)
-	local ptr = offset + 2	
-	local keyFastPath = schema[4]
-	local valFastPath = schema[5]	
-	local keys, vals = getTable(), getTable()
-	
-	if keyFastPath then
-		local bytes
-		keys, bytes = decodeData[keyFastPath](buff, ptr, len, keys)
-		ptr += bytes
-	else
-		local keyArg = schema[2]
-		local decodeKey = decodeData[keyArg] or decodeData[keyArg[1]] 
-		:: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-		for i = 1, len do
-			local key, b = decodeKey(buff, ptr, keyArg, inst)
-			ptr += b
-			keys[i] = key
-		end
-	end
-	
-	if valFastPath then
-		local bytes
-		vals, bytes = decodeData[valFastPath](buff, ptr, len, vals)
-		ptr += bytes
-	else
-		local valArg = schema[3]
-		local decodeVal = decodeData[valArg] or decodeData[valArg[1]] 
-		:: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-		for i = 1, len do
-			local val, b = decodeVal(buff, ptr, valArg, inst)
-			ptr += b
-			vals[i] = val
-		end
-	end
-	
-	local dictId = schema[6]
-	local template = dictTempCache[dictId]
-	local dict
-	if template then
-		table.clear(template)
-		dict = table.clone(template)
-	else
-		dict = {}
-	end
-
-	for i, key in keys do
-		dict[key] = vals[i]
-	end
-	recycleTable(keys)
-	recycleTable(vals)
-	if not template then
-		dictTempCache[dictId] = table.clone(dict)
-	end
-	return dict, ptr - offset
-end
-
-@native local function encodeDictDynamic(buff: buffer, offset: number, schema: SchemaArg, dict: {[any]: any},
-	inst: {Instance}): number
-	local startOffset = offset
-	local ptr = offset + 2
-	local idx = 0
-
-	for key, val in dict do
-		local keyType = getDataType(key)	
-		local encodeKey = encodeData[keyType] ::  (buffer, number, SchemaArg, any, {Instance}?) -> number
-		writeu8(buff, ptr, keyType)			
-		ptr += 1
-		ptr += encodeKey(buff, ptr, schema, key, inst)
-		
-		local valType = getDataType(val)
-		local encodeVal = encodeData[valType] :: (buffer, number, SchemaArg, any, {Instance}?) -> number
-		writeu8(buff, ptr, valType)
-		ptr += 1
-		ptr += encodeVal(buff, ptr, schema, val, inst)
-		idx += 1
-	end
-	writeu16(buff, offset, idx)
-	return ptr - offset
-end
-
-@native local function decodeDictDynamic(buff: buffer, offset: number, schema: SchemaArg, inst: {Instance}?)
-	: ({[any]: any}, number)
-	local len = readu16(buff, offset)
-	local ptr = offset + 2
-	local dict = {}
-
-	for i = 1, len do
-		local keyType = readu8(buff, ptr)
-		ptr += 1
-		local decodeKey = decodeData[keyType] or decodeData[Enums.Nil] 
-		:: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-		local key, b = decodeKey(buff, ptr, schema, inst)
-		ptr += b
-
-		local valType = readu8(buff, ptr)
-		ptr += 1
-		local decodeVal = decodeData[valType] or decodeData[Enums.Nil] 
-		:: (buffer, number, SchemaArg, {Instance}?) -> (any, number)
-		local val, b = decodeVal(buff, ptr, schema, inst)
-		ptr += b
-		dict[key] = val
-	end
-	return dict, ptr - offset
-end
-
-encodeData = {
-	[Enums.Start] = function() end,
-	[Enums.NumberU4] = encodeNumberU8,
-	[Enums.NumberU8] = encodeNumberU8,
-	[Enums.NumberU16] = encodeNumberU16,
-	[Enums.NumberU32] = encodeNumberU32,
-	[Enums.NumberI8] = encodeNumberI8,
-	[Enums.NumberI16] = encodeNumberI16,
-	[Enums.NumberI32] = encodeNumberI32,
-	[Enums.NumberF16] = encodeNumberF16,
-	[Enums.NumberF32] = encodeNumberF32,
-	[Enums.NumberF64] = encodeNumberF64,
-
-	[Enums.CFrameFX8] = encodeCFrameFX8,
-	[Enums.CFrameI16FX16] = encodeCFrameI16FX16,
-	[Enums.CFrameFX16] = encodeCFrameFX16,
-	[Enums.CFrameF16] = encodeCFrameF16,
-	[Enums.CFrameF32Aligned] = encodeCFrameF32Aligned,
-	[Enums.CFrameF32FX16] = encodeCFrameF32FX16,
-	[Enums.CFrameF32] = encodeCFrameF32,
-
-	[Enums.Vector3FX8] = encodeVector3FX8,
-	[Enums.Vector3I16] = encodeVector3I16,
-	[Enums.Vector3FX16] = encodeVector3FX16,
-	[Enums.Vector3F16] = encodeVector3F16,
-	[Enums.Vector3F32] = encodeVector3F32,
-
-	[Enums.Vector2FX8] = encodeVector2FX8,
-	[Enums.Vector2I16] = encodeVector2I16,
-	[Enums.Vector2FX16] = encodeVector2FX16,
-	[Enums.Vector2F16] = encodeVector2F16,
-	[Enums.Vector2F32] = encodeVector2F32,
-
-	[Enums.String] = encodeString,
-	[Enums.StringLong] = encodeStringLong,
-	[Enums.Color3] = encodeColor,
-	[Enums.BrickColor] = encodeBrickColor,
-	[Enums.Boolean] = encodeBool,
-	[Enums.Nil] = encodeNil,
-	[Enums.Buffer] = encodeBuffer,
-	[Enums.EnumItem] = encodeEnumItem,
-	[Enums.Instance] = encodeInstance,
-	[Enums.Player] = encodePlayer,
-	[Enums.DateTime32] = encodeDateTime32,
-	[Enums.DateTime64] = encodeDateTime64,
-	[Enums.TweenInfo] = encodeTweenInfo,
-	[Enums.ColorSequence] = encodeColorSequence,
-	[Enums.NumberSequence] = encodeNumberSequence,
-	[Enums.NumberRange] = encodeNumberRange,
-	[Enums.UDim] = encodeUDim,
-	[Enums.UDim2] = encodeUDim2,
-	[Enums.Region3] = encodeRegion3,
-	[Enums.PhysicalProperties] = encodePhysicalProperties,
-	[Enums.Rect] = encodeRect,
-
-	[Enums.Any] = encodeAny,
-	[Enums.Optional] = encodeOptional,
-	[Enums.Union] = encodeUnion,
-	[Enums.Literal] = encodeLiteral,
-	[Enums.ArrayStatic] = encodeArrayStatic,
-	[Enums.Array] = encodeArray,
-	[Enums.ArrayDynamic] = encodeArrayDynamic,
-	[Enums.DictStatic] = encodeDictStatic,
-	[Enums.Dict] = encodeDict,
-	[Enums.DictDynamic] = encodeDictDynamic,
-	
-	[Enums.FastNumberU4Array] = encodeBulkNumberU4Array,
-	[Enums.FastNumberU8Array] = encodeBulkNumberU8Array,
-	[Enums.FastNumberI32Array] = encodeBulkNumberI32Array,
-	[Enums.FastNumberF32Array] = encodeBulkNumberF32Array,
-	[Enums.FastBoolArray] = encodeBulkBoolArray,
-	[Enums.FastStringArray] = encodeBulkStringArray,
-	[Enums.FastNumberU8DictStatic] = encodeBulkNumberU8DictStatic,
-	[Enums.FastNumberI32DictStatic] = encodeBulkNumberI32DictStatic,
-	[Enums.FastNumberF32DictStatic] = encodeBulkNumberF32DictStatic,
-	[Enums.FastBoolDictStatic] = encodeBulkBoolDictStatic,
-	[Enums.FastStringDictStatic]= encodeBulkStringDictStatic,
-	[Enums.FastNumberU8Dict] = encodeBulkNumberU8Dict,
-	[Enums.FastNumberI32Dict] = encodeBulkNumberI32Dict,
-	[Enums.FastNumberF32Dict] = encodeBulkNumberF32Dict,
-	[Enums.FastBoolDict] = encodeBulkBoolDict,
-	[Enums.FastStringDict] = encodeBulkStringDict,
-}
-
-decodeData = {
-	[Enums.Start] = function() end,
-	[Enums.NumberU4] = decodeNumberU8,
-	[Enums.NumberU8] = decodeNumberU8,
-	[Enums.NumberU16] = decodeNumberU16,
-	[Enums.NumberU32] = decodeNumberU32,
-	[Enums.NumberI8] = decodeNumberI8,
-	[Enums.NumberI16] = decodeNumberI16,
-	[Enums.NumberI32] = decodeNumberI32,
-	[Enums.NumberF16] = decodeNumberF16,
-	[Enums.NumberF32] = decodeNumberF32,
-	[Enums.NumberF64] = decodeNumberF64,
-
-	[Enums.CFrameFX8] = decodeCFrameFX8,
-	[Enums.CFrameI16FX16] = decodeCFrameI16FX16,
-	[Enums.CFrameFX16] = decodeCFrameFX16,
-	[Enums.CFrameF16] = decodeCFrameF16,
-	[Enums.CFrameF32Aligned] = decodeCFrameF32Aligned,
-	[Enums.CFrameF32FX16] = decodeCFrameF32FX16,
-	[Enums.CFrameF32] = decodeCFrameF32,
-
-	[Enums.Vector3FX8] = decodeVector3FX8,
-	[Enums.Vector3I16] = decodeVector3I16,
-	[Enums.Vector3FX16] = decodeVector3FX16,
-	[Enums.Vector3F16] = decodeVector3F16,
-	[Enums.Vector3F32] = decodeVector3F32,
-
-	[Enums.Vector2FX8] = decodeVector2FX8,
-	[Enums.Vector2I16] = decodeVector2I16,
-	[Enums.Vector2FX16] = decodeVector2FX16,
-	[Enums.Vector2F16] = decodeVector2F16,
-	[Enums.Vector2F32] = decodeVector2F32,
-
-	[Enums.String] = decodeString,
-	[Enums.StringLong] = decodeStringLong,
-	[Enums.Color3] = decodeColor,
-	[Enums.BrickColor] = decodeBrickColor,
-	[Enums.Boolean] = decodeBool,
-	[Enums.Nil] = decodeNil,
-	[Enums.Buffer] = decodeBuffer,
-	[Enums.EnumItem] = decodeEnumItem,
-	[Enums.Instance] = decodeInstance,
-	[Enums.Player] = decodePlayer,
-	[Enums.DateTime32] = decodeDateTime32,
-	[Enums.DateTime64] = decodeDateTime64,
-	[Enums.TweenInfo] = decodeTweenInfo,
-	[Enums.ColorSequence] = decodeColorSequence,
-	[Enums.NumberSequence] = decodeNumberSequence,
-	[Enums.NumberRange] = decodeNumberRange,
-	[Enums.UDim] = decodeUDim,
-	[Enums.UDim2] = decodeUDim2,
-	[Enums.Region3] = decodeRegion3,
-	[Enums.PhysicalProperties] = decodePhysicalProperties,
-	[Enums.Rect] = decodeRect,
-
-	[Enums.Any] = decodeAny,
-	[Enums.Optional] = decodeOptional,
-	[Enums.Union] = decodeUnion,
-	[Enums.Literal] = decodeLiteral,
-	[Enums.ArrayStatic] = decodeArrayStatic,
-	[Enums.Array] = decodeArray,
-	[Enums.ArrayDynamic] = decodeArrayDynamic,
-	[Enums.DictStatic] = decodeDictStatic,
-	[Enums.Dict] = decodeDict,
-	[Enums.DictDynamic] = decodeDictDynamic,
-	
-	[Enums.FastNumberU4Array] = decodeBulkNumberU4Array,
-	[Enums.FastNumberU8Array] = decodeBulkNumberU8Array,
-	[Enums.FastNumberI32Array] = decodeBulkNumberI32Array,
-	[Enums.FastNumberF32Array] = decodeBulkNumberF32Array,
-	[Enums.FastBoolArray] = decodeBulkBoolArray,
-	[Enums.FastStringArray] = decodeBulkStringArray,
-	[Enums.FastNumberU8DictStatic] = decodeBulkNumberU8DictStatic,
-	[Enums.FastNumberI32DictStatic] = decodeBulkNumberI32DictStatic,
-	[Enums.FastNumberF32DictStatic] = decodeBulkNumberF32DictStatic,
-	[Enums.FastBoolDictStatic] = decodeBulkBoolDictStatic,
-	[Enums.FastStringDictStatic] = decodeBulkStringDictStatic,
-	[Enums.FastNumberU8Dict] = decodeBulkNumberU8Array,
-	[Enums.FastNumberI32Dict] = decodeBulkNumberI32Array,
-	[Enums.FastNumberF32Dict] = decodeBulkNumberF32Array,
-	[Enums.FastBoolDict] = decodeBulkBoolArray,
-	[Enums.FastStringDict] = decodeBulkStringArray,
-}
-
-local Serialize = {
-	encode = encodeData,
-	decode = decodeData,
-	enumItems = enumItems,
-	enumItemsByEnum = enumItemsByEnum,
-}
-
-
-return Serialize