Your community, in one place
350 executions
12,597 scripts
110 users
Save
Follow
Play
00Mobile
M
[FREE] Natural Disaster Survival | Fly, WalkSpeed, Jump Powe
MaxLegendsOwnerThe owner of BloxScripts.fun.Early CreatorPublish a script as one of the first 100 accounts.·Natural Disaster Survival
By Shakura · RscriptsScriptKeyless
BuilderX again REQUIRE
Natural Disaster SurvivalM Follow
MaxLegendsOwnerThe owner of BloxScripts.fun.Early CreatorPublish a script as one of the first 100 accounts.ContributorPublish your first script.
· 0 followersDesktop compatible
Description
please can you tell me this module script require
GAMENatural Disaster Survival
UPDATEDOct 10, 2026
ACCESSKeyless
PLATFORMDesktop
Script source Luau
-- [[ BloxScripts Risk Notice ]]
-- This script has not been verified by BloxScripts.fun. Deal with caution.
--
-- Stay safe:
-- • Never log in on unofficial Roblox sites or lookalike domains.
-- • Real Roblox links use roblox.com (check the .com ending).
-- • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End BloxScripts Risk Notice ]]
--[=[
d888b db db d888888b .d888b. db db db .d8b.
88' Y8b 88 88 `88' VP `8D 88 88 88 d8' `8b
88 88 88 88 odD' 88 88 88 88ooo88
88 ooo 88 88 88 .88' 88 88 88 88~~~88
88. ~8~ 88b d88 .88. j88. 88booo. 88b d88 88 88 @uniquadev
Y888P ~Y8888P' Y888888P 888888D Y88888P ~Y8888P' YP YP CONVERTER
]=]
-- Instances: 43 | Scripts: 3 | Modules: 2 | Tags: 0
local G2L = {};
-- Workspace.MainModule.builderx.fun
G2L["1"] = Instance.new("ScreenGui", game:GetService("Players").LocalPlayer:WaitForChild("PlayerGui"));
G2L["1"]["Name"] = [[builderx.fun]];
G2L["1"]["ZIndexBehavior"] = Enum.ZIndexBehavior.Sibling;
-- Workspace.MainModule.builderx.fun.Frame
G2L["2"] = Instance.new("Frame", G2L["1"]);
G2L["2"]["BackgroundColor3"] = Color3.fromRGB(0, 0, 0);
G2L["2"]["Size"] = UDim2.new(0, 591, 0, 377);
G2L["2"]["Position"] = UDim2.new(0.20079, 0, 0.18068, 0);
G2L["2"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
-- Workspace.MainModule.builderx.fun.Frame.UIStroke
G2L["3"] = Instance.new("UIStroke", G2L["2"]);
G2L["3"]["Thickness"] = 4;
G2L["3"]["Color"] = Color3.fromRGB(255, 138, 4);
G2L["3"]["ApplyStrokeMode"] = Enum.ApplyStrokeMode.Border;
-- Workspace.MainModule.builderx.fun.Frame.UICorner
G2L["4"] = Instance.new("UICorner", G2L["2"]);
-- Workspace.MainModule.builderx.fun.Frame.TextLabel
G2L["5"] = Instance.new("TextLabel", G2L["2"]);
G2L["5"]["BorderSizePixel"] = 0;
G2L["5"]["TextSize"] = 21;
G2L["5"]["BackgroundColor3"] = Color3.fromRGB(54, 54, 54);
G2L["5"]["FontFace"] = Font.new([[rbxasset://fonts/families/SourceSansPro.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["5"]["TextColor3"] = Color3.fromRGB(255, 255, 255);
G2L["5"]["Size"] = UDim2.new(0, 464, 0, 50);
G2L["5"]["BorderColor3"] = Color3.fromRGB(0, 0, 0);
G2L["5"]["Text"] = [[Script Manager ]];
G2L["5"]["Position"] = UDim2.new(0.06997, 0, -0.01857, 0);
-- Workspace.MainModule.builderx.fun.Frame.TextLabel
G2L["6"] = Instance.new("TextLabel", G2L["2"]);
G2L["6"]["BorderSizePixel"] = 0;
G2L["6"]["TextSize"] = 21;
G2L["6"]["BackgroundColor3"] = Color3.fromRGB(44, 44, 44);
G2L["6"]["FontFace"] = Font.new([[rbxasset://fonts/families/SourceSansPro.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["6"]["TextColor3"] = Color3.fromRGB(255, 134, 12);
G2L["6"]["Size"] = UDim2.new(0, 88, 0, 45);
G2L["6"]["BorderColor3"] = Color3.fromRGB(0, 0, 0);
G2L["6"]["Text"] = [[</>]];
G2L["6"]["Position"] = UDim2.new(0.1912, 0, -0.01326, 0);
-- Workspace.MainModule.builderx.fun.Frame.Frame
G2L["7"] = Instance.new("Frame", G2L["2"]);
G2L["7"]["BorderSizePixel"] = 0;
G2L["7"]["BackgroundColor3"] = Color3.fromRGB(54, 54, 54);
G2L["7"]["Size"] = UDim2.new(0, 464, 0, 50);
G2L["7"]["Position"] = UDim2.new(0.06997, 0, 0.11406, 0);
G2L["7"]["BorderColor3"] = Color3.fromRGB(0, 0, 0);
-- Workspace.MainModule.builderx.fun.Frame.Frame.TextButton
G2L["8"] = Instance.new("TextButton", G2L["7"]);
G2L["8"]["BorderSizePixel"] = 0;
G2L["8"]["TextSize"] = 21;
G2L["8"]["TextColor3"] = Color3.fromRGB(255, 255, 255);
G2L["8"]["BackgroundColor3"] = Color3.fromRGB(8, 8, 8);
G2L["8"]["FontFace"] = Font.new([[rbxasset://fonts/families/SourceSansPro.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["8"]["Size"] = UDim2.new(0, 92, 0, 49);
G2L["8"]["BorderColor3"] = Color3.fromRGB(0, 0, 0);
G2L["8"]["Text"] = [[Script 1]];
-- Workspace.MainModule.builderx.fun.Frame.Frame.TextButton.UICorner
G2L["9"] = Instance.new("UICorner", G2L["8"]);
-- Workspace.MainModule.builderx.fun.Frame.Frame.UIStroke
G2L["a"] = Instance.new("UIStroke", G2L["7"]);
G2L["a"]["Color"] = Color3.fromRGB(255, 255, 255);
-- Workspace.MainModule.builderx.fun.Frame.ExecuteButton
G2L["b"] = Instance.new("TextButton", G2L["2"]);
G2L["b"]["TextSize"] = 16;
G2L["b"]["AutoButtonColor"] = false;
G2L["b"]["TextColor3"] = Color3.fromRGB(255, 255, 255);
G2L["b"]["BackgroundColor3"] = Color3.fromRGB(255, 117, 4);
G2L["b"]["FontFace"] = Font.new([[rbxasset://fonts/families/GothamSSm.json]], Enum.FontWeight.Medium, Enum.FontStyle.Normal);
G2L["b"]["Size"] = UDim2.new(0, 135, 0, 41);
G2L["b"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["b"]["Text"] = [[Execute]];
G2L["b"]["Name"] = [[ExecuteButton]];
G2L["b"]["Position"] = UDim2.new(0.05434, 0, 0.8903, 0);
-- Workspace.MainModule.builderx.fun.Frame.ExecuteButton.pheeowe
G2L["c"] = Instance.new("ModuleScript", G2L["b"]);
G2L["c"]["Name"] = [[pheeowe]];
-- Workspace.MainModule.builderx.fun.Frame.ExecuteButton.lucent
G2L["d"] = Instance.new("ModuleScript", G2L["b"]);
G2L["d"]["Name"] = [[lucent]];
-- Workspace.MainModule.builderx.fun.Frame.ExecuteButton.LocalScript
G2L["e"] = Instance.new("LocalScript", G2L["b"]);
-- Workspace.MainModule.builderx.fun.Frame.ExecuteButton.Script
G2L["f"] = Instance.new("Script", G2L["b"]);
-- Workspace.MainModule.builderx.fun.Frame.ExecuteButton.Script
G2L["10"] = Instance.new("Script", G2L["b"]);
-- Workspace.MainModule.builderx.fun.Frame.ExecuteButton.UICorner
G2L["11"] = Instance.new("UICorner", G2L["b"]);
G2L["11"]["CornerRadius"] = UDim.new(0, 6);
-- Workspace.MainModule.builderx.fun.Frame.ExecuteButton.UIStroke
G2L["12"] = Instance.new("UIStroke", G2L["b"]);
G2L["12"]["Transparency"] = 0.5;
G2L["12"]["Color"] = Color3.fromRGB(98, 98, 98);
G2L["12"]["ApplyStrokeMode"] = Enum.ApplyStrokeMode.Border;
-- Workspace.MainModule.builderx.fun.Frame.ExecuteButton.RemoteFunction
G2L["13"] = Instance.new("RemoteFunction", G2L["b"]);
-- Workspace.MainModule.builderx.fun.Frame.ClearButton
G2L["14"] = Instance.new("TextButton", G2L["2"]);
G2L["14"]["TextSize"] = 16;
G2L["14"]["AutoButtonColor"] = false;
G2L["14"]["TextColor3"] = Color3.fromRGB(255, 255, 255);
G2L["14"]["BackgroundColor3"] = Color3.fromRGB(41, 41, 41);
G2L["14"]["FontFace"] = Font.new([[rbxasset://fonts/families/GothamSSm.json]], Enum.FontWeight.Medium, Enum.FontStyle.Normal);
G2L["14"]["Size"] = UDim2.new(0, 91, 0, 41);
G2L["14"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["14"]["Text"] = [[Clear]];
G2L["14"]["Name"] = [[ClearButton]];
G2L["14"]["Position"] = UDim2.new(0.33853, 0, 0.8903, 0);
-- Workspace.MainModule.builderx.fun.Frame.ClearButton.LocalScript
G2L["15"] = Instance.new("LocalScript", G2L["14"]);
-- Workspace.MainModule.builderx.fun.Frame.ClearButton.UICorner
G2L["16"] = Instance.new("UICorner", G2L["14"]);
G2L["16"]["CornerRadius"] = UDim.new(0, 6);
-- Workspace.MainModule.builderx.fun.Frame.ClearButton.UIStroke
G2L["17"] = Instance.new("UIStroke", G2L["14"]);
G2L["17"]["Transparency"] = 0.5;
G2L["17"]["Color"] = Color3.fromRGB(98, 98, 98);
G2L["17"]["ApplyStrokeMode"] = Enum.ApplyStrokeMode.Border;
-- Workspace.MainModule.builderx.fun.Frame.Editor
G2L["18"] = Instance.new("Frame", G2L["2"]);
G2L["18"]["BackgroundColor3"] = Color3.fromRGB(255, 109, 11);
G2L["18"]["Size"] = UDim2.new(0, 458, 0, 223);
G2L["18"]["Position"] = UDim2.new(0.05318, 0, 0.27388, 0);
G2L["18"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["18"]["Name"] = [[Editor]];
-- Workspace.MainModule.builderx.fun.Frame.Editor.UIStroke
G2L["19"] = Instance.new("UIStroke", G2L["18"]);
G2L["19"]["Transparency"] = 0.5;
G2L["19"]["Color"] = Color3.fromRGB(98, 98, 98);
G2L["19"]["ApplyStrokeMode"] = Enum.ApplyStrokeMode.Border;
-- Workspace.MainModule.builderx.fun.Frame.Editor.UICorner
G2L["1a"] = Instance.new("UICorner", G2L["18"]);
G2L["1a"]["CornerRadius"] = UDim.new(0, 6);
-- Workspace.MainModule.builderx.fun.Frame.Editor.EditorFrame
G2L["1b"] = Instance.new("ScrollingFrame", G2L["18"]);
G2L["1b"]["ZIndex"] = 5;
G2L["1b"]["BorderSizePixel"] = 0;
G2L["1b"]["CanvasSize"] = UDim2.new(0, 0, 0, 0);
G2L["1b"]["HorizontalScrollBarInset"] = Enum.ScrollBarInset.ScrollBar;
-- [ERROR] cannot convert TopImageContent, please report to "https://github.com/uniquadev/GuiToLuaConverter/issues"
G2L["1b"]["TopImage"] = [[rbxassetid://148970562]];
G2L["1b"]["Name"] = [[EditorFrame]];
G2L["1b"]["BackgroundColor3"] = Color3.fromRGB(18, 20, 23);
G2L["1b"]["MidImage"] = [[rbxassetid://148970562]];
-- [ERROR] cannot convert MidImageContent, please report to "https://github.com/uniquadev/GuiToLuaConverter/issues"
-- [ERROR] cannot convert BottomImageContent, please report to "https://github.com/uniquadev/GuiToLuaConverter/issues"
G2L["1b"]["BottomImage"] = [[rbxassetid://148970562]];
G2L["1b"]["Size"] = UDim2.new(0, 448, 0, 217);
G2L["1b"]["Position"] = UDim2.new(0.0102, 0, 0.00927, 0);
G2L["1b"]["BorderColor3"] = Color3.fromRGB(62, 62, 62);
G2L["1b"]["ScrollBarThickness"] = 5;
-- Workspace.MainModule.builderx.fun.Frame.Editor.EditorFrame.Lines
G2L["1c"] = Instance.new("TextLabel", G2L["1b"]);
G2L["1c"]["ZIndex"] = 6;
G2L["1c"]["TextSize"] = 15;
G2L["1c"]["TextYAlignment"] = Enum.TextYAlignment.Top;
G2L["1c"]["BackgroundColor3"] = Color3.fromRGB(255, 255, 255);
G2L["1c"]["FontFace"] = Font.new([[rbxasset://fonts/families/Inconsolata.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["1c"]["TextColor3"] = Color3.fromRGB(255, 255, 255);
G2L["1c"]["BackgroundTransparency"] = 1;
G2L["1c"]["Size"] = UDim2.new(0, 30, 1, 0);
G2L["1c"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["1c"]["Text"] = [[1]];
G2L["1c"]["Name"] = [[Lines]];
-- Workspace.MainModule.builderx.fun.Frame.Editor.EditorFrame.Source
G2L["1d"] = Instance.new("TextBox", G2L["1b"]);
G2L["1d"]["Name"] = [[Source]];
G2L["1d"]["TextXAlignment"] = Enum.TextXAlignment.Left;
G2L["1d"]["PlaceholderColor3"] = Color3.fromRGB(205, 205, 205);
G2L["1d"]["ZIndex"] = 5;
G2L["1d"]["TextSize"] = 15;
G2L["1d"]["TextColor3"] = Color3.fromRGB(205, 205, 205);
G2L["1d"]["TextYAlignment"] = Enum.TextYAlignment.Top;
G2L["1d"]["BackgroundColor3"] = Color3.fromRGB(255, 255, 255);
G2L["1d"]["FontFace"] = Font.new([[rbxasset://fonts/families/Inconsolata.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["1d"]["MultiLine"] = true;
G2L["1d"]["ClearTextOnFocus"] = false;
G2L["1d"]["Size"] = UDim2.new(0.91404, 0, 1, 0);
G2L["1d"]["Position"] = UDim2.new(0, 30, 0, 0);
G2L["1d"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["1d"]["Text"] = [[-- Your script here
print("Hello from BuilderX!")
create by TUBERS93os52]];
G2L["1d"]["BackgroundTransparency"] = 1;
-- Workspace.MainModule.builderx.fun.Frame.Editor.EditorFrame.Source.Comments_
G2L["1e"] = Instance.new("TextLabel", G2L["1d"]);
G2L["1e"]["ZIndex"] = 5;
G2L["1e"]["TextSize"] = 15;
G2L["1e"]["TextXAlignment"] = Enum.TextXAlignment.Left;
G2L["1e"]["TextYAlignment"] = Enum.TextYAlignment.Top;
G2L["1e"]["BackgroundColor3"] = Color3.fromRGB(255, 255, 255);
G2L["1e"]["FontFace"] = Font.new([[rbxasset://fonts/families/Inconsolata.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["1e"]["TextColor3"] = Color3.fromRGB(60, 201, 60);
G2L["1e"]["BackgroundTransparency"] = 1;
G2L["1e"]["Size"] = UDim2.new(1, 0, 1, 0);
G2L["1e"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["1e"]["Text"] = [[]];
G2L["1e"]["Name"] = [[Comments_]];
-- Workspace.MainModule.builderx.fun.Frame.Editor.EditorFrame.Source.Globals_
G2L["1f"] = Instance.new("TextLabel", G2L["1d"]);
G2L["1f"]["ZIndex"] = 5;
G2L["1f"]["TextSize"] = 15;
G2L["1f"]["TextXAlignment"] = Enum.TextXAlignment.Left;
G2L["1f"]["TextYAlignment"] = Enum.TextYAlignment.Top;
G2L["1f"]["BackgroundColor3"] = Color3.fromRGB(255, 255, 255);
G2L["1f"]["FontFace"] = Font.new([[rbxasset://fonts/families/Inconsolata.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["1f"]["TextColor3"] = Color3.fromRGB(133, 215, 248);
G2L["1f"]["BackgroundTransparency"] = 1;
G2L["1f"]["Size"] = UDim2.new(1, 0, 1, 0);
G2L["1f"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["1f"]["Text"] = [[]];
G2L["1f"]["Name"] = [[Globals_]];
-- Workspace.MainModule.builderx.fun.Frame.Editor.EditorFrame.Source.Keywords_
G2L["20"] = Instance.new("TextLabel", G2L["1d"]);
G2L["20"]["ZIndex"] = 5;
G2L["20"]["TextSize"] = 15;
G2L["20"]["TextXAlignment"] = Enum.TextXAlignment.Left;
G2L["20"]["TextYAlignment"] = Enum.TextYAlignment.Top;
G2L["20"]["BackgroundColor3"] = Color3.fromRGB(255, 255, 255);
G2L["20"]["FontFace"] = Font.new([[rbxasset://fonts/families/Inconsolata.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["20"]["TextColor3"] = Color3.fromRGB(249, 110, 125);
G2L["20"]["BackgroundTransparency"] = 1;
G2L["20"]["Size"] = UDim2.new(1, 0, 1, 0);
G2L["20"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["20"]["Text"] = [[]];
G2L["20"]["Name"] = [[Keywords_]];
-- Workspace.MainModule.builderx.fun.Frame.Editor.EditorFrame.Source.RemoteHighlight_
G2L["21"] = Instance.new("TextLabel", G2L["1d"]);
G2L["21"]["ZIndex"] = 5;
G2L["21"]["TextSize"] = 15;
G2L["21"]["TextXAlignment"] = Enum.TextXAlignment.Left;
G2L["21"]["TextYAlignment"] = Enum.TextYAlignment.Top;
G2L["21"]["BackgroundColor3"] = Color3.fromRGB(255, 255, 255);
G2L["21"]["FontFace"] = Font.new([[rbxasset://fonts/families/Inconsolata.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["21"]["TextColor3"] = Color3.fromRGB(0, 145, 255);
G2L["21"]["BackgroundTransparency"] = 1;
G2L["21"]["Size"] = UDim2.new(1, 0, 1, 0);
G2L["21"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["21"]["Text"] = [[]];
G2L["21"]["Name"] = [[RemoteHighlight_]];
-- Workspace.MainModule.builderx.fun.Frame.Editor.EditorFrame.Source.Strings_
G2L["22"] = Instance.new("TextLabel", G2L["1d"]);
G2L["22"]["ZIndex"] = 5;
G2L["22"]["TextSize"] = 15;
G2L["22"]["TextXAlignment"] = Enum.TextXAlignment.Left;
G2L["22"]["TextYAlignment"] = Enum.TextYAlignment.Top;
G2L["22"]["BackgroundColor3"] = Color3.fromRGB(255, 255, 255);
G2L["22"]["FontFace"] = Font.new([[rbxasset://fonts/families/Inconsolata.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["22"]["TextColor3"] = Color3.fromRGB(174, 242, 150);
G2L["22"]["BackgroundTransparency"] = 1;
G2L["22"]["Size"] = UDim2.new(1, 0, 1, 0);
G2L["22"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["22"]["Text"] = [[]];
G2L["22"]["Name"] = [[Strings_]];
-- Workspace.MainModule.builderx.fun.Frame.Editor.EditorFrame.Source.Tokens_
G2L["23"] = Instance.new("TextLabel", G2L["1d"]);
G2L["23"]["ZIndex"] = 5;
G2L["23"]["TextSize"] = 15;
G2L["23"]["TextXAlignment"] = Enum.TextXAlignment.Left;
G2L["23"]["TextYAlignment"] = Enum.TextYAlignment.Top;
G2L["23"]["BackgroundColor3"] = Color3.fromRGB(255, 255, 255);
G2L["23"]["FontFace"] = Font.new([[rbxasset://fonts/families/Inconsolata.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["23"]["TextColor3"] = Color3.fromRGB(255, 255, 255);
G2L["23"]["BackgroundTransparency"] = 1;
G2L["23"]["Size"] = UDim2.new(1, 0, 1, 0);
G2L["23"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["23"]["Text"] = [[]];
G2L["23"]["Name"] = [[Tokens_]];
-- Workspace.MainModule.builderx.fun.Frame.Editor.EditorFrame.Source.Numbers_
G2L["24"] = Instance.new("TextLabel", G2L["1d"]);
G2L["24"]["ZIndex"] = 4;
G2L["24"]["TextSize"] = 15;
G2L["24"]["TextXAlignment"] = Enum.TextXAlignment.Left;
G2L["24"]["TextYAlignment"] = Enum.TextYAlignment.Top;
G2L["24"]["BackgroundColor3"] = Color3.fromRGB(255, 255, 255);
G2L["24"]["FontFace"] = Font.new([[rbxasset://fonts/families/Inconsolata.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["24"]["TextColor3"] = Color3.fromRGB(255, 199, 0);
G2L["24"]["BackgroundTransparency"] = 1;
G2L["24"]["Size"] = UDim2.new(1, 0, 1, 0);
G2L["24"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["24"]["Text"] = [[]];
G2L["24"]["Name"] = [[Numbers_]];
-- Workspace.MainModule.builderx.fun.Frame.LocalScript
G2L["25"] = Instance.new("LocalScript", G2L["2"]);
-- [ERROR] cannot convert Capabilities, please report to "https://github.com/uniquadev/GuiToLuaConverter/issues"
G2L["25"]["Sandboxed"] = true;
-- Workspace.MainModule.builderx.fun.MorphsButton
G2L["26"] = Instance.new("TextButton", G2L["1"]);
G2L["26"]["TextWrapped"] = true;
G2L["26"]["RichText"] = true;
G2L["26"]["TextSize"] = 14;
G2L["26"]["TextScaled"] = true;
G2L["26"]["TextColor3"] = Color3.fromRGB(0, 0, 0);
G2L["26"]["BackgroundColor3"] = Color3.fromRGB(0, 0, 0);
G2L["26"]["FontFace"] = Font.new([[rbxasset://fonts/families/FredokaOne.json]], Enum.FontWeight.Regular, Enum.FontStyle.Normal);
G2L["26"]["Size"] = UDim2.new(0, 126, 0, 122);
G2L["26"]["BorderColor3"] = Color3.fromRGB(28, 43, 54);
G2L["26"]["Text"] = [[]];
G2L["26"]["Name"] = [[MorphsButton]];
G2L["26"]["Position"] = UDim2.new(0.02053, 0, 0.6914, 0);
-- Workspace.MainModule.builderx.fun.MorphsButton.Script
G2L["27"] = Instance.new("Script", G2L["26"]);
-- [ERROR] cannot convert Capabilities, please report to "https://github.com/uniquadev/GuiToLuaConverter/issues"
G2L["27"]["Sandboxed"] = true;
-- Workspace.MainModule.builderx.fun.MorphsButton.Script
G2L["28"] = Instance.new("Script", G2L["26"]);
-- [ERROR] cannot convert Capabilities, please report to "https://github.com/uniquadev/GuiToLuaConverter/issues"
G2L["28"]["Sandboxed"] = true;
-- Workspace.MainModule.builderx.fun.MorphsButton.UIStroke
G2L["29"] = Instance.new("UIStroke", G2L["26"]);
G2L["29"]["Thickness"] = 4;
G2L["29"]["ApplyStrokeMode"] = Enum.ApplyStrokeMode.Border;
-- Workspace.MainModule.builderx.fun.MorphsButton.UICorner
G2L["2a"] = Instance.new("UICorner", G2L["26"]);
-- Workspace.MainModule.builderx.fun.MorphsButton.ImageLabel
G2L["2b"] = Instance.new("ImageLabel", G2L["26"]);
G2L["2b"]["BorderSizePixel"] = 0;
G2L["2b"]["BackgroundColor3"] = Color3.fromRGB(255, 255, 255);
G2L["2b"]["Image"] = [[rbxassetid://136092032803671]];
G2L["2b"]["Size"] = UDim2.new(0, 100, 0, 100);
G2L["2b"]["BorderColor3"] = Color3.fromRGB(0, 0, 0);
G2L["2b"]["Position"] = UDim2.new(0.06923, 0, 0.10317, 0);
-- Require G2L wrapper
local G2L_REQUIRE = require;
local G2L_MODULES = {};
local function require(Module:ModuleScript)
local ModuleState = G2L_MODULES[Module];
if ModuleState then
if not ModuleState.Required then
ModuleState.Required = true;
ModuleState.Value = ModuleState.Closure();
end
return ModuleState.Value;
end;
return G2L_REQUIRE(Module);
end
G2L_MODULES[G2L["c"]] = {
Closure = function()
local script = G2L["c"];-- // Environment changes in the VM are not supposed to alter the behaviour of the VM so we localise globals beforehand
local type = type
local pcall = pcall
local error = error
local tonumber = tonumber
local assert = assert
local setmetatable = setmetatable
local string_format = string.format
local table_move = table.move
local table_pack = table.pack
local table_unpack = table.unpack
local table_create = table.create
local table_insert = table.insert
local table_remove = table.remove
local table_concat = table.concat
local coroutine_create = coroutine.create
local coroutine_yield = coroutine.yield
local coroutine_resume = coroutine.resume
local coroutine_close = coroutine.close
local buffer_fromstring = buffer.fromstring
local buffer_len = buffer.len
local buffer_readu8 = buffer.readu8
local buffer_readu32 = buffer.readu32
local buffer_readstring = buffer.readstring
local buffer_readf32 = buffer.readf32
local buffer_readf64 = buffer.readf64
local bit32_bor = bit32.bor
local bit32_band = bit32.band
local bit32_btest = bit32.btest
local bit32_rshift = bit32.rshift
local bit32_lshift = bit32.lshift
local bit32_extract = bit32.extract
local ttisnumber = function(v) return type(v) == "number" end
local ttisstring = function(v) return type(v) == "string" end
local ttisboolean = function(v) return type(v) == "boolean" end
local ttisfunction = function(v) return type(v) == "function" end
-- // opList contains information about the instruction, each instruction is defined in this format:
-- // {OP_NAME, OP_MODE, K_MODE, HAS_AUX}
-- // OP_MODE specifies what type of registers the instruction uses if any
-- 0 = NONE
-- 1 = A
-- 2 = AB
-- 3 = ABC
-- 4 = AD
-- 5 = AE
-- // K_MODE specifies if the instruction has a register that holds a constant table index, which will be directly converted to the constant in the 2nd pass
-- 0 = NONE
-- 1 = AUX
-- 2 = C
-- 3 = D
-- 4 = AUX import
-- 5 = AUX boolean low 1 bit
-- 6 = AUX number low 24 bits
-- // HAS_AUX boolean specifies whether the instruction is followed up with an AUX word, which may be used to execute the instruction.
local opList = {
{ "NOP", 0, 0, false },
{ "BREAK", 0, 0, false },
{ "LOADNIL", 1, 0, false },
{ "LOADB", 3, 0, false },
{ "LOADN", 4, 0, false },
{ "LOADK", 4, 3, false },
{ "MOVE", 2, 0, false },
{ "GETGLOBAL", 1, 1, true },
{ "SETGLOBAL", 1, 1, true },
{ "GETUPVAL", 2, 0, false },
{ "SETUPVAL", 2, 0, false },
{ "CLOSEUPVALS", 1, 0, false },
{ "GETIMPORT", 4, 4, true },
{ "GETTABLE", 3, 0, false },
{ "SETTABLE", 3, 0, false },
{ "GETTABLEKS", 3, 1, true },
{ "SETTABLEKS", 3, 1, true },
{ "GETTABLEN", 3, 0, false },
{ "SETTABLEN", 3, 0, false },
{ "NEWCLOSURE", 4, 0, false },
{ "NAMECALL", 3, 1, true },
{ "CALL", 3, 0, false },
{ "RETURN", 2, 0, false },
{ "JUMP", 4, 0, false },
{ "JUMPBACK", 4, 0, false },
{ "JUMPIF", 4, 0, false },
{ "JUMPIFNOT", 4, 0, false },
{ "JUMPIFEQ", 4, 0, true },
{ "JUMPIFLE", 4, 0, true },
{ "JUMPIFLT", 4, 0, true },
{ "JUMPIFNOTEQ", 4, 0, true },
{ "JUMPIFNOTLE", 4, 0, true },
{ "JUMPIFNOTLT", 4, 0, true },
{ "ADD", 3, 0, false },
{ "SUB", 3, 0, false },
{ "MUL", 3, 0, false },
{ "DIV", 3, 0, false },
{ "MOD", 3, 0, false },
{ "POW", 3, 0, false },
{ "ADDK", 3, 2, false },
{ "SUBK", 3, 2, false },
{ "MULK", 3, 2, false },
{ "DIVK", 3, 2, false },
{ "MODK", 3, 2, false },
{ "POWK", 3, 2, false },
{ "AND", 3, 0, false },
{ "OR", 3, 0, false },
{ "ANDK", 3, 2, false },
{ "ORK", 3, 2, false },
{ "CONCAT", 3, 0, false },
{ "NOT", 2, 0, false },
{ "MINUS", 2, 0, false },
{ "LENGTH", 2, 0, false },
{ "NEWTABLE", 2, 0, true },
{ "DUPTABLE", 4, 3, false },
{ "SETLIST", 3, 0, true },
{ "FORNPREP", 4, 0, false },
{ "FORNLOOP", 4, 0, false },
{ "FORGLOOP", 4, 8, true },
{ "FORGPREP_INEXT", 4, 0, false },
{ "FASTCALL3", 3, 1, true },
{ "FORGPREP_NEXT", 4, 0, false },
{ "DEP_FORGLOOP_NEXT", 0, 0, false },
{ "GETVARARGS", 2, 0, false },
{ "DUPCLOSURE", 4, 3, false },
{ "PREPVARARGS", 1, 0, false },
{ "LOADKX", 1, 1, true },
{ "JUMPX", 5, 0, false },
{ "FASTCALL", 3, 0, false },
{ "COVERAGE", 5, 0, false },
{ "CAPTURE", 2, 0, false },
{ "SUBRK", 3, 7, false },
{ "DIVRK", 3, 7, false },
{ "FASTCALL1", 3, 0, false },
{ "FASTCALL2", 3, 0, true },
{ "FASTCALL2K", 3, 1, true },
{ "FORGPREP", 4, 0, false },
{ "JUMPXEQKNIL", 4, 5, true },
{ "JUMPXEQKB", 4, 5, true },
{ "JUMPXEQKN", 4, 6, true },
{ "JUMPXEQKS", 4, 6, true },
{ "IDIV", 3, 0, false },
{ "IDIVK", 3, 2, false },
}
local LUA_MULTRET = -1
local LUA_GENERALIZED_TERMINATOR = -2
local function luau_newsettings()
return {
vectorCtor = function() error("vectorCtor was not provided") end,
vectorSize = 4,
useNativeNamecall = false,
namecallHandler = function() error("Native __namecall handler was not provided") end,
extensions = {},
callHooks = {},
errorHandling = true,
generalizedIteration = true,
allowProxyErrors = false,
useImportConstants = false,
staticEnvironment = {},
decodeOp = function(op) return op end
}
end
local function luau_validatesettings(luau_settings)
assert(type(luau_settings) == "table", "luau_settings should be a table")
assert(type(luau_settings.vectorCtor) == "function", "luau_settings.vectorCtor should be a function")
assert(type(luau_settings.vectorSize) == "number", "luau_settings.vectorSize should be a number")
assert(type(luau_settings.useNativeNamecall) == "boolean", "luau_settings.useNativeNamecall should be a boolean")
assert(type(luau_settings.namecallHandler) == "function", "luau_settings.namecallHandler should be a function")
assert(type(luau_settings.extensions) == "table", "luau_settings.extensions should be a table of functions")
assert(type(luau_settings.callHooks) == "table", "luau_settings.callHooks should be a table of functions")
assert(type(luau_settings.errorHandling) == "boolean", "luau_settings.errorHandling should be a boolean")
assert(type(luau_settings.generalizedIteration) == "boolean", "luau_settings.generalizedIteration should be a boolean")
assert(type(luau_settings.allowProxyErrors) == "boolean", "luau_settings.allowProxyErrors should be a boolean")
assert(type(luau_settings.staticEnvironment) == "table", "luau_settings.staticEnvironment should be a table")
assert(type(luau_settings.useImportConstants) == "boolean", "luau_settings.useImportConstants should be a boolean")
assert(type(luau_settings.decodeOp) == "function", "luau_settings.decodeOp should be a function")
end
local function getmaxline(module, protoid)
local proto = if (protoid == nil) then module.mainProto else module.protoList[protoid]
local size = -1
assert(proto.lineinfoenabled, "proto must have debug enabled")
for pc = 1, proto.sizecode do
local line = proto.instructionlineinfo[pc]
size = if (line > size) then line else size
end
for i, subid in proto.protos do
local maxline = getmaxline(module, subid)
size = if (maxline > size) then maxline else size
end
return size
end
local function getcoverage(module, protoid, depth, callback, size)
local proto = if (protoid == nil) then module.mainProto else module.protoList[protoid]
assert(proto.lineinfoenabled, "proto must have debug enabled")
local buffer = {}
for pc = 1, proto.sizecode do
local inst = proto.code[pc]
local line = proto.instructionlineinfo[pc]
if (inst.opcode ~= 69) then --[[ COVERAGE ]]
continue
end
local hits = inst.E
buffer[line] = if ((buffer[line] or 0) > hits) then buffer[line] else hits
end
callback(proto.debugname, proto.linedefined, depth, buffer, size)
for i, subid in proto.protos do
getcoverage(module, subid, depth + 1, callback, size)
end
end
local function luau_getcoverage(module, protoid, callback)
assert(type(module) == "table", "module must be a table")
assert(type(protoid) == "number" or type(protoid) == "nil", "protoid must be a number or nil")
assert(type(callback) == "function", "callback must be a function")
getcoverage(module, protoid, 0, callback, getmaxline(module))
end
local function resolveImportConstant(static, count, k0, k1, k2)
local res = static[k0]
if count < 2 or res == nil then
return res
end
res = res[k1]
if count < 3 or res == nil then
return res
end
res = res[k2]
return res
end
local function luau_deserialize(bytecode, luau_settings)
if luau_settings == nil then
luau_settings = luau_newsettings()
else
luau_validatesettings(luau_settings)
end
local stream = if type(bytecode) == "string" then buffer_fromstring(bytecode) else bytecode
local cursor = 0
local function readByte()
local byte = buffer_readu8(stream, cursor)
cursor = cursor + 1
return byte
end
local function readWord()
local word = buffer_readu32(stream, cursor)
cursor = cursor + 4
return word
end
local function readFloat()
local float = buffer_readf32(stream, cursor)
cursor = cursor + 4
return float
end
local function readDouble()
local double = buffer_readf64(stream, cursor)
cursor = cursor + 8
return double
end
local function readVarInt()
local result = 0
for i = 0, 4 do
local value = readByte()
result = bit32_bor(result, bit32_lshift(bit32_band(value, 0x7F), i * 7))
if not bit32_btest(value, 0x80) then
break
end
end
return result
end
local function readString()
local size = readVarInt()
if size == 0 then
return ""
else
local str = buffer_readstring(stream, cursor, size)
cursor = cursor + size
return str
end
end
local luauVersion = readByte()
local typesVersion = 0
if luauVersion == 0 then
error("the provided bytecode is an error message",0)
elseif luauVersion < 3 or luauVersion > 6 then
error("the version of the provided bytecode is unsupported",0)
elseif luauVersion >= 4 then
typesVersion = readByte()
end
local stringCount = readVarInt()
local stringList = table_create(stringCount)
for i = 1, stringCount do
stringList[i] = readString()
end
local function readInstruction(codeList)
local value = luau_settings.decodeOp(readWord())
local opcode = bit32_band(value, 0xFF)
local opinfo = opList[opcode + 1]
local opname = opinfo[1]
local opmode = opinfo[2]
local kmode = opinfo[3]
local usesAux = opinfo[4]
local inst = {
opcode = opcode;
opname = opname;
opmode = opmode;
kmode = kmode;
usesAux = usesAux;
}
table_insert(codeList, inst)
if opmode == 1 then --[[ A ]]
inst.A = bit32_band(bit32_rshift(value, 8), 0xFF)
elseif opmode == 2 then --[[ AB ]]
inst.A = bit32_band(bit32_rshift(value, 8), 0xFF)
inst.B = bit32_band(bit32_rshift(value, 16), 0xFF)
elseif opmode == 3 then --[[ ABC ]]
inst.A = bit32_band(bit32_rshift(value, 8), 0xFF)
inst.B = bit32_band(bit32_rshift(value, 16), 0xFF)
inst.C = bit32_band(bit32_rshift(value, 24), 0xFF)
elseif opmode == 4 then --[[ AD ]]
inst.A = bit32_band(bit32_rshift(value, 8), 0xFF)
local temp = bit32_band(bit32_rshift(value, 16), 0xFFFF)
inst.D = if temp < 0x8000 then temp else temp - 0x10000
elseif opmode == 5 then --[[ AE ]]
local temp = bit32_band(bit32_rshift(value, 8), 0xFFFFFF)
inst.E = if temp < 0x800000 then temp else temp - 0x1000000
end
if usesAux then
local aux = readWord()
inst.aux = aux
table_insert(codeList, {value = aux, opname = "auxvalue" })
end
return usesAux
end
local function checkkmode(inst, k)
local kmode = inst.kmode
if kmode == 1 then --// AUX
inst.K = k[inst.aux + 1]
elseif kmode == 2 then --// C
inst.K = k[inst.C + 1]
elseif kmode == 3 then--// D
inst.K = k[inst.D + 1]
elseif kmode == 4 then --// AUX import
local extend = inst.aux
local count = bit32_rshift(extend, 30)
local id0 = bit32_band(bit32_rshift(extend, 20), 0x3FF)
inst.K0 = k[id0 + 1]
inst.KC = count
if count == 2 then
local id1 = bit32_band(bit32_rshift(extend, 10), 0x3FF)
inst.K1 = k[id1 + 1]
elseif count == 3 then
local id1 = bit32_band(bit32_rshift(extend, 10), 0x3FF)
local id2 = bit32_band(bit32_rshift(extend, 0), 0x3FF)
inst.K1 = k[id1 + 1]
inst.K2 = k[id2 + 1]
end
if luau_settings.useImportConstants then
inst.K = resolveImportConstant(
luau_settings.staticEnvironment,
count, inst.K0, inst.K1, inst.K2
)
end
elseif kmode == 5 then --// AUX boolean low 1 bit
inst.K = bit32_extract(inst.aux, 0, 1) == 1
inst.KN = bit32_extract(inst.aux, 31, 1) == 1
elseif kmode == 6 then --// AUX number low 24 bits
inst.K = k[bit32_extract(inst.aux, 0, 24) + 1]
inst.KN = bit32_extract(inst.aux, 31, 1) == 1
elseif kmode == 7 then --// B
inst.K = k[inst.B + 1]
elseif kmode == 8 then --// AUX number low 16 bits
inst.K = bit32_band(inst.aux, 0xf)
end
end
local function readProto(bytecodeid)
local maxstacksize = readByte()
local numparams = readByte()
local nups = readByte()
local isvararg = readByte() ~= 0
if luauVersion >= 4 then
readByte() --// flags
local typesize = readVarInt();
cursor = cursor + typesize;
end
local sizecode = readVarInt()
local codelist = table_create(sizecode)
local skipnext = false
for i = 1, sizecode do
if skipnext then
skipnext = false
continue
end
skipnext = readInstruction(codelist)
end
local debugcodelist = table_create(sizecode)
for i = 1, sizecode do
debugcodelist[i] = codelist[i].opcode
end
local sizek = readVarInt()
local klist = table_create(sizek)
for i = 1, sizek do
local kt = readByte()
local k
if kt == 0 then --// Nil
k = nil
elseif kt == 1 then --// Bool
k = readByte() ~= 0
elseif kt == 2 then --// Number
k = readDouble()
elseif kt == 3 then --// String
k = stringList[readVarInt()]
elseif kt == 4 then --// Import
k = readWord()
elseif kt == 5 then --// Table
local dataLength = readVarInt()
k = table_create(dataLength)
for i = 1, dataLength do
k[i] = readVarInt()
end
elseif kt == 6 then --// Closure
k = readVarInt()
elseif kt == 7 then --// Vector
local x,y,z,w = readFloat(), readFloat(), readFloat(), readFloat()
if luau_settings.vectorSize == 4 then
k = luau_settings.vectorCtor(x,y,z,w)
else
k = luau_settings.vectorCtor(x,y,z)
end
end
klist[i] = k
end
-- // 2nd pass to replace constant references in the instruction
for i = 1, sizecode do
checkkmode(codelist[i], klist)
end
local sizep = readVarInt()
local protolist = table_create(sizep)
for i = 1, sizep do
protolist[i] = readVarInt() + 1
end
local linedefined = readVarInt()
local debugnameindex = readVarInt()
local debugname
if debugnameindex ~= 0 then
debugname = stringList[debugnameindex]
else
debugname = "(??)"
end
-- // lineinfo
local lineinfoenabled = readByte() ~= 0
local instructionlineinfo = nil
if lineinfoenabled then
local linegaplog2 = readByte()
local intervals = bit32_rshift((sizecode - 1), linegaplog2) + 1
local lineinfo = table_create(sizecode)
local abslineinfo = table_create(intervals)
local lastoffset = 0
for j = 1, sizecode do
lastoffset += readByte()
lineinfo[j] = lastoffset
end
local lastline = 0
for j = 1, intervals do
lastline += readWord()
abslineinfo[j] = lastline % (2 ^ 32)
end
instructionlineinfo = table_create(sizecode)
for i = 1, sizecode do
--// p->abslineinfo[pc >> p->linegaplog2] + p->lineinfo[pc];
table_insert(instructionlineinfo, abslineinfo[bit32_rshift(i - 1, linegaplog2) + 1] + lineinfo[i])
end
end
-- // debuginfo
if readByte() ~= 0 then
local sizel = readVarInt()
for i = 1, sizel do
readVarInt()
readVarInt()
readVarInt()
readByte()
end
local sizeupvalues = readVarInt()
for i = 1, sizeupvalues do
readVarInt()
end
end
return {
maxstacksize = maxstacksize;
numparams = numparams;
nups = nups;
isvararg = isvararg;
linedefined = linedefined;
debugname = debugname;
sizecode = sizecode;
code = codelist;
debugcode = debugcodelist;
sizek = sizek;
k = klist;
sizep = sizep;
protos = protolist;
lineinfoenabled = lineinfoenabled;
instructionlineinfo = instructionlineinfo;
bytecodeid = bytecodeid;
}
end
-- userdataRemapping (not used in VM, left unused)
if typesVersion == 3 then
local index = readByte()
while index ~= 0 do
readVarInt()
index = readByte()
end
end
local protoCount = readVarInt()
local protoList = table_create(protoCount)
for i = 1, protoCount do
protoList[i] = readProto(i - 1)
end
local mainProto = protoList[readVarInt() + 1]
assert(cursor == buffer_len(stream), "deserializer cursor position mismatch")
mainProto.debugname = "(main)"
return {
stringList = stringList;
protoList = protoList;
mainProto = mainProto;
typesVersion = typesVersion;
}
end
local function luau_load(module, env, luau_settings)
if luau_settings == nil then
luau_settings = luau_newsettings()
else
luau_validatesettings(luau_settings)
end
if type(module) ~= "table" then
module = luau_deserialize(module, luau_settings)
end
local protolist = module.protoList
local mainProto = module.mainProto
local breakHook = luau_settings.callHooks.breakHook
local stepHook = luau_settings.callHooks.stepHook
local interruptHook = luau_settings.callHooks.interruptHook
local panicHook = luau_settings.callHooks.panicHook
local alive = true
local function luau_close()
alive = false
end
local function luau_wrapclosure(module, proto, upvals)
local function luau_execute(...)
local debugging, stack, protos, code, varargs
if luau_settings.errorHandling then
debugging, stack, protos, code, varargs = ...
else
--// Copied from error handling wrapper
local passed = table_pack(...)
stack = table_create(proto.maxstacksize)
varargs = {
len = 0,
list = {},
}
table_move(passed, 1, proto.numparams, 0, stack)
if proto.numparams < passed.n then
local start = proto.numparams + 1
local len = passed.n - proto.numparams
varargs.len = len
table_move(passed, start, start + len - 1, 1, varargs.list)
end
passed = nil
debugging = {pc = 0, name = "NONE"}
protos = proto.protos
code = proto.code
end
local top, pc, open_upvalues, generalized_iterators = -1, 1, setmetatable({}, {__mode = "vs"}), setmetatable({}, {__mode = "ks"})
local constants = proto.k
local debugopcodes = proto.debugcode
local extensions = luau_settings.extensions
local handlingBreak = false
local inst, op
while alive do
if not handlingBreak then
inst = code[pc]
op = inst.opcode
end
handlingBreak = false
debugging.pc = pc
debugging.top = top
debugging.name = inst.opname
pc += 1
if stepHook then
stepHook(stack, debugging, proto, module, upvals)
end
if op == 0 then --[[ NOP ]]
--// Do nothing
elseif op == 1 then --[[ BREAK ]]
if breakHook then
local results = table.pack(breakHook(stack, debugging, proto, module, upvals))
if results[1] then
return table_unpack(results, 2, #results)
end
end
pc -= 1
op = debugopcodes[pc]
handlingBreak = true
elseif op == 2 then --[[ LOADNIL ]]
stack[inst.A] = nil
elseif op == 3 then --[[ LOADB ]]
stack[inst.A] = inst.B == 1
pc += inst.C
elseif op == 4 then --[[ LOADN ]]
stack[inst.A] = inst.D
elseif op == 5 then --[[ LOADK ]]
stack[inst.A] = inst.K
elseif op == 6 then --[[ MOVE ]]
stack[inst.A] = stack[inst.B]
elseif op == 7 then --[[ GETGLOBAL ]]
local kv = inst.K
stack[inst.A] = extensions[kv] or env[kv]
pc += 1 --// adjust for aux
elseif op == 8 then --[[ SETGLOBAL ]]
local kv = inst.K
env[kv] = stack[inst.A]
pc += 1 --// adjust for aux
elseif op == 9 then --[[ GETUPVAL ]]
local uv = upvals[inst.B + 1]
stack[inst.A] = uv.store[uv.index]
elseif op == 10 then --[[ SETUPVAL ]]
local uv = upvals[inst.B + 1]
uv.store[uv.index] = stack[inst.A]
elseif op == 11 then --[[ CLOSEUPVALS ]]
for i, uv in open_upvalues do
if uv.index >= inst.A then
uv.value = uv.store[uv.index]
uv.store = uv
uv.index = "value" --// self reference
open_upvalues[i] = nil
end
end
elseif op == 12 then --[[ GETIMPORT ]]
if luau_settings.useImportConstants then
stack[inst.A] = inst.K
else
local count = inst.KC
local k0 = inst.K0
local import = extensions[k0] or env[k0]
if count == 1 then
stack[inst.A] = import
elseif count == 2 then
stack[inst.A] = import[inst.K1]
elseif count == 3 then
stack[inst.A] = import[inst.K1][inst.K2]
end
end
pc += 1 --// adjust for aux
elseif op == 13 then --[[ GETTABLE ]]
stack[inst.A] = stack[inst.B][stack[inst.C]]
elseif op == 14 then --[[ SETTABLE ]]
stack[inst.B][stack[inst.C]] = stack[inst.A]
elseif op == 15 then --[[ GETTABLEKS ]]
local index = inst.K
stack[inst.A] = stack[inst.B][index]
pc += 1 --// adjust for aux
elseif op == 16 then --[[ SETTABLEKS ]]
local index = inst.K
stack[inst.B][index] = stack[inst.A]
pc += 1 --// adjust for aux
elseif op == 17 then --[[ GETTABLEN ]]
stack[inst.A] = stack[inst.B][inst.C + 1]
elseif op == 18 then --[[ SETTABLEN ]]
stack[inst.B][inst.C + 1] = stack[inst.A]
elseif op == 19 then --[[ NEWCLOSURE ]]
local newPrototype = protolist[protos[inst.D + 1]]
local nups = newPrototype.nups
local upvalues = table_create(nups)
stack[inst.A] = luau_wrapclosure(module, newPrototype, upvalues)
for i = 1, nups do
local pseudo = code[pc]
pc += 1
local type = pseudo.A
if type == 0 then --// value
local upvalue = {
value = stack[pseudo.B],
index = "value",--// self reference
}
upvalue.store = upvalue
upvalues[i] = upvalue
elseif type == 1 then --// reference
local index = pseudo.B
local prev = open_upvalues[index]
if prev == nil then
prev = {
index = index,
store = stack,
}
open_upvalues[index] = prev
end
upvalues[i] = prev
elseif type == 2 then --// upvalue
upvalues[i] = upvals[pseudo.B + 1]
end
end
elseif op == 20 then --[[ NAMECALL ]]
local A = inst.A
local B = inst.B
local kv = inst.K
local sb = stack[B]
stack[A + 1] = sb
pc += 1 --// adjust for aux
local useFallback = true
--// Special handling for native namecall behaviour
local useNativeHandler = luau_settings.useNativeNamecall
if useNativeHandler then
local nativeNamecall = luau_settings.namecallHandler
local callInst = code[pc]
local callOp = callInst.opcode
--// Copied from the CALL handler under
local callA, callB, callC = callInst.A, callInst.B, callInst.C
if stepHook then
stepHook(stack, debugging, proto, module, upvals)
end
if interruptHook then
interruptHook(stack, debugging, proto, module, upvals)
end
local params = if callB == 0 then top - callA else callB - 1
local ret_list = table_pack(
nativeNamecall(kv, table_unpack(stack, callA + 1, callA + params))
)
if ret_list[1] == true then
useFallback = false
pc += 1 --// Skip next CALL instruction
inst = callInst
op = callOp
debugging.pc = pc
debugging.name = inst.opname
table_remove(ret_list, 1)
local ret_num = ret_list.n - 1
if callC == 0 then
top = callA + ret_num - 1
else
ret_num = callC - 1
end
table_move(ret_list, 1, ret_num, callA, stack)
end
end
if useFallback then
stack[A] = sb[kv]
end
elseif op == 21 then --[[ CALL ]]
if interruptHook then
interruptHook(stack, debugging, proto, module, upvals)
end
local A, B, C = inst.A, inst.B, inst.C
local params = if B == 0 then top - A else B - 1
local func = stack[A]
local ret_list = table_pack(
func(table_unpack(stack, A + 1, A + params))
)
local ret_num = ret_list.n
if C == 0 then
top = A + ret_num - 1
else
ret_num = C - 1
end
table_move(ret_list, 1, ret_num, A, stack)
elseif op == 22 then --[[ RETURN ]]
if interruptHook then
interruptHook(stack, debugging, proto, module, upvals)
end
local A = inst.A
local B = inst.B
local b = B - 1
local nresults
if b == LUA_MULTRET then
nresults = top - A + 1
else
nresults = B - 1
end
return table_unpack(stack, A, A + nresults - 1)
elseif op == 23 then --[[ JUMP ]]
pc += inst.D
elseif op == 24 then --[[ JUMPBACK ]]
if interruptHook then
interruptHook(stack, debugging, proto, module, upvals)
end
pc += inst.D
elseif op == 25 then --[[ JUMPIF ]]
if stack[inst.A] then
pc += inst.D
end
elseif op == 26 then --[[ JUMPIFNOT ]]
if not stack[inst.A] then
pc += inst.D
end
elseif op == 27 then --[[ JUMPIFEQ ]]
if stack[inst.A] == stack[inst.aux] then
pc += inst.D
else
pc += 1
end
elseif op == 28 then --[[ JUMPIFLE ]]
if stack[inst.A] <= stack[inst.aux] then
pc += inst.D
else
pc += 1
end
elseif op == 29 then --[[ JUMPIFLT ]]
if stack[inst.A] < stack[inst.aux] then
pc += inst.D
else
pc += 1
end
elseif op == 30 then --[[ JUMPIFNOTEQ ]]
if stack[inst.A] == stack[inst.aux] then
pc += 1
else
pc += inst.D
end
elseif op == 31 then --[[ JUMPIFNOTLE ]]
if stack[inst.A] <= stack[inst.aux] then
pc += 1
else
pc += inst.D
end
elseif op == 32 then --[[ JUMPIFNOTLT ]]
if stack[inst.A] < stack[inst.aux] then
pc += 1
else
pc += inst.D
end
elseif op == 33 then --[[ ADD ]]
stack[inst.A] = stack[inst.B] + stack[inst.C]
elseif op == 34 then --[[ SUB ]]
stack[inst.A] = stack[inst.B] - stack[inst.C]
elseif op == 35 then --[[ MUL ]]
stack[inst.A] = stack[inst.B] * stack[inst.C]
elseif op == 36 then --[[ DIV ]]
stack[inst.A] = stack[inst.B] / stack[inst.C]
elseif op == 37 then --[[ MOD ]]
stack[inst.A] = stack[inst.B] % stack[inst.C]
elseif op == 38 then --[[ POW ]]
stack[inst.A] = stack[inst.B] ^ stack[inst.C]
elseif op == 39 then --[[ ADDK ]]
stack[inst.A] = stack[inst.B] + inst.K
elseif op == 40 then --[[ SUBK ]]
stack[inst.A] = stack[inst.B] - inst.K
elseif op == 41 then --[[ MULK ]]
stack[inst.A] = stack[inst.B] * inst.K
elseif op == 42 then --[[ DIVK ]]
stack[inst.A] = stack[inst.B] / inst.K
elseif op == 43 then --[[ MODK ]]
stack[inst.A] = stack[inst.B] % inst.K
elseif op == 44 then --[[ POWK ]]
stack[inst.A] = stack[inst.B] ^ inst.K
elseif op == 45 then --[[ AND ]]
local value = stack[inst.B]
stack[inst.A] = if value then stack[inst.C] or false else value
elseif op == 46 then --[[ OR ]]
local value = stack[inst.B]
stack[inst.A] = if value then value else stack[inst.C] or false
elseif op == 47 then --[[ ANDK ]]
local value = stack[inst.B]
stack[inst.A] = if value then inst.K or false else value
elseif op == 48 then --[[ ORK ]]
local value = stack[inst.B]
stack[inst.A] = if value then value else inst.K or false
elseif op == 49 then --[[ CONCAT ]]
local B, C = inst.B, inst.C
local success, s = pcall(table_concat, stack, "", B, C)
if not success then
s = stack[B]
for i = B + 1, C do
s ..= stack[i]
end
end
stack[inst.A] = s
elseif op == 50 then --[[ NOT ]]
stack[inst.A] = not stack[inst.B]
elseif op == 51 then --[[ MINUS ]]
stack[inst.A] = -stack[inst.B]
elseif op == 52 then --[[ LENGTH ]]
stack[inst.A] = #stack[inst.B]
elseif op == 53 then --[[ NEWTABLE ]]
stack[inst.A] = table_create(inst.aux)
pc += 1 --// adjust for aux
elseif op == 54 then --[[ DUPTABLE ]]
local template = inst.K
local serialized = {}
for _, id in template do
serialized[constants[id + 1]] = nil
end
stack[inst.A] = serialized
elseif op == 55 then --[[ SETLIST ]]
local A = inst.A
local B = inst.B
local c = inst.C - 1
if c == LUA_MULTRET then
c = top - B + 1
end
table_move(stack, B, B + c - 1, inst.aux, stack[A])
pc += 1 --// adjust for aux
elseif op == 56 then --[[ FORNPREP ]]
local A = inst.A
local limit = stack[A]
if not ttisnumber(limit) then
local number = tonumber(limit)
if number == nil then
error("invalid 'for' limit (number expected)")
end
stack[A] = number
limit = number
end
local step = stack[A + 1]
if not ttisnumber(step) then
local number = tonumber(step)
if number == nil then
error("invalid 'for' step (number expected)")
end
stack[A + 1] = number
step = number
end
local index = stack[A + 2]
if not ttisnumber(index) then
local number = tonumber(index)
if number == nil then
error("invalid 'for' index (number expected)")
end
stack[A + 2] = number
index = number
end
if step > 0 then
if not (index <= limit) then
pc += inst.D
end
else
if not (limit <= index) then
pc += inst.D
end
end
elseif op == 57 then --[[ FORNLOOP ]]
if interruptHook then
interruptHook(stack, debugging, proto, module, upvals)
end
local A = inst.A
local limit = stack[A]
local step = stack[A + 1]
local index = stack[A + 2] + step
stack[A + 2] = index
if step > 0 then
if index <= limit then
pc += inst.D
end
else
if limit <= index then
pc += inst.D
end
end
elseif op == 58 then --[[ FORGLOOP ]]
if interruptHook then
interruptHook(stack, debugging, proto, module, upvals)
end
local A = inst.A
local res = inst.K
top = A + 6
local it = stack[A]
if (luau_settings.generalizedIteration == false) or ttisfunction(it) then
local vals = { it(stack[A + 1], stack[A + 2]) }
table_move(vals, 1, res, A + 3, stack)
if stack[A + 3] ~= nil then
stack[A + 2] = stack[A + 3]
pc += inst.D
else
pc += 1
end
else
local ok, vals = coroutine_resume(generalized_iterators[inst], it, stack[A + 1], stack[A + 2])
if not ok then
error(vals)
end
if vals == LUA_GENERALIZED_TERMINATOR then
generalized_iterators[inst] = nil
pc += 1
else
table_move(vals, 1, res, A + 3, stack)
stack[A + 2] = stack[A + 3]
pc += inst.D
end
end
elseif op == 59 then --[[ FORGPREP_INEXT ]]
if not ttisfunction(stack[inst.A]) then
error(string_format("attempt to iterate over a %s value", type(stack[inst.A]))) -- FORGPREP_INEXT encountered non-function value
end
pc += inst.D
elseif op == 60 then --[[ FASTCALL3 ]]
--[[ Skipped ]]
pc += 1 --// adjust for aux
elseif op == 61 then --[[ FORGPREP_NEXT ]]
if not ttisfunction(stack[inst.A]) then
error(string_format("attempt to iterate over a %s value", type(stack[inst.A]))) -- FORGPREP_NEXT encountered non-function value
end
pc += inst.D
elseif op == 63 then --[[ GETVARARGS ]]
local A = inst.A
local b = inst.B - 1
if b == LUA_MULTRET then
b = varargs.len
top = A + b - 1
end
table_move(varargs.list, 1, b, A, stack)
elseif op == 64 then --[[ DUPCLOSURE ]]
local newPrototype = protolist[inst.K + 1] --// correct behavior would be to reuse the prototype if possible but it would not be useful here
local nups = newPrototype.nups
local upvalues = table_create(nups)
stack[inst.A] = luau_wrapclosure(module, newPrototype, upvalues)
for i = 1, nups do
local pseudo = code[pc]
pc += 1
local type = pseudo.A
if type == 0 then --// value
local upvalue = {
value = stack[pseudo.B],
index = "value",--// self reference
}
upvalue.store = upvalue
upvalues[i] = upvalue
--// references dont get handled by DUPCLOSURE
elseif type == 2 then --// upvalue
upvalues[i] = upvals[pseudo.B + 1]
end
end
elseif op == 65 then --[[ PREPVARARGS ]]
--[[ Handled by wrapper ]]
elseif op == 66 then --[[ LOADKX ]]
local kv = inst.K
stack[inst.A] = kv
pc += 1 --// adjust for aux
elseif op == 67 then --[[ JUMPX ]]
if interruptHook then
interruptHook(stack, debugging, proto, module, upvals)
end
pc += inst.E
elseif op == 68 then --[[ FASTCALL ]]
--[[ Skipped ]]
elseif op == 69 then --[[ COVERAGE ]]
inst.E += 1
elseif op == 70 then --[[ CAPTURE ]]
--[[ Handled by CLOSURE ]]
error("encountered unhandled CAPTURE")
elseif op == 71 then --[[ SUBRK ]]
stack[inst.A] = inst.K - stack[inst.C]
elseif op == 72 then --[[ DIVRK ]]
stack[inst.A] = inst.K / stack[inst.C]
elseif op == 73 then --[[ FASTCALL1 ]]
--[[ Skipped ]]
elseif op == 74 then --[[ FASTCALL2 ]]
--[[ Skipped ]]
pc += 1 --// adjust for aux
elseif op == 75 then --[[ FASTCALL2K ]]
--[[ Skipped ]]
pc += 1 --// adjust for aux
elseif op == 76 then --[[ FORGPREP ]]
local iterator = stack[inst.A]
if luau_settings.generalizedIteration and not ttisfunction(iterator) then
local loopInstruction = code[pc + inst.D]
if generalized_iterators[loopInstruction] == nil then
local function gen_iterator(...)
for r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72, r73, r74, r75, r76, r77, r78, r79, r80, r81, r82, r83, r84, r85, r86, r87, r88, r89, r90, r91, r92, r93, r94, r95, r96, r97, r98, r99, r100, r101, r102, r103, r104, r105, r106, r107, r108, r109, r110, r111, r112, r113, r114, r115, r116, r117, r118, r119, r120, r121, r122, r123, r124, r125, r126, r127, r128, r129, r130, r131, r132, r133, r134, r135, r136, r137, r138, r139, r140, r141, r142, r143, r144, r145, r146, r147, r148, r149, r150, r151, r152, r153, r154, r155, r156, r157, r158, r159, r160, r161, r162, r163, r164, r165, r166, r167, r168, r169, r170, r171, r172, r173, r174, r175, r176, r177, r178, r179, r180, r181, r182, r183, r184, r185, r186, r187, r188, r189, r190, r191, r192, r193, r194, r195, r196, r197, r198, r199, r200 in ... do
coroutine_yield({r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72, r73, r74, r75, r76, r77, r78, r79, r80, r81, r82, r83, r84, r85, r86, r87, r88, r89, r90, r91, r92, r93, r94, r95, r96, r97, r98, r99, r100, r101, r102, r103, r104, r105, r106, r107, r108, r109, r110, r111, r112, r113, r114, r115, r116, r117, r118, r119, r120, r121, r122, r123, r124, r125, r126, r127, r128, r129, r130, r131, r132, r133, r134, r135, r136, r137, r138, r139, r140, r141, r142, r143, r144, r145, r146, r147, r148, r149, r150, r151, r152, r153, r154, r155, r156, r157, r158, r159, r160, r161, r162, r163, r164, r165, r166, r167, r168, r169, r170, r171, r172, r173, r174, r175, r176, r177, r178, r179, r180, r181, r182, r183, r184, r185, r186, r187, r188, r189, r190, r191, r192, r193, r194, r195, r196, r197, r198, r199, r200})
end
coroutine_yield(LUA_GENERALIZED_TERMINATOR)
end
generalized_iterators[loopInstruction] = coroutine_create(gen_iterator)
end
end
pc += inst.D
elseif op == 77 then --[[ JUMPXEQKNIL ]]
local kn = inst.KN
if (stack[inst.A] == nil) ~= kn then
pc += inst.D
else
pc += 1
end
elseif op == 78 then --[[ JUMPXEQKB ]]
local kv = inst.K
local kn = inst.KN
local ra = stack[inst.A]
if (ttisboolean(ra) and (ra == kv)) ~= kn then
pc += inst.D
else
pc += 1
end
elseif op == 79 then --[[ JUMPXEQKN ]]
local kv = inst.K
local kn = inst.KN
local ra = stack[inst.A]
if (ra == kv) ~= kn then
pc += inst.D
else
pc += 1
end
elseif op == 80 then --[[ JUMPXEQKS ]]
local kv = inst.K
local kn = inst.KN
local ra = stack[inst.A]
if (ra == kv) ~= kn then
pc += inst.D
else
pc += 1
end
elseif op == 81 then --[[ IDIV ]]
stack[inst.A] = stack[inst.B] // stack[inst.C]
elseif op == 82 then --[[ IDIVK ]]
stack[inst.A] = stack[inst.B] // inst.K
else
error("Unsupported Opcode: " .. inst.opname .. " op: " .. op)
end
end
for i, uv in open_upvalues do
uv.value = uv.store[uv.index]
uv.store = uv
uv.index = "value" --// self reference
open_upvalues[i] = nil
end
for i, iter in generalized_iterators do
coroutine_close(iter)
generalized_iterators[i] = nil
end
end
local function wrapped(...)
local passed = table_pack(...)
local stack = table_create(proto.maxstacksize)
local varargs = {
len = 0,
list = {},
}
table_move(passed, 1, proto.numparams, 0, stack)
if proto.numparams < passed.n then
local start = proto.numparams + 1
local len = passed.n - proto.numparams
varargs.len = len
table_move(passed, start, start + len - 1, 1, varargs.list)
end
passed = nil
local debugging = {pc = 0, name = "NONE"}
local result
if luau_settings.errorHandling then
result = table_pack(pcall(luau_execute, debugging, stack, proto.protos, proto.code, varargs))
else
result = table_pack(true, luau_execute(debugging, stack, proto.protos, proto.code, varargs))
end
if result[1] then
return table_unpack(result, 2, result.n)
else
local message = result[2]
if panicHook then
panicHook(message, stack, debugging, proto, module, upvals)
end
if ttisstring(message) == false then
if luau_settings.allowProxyErrors then
error(message)
else
message = type(message)
end
end
if proto.lineinfoenabled then
return error(string_format("Fiu VM Error { Name: %s Line: %s PC: %s Opcode: %s }: %s", proto.debugname, proto.instructionlineinfo[debugging.pc], debugging.pc, debugging.name, message), 0)
else
return error(string_format("Fiu VM Error { Name: %s PC: %s Opcode: %s }: %s", proto.debugname, debugging.pc, debugging.name, message), 0)
end
end
end
if luau_settings.errorHandling then
return wrapped
else
return luau_execute
end
end
return luau_wrapclosure(module, mainProto), luau_close
end
return {
luau_newsettings = luau_newsettings,
luau_validatesettings = luau_validatesettings,
luau_deserialize = luau_deserialize,
luau_load = luau_load,
luau_getcoverage = luau_getcoverage,
}
end;
};
G2L_MODULES[G2L["d"]] = {
Closure = function()
local script = G2L["d"];--!optimize 2
--// LuauCeption - Full variant
--// Luau 0.654 (8cc289fae430d9b0c22bde209fe5cf2d01751ff1)
local STUB_WARN = true
--// Vanilla Luau Vector3 implementation
--// Provides Vector3 lib if no existing implementation is available
--// Missing: xAxis, yAxis, zAxis, Magnitude, Unit, and all namecall functions
--// Last checked: 11 December 2024
local type = type
local typeof = typeof
local Vector3 = Vector3 do
local lOk, lRbx = pcall(require, "@lune/roblox")
Vector3 = Vector3 or (if lOk then lRbx.Vector3 else nil) or (if vector then { new = vector.create } else nil)
end
if not Vector3 then
local Vector3Internal = {}
Vector3Internal.__index = Vector3Internal
Vector3Internal.__type = "Vector3"
Vector3Internal.__metatable = "This metatable is locked"
Vector3 = {}
Vector3.new = function(x, y, z)
return setmetatable({X = x or 0, Y = y or 0, Z = z or 0}, Vector3Internal)
end
Vector3.zero = Vector3.new(0,0,0)
Vector3.one = Vector3.new(1,1,1)
table.freeze(Vector3)
Vector3Internal.__concat = function()
assert(false, "attempt to concatenate Vector3 with Vector3")
return
end
Vector3Internal.__unm = function(self)
return Vector3.new(-self.X, -self.Y, -self.Z)
end
Vector3Internal.__add = function(self, v3_2)
v3_2 = if (typeof(v3_2) == "number") then Vector3.new(v3_2, v3_2, v3_2) else v3_2
return Vector3.new(self.X + v3_2.X, self.Y + v3_2.Y, self.Z + v3_2.Z)
end
Vector3Internal.__sub = function(self, v3_2)
v3_2 = if (typeof(v3_2) == "number") then Vector3.new(v3_2, v3_2, v3_2) else v3_2
return Vector3.new(self.X - v3_2.X, self.Y - v3_2.Y, self.Z - v3_2.Z)
end
Vector3Internal.__mul = function(self, v3_2)
v3_2 = if (typeof(v3_2) == "number") then Vector3.new(v3_2, v3_2, v3_2) else v3_2
return Vector3.new(self.X * v3_2.X, self.Y * v3_2.Y, self.Z * v3_2.Z)
end
Vector3Internal.__div = function(self, v3_2)
v3_2 = if (typeof(v3_2) == "number") then Vector3.new(v3_2, v3_2, v3_2) else v3_2
return Vector3.new(self.X / v3_2.X, self.Y / v3_2.Y, self.Z / v3_2.Z)
end
Vector3Internal.__mod = function(_, t)
if (typeof(t) == "table") and (t["__type"] == "Vector3") then
assert(false, "attempt to perform arithmetic (mod) on Vector3")
else
assert(false, "attempt to perform arithmetic (mod) on Vector3 and "..typeof(t))
end
return
end
Vector3Internal.__pow = function(_, t)
if (typeof(t) == "table") and (t["__type"] == "Vector3") then
assert(false, "attempt to perform arithmetic (pow) on Vector3")
else
assert(false, "attempt to perform arithmetic (pow) on Vector3 and "..typeof(t))
end
return
end
Vector3Internal.__tostring = function(self)
return self.X..", "..self.Y..", "..self.Z
end
Vector3Internal.__eq = function(self, v3_2)
if (typeof(v3_2) ~= "Vector3") then return false end
return (self.X == v3_2.X) and (self.Y == v3_2.Y) and (self.Z == v3_2.Z)
end
Vector3Internal.__lt = function(self, v3_2)
if (typeof(v3_2) ~= "Vector3") then return false end
return (self.X < v3_2.X) and (self.Y < v3_2.Y) and (self.Z < v3_2.Z)
end
Vector3Internal.__le = function(self, v3_2)
if (typeof(v3_2) ~= "Vector3") then return false end
return (self.X <= v3_2.X) and (self.Y <= v3_2.Y) and (self.Z <= v3_2.Z)
end
Vector3Internal.__len = function()
assert(false, "attempt to get length of a Vector3 value")
return
end
local oldtype = type
type = function(v)
return if (oldtype(v) == "table") and v["__type"] then v["__type"] else oldtype(v)
end
local oldtypeof = typeof
typeof = function(v)
return if (oldtypeof(v) == "table") and v["__type"] then v["__type"] else oldtypeof(v)
end
end
local function no_op(num)
return num
end
local bit_lshift = bit32.lshift
local bit_rshift = bit32.rshift
local bit_arshift = bit32.arshift
local bit_and = bit32.band
local bit_or = bit32.bor
local bit_xor = bit32.bxor
local bit_not = bit32.bnot
local bit_extract = bit32.extract
local bit_replace = bit32.replace
-- X: a[0 __21]
-- Y: a[22__31]
-- | b[0 __11]
-- Z: b[12__31]
local constructor = Vector3.new
local rt_i64_ZERO = constructor(0, 0, 0)
local function rt_i64_from_u32(data_1, data_2)
local x = bit_and(data_1, 0x3FFFFF)
local y = bit_and(data_2, 0x3FFFFF)
local z = bit_replace(bit_rshift(data_1, 22), bit_rshift(data_2, 22), 10, 10)
return constructor(x, y, z)
end
local function rt_i64_is_zero(value)
return value == rt_i64_ZERO
end
local function load_d1(value)
return bit_replace(bit_and(value.X, 0x3FFFFF), value.Z, 22, 10)
end
local function load_d2(value)
return bit_replace(bit_and(value.Y, 0x3FFFFF), bit_rshift(value.Z, 10), 22, 10)
end
local function rt_i64_into_u32(value)
local x, y, z = value.X, value.Y, value.Z
return bit_replace(bit_and(x, 0x3FFFFF), z, 22, 10), bit_replace(bit_and(y, 0x3FFFFF), bit_rshift(z, 10), 22, 10)
end
local function rt_i64_from_u64(value)
return rt_i64_from_u32(bit_and(value % 0x100000000), bit_and(value / 0x100000000))
end
local function rt_convert_f64_u64(value)
local value_1, value_2 = rt_i64_into_u32(value)
return value_1 + value_2 * 0x100000000
end
local rt_i64_ONE = rt_i64_from_u64(1)
local NUM_SIX_FOUR = rt_i64_from_u64(64)
local NUM_BIT_26 = rt_i64_from_u64(0x4000000)
local NUM_BIT_52 = rt_i64_from_u64(0x10000000000000)
local function rt_add_i64(lhs, rhs)
local lhs_1, lhs_2 = rt_i64_into_u32(lhs)
local rhs_1, rhs_2 = rt_i64_into_u32(rhs)
local data_1 = lhs_1 + rhs_1
local data_2 = lhs_2 + rhs_2
if data_1 >= 0x100000000 then
data_1 = data_1 - 0x100000000
data_2 = data_2 + 1
end
if data_2 >= 0x100000000 then
data_2 = data_2 - 0x100000000
end
return rt_i64_from_u32(data_1, data_2)
end
local function rt_sub_i64(lhs, rhs)
local lhs_1, lhs_2 = rt_i64_into_u32(lhs)
local rhs_1, rhs_2 = rt_i64_into_u32(rhs)
local data_1 = lhs_1 - rhs_1
local data_2 = lhs_2 - rhs_2
if data_1 < 0 then
data_1 = data_1 + 0x100000000
data_2 = data_2 - 1
end
if data_2 < 0 then
data_2 = data_2 + 0x100000000
end
return rt_i64_from_u32(data_1, data_2)
end
local function rt_lt_u64(lhs, rhs)
local data_l_2 = load_d2(lhs)
local data_r_2 = load_d2(rhs)
return data_l_2 < data_r_2 or (data_l_2 == data_r_2 and load_d1(lhs) < load_d1(rhs))
end
local function rt_mul_i64(lhs, rhs)
if rt_i64_is_zero(lhs) or rt_i64_is_zero(rhs) then
return rt_i64_ZERO
elseif rt_lt_u64(lhs, NUM_BIT_26) and rt_lt_u64(rhs, NUM_BIT_26) then
return rt_i64_from_u64(load_d1(lhs) * load_d1(rhs))
end
-- Divide each long into 4 chunks of 16 bits, and then add up 4x4 products_
-- We can skip products that would overflow_
local lhs_1, lhs_2 = rt_i64_into_u32(lhs)
local rhs_1, rhs_2 = rt_i64_into_u32(rhs)
local a48 = bit_rshift(lhs_2, 16)
local a32 = bit_and(lhs_2, 0xFFFF)
local a16 = bit_rshift(lhs_1, 16)
local a00 = bit_and(lhs_1, 0xFFFF)
local b48 = bit_rshift(rhs_2, 16)
local b32 = bit_and(rhs_2, 0xFFFF)
local b16 = bit_rshift(rhs_1, 16)
local b00 = bit_and(rhs_1, 0xFFFF)
local c00 = a00 * b00
local c16 = bit_rshift(c00, 16)
c00 = bit_and(c00, 0xFFFF)
c16 = c16 + a16 * b00
local c32 = bit_rshift(c16, 16)
c16 = bit_and(c16, 0xFFFF)
c16 = c16 + a00 * b16
c32 = c32 + bit_rshift(c16, 16)
c16 = bit_and(c16, 0xFFFF)
c32 = c32 + a32 * b00
local c48 = bit_rshift(c32, 16)
c32 = bit_and(c32, 0xFFFF)
c32 = c32 + a16 * b16
c48 = c48 + bit_rshift(c32, 16)
c32 = bit_and(c32, 0xFFFF)
c32 = c32 + a00 * b32
c48 = c48 + bit_rshift(c32, 16)
c32 = bit_and(c32, 0xFFFF)
c48 = c48 + a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48
c48 = bit_and(c48, 0xFFFF)
local data_1 = bit_replace(c00, c16, 16, 16)
local data_2 = bit_replace(c32, c48, 16, 16)
return rt_i64_from_u32(data_1, data_2)
end
local function rt_bit_or_i64(lhs, rhs)
local x = bit_or(lhs.X, rhs.X)
local y = bit_or(lhs.Y, rhs.Y)
local z = bit_or(lhs.Z, rhs.Z)
return constructor(x, y, z)
end
local function rt_shl_i64(lhs, rhs)
local count = rhs.X % 64
if count == 0 then
return lhs
elseif count < 32 then
local pad = 32 - count
local lhs_1, lhs_2 = rt_i64_into_u32(lhs)
local data_1 = bit_lshift(lhs_1, count)
local data_2 = bit_replace(bit_rshift(lhs_1, pad), lhs_2, count, pad)
return rt_i64_from_u32(data_1, data_2)
else
local lhs_1 = load_d1(lhs)
return rt_i64_from_u32(0, bit_lshift(lhs_1, count - 32))
end
end
local function rt_div_u64(lhs, rhs)
if rt_i64_is_zero(rhs) then
error("division by zero")
elseif rt_i64_is_zero(lhs) then
return rt_i64_ZERO, rt_i64_ZERO
elseif rt_lt_u64(lhs, NUM_BIT_52) and rt_lt_u64(rhs, NUM_BIT_52) then
local lhs_u = rt_convert_f64_u64(lhs)
local rhs_u = rt_convert_f64_u64(rhs)
return rt_i64_from_u64(lhs_u / rhs_u), rt_i64_from_u64(lhs_u % rhs_u)
end
local quotient = rt_i64_ZERO
local remainder = rt_i64_ZERO
local num_1, num_2 = rt_i64_into_u32(lhs)
for i = 63, 0, -1 do
local rem_1, rem_2 = rt_i64_into_u32(rt_shl_i64(remainder, rt_i64_ONE))
if i > 31 then
rem_1 = bit_or(rem_1, bit_extract(num_2, i - 32, 1))
else
rem_1 = bit_or(rem_1, bit_extract(num_1, i, 1))
end
remainder = rt_i64_from_u32(rem_1, rem_2)
if not rt_lt_u64(remainder, rhs) then
remainder = rt_sub_i64(remainder, rhs)
quotient = rt_bit_or_i64(quotient, rt_shl_i64(rt_i64_ONE, rt_i64_from_u32(i, 0)))
end
end
return quotient, remainder
end
local function rt_i64_is_negative(value)
return value.Z >= 0x80000
end
local function rt_i64_negate(value)
local value_1, value_2 = rt_i64_into_u32(value)
local data_1 = bit_not(value_1) + 1
local data_2 = bit_not(value_2)
if data_1 >= 0x100000000 then
data_1 = data_1 - 0x100000000
data_2 = data_2 + 1
end
if data_2 >= 0x100000000 then
data_2 = data_2 - 0x100000000
end
return rt_i64_from_u32(data_1, data_2)
end
local function rt_div_i64(lhs, rhs)
local left_negative = rt_i64_is_negative(lhs)
local right_negative = rt_i64_is_negative(rhs)
if left_negative then
lhs = rt_i64_negate(lhs)
end
if right_negative then
rhs = rt_i64_negate(rhs)
end
local quotient, remainder = rt_div_u64(lhs, rhs)
if left_negative ~= right_negative then
quotient = rt_i64_negate(quotient)
end
if left_negative then
remainder = rt_i64_negate(remainder)
end
return quotient, remainder
end
local function rt_bit_and_i64(lhs, rhs)
local x = bit_and(lhs.X, rhs.X)
local y = bit_and(lhs.Y, rhs.Y)
local z = bit_and(lhs.Z, rhs.Z)
return constructor(x, y, z)
end
local function rt_bit_not_i64(value)
local x = bit_and(bit_not(value.X), 0xFFFFFF)
local y = bit_and(bit_not(value.Y), 0xFFFFFF)
local z = bit_and(bit_not(value.Z), 0xFFFFFF)
return constructor(x, y, z)
end
local function rt_bit_xor_i64(lhs, rhs)
local x = bit_xor(lhs.X, rhs.X)
local y = bit_xor(lhs.Y, rhs.Y)
local z = bit_xor(lhs.Z, rhs.Z)
return constructor(x, y, z)
end
local function rt_shr_u64(lhs, rhs)
local count = rhs.X % 64
if count == 0 then
return lhs
elseif count < 32 then
local lhs_1, lhs_2 = rt_i64_into_u32(lhs)
local data_1 = bit_replace(bit_rshift(lhs_1, count), lhs_2, 32 - count, count)
local data_2 = bit_rshift(lhs_2, count)
return rt_i64_from_u32(data_1, data_2)
else
local lhs_2 = load_d2(lhs)
return rt_i64_from_u32(bit_rshift(lhs_2, count - 32), 0)
end
end
local function rt_shr_i64(lhs, rhs)
local count = rhs.X % 64
if count == 0 then
return lhs
elseif count < 32 then
local lhs_1, lhs_2 = rt_i64_into_u32(lhs)
local data_1 = bit_replace(bit_rshift(lhs_1, count), lhs_2, 32 - count, count)
local data_2 = bit_arshift(lhs_2, count)
return rt_i64_from_u32(data_1, data_2)
else
local lhs_2 = load_d2(lhs)
local data_1 = bit_arshift(lhs_2, count - 32)
local data_2 = lhs_2 >= 0x80000000 and 0xFFFFFFFF or 0
return rt_i64_from_u32(data_1, data_2)
end
end
local function rt_rotl_i64(lhs, rhs)
if rt_i64_is_zero(rhs) then
return lhs
else
local data_1 = rt_shl_i64(lhs, rhs)
local data_2 = rt_shr_u64(lhs, rt_sub_i64(NUM_SIX_FOUR, rhs))
return rt_bit_or_i64(data_1, data_2)
end
end
local function rt_rotr_i64(lhs, rhs)
if rt_i64_is_zero(rhs) then
return lhs
else
local data_1 = rt_shr_u64(lhs, rhs)
local data_2 = rt_shl_i64(lhs, rt_sub_i64(NUM_SIX_FOUR, rhs))
return rt_bit_or_i64(data_1, data_2)
end
end
local function rt_eq_i64(lhs, rhs)
return lhs == rhs
end
local function rt_gt_u64(lhs, rhs)
local data_l_2 = load_d2(lhs)
local data_r_2 = load_d2(rhs)
return data_l_2 > data_r_2 or (data_l_2 == data_r_2 and load_d1(lhs) > load_d1(rhs))
end
local function rt_lt_i64(lhs, rhs)
local neg_a = rt_i64_is_negative(lhs)
local neg_b = rt_i64_is_negative(rhs)
if neg_a and not neg_b then
return true
elseif not neg_a and neg_b then
return false
else
return rt_i64_is_negative(rt_sub_i64(lhs, rhs))
end
end
local function rt_gt_i64(lhs, rhs)
local neg_a = rt_i64_is_negative(lhs)
local neg_b = rt_i64_is_negative(rhs)
if neg_a and not neg_b then
return false
elseif not neg_a and neg_b then
return true
else
return rt_i64_is_negative(rt_sub_i64(rhs, lhs))
end
end
local function rt_convert_f64_i32(num)
return bit_xor(num, 0x80000000) - 0x80000000
end
local assert = assert
local math_abs = math.abs
local math_fmod = math.fmod
local math_modf = math.modf
local math_round = math.round
local math_sign = math.sign
local math_min = math.min
local math_max = math.max
local function rt_add_i32(lhs, rhs)
return bit_or(lhs + rhs, 0)
end
local function rt_sub_i32(lhs, rhs)
return bit_or(lhs - rhs, 0)
end
local function rt_mul_i32(lhs, rhs)
if (lhs + rhs) < 0x8000000 then
return bit_or(lhs * rhs, 0)
else
local a16 = bit_rshift(lhs, 16)
local a00 = bit_and(lhs, 0xFFFF)
local b16 = bit_rshift(rhs, 16)
local b00 = bit_and(rhs, 0xFFFF)
local c00 = a00 * b00
local c16 = a16 * b00 + a00 * b16
return bit_or(c00 + bit_lshift(c16, 16), 0)
end
end
local function rt_div_i32(lhs, rhs)
assert(rhs ~= 0, "division by zero")
lhs = rt_convert_f64_i32(lhs)
rhs = rt_convert_f64_i32(rhs)
return bit_or(math_modf(lhs / rhs), 0)
end
local function rt_div_u32(lhs, rhs)
assert(rhs ~= 0, "division by zero")
return bit_or(math_modf(lhs / rhs), 0)
end
local function rt_rem_i32(lhs, rhs)
assert(rhs ~= 0, "division by zero")
lhs = rt_convert_f64_i32(lhs)
rhs = rt_convert_f64_i32(rhs)
return bit_or(math_fmod(lhs, rhs), 0)
end
local function rt_rem_i64(lhs, rhs)
local _, remainder = rt_div_i64(lhs, rhs)
return remainder
end
local function rt_rem_u64(lhs, rhs)
local _, remainder = rt_div_u64(lhs, rhs)
return remainder
end
local function rt_neg_f64(num)
return -num
end
local function rt_min_f64(lhs, rhs)
if rhs == rhs then
return math_min(lhs, rhs)
else
return rhs
end
end
local function rt_max_f64(lhs, rhs)
if rhs == rhs then
return math_max(lhs, rhs)
else
return rhs
end
end
local buffer_create = buffer.create
local CP_INSTANCE = buffer_create(8)
local buffer_write_f64 = buffer.writef64
local buffer_read_i8 = buffer.readi8
local function rt_copysign_f64(lhs, rhs)
buffer_write_f64(CP_INSTANCE, 0, rhs)
if buffer_read_i8(CP_INSTANCE, 7) >= 0 then
return (math_abs(lhs))
else
return -math_abs(lhs)
end
end
local function rt_nearest_f32(num)
local result = math_round(num)
if (math_abs(num) + 0.5) % 2 == 1 then
return result - math_sign(result)
else
return result
end
end
local bit_countlz = bit32.countlz
local bit_countrz = bit32.countrz
local function rt_popcnt_i32(num)
num = num - bit_and(bit_rshift(num, 1), 0x55555555)
num = bit_and(num, 0x33333333) + bit_and(bit_rshift(num, 2), 0x33333333)
num = bit_and((num + bit_rshift(num, 4)), 0x0F0F0F0F)
num = num + bit_rshift(num, 8)
num = num + bit_rshift(num, 16)
return bit_and(num, 0x0000003F)
end
local function rt_clz_i64(num)
local data_1, data_2 = rt_i64_into_u32(num)
local temp
if data_2 == 0 then
temp = bit_countlz(data_1) + 32
else
temp = bit_countlz(data_2)
end
return rt_i64_from_u32(temp, 0)
end
local function rt_ctz_i64(num)
local data_1, data_2 = rt_i64_into_u32(num)
local temp
if data_1 == 0 then
temp = bit_countrz(data_2) + 32
else
temp = bit_countrz(data_1)
end
return rt_i64_from_u32(temp, 0)
end
local function rt_popcnt_i64(num)
local data_1, data_2 = rt_i64_into_u32(num)
local temp = rt_popcnt_i32(data_1) + rt_popcnt_i32(data_2)
return rt_i64_from_u32(temp, 0)
end
local function rt_le_i32(lhs, rhs)
return rt_convert_f64_i32(lhs) <= rt_convert_f64_i32(rhs)
end
local function rt_lt_i32(lhs, rhs)
return rt_convert_f64_i32(lhs) < rt_convert_f64_i32(rhs)
end
local function rt_ge_i32(lhs, rhs)
return rt_convert_f64_i32(lhs) >= rt_convert_f64_i32(rhs)
end
local function rt_gt_i32(lhs, rhs)
return rt_convert_f64_i32(lhs) > rt_convert_f64_i32(rhs)
end
local function rt_ne_i64(lhs, rhs)
return not rt_eq_i64(lhs, rhs)
end
local function rt_le_i64(lhs, rhs)
return rt_lt_i64(lhs, rhs) or rt_eq_i64(lhs, rhs)
end
local function rt_le_u64(lhs, rhs)
return rt_lt_u64(lhs, rhs) or rt_eq_i64(lhs, rhs)
end
local function rt_ge_i64(lhs, rhs)
return rt_gt_i64(lhs, rhs) or rt_eq_i64(lhs, rhs)
end
local function rt_ge_u64(lhs, rhs)
return rt_gt_u64(lhs, rhs) or rt_eq_i64(lhs, rhs)
end
local bit_lrotate = bit32.lrotate
local bit_rrotate = bit32.rrotate
local function rt_shl_i32(lhs, rhs)
return bit_lshift(lhs, rhs % 32)
end
local function rt_shr_u32(lhs, rhs)
return bit_rshift(lhs, rhs % 32)
end
local function rt_shr_i32(lhs, rhs)
return bit_arshift(lhs, rhs % 32)
end
local function rt_rotl_i32(lhs, rhs)
return bit_lrotate(lhs, rhs % 32)
end
local function rt_rotr_i32(lhs, rhs)
return bit_rrotate(lhs, rhs % 32)
end
local math_ceil = math.ceil
local math_floor = math.floor
local math_clamp = math.clamp
local NUM_MIN_I64 = rt_i64_from_u32(0, 0x80000000)
local NUM_MAX_I64 = rt_i64_from_u32(0xFFFFFFFF, 0x7FFFFFFF)
local NUM_MAX_U64 = rt_i64_from_u32(0xFFFFFFFF, 0xFFFFFFFF)
local function rt_truncate_f64(num)
if num >= 0 then
return math_floor(num)
else
return math_ceil(num)
end
end
local function rt_wrap_i32_i64(num)
local data_1, _ = rt_i64_into_u32(num)
return data_1
end
local function rt_truncate_i32_f64(num)
return bit_or(rt_truncate_f64(num), 0)
end
local function rt_truncate_i64_f64(num)
if num < 0 then
local temp = rt_i64_from_u64(-num)
return rt_i64_negate(temp)
else
return rt_i64_from_u64(num)
end
end
local function rt_truncate_u64_f64(num)
if num <= 0 then
return rt_i64_ZERO
else
return rt_i64_from_u64(math_floor(num))
end
end
local function rt_saturate_i32_f64(num)
local temp = math_clamp(rt_truncate_f64(num), -0x80000000, 0x7FFFFFFF)
return bit_or(temp, 0)
end
local function rt_saturate_u32_f64(num)
return math_clamp(rt_truncate_f64(num), 0, 0xFFFFFFFF)
end
local function rt_saturate_i64_f64(num)
if num >= 2 ^ 63 - 1 then
return NUM_MAX_I64
elseif num <= -2 ^ 63 then
return NUM_MIN_I64
else
return rt_truncate_i64_f64(num)
end
end
local function rt_saturate_u64_f64(num)
if num >= 2 ^ 64 then
return NUM_MAX_U64
elseif num <= 0 then
return rt_i64_ZERO
else
return rt_truncate_i64_f64(num)
end
end
local function rt_extend_i32_n8(num)
num = bit_and(num, 0xFF)
if num >= 0x80 then
return bit_or(num - 0x100, 0)
else
return num
end
end
local function rt_extend_i32_n16(num)
num = bit_and(num, 0xFFFF)
if num >= 0x8000 then
return bit_or(num - 0x10000, 0)
else
return num
end
end
local function rt_extend_i64_n8(num)
local data_1, _ = rt_i64_into_u32(num)
data_1 = bit_and(data_1, 0xFF)
if data_1 >= 0x80 then
local temp = rt_i64_from_u32(-data_1 + 0x100, 0)
return rt_i64_negate(temp)
else
return rt_i64_from_u32(data_1, 0)
end
end
local function rt_extend_i64_n16(num)
local data_1, _ = rt_i64_into_u32(num)
data_1 = bit_and(data_1, 0xFFFF)
if data_1 >= 0x8000 then
local temp = rt_i64_from_u32(-data_1 + 0x10000, 0)
return rt_i64_negate(temp)
else
return rt_i64_from_u32(data_1, 0)
end
end
local function rt_extend_i64_n32(num)
local data_1, _ = rt_i64_into_u32(num)
if data_1 >= 0x80000000 then
local temp = rt_i64_from_u32(-data_1 + 0x100000000, 0)
return rt_i64_negate(temp)
else
return rt_i64_from_u32(data_1, 0)
end
end
local function rt_extend_i64_i32(num)
if num >= 0x80000000 then
local temp = rt_i64_from_u32(-num + 0x100000000, 0)
return rt_i64_negate(temp)
else
return rt_i64_from_u32(num, 0)
end
end
local function rt_extend_i64_u32(num)
return rt_i64_from_u32(num, 0)
end
local function rt_convert_f64_i64(num)
if rt_i64_is_negative(num) then
local temp = rt_i64_negate(num)
return -rt_convert_f64_u64(temp)
else
return rt_convert_f64_u64(num)
end
end
local RE_INSTANCE = buffer_create(8)
local buffer_read_f32 = buffer.readf32
local buffer_read_f64 = buffer.readf64
local buffer_read_u32 = buffer.readu32
local buffer_write_f32 = buffer.writef32
local buffer_write_u32 = buffer.writeu32
local function rt_reinterpret_i32_f32(num)
buffer_write_f32(RE_INSTANCE, 0, num)
return buffer_read_u32(RE_INSTANCE, 0)
end
local function rt_reinterpret_i64_f64(num)
buffer_write_f64(RE_INSTANCE, 0, num)
local data_1 = buffer_read_u32(RE_INSTANCE, 0)
local data_2 = buffer_read_u32(RE_INSTANCE, 4)
return rt_i64_from_u32(data_1, data_2)
end
local function rt_reinterpret_f32_i32(num)
buffer_write_u32(RE_INSTANCE, 0, num)
return buffer_read_f32(RE_INSTANCE, 0)
end
local function rt_reinterpret_f64_i64(num)
local data_1, data_2 = rt_i64_into_u32(num)
buffer_write_u32(RE_INSTANCE, 0, data_1)
buffer_write_u32(RE_INSTANCE, 4, data_2)
return buffer_read_f64(RE_INSTANCE, 0)
end
local string_sub = string.sub
local buffer_to_string = buffer.tostring
local buffer_from_string = buffer.fromstring
local buffer_len = buffer.len
local buffer_copy = buffer.copy
local buffer_fill = buffer.fill
local buffer_read_u8 = buffer.readu8
local buffer_read_i16 = buffer.readi16
local buffer_read_u16 = buffer.readu16
local buffer_read_i32 = buffer.readi32
local buffer_write_u8 = buffer.writeu8
local buffer_write_u16 = buffer.writeu16
local function rt_load_i32_i8(memory, addr)
return bit_or(buffer_read_i8(memory.data, addr), 0)
end
local function rt_load_i32_u8(memory, addr)
return buffer_read_u8(memory.data, addr)
end
local function rt_load_i32_i16(memory, addr)
return bit_or(buffer_read_i16(memory.data, addr), 0)
end
local function rt_load_i32_u16(memory, addr)
return buffer_read_u16(memory.data, addr)
end
local function rt_load_i32(memory, addr)
return buffer_read_u32(memory.data, addr)
end
local function rt_load_i64_i8(memory, addr)
local value = buffer_read_i8(memory.data, addr)
if value >= 0 then
return rt_i64_from_u32(value, 0)
else
return rt_i64_from_u32(value + 0x100000000, 0xFFFFFFFF)
end
end
local function rt_load_i64_u8(memory, addr)
return rt_i64_from_u32(buffer_read_u8(memory.data, addr), 0)
end
local function rt_load_i64_i16(memory, addr)
local value = buffer_read_i16(memory.data, addr)
if value >= 0 then
return rt_i64_from_u32(value, 0)
else
return rt_i64_from_u32(value + 0x100000000, 0xFFFFFFFF)
end
end
local function rt_load_i64_u16(memory, addr)
return rt_i64_from_u32(buffer_read_u16(memory.data, addr), 0)
end
local function rt_load_i64_i32(memory, addr)
local value = buffer_read_i32(memory.data, addr)
if value >= 0 then
return rt_i64_from_u32(value, 0)
else
return rt_i64_from_u32(value + 0x100000000, 0xFFFFFFFF)
end
end
local function rt_load_i64_u32(memory, addr)
return rt_i64_from_u32(buffer_read_u32(memory.data, addr), 0)
end
local function rt_load_i64(memory, addr)
local data = memory.data
local value_1 = buffer_read_u32(data, addr)
local value_2 = buffer_read_u32(data, addr + 4)
return rt_i64_from_u32(value_1, value_2)
end
local function rt_load_f32(memory, addr)
return buffer_read_f32(memory.data, addr)
end
local function rt_load_f64(memory, addr)
return buffer_read_f64(memory.data, addr)
end
local function rt_load_string(memory, addr, len)
local temp = buffer_create(len)
buffer_copy(temp, 0, memory.data, addr, len)
return buffer_to_string(temp)
end
local function rt_store_i32_n8(memory, addr, value)
buffer_write_u8(memory.data, addr, value)
end
local function rt_store_i32_n16(memory, addr, value)
buffer_write_u16(memory.data, addr, value)
end
local function rt_store_i32(memory, addr, value)
buffer_write_u32(memory.data, addr, value)
end
local function rt_store_i64_n8(memory, addr, value)
local value_1, _ = rt_i64_into_u32(value)
buffer_write_u8(memory.data, addr, value_1)
end
local function rt_store_i64_n16(memory, addr, value)
local value_1, _ = rt_i64_into_u32(value)
buffer_write_u16(memory.data, addr, value_1)
end
local function rt_store_i64_n32(memory, addr, value)
local value_1, _ = rt_i64_into_u32(value)
buffer_write_u32(memory.data, addr, value_1)
end
local function rt_store_i64(memory, addr, value)
local data = memory.data
local value_1, value_2 = rt_i64_into_u32(value)
buffer_write_u32(data, addr, value_1)
buffer_write_u32(data, addr + 4, value_2)
end
local function rt_store_f32(memory, addr, value)
buffer_write_f32(memory.data, addr, value)
end
local function rt_store_f64(memory, addr, value)
buffer_write_f64(memory.data, addr, value)
end
local function rt_store_string(memory, addr, data, len)
local content = if not len or len == #data then data else string_sub(data, 1, len)
local temp = buffer_from_string(content)
buffer_copy(memory.data, addr, temp)
end
local function rt_store_copy(memory_1, addr_1, memory_2, addr_2, len)
buffer_copy(memory_1.data, addr_1, memory_2.data, addr_2, len)
end
local function rt_store_fill(memory, addr, len, value)
buffer_fill(memory.data, addr, value, len)
end
local WASM_PAGE_SIZE = 65536
local function rt_allocator_new(min, max)
return { max = max, data = buffer_create(min * WASM_PAGE_SIZE) }
end
local function rt_allocator_size(memory)
return buffer_len(memory.data) / WASM_PAGE_SIZE
end
local function rt_allocator_grow(memory, num)
local old = rt_allocator_size(memory)
local new = old + num
if new <= memory.max then
local reallocated = buffer_create(new * WASM_PAGE_SIZE)
buffer_copy(reallocated, 0, memory.data)
memory.data = reallocated
return old
else
return 0xFFFFFFFF
end
end
local memory_at_0
local FUNC_LIST = table.create(1443)
local TABLE_LIST = table.create(0)
local MEMORY_LIST = table.create(0)
local GLOBAL_LIST = table.create(1)
FUNC_LIST[14] = --[[ Luau::Compile::assignMutable(Luau::DenseHashMap<Luau::AstName, Luau::Compile::Global, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName>>&, Luau::AstNameTable const&, char const* const*) ]] function(loc_0, loc_1, loc_2)
local loc_3 = 0
local loc_4 = 0
local reg_0
local reg_1
while true do
loc_4 = rt_sub_i32(GLOBAL_LIST[0].value, 16)
GLOBAL_LIST[0].value = loc_4
reg_1 = FUNC_LIST[1007](loc_1, 9932)
loc_3 = reg_1
rt_store_i32(memory_at_0, loc_4 + 12, loc_3)
if loc_3 ~= 0 then
while true do
reg_0 = FUNC_LIST[15](loc_0, rt_add_i32(loc_4, 12))
rt_store_i32(memory_at_0, reg_0, 1)
break
end
end
while true do
if loc_2 == 0 then
break
end
loc_3 = rt_load_i32(memory_at_0, loc_2)
if loc_3 == 0 then
break
end
while true do
reg_1 = FUNC_LIST[1007](loc_1, loc_3)
loc_3 = reg_1
rt_store_i32(memory_at_0, loc_4 + 8, loc_3)
if loc_3 ~= 0 then
while true do
reg_0 = FUNC_LIST[15](loc_0, rt_add_i32(loc_4, 8))
rt_store_i32(memory_at_0, reg_0, 1)
break
end
end
loc_3 = rt_load_i32(memory_at_0, loc_2 + 4)
loc_2 = rt_add_i32(loc_2, 4)
if loc_3 ~= 0 then
continue
end
break
end
break
end
GLOBAL_LIST[0].value = rt_add_i32(loc_4, 16)
break
end
end
FUNC_LIST[15] = --[[ Luau::DenseHashMap<Luau::AstName, Luau::Compile::Global, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName>>::operator[](Luau::AstName const&) ]] function(loc_0, loc_1)
local loc_2 = 0
local loc_3 = 0
local loc_4 = 0
local loc_5 = 0
local loc_6 = 0
local loc_7 = 0
local loc_8 = 0
local loc_9 = 0
local reg_0
local desired
while true do
while true do
loc_3 = rt_load_i32(memory_at_0, loc_0 + 8)
loc_6 = rt_load_i32(memory_at_0, loc_0 + 4)
if loc_3 < rt_shr_u32(rt_mul_i32(loc_6, 3), 2) then
break
end
while true do
if loc_3 == 0 then
break
end
loc_4 = rt_load_i32(memory_at_0, loc_1)
loc_8 = rt_load_i32(memory_at_0, loc_0 + 12)
if loc_4 == loc_8 then
break
end
loc_2 = bit_xor(rt_shr_u32(loc_4, 4), rt_shr_u32(loc_4, 9))
loc_7 = rt_sub_i32(loc_6, 1)
loc_9 = rt_load_i32(memory_at_0, loc_0)
loc_3 = 0
while true do
loc_5 = bit_and(loc_2, loc_7)
loc_2 = rt_load_i32(memory_at_0, rt_add_i32(rt_shl_i32(loc_5, 3), loc_9))
if loc_4 == loc_2 then
desired = 1
break
end
if loc_2 == loc_8 then
desired = 2
break
end
loc_3 = rt_add_i32(loc_3, 1)
loc_2 = rt_add_i32(loc_5, loc_3)
if loc_3 <= loc_7 then
continue
end
break
end
if desired then
if desired == 2 then
desired = nil
end
break
end
break
end
if desired then
if desired == 1 then
desired = nil
end
break
end
FUNC_LIST[16](loc_0)
loc_6 = rt_load_i32(memory_at_0, loc_0 + 4)
break
end
while true do
while true do
loc_8 = rt_load_i32(memory_at_0, loc_0)
loc_6 = rt_sub_i32(loc_6, 1)
loc_5 = rt_load_i32(memory_at_0, loc_1)
loc_3 = bit_and(loc_6, bit_xor(rt_shr_u32(loc_5, 4), rt_shr_u32(loc_5, 9)))
loc_4 = rt_add_i32(loc_8, rt_shl_i32(loc_3, 3))
loc_2 = rt_load_i32(memory_at_0, loc_4)
loc_9 = rt_load_i32(memory_at_0, loc_0 + 12)
if loc_2 == loc_9 then
break
end
if loc_2 == loc_5 then
desired = 1
break
end
loc_2 = 0
while true do
loc_2 = rt_add_i32(loc_2, 1)
loc_3 = bit_and(loc_6, rt_add_i32(loc_3, loc_2))
loc_4 = rt_add_i32(rt_shl_i32(loc_3, 3), loc_8)
loc_7 = rt_load_i32(memory_at_0, loc_4)
if loc_9 == loc_7 then
desired = 2
break
end
if loc_5 ~= loc_7 then
continue
end
break
end
if desired then
if desired == 2 then
desired = nil
end
break
end
desired = 1
break
end
if desired then
if desired == 1 then
desired = nil
end
break
end
rt_store_i32(memory_at_0, loc_4, loc_5)
rt_store_i32(memory_at_0, loc_0 + 8, rt_add_i32(rt_load_i32(memory_at_0, loc_0 + 8), 1))
break
end
reg_0 = rt_add_i32(loc_4, 4)
break
end
return reg_0
end
FUNC_LIST[16] = --[[ Luau::detail::DenseHashTable<Luau::AstName, std::__2::pair<Luau::AstName, Luau::Compile::Global>, std::__2::pair<Luau::AstName const, Luau::Compile::Global>, Luau::detail::ItemInterfaceMap<Luau::AstName, Luau::Compile::Global>, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName>>::rehash() ]] function(loc_0)
local loc_1 = 0
local loc_2 = 0
local loc_3 = 0
local loc_4 = 0
local loc_5 = 0
local loc_6 = 0
local loc_7 = 0
local loc_8 = 0
local loc_9 = 0
local loc_10 = 0
local loc_11 = 0
local loc_12 = 0
local reg_0
local desired
while true do
loc_11 = rt_load_i32(memory_at_0, loc_0 + 12)
while true do
loc_10 = rt_load_i32(memory_at_0, loc_0 + 4)
loc_6 = (if loc_10 ~= 0 then rt_shl_i32(loc_10, 1) else 16)
if loc_6 == 0 then
while true do
desired = 1
break
end
if desired then
if desired == 1 then
desired = nil
end
break
end
end
loc_8 = bit_and(loc_6, 2)
reg_0 = FUNC_LIST[1310](rt_shl_i32(loc_6, 3))
loc_7 = reg_0
loc_3 = rt_load_i32(memory_at_0, loc_0 + 12)
if loc_6 >= 4 then
while true do
loc_9 = bit_and(loc_6, 4294967292)
while true do
loc_1 = rt_add_i32(rt_shl_i32(loc_2, 3), loc_7)
rt_store_i32(memory_at_0, loc_1 + 4, 0)
rt_store_i32(memory_at_0, loc_1, loc_3)
rt_store_i32(memory_at_0, loc_1 + 8, loc_3)
rt_store_i32(memory_at_0, loc_1 + 12, 0)
rt_store_i32(memory_at_0, loc_1 + 20, 0)
rt_store_i32(memory_at_0, loc_1 + 16, loc_3)
rt_store_i32(memory_at_0, loc_1 + 28, 0)
rt_store_i32(memory_at_0, loc_1 + 24, loc_3)
loc_2 = rt_add_i32(loc_2, 4)
loc_5 = rt_add_i32(loc_5, 4)
if loc_9 ~= loc_5 then
continue
end
break
end
if desired then
break
end
break
end
if desired then
if desired == 1 then
desired = nil
end
break
end
end
if loc_8 ~= 0 then
while true do
while true do
loc_1 = rt_add_i32(rt_shl_i32(loc_2, 3), loc_7)
rt_store_i32(memory_at_0, loc_1 + 4, 0)
rt_store_i32(memory_at_0, loc_1, loc_3)
loc_2 = rt_add_i32(loc_2, 1)
loc_4 = rt_add_i32(loc_4, 1)
if loc_8 ~= loc_4 then
continue
end
break
end
if desired then
break
end
break
end
if desired then
if desired == 1 then
desired = nil
end
break
end
end
loc_10 = rt_load_i32(memory_at_0, loc_0 + 4)
break
end
if loc_10 ~= 0 then
while true do
loc_8 = rt_sub_i32(loc_6, 1)
loc_9 = 0
while true do
loc_12 = rt_add_i32(rt_load_i32(memory_at_0, loc_0), rt_shl_i32(loc_9, 3))
loc_4 = rt_load_i32(memory_at_0, loc_12)
if loc_4 ~= rt_load_i32(memory_at_0, loc_0 + 12) then
while true do
while true do
while true do
loc_1 = bit_and(loc_8, bit_xor(rt_shr_u32(loc_4, 4), rt_shr_u32(loc_4, 9)))
loc_5 = rt_add_i32(rt_shl_i32(loc_1, 3), loc_7)
loc_3 = rt_load_i32(memory_at_0, loc_5)
if loc_11 == loc_3 then
break
end
loc_2 = 0
if loc_3 == loc_4 then
desired = 4
break
end
while true do
loc_2 = rt_add_i32(loc_2, 1)
loc_1 = bit_and(loc_8, rt_add_i32(loc_1, loc_2))
loc_5 = rt_add_i32(rt_shl_i32(loc_1, 3), loc_7)
loc_3 = rt_load_i32(memory_at_0, loc_5)
if loc_11 == loc_3 then
desired = 5
break
end
if loc_3 ~= loc_4 then
continue
end
break
end
if desired then
if desired == 5 then
desired = nil
end
break
end
desired = 4
break
end
if desired then
if desired == 4 then
desired = nil
end
break
end
rt_store_i32(memory_at_0, loc_5, loc_4)
break
end
if desired then
break
end
rt_store_i32(memory_at_0, loc_5, loc_4)
rt_store_i32(memory_at_0, loc_5 + 4, rt_load_i32(memory_at_0, loc_12 + 4))
break
end
if desired then
if desired == 2 then
desired = nil
continue
end
break
end
end
loc_9 = rt_add_i32(loc_9, 1)
if loc_10 ~= loc_9 then
continue
end
break
end
break
end
end
rt_store_i32(memory_at_0, loc_0 + 4, loc_6)
loc_1 = rt_load_i32(memory_at_0, loc_0)
rt_store_i32(memory_at_0, loc_0, loc_7)
if loc_1 ~= 0 then
while true do
FUNC_LIST[1316](loc_1)
break
end
end
break
end
end
FUNC_LIST[17] = --[[ Luau::Compile::trackValues(Luau::DenseHashMap<Luau::AstName, Luau::Compile::Global, std::__2::hash<Luau::AstName>, std::__2::equal_to<Luau::AstName>>&, Luau::DenseHashMap<Luau::AstLocal*, Luau::Compile::Variable, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*>>&, Luau::AstNode*) ]] function(loc_0, loc_1, loc_2)
local loc_3 = 0
while true do
loc_3 = rt_sub_i32(GLOBAL_LIST[0].value, 16)
GLOBAL_LIST[0].value = loc_3
rt_store_i32(memory_at_0, loc_3 + 12, loc_1)
rt_store_i32(memory_at_0, loc_3 + 8, loc_0)
rt_store_i32(memory_at_0, loc_3 + 4, 13272)
TABLE_LIST[0].data[rt_load_i32(memory_at_0, rt_load_i32(memory_at_0, loc_2))](loc_2, rt_add_i32(loc_3, 4))
GLOBAL_LIST[0].value = rt_add_i32(loc_3, 16)
break
end
end
FUNC_LIST[18] = --[[ Luau::Compile::ValueVisitor::~ValueVisitor() ]] function(loc_0)
while true do
FUNC_LIST[1317](loc_0, 12)
break
end
end
FUNC_LIST[19] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatLocal*) ]] function(loc_0, loc_1)
local loc_2 = 0
local loc_3 = 0
local loc_4 = 0
local reg_0
local desired
while true do
while true do
loc_3 = rt_load_i32(memory_at_0, loc_1 + 32)
if loc_3 == 0 then
break
end
while true do
if rt_load_i32(memory_at_0, loc_1 + 40) == 0 then
break
end
while true do
loc_3 = rt_shl_i32(loc_2, 2)
loc_4 = rt_load_i32(memory_at_0, rt_add_i32(loc_3, rt_load_i32(memory_at_0, loc_1 + 36)))
reg_0 = FUNC_LIST[20](rt_load_i32(memory_at_0, loc_0 + 8), rt_add_i32(loc_3, rt_load_i32(memory_at_0, loc_1 + 28)))
rt_store_i32(memory_at_0, reg_0, loc_4)
loc_2 = rt_add_i32(loc_2, 1)
loc_3 = rt_load_i32(memory_at_0, loc_1 + 32)
if loc_2 >= loc_3 then
desired = 2
break
end
if rt_load_i32(memory_at_0, loc_1 + 40) > loc_2 then
continue
end
break
end
if desired then
if desired == 2 then
desired = nil
end
break
end
break
end
if desired then
if desired == 1 then
desired = nil
end
break
end
loc_2 = rt_load_i32(memory_at_0, loc_1 + 40)
if loc_3 <= loc_2 then
break
end
while true do
reg_0 = FUNC_LIST[20](rt_load_i32(memory_at_0, loc_0 + 8), rt_add_i32(rt_load_i32(memory_at_0, loc_1 + 28), rt_shl_i32(loc_2, 2)))
rt_store_i32(memory_at_0, reg_0, 0)
loc_2 = rt_add_i32(loc_2, 1)
if loc_2 < rt_load_i32(memory_at_0, loc_1 + 32) then
continue
end
break
end
if desired then
if desired == 1 then
desired = nil
end
break
end
break
end
reg_0 = 1
break
end
return reg_0
end
FUNC_LIST[20] = --[[ Luau::DenseHashMap<Luau::AstLocal*, Luau::Compile::Variable, Luau::DenseHashPointer, std::__2::equal_to<Luau::AstLocal*>>::operator[](Luau::AstLocal* const&) ]] function(loc_0, loc_1)
local loc_2 = 0
local loc_3 = 0
local loc_4 = 0
local loc_5 = 0
local loc_6 = 0
local loc_7 = 0
local loc_8 = 0
local loc_9 = 0
local reg_0
local desired
while true do
while true do
loc_3 = rt_load_i32(memory_at_0, loc_0 + 8)
loc_6 = rt_load_i32(memory_at_0, loc_0 + 4)
if loc_3 < rt_shr_u32(rt_mul_i32(loc_6, 3), 2) then
break
end
while true do
if loc_3 == 0 then
break
end
loc_4 = rt_load_i32(memory_at_0, loc_1)
loc_8 = rt_load_i32(memory_at_0, loc_0 + 12)
if loc_4 == loc_8 then
break
end
loc_2 = bit_xor(rt_shr_u32(loc_4, 4), rt_shr_u32(loc_4, 9))
loc_7 = rt_sub_i32(loc_6, 1)
loc_9 = rt_load_i32(memory_at_0, loc_0)
loc_3 = 0
while true do
loc_5 = bit_and(loc_2, loc_7)
loc_2 = rt_load_i32(memory_at_0, rt_add_i32(rt_mul_i32(loc_5, 12), loc_9))
if loc_4 == loc_2 then
desired = 1
break
end
if loc_2 == loc_8 then
desired = 2
break
end
loc_3 = rt_add_i32(loc_3, 1)
loc_2 = rt_add_i32(loc_5, loc_3)
if loc_3 <= loc_7 then
continue
end
break
end
if desired then
if desired == 2 then
desired = nil
end
break
end
break
end
if desired then
if desired == 1 then
desired = nil
end
break
end
FUNC_LIST[25](loc_0)
loc_6 = rt_load_i32(memory_at_0, loc_0 + 4)
break
end
while true do
while true do
loc_8 = rt_load_i32(memory_at_0, loc_0)
loc_6 = rt_sub_i32(loc_6, 1)
loc_5 = rt_load_i32(memory_at_0, loc_1)
loc_3 = bit_and(loc_6, bit_xor(rt_shr_u32(loc_5, 4), rt_shr_u32(loc_5, 9)))
loc_4 = rt_add_i32(loc_8, rt_mul_i32(loc_3, 12))
loc_2 = rt_load_i32(memory_at_0, loc_4)
loc_9 = rt_load_i32(memory_at_0, loc_0 + 12)
if loc_2 == loc_9 then
break
end
if loc_2 == loc_5 then
desired = 1
break
end
loc_2 = 0
while true do
loc_2 = rt_add_i32(loc_2, 1)
loc_3 = bit_and(loc_6, rt_add_i32(loc_3, loc_2))
loc_4 = rt_add_i32(rt_mul_i32(loc_3, 12), loc_8)
loc_7 = rt_load_i32(memory_at_0, loc_4)
if loc_9 == loc_7 then
desired = 2
break
end
if loc_5 ~= loc_7 then
continue
end
break
end
if desired then
if desired == 2 then
desired = nil
end
break
end
desired = 1
break
end
if desired then
if desired == 1 then
desired = nil
end
break
end
rt_store_i32(memory_at_0, loc_4, loc_5)
rt_store_i32(memory_at_0, loc_0 + 8, rt_add_i32(rt_load_i32(memory_at_0, loc_0 + 8), 1))
break
end
reg_0 = rt_add_i32(loc_4, 4)
break
end
return reg_0
end
FUNC_LIST[21] = --[[ Luau::Compile::ValueVisitor::visit(Luau::AstStatAssign*) ]] function(loc_0, loc_1)
local loc_2 = 0
local loc_3 = 0
local loc_4 = 0
local reg_0
local desired
while true do
if rt_load_i32(memory_at_0, loc_1 + 32) ~= 0 then
while true do
while true do
loc_2 = rt_load_i32(memory_at_0, rt_add_i32(rt_load_i32(memory_at_0, loc_1 + 28), rt_shl_i32(loc_3, 2)))
loc_4 = rt_load_i32(memory_at_0, loc_2 + 4)
while true do
while true do
if loc_2 == 0 then
break
end
if rt_load_i32(memory_at_0, 61160) ~= loc_4 then
break
end
reg_0 = FUNC_LIST[20](rt_load_i32(memory_at_0, loc_0 + 8), rt_add_i32(loc_2, 24))
rt_store_i32_n8(memory_at_0, reg_0 + 4, 1)
desired = 3
break
end
if desired then
if desired == 3 then
desired = nil
end
break
end
while true do
if loc_2 == 0 then
break
end
if rt_load_i32(memory_at_0, 61168) ~= loc_4 then
break
end
reg_0 = FUNC_LIST[15](rt_load_i32(memory_at_Review the source before using it. Executions count successful copies, capped at 10 per user and network per script in 24 hours.
Community discussion
0Start the conversation.
More for Natural Disaster Survival
00Mobile00MobileM
KEYLESS Fly, WalkSpeed, Jump Power, No Fall Damage
MaxLegendsOwnerThe owner of BloxScripts.fun.Early CreatorPublish a script as one of the first 100 accounts.·Natural Disaster Survival
By Satsuji · Rscripts00MobileM
KEYLESS Fling, Auto Survive, Auto Farm, Disaster ESP
MaxLegendsOwnerThe owner of BloxScripts.fun.Early CreatorPublish a script as one of the first 100 accounts.·Natural Disaster Survival
By BataPa · Rscripts10M
you are an diot only 1
MaxLegendsOwnerThe owner of BloxScripts.fun.Early CreatorPublish a script as one of the first 100 accounts.·Natural Disaster Survival
By TUBERS93os52 · Rscripts