Prompt: --// Renders

Response:
local L_167_

L_109_:connect(function()
	if L_15_ then
		L_162_, L_163_ = L_162_ or 0, L_163_ or 0
		if L_165_ == nil or L_164_ == nil then
			L_165_ = L_45_.C0
			L_164_ = L_45_.C1
		end

		local L_275_ = (math.sin(L_156_ * L_158_ / 2) * L_157_)
		local L_276_ = (math.sin(L_156_ * L_158_) * L_157_)
		local L_277_ = CFrame.new(L_275_, L_276_, 0.02)

		local L_278_ = (math.sin(L_156_ * L_158_ / 2) * L_157_)
		local L_279_ = (math.sin(L_156_ * L_158_) * L_157_)
		local L_280_ = CFrame.new(L_275_, L_276_, 0.02) * CFrame.Angles((math.cos(L_156_ * L_158_) * L_157_), (math.cos(L_156_ * L_158_ / 2) * L_157_), 0)

		local L_281_ = (math.sin(L_152_ * L_155_ / 2) * L_154_)
		local L_282_ = (math.cos(L_152_ * L_155_) * L_154_)
		local L_283_ = CFrame.new(L_281_, L_282_, 0.02)

		if L_149_ then
			L_156_ = L_156_ + .017
			if L_24_.WalkAnimEnabled == true then
				L_150_ = L_280_
			else
				L_150_ = CFrame.new()
			end
		else
			L_156_ = 0
			L_150_ = CFrame.new()
		end

		L_148_.t = Vector3.new(L_143_, L_144_, 0)
		local L_284_ = L_148_.p
		local L_285_ = L_284_.X / L_145_ * (L_64_ and L_147_ or L_146_)
		local L_286_ = L_284_.Y / L_145_ * (L_64_ and L_147_ or L_146_)

		L_5_.CFrame = L_5_.CFrame:lerp(L_5_.CFrame * L_151_, 0.2)

		if L_64_ then
			L_139_ = CFrame.Angles(math.rad(-L_285_), math.rad(L_285_), math.rad(L_286_)) * CFrame.fromAxisAngle(Vector3.new(5, 0, -1), math.rad(L_285_))
			L_152_ = 0
			L_153_ = CFrame.new()
		elseif not L_64_ then
			L_139_ = CFrame.Angles(math.rad(-L_286_), math.rad(-L_285_), math.rad(-L_285_)) * CFrame.fromAxisAngle(L_44_.Position, math.rad(-L_286_))
			L_152_ = L_152_ + 0.017
			L_153_ = L_283_
		end

		if L_24_.SwayEnabled ==  true then
			L_45_.C0 = L_45_.C0:lerp(L_165_ * L_139_ * L_150_ * L_153_, 0.1)
		else
			L_45_.C0 = L_45_.C0:lerp(L_165_ * L_150_, 0.1)
		end

		if L_67_ and not L_70_ and L_72_ and not L_64_ and not L_66_ and not Shooting then
			L_45_.C1 = L_45_.C1:lerp(L_45_.C0 * L_24_.SprintPos, 0.1)
		elseif not L_67_ and not L_70_ and not L_72_ and not L_64_ and not L_66_ and not Shooting and not L_79_ then
			L_45_.C1 = L_45_.C1:lerp(CFrame.new() * L_137_, 0.05)
		end

		if L_64_ and not L_67_ then
			if not L_65_ then
				L_90_ = L_24_.AimCamRecoil
				L_89_ = L_24_.AimGunRecoil
				L_91_ = L_24_.AimKickback
			elseif L_65_ then
				if L_93_ == 1 then
					L_90_ = L_24_.AimCamRecoil / 1.5
					L_89_ = L_24_.AimGunRecoil / 1.5
					L_91_ = L_24_.AimKickback / 1.5
				end

				if L_93_ == 2 then
					L_90_ = L_24_.AimCamRecoil / 2
					L_89_ = L_24_.AimGunRecoil / 2
					L_91_ = L_24_.AimKickback / 2
				end
			end

			if (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude < 2 then
				L_45_.C1 = L_45_.C1:lerp(L_45_.C0 * L_56_.CFrame:toObjectSpace(L_44_.CFrame), L_24_.AimSpeed)

				L_42_:WaitForChild('Sense'):WaitForChild('Sensitivity').Visible = true
				L_42_:WaitForChild('Sense'):WaitForChild('Sensitivity').Text = L_51_
				L_110_.MouseDeltaSensitivity = L_51_
			end
		elseif not L_64_ and not L_67_ and L_15_ and not L_79_ then
			if (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude < 2 then
				L_45_.C1 = L_45_.C1:lerp(CFrame.new() * L_137_, L_24_.UnaimSpeed)

				L_42_:WaitForChild('Sense'):WaitForChild('Sensitivity').Visible = false
				L_42_:WaitForChild('Sense'):WaitForChild('Sensitivity').Text = L_51_
				L_110_.MouseDeltaSensitivity = L_52_
			end

			if not L_65_ then
				L_90_ = L_24_.camrecoil
				L_89_ = L_24_.gunrecoil
				L_91_ = L_24_.Kickback
			elseif L_65_ then
				if L_93_ == 1 then
					L_90_ = L_24_.camrecoil / 1.5
					L_89_ = L_24_.gunrecoil / 1.5
					L_91_ = L_24_.Kickback / 1.5
				end

				if L_93_ == 2 then
					L_90_ = L_24_.camrecoil / 2
					L_89_ = L_24_.gunrecoil / 2
					L_91_ = L_24_.Kickback / 2
				end
			end
		end

		if Recoiling then
			if not L_64_ then
				L_151_ = CFrame.fromEulerAnglesXYZ(math.rad(L_90_ * math.random(0, L_24_.CamShake)), math.rad(L_90_ * math.random(-L_24_.CamShake, L_24_.CamShake)), math.rad(L_90_ * math.random(-L_24_.CamShake, L_24_.CamShake)))--CFrame.Angles(camrecoil,0,0)
			else
				L_151_ = CFrame.fromEulerAnglesXYZ(math.rad(L_90_ * math.random(0, L_24_.AimCamShake)), math.rad(L_90_ * math.random(-L_24_.AimCamShake, L_24_.AimCamShake)), math.rad(L_90_ * math.random(-L_24_.AimCamShake, L_24_.AimCamShake)))
			end
			--cam.CoordinateFrame = cam.CoordinateFrame *  CFrame.fromEulerAnglesXYZ(math.rad(camrecoil*math.random(0,3)), math.rad(camrecoil*math.random(-1,1)), math.rad(camrecoil*math.random(-1,1)))
			L_45_.C0 = L_45_.C0:lerp(L_45_.C0 * CFrame.new(0, 0, L_89_) * CFrame.Angles(-math.rad(L_91_), 0, 0), 0.3)
		elseif not Recoiling then
			L_151_ = CFrame.Angles(0, 0, 0)
			L_45_.C0 = L_45_.C0:lerp(CFrame.new(), 0.2)
		end

		if L_65_ then
			L_3_:WaitForChild('Humanoid').Jump = false
		end

		if L_15_ then
			L_5_.FieldOfView = L_5_.FieldOfView * (1 - L_24_.ZoomSpeed) + (L_97_ * L_24_.ZoomSpeed)
			if (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude >= 2 then
				L_90_ = L_24_.AimCamRecoil
				L_89_ = L_24_.AimGunRecoil
				L_91_ = L_24_.AimKickback

				L_42_:WaitForChild('Sense'):WaitForChild('Sensitivity').Visible = true
				L_42_:WaitForChild('Sense'):WaitForChild('Sensitivity').Text = L_51_
				L_110_.MouseDeltaSensitivity = L_51_
			elseif (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude < 2 and not L_64_ and not L_65_ then
				L_90_ = L_24_.camrecoil
				L_89_ = L_24_.gunrecoil
				L_91_ = L_24_.Kickback

				L_42_:WaitForChild('Sense'):WaitForChild('Sensitivity').Visible = false
				L_42_:WaitForChild('Sense'):WaitForChild('Sensitivity').Text = L_51_
				L_110_.MouseDeltaSensitivity = L_52_
			end
		end

		if L_15_ and L_24_.CameraGo then --and (char.Head.Position - cam.CoordinateFrame.p).magnitude < 2 then
			L_4_.TargetFilter = game.Workspace
			local L_287_ =  L_3_:WaitForChild("HumanoidRootPart").CFrame * CFrame.new(0, 1.5, 0) * CFrame.new(L_3_:WaitForChild("Humanoid").CameraOffset)
			L_48_.C0 = L_8_.CFrame:toObjectSpace(L_287_)
			L_48_.C1 = CFrame.Angles(-math.asin((L_4_.Hit.p - L_4_.Origin.p).unit.y), 0, 0)
			L_110_.MouseIconEnabled = false
		end

		if L_15_ and (L_3_.Head.Position - L_5_.CoordinateFrame.p).magnitude >= 2 then
			if L_4_.Icon ~= "http://www.roblox.com/asset?id=" .. L_24_.TPSMouseIcon then
				L_4_.Icon = "http://www.roblox.com/asset?id=" .. L_24_.TPSMouseIcon
			end
			L_110_.MouseIconEnabled = true

			if L_3_:FindFirstChild('Right Arm') and L_3_:FindFirstChild('Left Arm') then
				L_3_['Right Arm'].LocalTransparencyModifier = 1
				L_3_['Left Arm'].LocalTransparencyModifier = 1
			end
		end;
	end
end)


Prompt: -- play a random sound selected from children

Response:
local sounds:{Sound}=script:GetChildren()

while task.wait(math.random(1,10)) do
	local sound=sounds[math.random(1,#sounds)]
	sound.Parent=script.Parent
	sound:Play()
end


Prompt: -- VisualComponents by Travis, modified for native visuals.

Response:
local RS = game:GetService("RunService")
local panels = {}
wait(5)

function SetUp()

	for _,v in pairs(game.Workspace.VisualComponents.Panels:GetChildren()) do
		local temp = {}
		for image = 1,8 do
			table.insert(temp,v.VisualScreen.Main["Image"..image])
		end
		table.insert(panels,temp)
	end
end
SetUp()

local len = #panels
local max = 3000
local max8 = max/8;
for i,v in pairs(workspace.VisualComponents.Panels:GetChildren()) do
	RS.RenderStepped:connect(function()
		v.VisualScreen.Main.Image1.Visible = workspace.VisualComponents.Values.On.Value
		v.VisualScreen.Main.Image2.Visible = workspace.VisualComponents.Values.On.Value
		v.VisualScreen.Main.Image3.Visible = workspace.VisualComponents.Values.On.Value
		v.VisualScreen.Main.Image4.Visible = workspace.VisualComponents.Values.On.Value
		v.VisualScreen.Main.Image5.Visible = workspace.VisualComponents.Values.On.Value
		v.VisualScreen.Main.Image6.Visible = workspace.VisualComponents.Values.On.Value
		v.VisualScreen.Main.Image7.Visible = workspace.VisualComponents.Values.On.Value
		v.VisualScreen.Main.Image8.Visible = workspace.VisualComponents.Values.On.Value
	end)
end
RS.RenderStepped:connect(function(delta)
	local t = script.Value.Value
	local tempArr = {}
	for image = 1,8 do
		tempArr[image] = (t + image) * max8 % max
	end
	for index = 1,len do
		local temp2 = panels[index]
		for key, value in pairs(tempArr) do
			temp2[key].Size = UDim2.new(0,value*10000,0,value*10000)
		end
	end
end)


Prompt: --[[Susupension]]

Response:
	Tune.SusEnabled		= true		-- works only in with PGSPhysicsSolverEnabled, defaults to false when PGS is disabled

	--Front Suspension
	Tune.FSusDamping	= 500		-- Spring Dampening
	Tune.FSusStiffness	= 9000		-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

	Tune.FSusLength		= 2			-- Suspension length (in studs)
	Tune.FPreCompress	= .4		-- Pre-compression adds resting length force
	Tune.FExtensionLim	= .4		-- Max Extension Travel (in studs)
	Tune.FCompressLim	= .4		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

	Tune.FWsBoneLen		= 5			-- Wishbone Length
	Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Rear Suspension
	Tune.RSusDamping	= 500		-- Spring Dampening
	Tune.RSusStiffness	= 9000		-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)

	Tune.RSusLength		= 2			-- Suspension length (in studs)
	Tune.RPreCompress	= .4		-- Pre-compression adds resting length force
	Tune.RExtensionLim	= .4		-- Max Extension Travel (in studs)
	Tune.RCompressLim	= .4		-- Max Compression Travel (in studs)
	Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)

	Tune.RWsBoneLen		= 5			-- Wishbone Length
	Tune.RWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Aesthetics
	Tune.SusVisible		= true			-- Spring Visible
	Tune.WsBVisible		= false			-- Wishbone Visible
	Tune.SusRadius		= .2			-- Suspension Coil Radius
	Tune.SusThickness	= .1			-- Suspension Coil Thickness
	Tune.SusColor		= "Really black"	-- Suspension Color [BrickColor]
	Tune.SusCoilCount	= 6				-- Suspension Coil Count
	Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
	Tune.WsThickness	= .1			-- Wishbone Rod Thickness


Prompt: --yep

Response:
goal.Transparency = 1
door.PrimaryPart.Transparency = 1

local function tweenModel(model, CF, info)
	local CFrameValue = Instance.new("CFrameValue")
	CFrameValue.Value = model:GetPrimaryPartCFrame()

	CFrameValue:GetPropertyChangedSignal("Value"):Connect(function()
		model:SetPrimaryPartCFrame(CFrameValue.Value)
	end)

	local tween = tweenService:Create(CFrameValue, info, {Value = CF})
	tween:Play()

	tween.Completed:Connect(function()
		CFrameValue:Destroy()
	end)
end

local function onClicked()
	if canOpen then
		canOpen = false

		if open then
			open = false

			tweenModel(door, origCFrame, TweenInfo.new(downtime))
		else
			open = true

			tweenModel(door, goal.CFrame, TweenInfo.new(uptime))
		end

		wait(waitTime + uptime)
		canOpen = true
	end
end

clickDetector.MouseButton1Click:connect(onClicked)


Prompt: -- Constructor

Response:
Constructor.new = function(data, public)
	local proxy = newproxy(true)
	local metatable = getmetatable(proxy)
	for index, value in data do metatable[index] = value end
	metatable.__index = Index
	metatable.__newindex = NewIndex
	metatable.__public = public or {}
	return proxy, metatable
end


Prompt: -- tableUtil.Assign(Table target, ...Table sources)

Response:
local function Assign(target, ...)
	for _,src in ipairs({...}) do
		for k,v in pairs(src) do
			target[k] = v
		end
	end
	return target
end

local function Print(tbl, label, deepPrint)

	assert(type(tbl) == "table", "First argument must be a table")
	assert(label == nil or type(label) == "string", "Second argument must be a string or nil")

	label = (label or "TABLE")

	local strTbl = {}
	local indent = " - "

	-- Insert(string, indentLevel)
	local function Insert(s, l)
		strTbl[#strTbl + 1] = (indent:rep(l) .. s .. "\n")
	end

	local function AlphaKeySort(a, b)
		return (tostring(a.k) < tostring(b.k))
	end

	local function PrintTable(t, lvl, lbl)
		Insert(lbl .. ":", lvl - 1)
		local nonTbls = {}
		local tbls = {}
		local keySpaces = 0
		for k,v in pairs(t) do
			if (type(v) == "table") then
				table.insert(tbls, {k = k, v = v})
			else
				table.insert(nonTbls, {k = k, v = "[" .. typeof(v) .. "] " .. tostring(v)})
			end
			local spaces = #tostring(k) + 1
			if (spaces > keySpaces) then
				keySpaces = spaces
			end
		end
		table.sort(nonTbls, AlphaKeySort)
		table.sort(tbls, AlphaKeySort)
		for _,v in ipairs(nonTbls) do
			Insert(tostring(v.k) .. ":" .. (" "):rep(keySpaces - #tostring(v.k)) .. v.v, lvl)
		end
		if (deepPrint) then
			for _,v in ipairs(tbls) do
				PrintTable(v.v, lvl + 1, tostring(v.k) .. (" "):rep(keySpaces - #tostring(v.k)) .. " [Table]")
			end
		else
			for _,v in ipairs(tbls) do
				Insert(tostring(v.k) .. ":" .. (" "):rep(keySpaces - #tostring(v.k)) .. "[Table]", lvl)
			end
		end
	end

	PrintTable(tbl, 1, label)

	print(table.concat(strTbl, ""))

end

local function Reverse(tbl)
	local n = #tbl
	local tblRev = table.create(n)
	for i = 1,n do
		tblRev[i] = tbl[n - i + 1]
	end
	return tblRev
end

local function Shuffle(tbl)
	assert(type(tbl) == "table", "First argument must be a table")
	local rng = Random.new()
	for i = #tbl, 2, -1 do
		local j = rng:NextInteger(1, i)
		tbl[i], tbl[j] = tbl[j], tbl[i]
	end
end

local function IsEmpty(tbl)
	return (next(tbl) == nil)
end

local function EncodeJSON(tbl)
	return http:JSONEncode(tbl)
end

local function DecodeJSON(str)
	return http:JSONDecode(str)
end

local function FastRemoveFirstValue(t, v)
	local index = IndexOf(t, v)
	if (index) then
		FastRemove(t, index)
		return true, index
	end
	return false, nil
end

TableUtil.Copy = CopyTable
TableUtil.CopyShallow = CopyTableShallow
TableUtil.Sync = Sync
TableUtil.FastRemove = FastRemove
TableUtil.FastRemoveFirstValue = FastRemoveFirstValue
TableUtil.Print = Print
TableUtil.Map = Map
TableUtil.Filter = Filter
TableUtil.Reduce = Reduce
TableUtil.Assign = Assign
TableUtil.IndexOf = IndexOf
TableUtil.Reverse = Reverse
TableUtil.Shuffle = Shuffle
TableUtil.IsEmpty = IsEmpty
TableUtil.EncodeJSON = EncodeJSON
TableUtil.DecodeJSON = DecodeJSON

return TableUtil


Prompt: -- Complete list of default art assets provided

Response:
return {
	BloxyAward = {
		name = "Bloxy Award",
		assetId = "rbxassetid://7322500962",
	},
	RobloxStudioBlue = {
		name = "Roblox Studio in Blue",
		assetId = "rbxassetid://7322508294",
	},
	RobloxStudioGrey = {
		name = "Roblox Studio in Grey",
		assetId = "rbxassetid://7322513437",
	},
	ShootingStar = {
		name = "Shooting Star",
		assetId = "rbxassetid://7322516002",
	},
	DespacitoSpider = {
		name = "DespacitoSpider",
		assetId = "rbxassetid://7337695014",
	},
	BigHeadNoob = {
		name = "Big Head Noob",
		assetId = "rbxassetid://7322517479",
	},
	RoundHeadNoob = {
		name = "Round Head Noob",
		assetId = "rbxassetid://7337696808",
	},
	FemalePirate = {
		name = "Female Pirate",
		assetId = "rbxassetid://7337690429",
	},
	RichNoob = {
		name = "Rich Noob",
		assetId = "rbxassetid://7337685806",
	},
	BuildermanSayingHi = {
		name = "Builderman Saying Hi",
		assetId = "rbxassetid://7337688743",
	},
	TeddyBearClawMachine = {
		name = "Teddy Bear Claw Machine",
		assetId = "rbxassetid://7337691467",
	},
	NoobInAMecha = {
		name = "Noob In A Mecha",
		assetId = "rbxassetid://7337703782",
	},
	BaconHairNoob = {
		name = "BaconHairNoob",
		assetId = "rbxassetid://7337705040",
	},
	HotDog = {
		name = "Hot Dog",
		assetId = "rbxassetid://7337693237",
	},
	FrenchFries = {
		name = "French Fries",
		assetId = "rbxassetid://7337698666",
	},
	RobloxSprayPaint = {
		name = "Roblox Spray Paint",
		assetId = "rbxassetid://7322547665",
	},
	MeltyFaceSprayPaint = {
		name = "Melty Face Spray Paint",
		assetId = "rbxassetid://7322550149",
	},
}


Prompt:
-- Removes old Motor6Ds and builds the rig from the attachments in the parts
-- Call this with nil, HumanoidRootPart

Response:
function buildRigFromAttachments(last, part)
	for _, attachment in pairs(part:GetChildren()) do
		if attachment:IsA("Attachment") and string.find(attachment.Name, "RigAttachment") then
			for _, sibling in pairs(part.Parent:GetChildren()) do
				if sibling ~= part and sibling ~= last then
					local matchingAttachment = sibling:FindFirstChild(attachment.Name)
					if matchingAttachment then
						buildJoint(attachment, matchingAttachment)
						-- Continue the recursive tree traversal building joints
						buildRigFromAttachments(part, matchingAttachment.Parent)
					end
				end
			end
		end
	end
end

local function getOldCharacterMesh(character, newCharacterMesh)
    for _, obj in pairs(character:GetChildren()) do
        if obj:IsA("CharacterMesh") and obj.BodyPart == newCharacterMesh.BodyPart then
            return obj
        end
    end
    return nil
end


Prompt:
--[[		if Figure.Raise.Value == true then
			RightShoulder.MaxVelocity = 0.05
			RightShoulder:SetDesiredAngle(3)
		elseif Figure.Cast.Value == true then
			RightShoulder.MaxVelocity = 0.65
			RightShoulder:SetDesiredAngle(1)
		else]]

Response:
			RightShoulder.MaxVelocity = 0.25
			RightShoulder:SetDesiredAngle(1.5)


Prompt:
---------------
-- Constants --
---------------

Response:
local USE_STACKING_TRANSPARENCY = true	-- Multiple items between the subject and camera get transparency values that add up to TARGET_TRANSPARENCY
local TARGET_TRANSPARENCY = 0.75 -- Classic Invisicam's Value, also used by new invisicam for parts hit by head and torso rays
local TARGET_TRANSPARENCY_PERIPHERAL = 0.5 -- Used by new SMART_CIRCLE mode for items not hit by head and torso rays

local MODE = {
	CUSTOM = 1, -- Whatever you want!
	LIMBS = 2, -- Track limbs
	MOVEMENT = 3, -- Track movement
	CORNERS = 4, -- Char model corners
	CIRCLE1 = 5, -- Circle of casts around character
	CIRCLE2 = 6, -- Circle of casts around character, camera relative
	LIMBMOVE = 7, -- LIMBS mode + MOVEMENT mode
	SMART_CIRCLE = 8, -- More sample points on and around character
	CHAR_OUTLINE = 9,
}

Invisicam.MODE = MODE
local STARTING_MODE = MODE.SMART_CIRCLE

local LIMB_TRACKING_SET = {
	-- Common to R6, R15
	['Head'] = true,

	-- R6 Only
	['Left Arm'] = true,
	['Right Arm'] = true,
	['Left Leg'] = true,
	['Right Leg'] = true,

	-- R15 Only
	['LeftLowerArm'] = true,
	['RightLowerArm'] = true,
	['LeftUpperLeg'] = true,
	['RightUpperLeg'] = true
}

local CORNER_FACTORS = {
	Vector3.new(1,1,-1),
	Vector3.new(1,-1,-1),
	Vector3.new(-1,-1,-1),
	Vector3.new(-1,1,-1)
}

local CIRCLE_CASTS = 10
local MOVE_CASTS = 3
local SMART_CIRCLE_CASTS = 24
local SMART_CIRCLE_INCREMENT = 2.0 * math.pi / SMART_CIRCLE_CASTS
local CHAR_OUTLINE_CASTS = 24


Prompt: --Precalculated paths

Response:
local t,f,n=true,false,{}
local r={
[58]={{28,29,31,32,34,35,39,41,30,56,58},t},
[49]={{28,44,45,49},t},
[16]={n,f},
[19]={{28,29,31,32,34,35,39,41,30,56,58,20,19},t},
[59]={{28,29,31,32,34,35,39,41,59},t},
[63]={{28,29,31,32,34,35,39,41,30,56,58,23,62,63},t},
[34]={{28,29,31,32,34},t},
[21]={{28,29,31,32,34,35,39,41,30,56,58,20,21},t},
[48]={{28,44,45,49,48},t},
[27]={{28,27},t},
[14]={n,f},
[31]={{28,29,31},t},
[56]={{28,29,31,32,34,35,39,41,30,56},t},
[29]={{28,29},t},
[13]={n,f},
[47]={{28,44,45,49,48,47},t},
[12]={n,f},
[45]={{28,44,45},t},
[57]={{28,29,31,32,34,35,39,41,30,56,57},t},
[36]={{28,29,31,32,33,36},t},
[25]={{28,27,26,25},t},
[71]={{28,29,31,32,34,35,39,41,59,61,71},t},
[20]={{28,29,31,32,34,35,39,41,30,56,58,20},t},
[60]={{28,29,31,32,34,35,39,41,60},t},
[8]={n,f},
[4]={n,f},
[75]={{28,29,31,32,34,35,39,41,59,61,71,72,76,73,75},t},
[22]={{28,29,31,32,34,35,39,41,30,56,58,20,21,22},t},
[74]={{28,29,31,32,34,35,39,41,59,61,71,72,76,73,74},t},
[62]={{28,29,31,32,34,35,39,41,30,56,58,23,62},t},
[1]={n,f},
[6]={n,f},
[11]={n,f},
[15]={n,f},
[37]={{28,29,31,32,33,36,37},t},
[2]={n,f},
[35]={{28,29,31,32,34,35},t},
[53]={{28,44,45,49,48,47,52,53},t},
[73]={{28,29,31,32,34,35,39,41,59,61,71,72,76,73},t},
[72]={{28,29,31,32,34,35,39,41,59,61,71,72},t},
[33]={{28,29,31,32,33},t},
[69]={{28,29,31,32,34,35,39,41,60,69},t},
[65]={{28,29,31,32,34,35,39,41,30,56,58,20,19,66,64,65},t},
[26]={{28,27,26},t},
[68]={{28,29,31,32,34,35,39,41,30,56,58,20,19,66,64,67,68},t},
[76]={{28,29,31,32,34,35,39,41,59,61,71,72,76},t},
[50]={{28,44,45,49,48,47,50},t},
[66]={{28,29,31,32,34,35,39,41,30,56,58,20,19,66},t},
[10]={n,f},
[24]={{28,27,26,25,24},t},
[23]={{28,29,31,32,34,35,39,41,30,56,58,23},t},
[44]={{28,44},t},
[39]={{28,29,31,32,34,35,39},t},
[32]={{28,29,31,32},t},
[3]={n,f},
[30]={{28,29,31,32,34,35,39,41,30},t},
[51]={{28,44,45,49,48,47,50,51},t},
[18]={n,f},
[67]={{28,29,31,32,34,35,39,41,30,56,58,20,19,66,64,67},t},
[61]={{28,29,31,32,34,35,39,41,59,61},t},
[55]={{28,44,45,49,48,47,52,53,54,55},t},
[46]={{28,44,45,49,48,47,46},t},
[42]={{28,29,31,32,34,35,38,42},t},
[40]={{28,29,31,32,34,35,40},t},
[52]={{28,44,45,49,48,47,52},t},
[54]={{28,44,45,49,48,47,52,53,54},t},
[43]={n,f},
[7]={n,f},
[9]={n,f},
[41]={{28,29,31,32,34,35,39,41},t},
[17]={n,f},
[38]={{28,29,31,32,34,35,38},t},
[28]={{28},t},
[5]={n,f},
[64]={{28,29,31,32,34,35,39,41,30,56,58,20,19,66,64},t},
}
return r


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local v1 = {};
v1.__index = v1;
v1.ClassName = "Signal";
function v1.new()
	local v2 = setmetatable({}, v1);
	v2._bindableEvent = Instance.new("BindableEvent");
	v2._argData = nil;
	v2._argCount = nil;
	return v2;
end;
function v1.Fire(p1, ...)
	p1._argData = { ... };
	p1._argCount = select("#", ...);
	p1._bindableEvent:Fire();
	p1._argData = nil;
	p1._argCount = nil;
end;
function v1.Connect(p2, p3)
	if type(p3) ~= "function" then
		error(("connect(%s)"):format(typeof(p3)), 2);
	end;
	return p2._bindableEvent.Event:Connect(function()
		p3(unpack(p2._argData, 1, p2._argCount));
	end);
end;
function v1.Wait(p4)
	p4._bindableEvent.Event:Wait();
	assert(p4._argData, "Missing arg data, likely due to :TweenSize/Position corrupting threadrefs.");
	return unpack(p4._argData, 1, p4._argCount);
end;
function v1.Destroy(p5)
	if p5._bindableEvent then
		p5._bindableEvent:Destroy();
		p5._bindableEvent = nil;
	end;
	p5._argData = nil;
	p5._argCount = nil;
end;
function v1.Disconnect(p6)
	p6:Destroy();
end;
return v1;


Prompt:
-----------------
--| Functions |--
-----------------

Response:
local function OnActivated()
	local myModel = MyPlayer.Character
	if Tool.Enabled and myModel and myModel:FindFirstChildOfClass("Humanoid") and myModel.Humanoid.Health > 0 then
		Tool.Enabled = false
		local Pos = MouseLoc:InvokeClient(MyPlayer)
		-- Create a clone of Rocket and set its color
		local rocketClone = Rocket:Clone()
		DebrisService:AddItem(rocketClone, 30)
		rocketClone.BrickColor = MyPlayer.TeamColor

		-- Position the rocket clone and launch!
		local spawnPosition = (ToolHandle.CFrame * CFrame.new(5, 0, 0)).p
		rocketClone.CFrame = CFrame.new(spawnPosition, Pos) --NOTE: This must be done before assigning Parent
		rocketClone.CanQuery =false
		rocketClone.Parent = workspace
		task.spawn(function()
			while rocketClone.Parent == workspace and task.wait(.0) do
				local Pos = MouseLoc:InvokeClient(MyPlayer)
				print(Pos)
				rocketClone.CFrame = CFrame.lookAt(rocketClone.Position,Pos)
				rocketClone.CFrame *= CFrame.new(0,0,-ROCKET_SPEED)
			end
		end)

		wait(RELOAD_TIME)

		Tool.Enabled = true
	end
end

function OnEquipped()
	MyPlayer = PlayersService:GetPlayerFromCharacter(Tool.Parent)
end


Response:
function onClicked()
Car.BodyVelocity.maxForce = Vector3.new(math.huge, math.huge, math.huge)
Car.BodyVelocity.velocity = Vector3.new(0, -10, 0)
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)


Prompt:
--!nonstrict
--[[
	LegacyCamera - Implements legacy controller types: Attach, Fixed, Watch
	2018 Camera Update - AllYourBlox
--]]

Response:
local ZERO_VECTOR2 = Vector2.new()
local PITCH_LIMIT = math.rad(80)

local Util = require(script.Parent:WaitForChild("CameraUtils"))
local CameraInput = require(script.Parent:WaitForChild("CameraInput"))


Prompt:
--[[
	Converts a yielding function into a Promise-returning one.
]]

Response:
function Promise.promisify(callback)
	return function(...)
		return Promise._try(debug.traceback(nil, 2), callback, ...)
	end
end


Prompt:
--[[function Communication:EffectWriter()
    local CommunicationServer = Knit.GetService("Communication")

    CommunicationServer.EffectWriter:Connect(function(Module, Model)
        require(script.Parent.Parent.Effects[Module]):Init(Model)
    end)
end]]

Response:
function Communication:KnitInit()
    ReplicaController.ReplicaOfClassCreated(`States{Players.LocalPlayer.UserId}`, function(replica)
        self["States"] = replica
    end)

    ReplicaController.RequestData()
end

return Communication


Prompt:
--[[for x = 1, 50 do
s.Pitch = s.Pitch + 0.01
s:play()
wait(0.001)
end]]

Response:
for x = 100, 120 do
s:play()
wait(0.001)
end
for x = 100, 210 do
s.Pitch = s.Pitch - 0.0031
s:play()
wait(0.001)
end
wait()
end


Prompt: -- How many times per second the gun can fire

Response: local FireRate = 1 / 2


Prompt:
--[[
	Chains a Promise from this one that is resolved if this Promise is
	resolved, and rejected if it is not resolved.
]]

Response:
function Promise.prototype:now(rejectionValue)
	local traceback = debug.traceback(nil, 2)
	if self._status == Promise.Status.Resolved then
		return self:_andThen(traceback, function(...)
			return ...
		end)
	else
		return Promise.reject(rejectionValue == nil and Error.new({
			kind = Error.Kind.NotResolvedInTime,
			error = "This Promise was not resolved in time for :now()",
			context = ":now() was called at:\n\n" .. traceback,
		}) or rejectionValue)
	end
end


Prompt: --------------------) Settings

Response:
Damage = 0 -- the ammout of health the player or mob will take

Cooldown = 0.5 -- cooldown for use of the tool again

ZoneModelName = "Make it bomb" -- name the zone model

MobHumanoidName = "Humanoid"-- the name of player or mob u want to damage


Response:
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)


Response:
local toCopy=model.Part4

local spd=script.Speed:Clone()
spd.Parent = toCopy
spd.Value = 0.15

local die=script.Died:Clone()
die.Parent = toCopy
die.Disabled = false

local scr=script.MovedBlock:Clone()
scr.Parent = toCopy
scr.Disabled = false

while true do
	wait(1)
	local tmp = toCopy.Speed.Value - 0.03

	if tmp < 0.01 then
		tmp = 0.2
	end

	toCopy.Speed.Value = tmp
end


Prompt:
--[[

This script prevents Blue from colliding with players. Without this script,
Blue can push players, quite often into lava!

This script uses collision groups to prevent player/Blue collisions. This allows
players and Blue to still collide with the environment while not colliding
with each other.

--]]


Prompt: --[[Weight and CG]]

Response:
	Tune.Weight			= 4689		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		8.5		,
	 --[[Height]]		5.5		,
	 --[[Length]]		21		}
	Tune.WeightDist		= 50		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= 1.9		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible

	--Unsprung Weight
	Tune.FWheelDensity	= .1		-- Front Wheel Density
	Tune.RWheelDensity	= .1		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]

	Tune.AxleSize		= 2			-- Size of structural members (larger = MORE STABLE / carry more weight)
	Tune.AxleDensity	= .1		-- Density of structural members


Prompt: -- Offset of arrow above part in studs

Response: local OFFSET = 5


Prompt: -- Variables

Response:
local poolSizeMultiplier = getSetting("Pool size multiplier") or 1

playerService.PlayerAdded:Connect(function (plr)

	if not workspace:FindFirstChild("Blood") then
		folder = Instance.new("Folder", workspace)
		folder.Name = "Blood"
	end

	local charFolder = Instance.new("Folder", folder)
	charFolder.Name = plr.Name

	plr.CharacterAdded:Connect(function (char)

		local humanoid = char:WaitForChild("Humanoid")

		humanoid.Died:Connect(function ()
			pcall(function ()

				local torso = char:FindFirstChild("Torso") or char:FindFirstChild("UpperTorso") or nil
				local root = char:FindFirstChild("HumanoidRootPart") or nil
				local base

				local function bloodPool (part, limbCenter)

					local pool = Instance.new("Part", charFolder)
					pool.CanCollide = false
					pool.BrickColor = BrickColor.new("Crimson")
					pool.Material = Enum.Material.Sand
					pool.Transparency = .2
					pool.CastShadow = false
					pool.Shape = "Cylinder"
					pool.Anchored = true

					pool.Size = Vector3.new(.1, 0, 0)
					pool.CFrame = part.CFrame

					if limbCenter then
						pool.CFrame = CFrame.new(torso.Position.X + math.random(-4, 4), base.Position.Y - (base.Size.Y / 2) + math.random(0, .2), torso.Position.Z + math.random(-4, 4))
					else
						pool.CFrame = CFrame.new(torso.Position.X + math.random(-4, 4), base.Position.Y + (base.Size.Y / 2), torso.Position.Z + math.random(-4, 4))
					end

					pool.Orientation = Vector3.new(0, 0, 90)
					tweenService:Create(pool, TweenInfo.new(math.random(.4, 4), Enum.EasingStyle.Linear, Enum.EasingDirection.Out), {Size = Vector3.new(.1, math.random(3, 7) * poolSizeMultiplier, math.random(3, 7) *poolSizeMultiplier)}):Play()

					debris:AddItem(pool, 9)
				end

				if char.Humanoid.RigType == Enum.HumanoidRigType.R6 then
					wait(.2)
					if not char:FindFirstChild("Head") and workspace:FindFirstChild(plr.Name .. "-2") then
						char = workspace[plr.Name .. "-2"]
					end
				end

				repeat wait() until math.floor(torso.Velocity.Magnitude) == 0
				local baseBlacklist = char:GetChildren()

				pcall(function ()
					for _,plr in pairs(game:GetService("Players"):GetPlayers()) do
						if plr.Character then
							for _,v in pairs(plr.Character:GetChildren()) do
								if v:IsA("BasePart") then
									table.insert(baseBlacklist, v)
								elseif v:IsA("Accoutrement") then
									table.insert(baseBlacklist, v:FindFirstChildWhichIsA("BasePart"))
								elseif v:IsA("Tool") and v:FindFirstChild("Handle") then
									table.insert(baseBlacklist, v.Handle)
								end
							end
						end
						if workspace:FindFirstChild(plr.Name .. "-2") then
							for _,p in pairs(workspace[plr.Name .. "-2"]:GetChildren()) do
								if p:IsA("BasePart") then
									table.insert(baseBlacklist, p)
								elseif p:IsA("Accoutrement") then
									table.insert(baseBlacklist, p:FindFirstChildWhichIsA("BasePart"))
								end
							end
						end
					end
				end)

				if type(baseBlacklist) == "table" then

					local limbCenter = false
					base = workspace:FindPartsInRegion3WithIgnoreList(Region3.new(torso.Position - torso.Size * 2, torso.Position + torso.Size * 2), baseBlacklist, 1)[1]

					if not base then
						if char:FindFirstChild("Left Leg") then
							base = char["Left Leg"]
							limbCenter = true
						elseif char:FindFirstChild("LeftFoot") then
							base = char["LeftFoot"]
							limbCenter = true
						end
					end

					if base then
						for _,limb in pairs(char:GetChildren()) do
							if limb:IsA("BasePart") and limb.Name ~= "HumanoidRootPart" then
								bloodPool(limb, limbCenter)
							end
						end
					end
				end
			end)
		end)
	end)
end)

playerService.PlayerRemoving:Connect(function (plr)
	if folder:FindFirstChild(plr.Name) then
		folder[plr.Name]:Destroy()
	end
end)


Prompt: -- Start library manager

Response: require(Tool:WaitForChild 'LibraryManager')


Prompt:
--Made by Repressed_Memories
-- Edited by Truenus

Response:
local component = script.Parent.Parent
local car = script.Parent.Parent.Parent.Parent.Car.Value
local mouse = game.Players.LocalPlayer:GetMouse()
local leftsignal = "z"
local rightsignal = "c"
local hazards = "x"
local hazardson = false
local lefton = false
local righton = false
local leftlight = car.Body.Lights.Left.TurnSignal.TSL
local rightlight = car.Body.Lights.Right.TurnSignal.TSL
local leftfront = car.Body.Lights.Left.TurnSignal2
local rightfront = car.Body.Lights.Right.TurnSignal2
local signalblinktime = 0.32
local neonleft = car.Body.Lights.Left.TurnSignal
local neonright = car.Body.Lights.Right.TurnSignal
local off =  BrickColor.New("Mid gray")
local on = BrickColor.New("Deep orange")
mouse.KeyDown:connect(function(lkey)
	local key = string.lower(lkey)
	if key == leftsignal then
		if lefton == false then
			lefton = true
			repeat
				neonleft.BrickColor = on
				leftlight.Enabled = true
				neonleft.Material = "Neon"
				leftfront.Material = "Neon"
				component.TurnSignal:play()
				wait(signalblinktime)
				neonleft.BrickColor = off
				component.TurnSignal:play()
				neonleft.Material = "SmoothPlastic"
				leftfront.Material = "SmoothPlastic"
				leftlight.Enabled = false
				wait(signalblinktime)
			until
			lefton == false or righton == true
		elseif lefton == true or righton == true then
			lefton = false
			component.TurnSignal:stop()
			leftlight.Enabled = false
		end
	elseif key == rightsignal then
		if righton == false then
			righton = true
			repeat
				neonright.BrickColor = on
				rightlight.Enabled = true
				neonright.Material = "Neon"
				rightfront.Material = "Neon"
				component.TurnSignal:play()
				wait(signalblinktime)
				neonright.BrickColor = off
				component.TurnSignal:play()
				neonright.Material = "SmoothPlastic"
				rightfront.Material = "SmoothPlastic"
				rightlight.Enabled = false
				wait(signalblinktime)
			until
			righton == false or lefton == true
		elseif righton == true or lefton == true then
			righton = false
			component.TurnSignal:stop()
			rightlight.Enabled = false
		end
	elseif key == hazards then
		if hazardson == false then
			hazardson = true
			repeat
				neonright.BrickColor = on
				neonleft.BrickColor = on
				neonright.Material = "Neon"
				rightfront.Material = "Neon"
				neonleft.Material = "Neon"
				leftfront.Material = "Neon"
				component.TurnSignal:play()
				rightlight.Enabled = true
				leftlight.Enabled = true
				wait(signalblinktime)
				neonright.BrickColor = off
				neonleft.BrickColor = off
				component.TurnSignal:play()
				neonright.Material = "SmoothPlastic"
				rightfront.Material = "SmoothPlastic"
				neonleft.Material = "SmoothPlastic"
				leftfront.Material = "SmoothPlastic"
				rightlight.Enabled = false
				leftlight.Enabled = false
				wait(signalblinktime)
			until
			hazardson == false
		elseif hazardson == true then
			hazardson = false
			component.TurnSignal:stop()
			rightlight.Enabled = false
			leftlight.Enabled = false
		end
	end
end)


Prompt: --// Settings //--

Response:
Prompt.Triggered:Connect(function(plr)
	plr.leaderstats.Coins.Value = plr.leaderstats.Coins.Value + amount
end)


Prompt: --/Recoil Modification

Response:
module.camRecoil = {
	RecoilUp 		= 1
	,RecoilTilt 	= 1
	,RecoilLeft 	= 1
	,RecoilRight 	= 1
}

module.gunRecoil = {
	RecoilUp 		= 1
	,RecoilTilt 	= 1
	,RecoilLeft 	= 1
	,RecoilRight 	= 1
}

module.AimRecoilReduction = 1
module.AimSpreadReduction = 1

module.MinRecoilPower 			= 0.5
module.MaxRecoilPower 			= 0.5
module.RecoilPowerStepAmount 	= 1

module.MinSpread 				= 0.5
module.MaxSpread 				= 0.5
module.AimInaccuracyStepAmount 	= 1
module.AimInaccuracyDecrease 	= 1
module.WalkMult 				= 1

module.MuzzleVelocityMod	 	= 1

return module


Prompt: --while wait(5) do timeFix() end --This will cause the timeFix() function to run once every second.


Prompt: --Creates a server-side buffer. Inherits the base buffer class.

Response:
function BufferCreator:CreateServerBuffer(BufferName)
	local BufferFolder = Instance.new("Folder")
	BufferFolder.Name = BufferName
	BufferFolder.Parent = Tool

	local Buffer = CreateBuffer(BufferFolder)
	local Player

	--Adds an item to the buffer.
	function Buffer:AddItem(NewItem)
		NewItem.Parent = BufferFolder

		local Part = (NewItem:IsA("BasePart") and NewItem) or NewItem:FindFirstChildWhichIsA("BasePart",true)
		if Part then
			--Add a position lock.
			local HoldPos = Vector3.new(math.random(-1000,1000),100000,math.random(-1000,1000))
			Part.CFrame = CFrame.new(HoldPos)
			local PositionLock = Instance.new("BodyPosition")
			PositionLock.Position = HoldPos
			PositionLock.MaxForce = Vector3.new(math.huge,math.huge,math.huge)
			PositionLock.Name = "BufferPositionLock"
			PositionLock.Parent = Part

			--Set the network ownership to the client so it can control physics.
			if Part:IsDescendantOf(game.Workspace) and not Part.Anchored and Player then
				Part:SetNetworkOwner(Player)
			end
		end
	end

	--Sets the network ownership of the buffer.
	function Buffer:SetCurrentPlayer(NewPlayer)
		Player = NewPlayer

		for _,Item in pairs(BufferFolder:GetChildren()) do
			local Part = (Item:IsA("BasePart") and Item) or Item:FindFirstChildWhichIsA("BasePart",true)

			if Part and Part:IsDescendantOf(game.Workspace) and not Part.Anchored and Player then
				Part:SetNetworkOwner(NewPlayer)
			end
		end
	end

	--Return the buffer class.
	return Buffer
end


Prompt: -- reporters

Response:
local Src = script.Parent
local ReporterGoogleAnalytics = require(Src.Reporters.GoogleAnalytics)
local ReporterPlayFab = require(Src.Reporters.PlayFab)


Prompt: ----- Private functions -----

Response:
local function WaitForLiveAccessCheck() -- This function was created to prevent the ProfileService module yielding execution when required
	while IsLiveCheckActive == true do
		Madwork.HeartbeatWait()
	end
end

local function WaitForPendingProfileStore(profile_store)
	while profile_store._is_pending == true do
		Madwork.HeartbeatWait()
	end
end

local function RegisterIssue(error_message, profile_store_name, profile_key) -- Called when a DataStore API call errors
	warn("[ProfileService]: DataStore API error (Store:\"" .. profile_store_name .. "\";Key:\"" .. profile_key .. "\") - \"" .. tostring(error_message) .. "\"")
	table.insert(IssueQueue, os.clock()) -- Adding issue time to queue
	ProfileService.IssueSignal:Fire(tostring(error_message), profile_store_name, profile_key)
end

local function RegisterCorruption(profile_store_name, profile_key) -- Called when a corrupted profile is loaded
	warn("[ProfileService]: Profile corruption - ProfileStore = \"" .. profile_store_name .. "\", Key = \"" .. profile_key .. "\"")
	ProfileService.CorruptionSignal:Fire(profile_store_name, profile_key)
end

local function MockUpdateAsync(mock_data_store, profile_store_name, key, transform_function)
	local profile_store = mock_data_store[profile_store_name]
	if profile_store == nil then
		profile_store = {}
		mock_data_store[profile_store_name] = profile_store
	end
	local transform = transform_function(profile_store[key])
	if transform == nil then
		return nil
	else
		profile_store[key] = DeepCopyTable(transform)
		return DeepCopyTable(profile_store[key])
	end
end

local function IsThisSession(session_tag)
	return session_tag[1] == PlaceId and session_tag[2] == JobId
end


Prompt:
--[[
	Exposes an interface to set global configuration values for Roact.

	Configuration can only occur once, and should only be done by an application
	using Roact, not a library.

	Any keys that aren't recognized will cause errors. Configuration is only
	intended for configuring Roact itself, not extensions or libraries.

	Configuration is expected to be set immediately after loading Roact. Setting
	configuration values after an application starts may produce unpredictable
	behavior.
]]


Prompt:
--[=[
	@private
	@class ScriptInfoUtils
]=]

Response:
local CollectionService = game:GetService("CollectionService")

local loader = script.Parent
local Utils = require(script.Parent.Utils)
local BounceTemplateUtils = require(script.Parent.BounceTemplateUtils)

local ScriptInfoUtils = {}

ScriptInfoUtils.DEPENDENCY_FOLDER_NAME = "node_modules";
ScriptInfoUtils.ModuleReplicationTypes = Utils.readonly({
	CLIENT = "client";
	SERVER = "server";
	SHARED = "shared";
	IGNORE = "ignore";
	PLUGIN = "plugin";
})

function ScriptInfoUtils.createScriptInfo(instance, name, replicationMode)
	assert(typeof(instance) == "Instance", "Bad instance")
	assert(type(name) == "string", "Bad name")
	assert(type(replicationMode) == "string", "Bad replicationMode")

	return Utils.readonly({
		name = name;
		replicationMode = replicationMode;
		instance = instance;
	})
end

function ScriptInfoUtils.createScriptInfoLookup()
	-- Server/client also contain shared entries
	return Utils.readonly({
		[ScriptInfoUtils.ModuleReplicationTypes.SERVER] = {}; -- [string name] = scriptInfo
		[ScriptInfoUtils.ModuleReplicationTypes.CLIENT] = {};
		[ScriptInfoUtils.ModuleReplicationTypes.SHARED] = {};
		[ScriptInfoUtils.ModuleReplicationTypes.PLUGIN] = {};
	})
end

function ScriptInfoUtils.getScriptInfoLookupForMode(scriptInfoLookup, replicationMode)
	assert(type(scriptInfoLookup) == "table", "Bad scriptInfoLookup")
	assert(type(replicationMode) == "string", "Bad replicationMode")

	return scriptInfoLookup[replicationMode]
end

function ScriptInfoUtils.populateScriptInfoLookup(instance, scriptInfoLookup, lastReplicationMode)
	assert(typeof(instance) == "Instance", "Bad instance")
	assert(type(scriptInfoLookup) == "table", "Bad scriptInfoLookup")
	assert(type(lastReplicationMode) == "string", "Bad lastReplicationMode")

	if instance:IsA("Folder") then
		local replicationMode = ScriptInfoUtils.getFolderReplicationMode(instance.Name, lastReplicationMode)
		if replicationMode ~= ScriptInfoUtils.ModuleReplicationTypes.IGNORE then
			for _, item in pairs(instance:GetChildren()) do
				if not BounceTemplateUtils.isBounceTemplate(item) then
					if item:IsA("Folder") then
						ScriptInfoUtils.populateScriptInfoLookup(item, scriptInfoLookup, replicationMode)
					elseif item:IsA("ModuleScript") then
						ScriptInfoUtils.addToInfoMap(scriptInfoLookup,
							ScriptInfoUtils.createScriptInfo(item, item.Name, replicationMode))
					end
				end
			end
		end
	elseif instance:IsA("ModuleScript") then
		if not BounceTemplateUtils.isBounceTemplate(instance) then
			if instance == loader then
				-- STRICT hack to support this module script as "loader" over "Nevermore" in replicated scenario
				ScriptInfoUtils.addToInfoMap(scriptInfoLookup,
					ScriptInfoUtils.createScriptInfo(instance, "loader", lastReplicationMode))
			else
				ScriptInfoUtils.addToInfoMap(scriptInfoLookup,
					ScriptInfoUtils.createScriptInfo(instance, instance.Name, lastReplicationMode))
			end
		end
	elseif instance:IsA("ObjectValue") then
		error("ObjectValue links are not supported at this time for retrieving inline module scripts")
	end
end

local AVAILABLE_IN_SHARED = {
	["HoldingBindersServer"] = true;
	["HoldingBindersClient"] = true;
	["IKService"] = true;
	["IKServiceClient"] = true;
}

function ScriptInfoUtils.isAvailableInShared(scriptInfo)
	if CollectionService:HasTag(scriptInfo.instance, "LinkToShared") then
		return true
	end

	-- Hack because we can't tag things in Rojo yet
	return AVAILABLE_IN_SHARED[scriptInfo.name]
end

function ScriptInfoUtils.addToInfoMap(scriptInfoLookup, scriptInfo)
	assert(type(scriptInfoLookup) == "table", "Bad scriptInfoLookup")
	assert(type(scriptInfo) == "table", "Bad scriptInfo")

	local replicationMode = assert(scriptInfo.replicationMode, "Bad replicationMode")
	local replicationMap = assert(scriptInfoLookup[replicationMode], "Bad replicationMode")

	ScriptInfoUtils.addToInfoMapForMode(replicationMap, scriptInfo)

	if replicationMode == ScriptInfoUtils.ModuleReplicationTypes.SHARED then
		ScriptInfoUtils.addToInfoMapForMode(
			scriptInfoLookup[ScriptInfoUtils.ModuleReplicationTypes.SERVER], scriptInfo)
		ScriptInfoUtils.addToInfoMapForMode(
			scriptInfoLookup[ScriptInfoUtils.ModuleReplicationTypes.CLIENT], scriptInfo)
	elseif ScriptInfoUtils.isAvailableInShared(scriptInfo) then
		ScriptInfoUtils.addToInfoMapForMode(
			scriptInfoLookup[ScriptInfoUtils.ModuleReplicationTypes.SHARED], scriptInfo)
	end
end

function ScriptInfoUtils.addToInfoMapForMode(replicationMap, scriptInfo)
	if replicationMap[scriptInfo.name] then
		warn(("Duplicate module %q in same package under same replication scope. Only using first one. \n- %q\n- %q")
			:format(scriptInfo.name,
				scriptInfo.instance:GetFullName(),
				replicationMap[scriptInfo.name].instance:GetFullName()))
		return
	end

	replicationMap[scriptInfo.name] = scriptInfo
end

function ScriptInfoUtils.getFolderReplicationMode(folderName, lastReplicationMode)
	assert(type(folderName) == "string", "Bad folderName")
	assert(type(lastReplicationMode) == "string", "Bad lastReplicationMode")

	--Plugin always replicates further
	if folderName == ScriptInfoUtils.DEPENDENCY_FOLDER_NAME then
		return ScriptInfoUtils.ModuleReplicationTypes.IGNORE
	elseif lastReplicationMode == ScriptInfoUtils.ModuleReplicationTypes.PLUGIN then
		return lastReplicationMode
	elseif folderName == "Shared" then
		return ScriptInfoUtils.ModuleReplicationTypes.SHARED
	elseif folderName == "Client" then
		return ScriptInfoUtils.ModuleReplicationTypes.CLIENT
	elseif folderName == "Server" then
		return ScriptInfoUtils.ModuleReplicationTypes.SERVER
	else
		return lastReplicationMode
	end
end

return ScriptInfoUtils


Prompt:
--[[

	DEVELOPMENT HAS BEEN MOVED FROM DAVEY_BONES/SCELERATIS TO THE EPIX INCORPORATED GROUP

	CURRENT LOADER:
	https://www.roblox.com/library/7510622625/Adonis-Loader-Sceleratis-Davey-Bones-Epix

	CURRENT MODULE:
	https://www.roblox.com/library/7510592873/Adonis-MainModule

--]]


Prompt:
--[[
	Fired when Finished is entered, throwing out a player state update, as well as transitioning the player state
]]

Response:
function Transitions.onEnterFinished(stateMachine, event, from, to, playerComponent)
	Logger.trace(playerComponent.player.Name, " state change: ", from, " -> ", to)
	playerComponent:updateStatus("currentState", to)
	PlayerFinished.enter(stateMachine, playerComponent)
end


Prompt: -- delete the line above me if you already made this script's parent visible = false

Response:
uis = game:GetService("UserInputService") -- this line gets the service
ismobile = uis.TouchEnabled -- this line checks if the user is on mobile

script.Parent.Visible = ismobile -- this line makes the script's parent visible on mobile user screen


Prompt:
--[[

	LOWGames Studios
	Date: 27 October 2022
	by Elder

]]

Response:
--

local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library"));
end)();
return function(p1, p2)
	for v1, v2 in pairs(p1) do
		if v2 == p2 then
			return v1;
		end;
	end;
end;


Response:
elseif script.Parent.Parent.Parent.TrafficControl.Value == "=" then

	script.Parent.Parent.A.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.B.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.C.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.D.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.E.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.F.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.G.BrickColor = BrickColor.new("Medium stone grey")

	wait(0.3)

	script.Parent.Parent.A.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.B.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.C.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.D.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.E.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.F.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.G.BrickColor = BrickColor.new("Medium stone grey")

	wait(0.35)

	script.Parent.Parent.A.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.B.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.C.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.D.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.E.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.F.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.G.BrickColor = BrickColor.new("Medium stone grey")

	wait(0.35)

	script.Parent.Parent.A.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.B.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.C.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.D.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.E.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.F.BrickColor = BrickColor.new("New Yeller")

	script.Parent.Parent.G.BrickColor = BrickColor.new("New Yeller")

	wait(0.35)

	script.Parent.Parent.A.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.B.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.C.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.D.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.E.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.F.BrickColor = BrickColor.new("Medium stone grey")

	script.Parent.Parent.G.BrickColor = BrickColor.new("Medium stone grey")

	wait(0.35)

end
end


Prompt: -- Modules

Response: Utils = require(SharedModules:WaitForChild("Utilities"))


Prompt: -- add a leaderboard to the game

Response:
local leaderstats = Instance.new("Folder")
leaderstats.Name = "leaderstats"
leaderstats.Parent = game.Players.LocalPlayer


Prompt:
--[[
	Constructs a new ForKeys state object which maps keys of an array using
	a `processor` function.

	Optionally, a `destructor` function can be specified for cleaning up
	calculated keys. If omitted, the default cleanup function will be used instead.

	Optionally, a `meta` value can be returned in the processor function as the
	second value to pass data from the processor to the destructor.
]]

Response:
local Dependencies = require(script.Parent.Parent.Dependencies)
local utility = Dependencies.utility

local class = {}

local CLASS_METATABLE = { __index = class }


Prompt: -- << VARIABLES >>

Response:
local humanoidDescriptions = {}
local accessoryTypes = {
	[8] = "HatAccessory",
    [41] = "HairAccessory",
    [42] = "FaceAccessory",
    [43] = "NeckAccessory",
    [44] = "ShouldersAccessory",
    [45] = "FrontAccessory",
    [46] = "BackAccessory",
    [47] = "WaistAccessory",
}
local correspondingBodyParts = {
	["Torso"]		= {"UpperTorso","LowerTorso"};
	["Left Arm"] 	= {"LeftHand","LeftLowerArm","LeftUpperArm"};
	["Right Arm"]	= {"RightHand","RightLowerArm","RightUpperArm"};
	["Left Leg"]	= {"LeftFoot","LeftLowerLeg","LeftUpperLeg"};
	["Right Leg"]	= {"RightFoot","RightLowerLeg","RightUpperLeg"};
	}


Prompt: --EEwwwwww gross

Response:
print("Made By OfficerVargas And FPSVision")
seat = script.Parent
s = script


Prompt: -- Editable Values

Response:
local TurboId = 240323039
local SuperId = 404779487
local BovId = 3568930062

local TurboVol = .025				--Per Psi
local TurboRollOffMax = 1000
local TurboRollOffMin = 10

local SuperVol = .025				--Per Psi
local SuperRollOffMax = 1000
local SuperRollOffMin = 10

local BovVol = .025				--Per Psi
local BovRollOffMax = 1000
local BovRollOffMin = 10
local BovSensitivity = .5

local TurboSetPitch = 1		--Base Pitch
local SuperSetPitch = .8	--Base Pitch
local BovSetPitch = .7		--Base Pitch
local TurboPitchIncrease = .05	--Per Psi
local SuperPitchIncrease = .05	--Per Psi
local BovPitchIncrease = .05	--Per Psi

local FE=true


Prompt: -- create beam

Response:
local beam = Instance.new("Beam")
beam.Segments = 1
beam.Width0 = 0.2
beam.Width1 = 0.2
beam.Color = ColorSequence.new(Color3.new(1, 0, 0))
beam.FaceCamera = true


Prompt:
--[=[
	Nevermore loader utility library
	@private
	@class GroupInfoUtils
]=]

Response:
local Utils = require(script.Parent.Utils)
local Queue = require(script.Parent.Queue)
local LoaderConstants = require(script.Parent.LoaderConstants)

local GroupInfoUtils = {}

function GroupInfoUtils.createGroupInfo()
	return Utils.readonly({
		scriptInfoMap = {}; -- [name] = scriptInfo (required link packages)
		packageScriptInfoMap = {};
		packageSet = {}; -- [packageInfo] = true (actually included packages)
	})
end

function GroupInfoUtils.groupPackageInfos(packageInfoList, replicationMode)
	assert(type(packageInfoList) == "table", "Bad packageInfoList")
	assert(type(replicationMode) == "string", "Bad replicationMode")

	local queue = Queue.new()
	local seen = {}

	for _, packageInfo in pairs(packageInfoList) do
		if not seen[packageInfo] then
			seen[packageInfo] = true
			queue:PushRight(packageInfo)
		end
	end

	local built = {}
	local current = GroupInfoUtils.createGroupInfo()
	while not queue:IsEmpty() do
		local packageInfo = queue:PopLeft()
		if GroupInfoUtils.hasAnythingToReplicate(packageInfo, replicationMode) then
			if GroupInfoUtils.canAddPackageInfoToGroup(current, packageInfo, replicationMode) then
				GroupInfoUtils.addPackageInfoToGroup(current, packageInfo, replicationMode)

				if LoaderConstants.GROUP_EACH_PACKAGE_INDIVIDUALLY then
					table.insert(built, current)
					current = GroupInfoUtils.createGroupInfo()
				end
			elseif LoaderConstants.ALLOW_MULTIPLE_GROUPS then
				-- Create a new group
				table.insert(built, current)
				current = GroupInfoUtils.createGroupInfo()
				GroupInfoUtils.addPackageInfoToGroup(current, packageInfo, replicationMode)
			else
				-- Force generate error
				GroupInfoUtils.addPackageInfoToGroup(current, packageInfo, replicationMode)

				error("Cannot add package to group")
			end
		end

		for dependentPackageInfo, _ in pairs(packageInfo.dependencySet) do
			if not seen[dependentPackageInfo] then
				seen[dependentPackageInfo] = true
				queue:PushRight(dependentPackageInfo)
			end
		end
	end

	if next(current.packageSet) then
		table.insert(built, current)
	end

	return built
end

function GroupInfoUtils.hasAnythingToReplicate(packageInfo, replicationMode)
	return next(packageInfo.scriptInfoLookup[replicationMode]) ~= nil
end

function GroupInfoUtils.canAddScriptInfoToGroup(groupInfo, scriptInfo, scriptName, tempScriptInfoMap)
	assert(type(groupInfo) == "table", "Bad groupInfo")
	assert(type(scriptInfo) == "table", "Bad scriptInfo")
	assert(type(scriptName) == "string", "Bad scriptName")
	assert(type(tempScriptInfoMap) == "table", "Bad tempScriptInfoMap")

	local wouldHaveInfo = tempScriptInfoMap[scriptName]
	if wouldHaveInfo and wouldHaveInfo ~= scriptInfo then
		return false
	end

	local currentScriptInfo = groupInfo.scriptInfoMap[scriptName]
	if currentScriptInfo and currentScriptInfo ~= scriptInfo then
		return false
	end

	return true
end

function GroupInfoUtils.canAddPackageInfoToGroup(groupInfo, packageInfo, replicationMode)
	assert(type(groupInfo) == "table", "Bad groupInfo")
	assert(type(packageInfo) == "table", "Bad packageInfo")
	assert(type(replicationMode) == "string", "Bad replicationMode")

	local tempScriptInfoMap = {}

	-- Existing scripts must be added
	for scriptName, scriptInfo in pairs(packageInfo.scriptInfoLookup[replicationMode]) do
		if GroupInfoUtils.canAddScriptInfoToGroup(groupInfo, scriptInfo, scriptName, tempScriptInfoMap) then
			tempScriptInfoMap[scriptName] = scriptInfo
		else
			return false
		end
	end

	-- Dependencies are expected at parent level
	for dependencyPackageInfo, _ in pairs(packageInfo.dependencySet) do
		if not groupInfo.packageSet[dependencyPackageInfo] then
			-- Lookup dependencies and try to merge them
			-- O(p*d*s)
			for scriptName, scriptInfo in pairs(dependencyPackageInfo.scriptInfoLookup[replicationMode]) do
				if GroupInfoUtils.canAddScriptInfoToGroup(groupInfo, scriptInfo, scriptName, tempScriptInfoMap) then
					tempScriptInfoMap[scriptName] = scriptInfo
				else
					return false
				end
			end
		end
	end

	return true
end

function GroupInfoUtils.addScriptToGroup(groupInfo, scriptName, scriptInfo)
	assert(type(groupInfo) == "table", "Bad groupInfo")
	assert(type(scriptInfo) == "table", "Bad scriptInfo")
	assert(type(scriptName) == "string", "Bad scriptName")

	local currentScriptInfo = groupInfo.scriptInfoMap[scriptName]
	if currentScriptInfo and currentScriptInfo ~= scriptInfo then
		error(("Cannot add to package group, conflicting scriptInfo for %q already there")
			:format(scriptName))
	end

	groupInfo.scriptInfoMap[scriptName] = scriptInfo
end

function GroupInfoUtils.addPackageInfoToGroup(groupInfo, packageInfo, replicationMode)
	groupInfo.packageSet[packageInfo] = true

	-- Existing scripts must be added
	for scriptName, scriptInfo in pairs(packageInfo.scriptInfoLookup[replicationMode]) do
		GroupInfoUtils.addScriptToGroup(groupInfo, scriptName, scriptInfo)
		groupInfo.packageScriptInfoMap[scriptName] = scriptInfo
	end

	-- Dependencies are expected at parent level
	for dependencyPackageInfo, _ in pairs(packageInfo.dependencySet) do
		if not groupInfo.packageSet[dependencyPackageInfo] then
			-- Lookup dependencies and try to merge them
			-- O(p*d*s)
			for scriptName, scriptInfo in pairs(dependencyPackageInfo.scriptInfoLookup[replicationMode]) do
				GroupInfoUtils.addScriptToGroup(groupInfo, scriptName, scriptInfo)
			end
		end
	end
end

return GroupInfoUtils


Prompt: -- Force attachment

Response:
EjectionForce.ForcePoint = Vector3.new(
	0,0,0
)

return EjectionForce


Prompt: -- OTHER VARIABLES --

Response:
local player = game.Players.LocalPlayer
local char = player.Character or player.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")
local humanoid = char:WaitForChild("Humanoid")


Prompt:
--Simple Control System, Developed by PixleStuff
--V. 1.0.0


Prompt:
--if false then
--	local i, v = 1, 2
--	local Item = Items[i]
--	local NewItem = script.Parent.Gear.ItemsScrollingFrame.ItemTemplate1:Clone()
--	NewItem.Parent = script.Parent.Gear.ItemsScrollingFrame
--	NewItem.Visible = true
--	NewItem.Name = v.Name
--	NewItem.Price.Text = v.Price
--	NewItem.Icon.Image = v.Decal
--	NewItem.ItemName.Text = v.Name
--	NewItem.Buy.MouseButton1Click:Connect(function()
--		local f = script.Parent.Gear.Item
--		f.ItemName.Text = NewItem.Name
--		f.ItemImage.Image = v.Decal
--		f.Description.Text = v.Special
--		f.Add.MouseButton1Click:Connect(function()
--			table.insert(Cart,Item)
--		end)
--	end)
--end


Prompt: -- connect to RenderStepped (update every frame)

Response:
RunService.RenderStepped:Connect(function()

	-- make sure the character exists
	local character = localPlayer.Character
	if not character then
		-- disable the beam
		beam.Enabled = false
		return
	end

	-- make sure the head exists
	local head = character:FindFirstChild("Head")
	if not head then
		-- disable the beam
		beam.Enabled = false
		return
	end

	-- enable the beam
	beam.Enabled = true

	-- define origin and finish
	local origin = head.Position
	local finish = mouse.Hit.p

	-- move the attachments
	attachment0.Position = origin
	attachment1.Position = finish
end)


Prompt:
--[[
	Expand a node by setting its callback environment and then calling it. Any
	further it and describe calls within the callback will be added to the tree.
]]

Response:
function TestNode:expand()
	local originalEnv = getfenv(self.callback)
	local callbackEnv = setmetatable({}, { __index = originalEnv })
	for key, value in pairs(self.environment) do
		callbackEnv[key] = value
	end
	setfenv(self.callback, callbackEnv)

	local success, result = xpcall(self.callback, debug.traceback)

	if not success then
		self.loadError = result
	end
end

local TestPlan = {}
TestPlan.__index = TestPlan


Prompt:
--[[**
	Returns a t.union of each key in the table as a t.literal

	@param keyTable The table to get keys from

	@returns True iff the condition is satisfied, false otherwise
**--]]

Response:
function t.keyOf(keyTable)
	local keys = {}
	local length = 0
	for key in pairs(keyTable) do
		length = length + 1
		keys[length] = key
	end

	return t.literal(table.unpack(keys, 1, length))
end


Prompt: --local Array = require(LuauPolyfill.Array)

Response:
local isArray = require(LuauPolyfill.Array.isArray)
local arrayFromString = require(LuauPolyfill.Array.from.fromString)
local arrayForEach = require(LuauPolyfill.Array.forEach)
local types = require(LuauPolyfill.types)
type Array<T> = types.Array<T>
type Object = types.Object
type setCallbackFn<T> = types.setCallbackFn<T>
type setCallbackFnWithThisArg<T> = types.setCallbackFnWithThisArg<T>
type Set<T> = types.Set<T>

local inspect = require(LuauPolyfill.util.inspect)

type Set_Statics = {
	new: <T>(iterable: Array<T> | Set<T> | string | nil) -> Set<T>,
}

local Set: Set<any> & Set_Statics = (
	{
		__iter = function(self)
			return next, self._array
		end,
		__tostring = function(self)
			local result = "Set "
			if #self._array > 0 then
				result ..= "(" .. tostring(#self._array) .. ") "
			end
			result ..= inspect(self._array)
			return result
		end,
	} :: any
) :: Set<any> & Set_Statics;
(Set :: any).__index = Set

function Set.new<T>(iterable: Array<T> | Set<T> | string | nil): Set<T>
	local array
	local map = {}
	if iterable ~= nil then
		local arrayIterable

		if typeof(iterable) == "table" then
			if isArray(iterable) then
				arrayIterable = table.clone(iterable)
			else
				local mt = getmetatable(iterable :: any)
				if mt and rawget(mt, "__iter") then
					arrayIterable = iterable :: Set<T>
				elseif _G.__DEV__ then
					error("cannot create array from an object-like table")
				end
			end
		elseif typeof(iterable) == "string" then
			-- TODO Luau: need overloads for `from` to avoid needing the manual cast
			arrayIterable = arrayFromString(iterable :: string) :: Array<string>
		else
			error(("cannot create array from value of type `%s`"):format(typeof(iterable)))
		end

		if arrayIterable then
			array = table.create(#arrayIterable)
			for _, element in arrayIterable do
				if not map[element] then
					map[element] = true
					table.insert(array, element)
				end
			end
		else
			array = {}
		end
	else
		array = {}
	end

	return (setmetatable({
		size = #array,
		_map = map,
		_array = array,
	}, Set) :: any) :: Set<T>
end

function Set:add(value)
	if not self._map[value] then
		-- Luau FIXME: analyze should know self is Set<T> which includes size as a number
		self.size = self.size :: number + 1
		self._map[value] = true
		table.insert(self._array, value)
	end
	return self
end

function Set:clear()
	self.size = 0
	table.clear(self._map)
	table.clear(self._array)
end

function Set:delete(value): boolean
	if not self._map[value] then
		return false
	end
	-- Luau FIXME: analyze should know self is Map<K, V> which includes size as a number
	self.size = self.size :: number - 1
	self._map[value] = nil
	local index = table.find(self._array, value)
	if index then
		table.remove(self._array, index)
	end
	return true
end


Prompt: -- functions

Response:
function onDied()
	stopLoopedSounds()
end

local fallCount = 0
local fallSpeed = 0
function onStateFall(state, sound)
	fallCount = fallCount + 1
	if state then
		sound.Volume = 0
		sound:Play()
		Spawn( function()
			local t = 0
			local thisFall = fallCount
			while t < 1.5 and fallCount == thisFall do
				local vol = math.max(t - 0.3 , 0)
				sound.Volume = vol
				wait(0.1)
				t = t + 0.1
			end
		end)
	else
		sound:Stop()
	end
	fallSpeed = math.max(fallSpeed, math.abs(Head.Velocity.Y))
end

function onStateNoStop(state, sound)
	if state then
		sound:Play()
	end
end

function onRunning(speed)
	sClimbing:Stop()
	sSwimming:Stop()
	if (prevState == "FreeFall" and fallSpeed > 0.1) then
		local vol = math.min(1.0, math.max(0.0, (fallSpeed - 50) / 110))
		sLanding.Volume = vol
		sLanding:Play()
		fallSpeed = 0
	end
	if speed>0.5 then
		sRunning:Play()
		sRunning.Pitch = speed / 8.0
	else
		sRunning:Stop()
	end
	prevState = "Run"
end

function onSwimming(speed)
	if (prevState ~= "Swim" and speed > 0.1) then
		local volume = math.min(1.0, speed / 350)
		sSplash.Volume = volume
		sSplash:Play()
		prevState = "Swim"
	end
	sClimbing:Stop()
	sRunning:Stop()
	sSwimming.Pitch = 1.6
	sSwimming:Play()
end

function onClimbing(speed)
	sRunning:Stop()
	sSwimming:Stop()
	if speed>0.01 then
		sClimbing:Play()
		sClimbing.Pitch = speed / 5.5
	else
		sClimbing:Stop()
	end
	prevState = "Climb"
end


Prompt:
-- Note: Overrides base class GetIsJumping with get-and-clear behavior to do a single jump
-- rather than sustained jumping. This is only to preserve the current behavior through the refactor.

Response:
function DynamicThumbstick:GetIsJumping()
	local wasJumping = self.isJumping
	self.isJumping = false
	return wasJumping
end

function DynamicThumbstick:EnableAutoJump(enable) -- Remove on FFlagUserDTDoesNotForceAutoJump
	if FFlagUserDTDoesNotForceAutoJump then
		return
	end
	local humanoid = LocalPlayer.Character and LocalPlayer.Character:FindFirstChildOfClass("Humanoid")
	if humanoid then
		if enable then
			self.shouldRevertAutoJumpOnDisable = (humanoid.AutoJumpEnabled == false) and (LocalPlayer.DevTouchMovementMode == Enum.DevTouchMovementMode.UserChoice)
			humanoid.AutoJumpEnabled = true
		elseif self.shouldRevertAutoJumpOnDisable then
			humanoid.AutoJumpEnabled = false
		end
	end
end

function DynamicThumbstick:Enable(enable, uiParentFrame)
	if enable == nil then return false end			-- If nil, return false (invalid argument)
	enable = enable and true or false				-- Force anything non-nil to boolean before comparison
	if self.enabled == enable then return true end	-- If no state change, return true indicating already in requested state

	if enable then
		-- Enable
		if not self.thumbstickFrame then
			self:Create(uiParentFrame)
		end

		self:BindContextActions()

		if not FFlagUserDTDoesNotTrackTools then
			if LocalPlayer.Character then
				self:OnCharacterAdded(LocalPlayer.Character)
			else
				LocalPlayer.CharacterAdded:Connect(function(char)
					self:OnCharacterAdded(char)
				end)
			end
		end
	else
		ContextActionService:UnbindAction(DYNAMIC_THUMBSTICK_ACTION_NAME)
		-- Disable
		self:OnInputEnded() -- Cleanup
	end

	self.enabled = enable
	self.thumbstickFrame.Visible = enable
end

function DynamicThumbstick:OnCharacterAdded(char) -- Remove on FFlagUserDTDoesNotTrackTools
	assert(not FFlagUserDTDoesNotTrackTools)

	for _, child in ipairs(char:GetChildren()) do
		if child:IsA("Tool") then
			self.toolEquipped = child
		end
	end

	char.ChildAdded:Connect(function(child)
		if child:IsA("Tool") then
			self.toolEquipped = child
		elseif child:IsA("Humanoid") then
			self:EnableAutoJump(true) -- Remove on FFlagUserDTDoesNotForceAutoJump
		end
	end)
	char.ChildRemoved:Connect(function(child)
		if child == self.toolEquipped then
			self.toolEquipped = nil
		end
	end)

	self.humanoid = char:FindFirstChildOfClass("Humanoid")
	if self.humanoid then
		self:EnableAutoJump(true) -- Remove on FFlagUserDTDoesNotForceAutoJump
	end
end


Prompt: ---------END RIGHT DOOR

Response:
game.Workspace.backdoorleft.p1.CFrame = game.Workspace.backdoorleft.p1.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p2.CFrame = game.Workspace.backdoorleft.p2.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p3.CFrame = game.Workspace.backdoorleft.p3.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p4.CFrame = game.Workspace.backdoorleft.p4.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p5.CFrame = game.Workspace.backdoorleft.p5.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p6.CFrame = game.Workspace.backdoorleft.p6.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p7.CFrame = game.Workspace.backdoorleft.p7.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p8.CFrame = game.Workspace.backdoorleft.p8.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p9.CFrame = game.Workspace.backdoorleft.p9.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p10.CFrame = game.Workspace.backdoorleft.p10.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p11.CFrame = game.Workspace.backdoorleft.p11.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p12.CFrame = game.Workspace.backdoorleft.p12.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p13.CFrame = game.Workspace.backdoorleft.p13.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p14.CFrame = game.Workspace.backdoorleft.p14.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p15.CFrame = game.Workspace.backdoorleft.p15.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p16.CFrame = game.Workspace.backdoorleft.p16.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p17.CFrame = game.Workspace.backdoorleft.p17.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p18.CFrame = game.Workspace.backdoorleft.p18.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p19.CFrame = game.Workspace.backdoorleft.p19.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)
game.Workspace.backdoorleft.p20.CFrame = game.Workspace.backdoorleft.p20.CFrame * CFrame.new(0.5, 0, 0) * CFrame.fromEulerAnglesXYZ(0, 0, 0)


Prompt: --Made by Stickmasterluke

Response:
local sp=script.Parent

local tauntcooldown=10

local originalgrip=CFrame.Angles(math.pi/2,0,0)+Vector3.new(0,-.25,-1.4)

local currentgrip=originalgrip

local debris=game:GetService("Debris")
local enabled=true
local taunting=false
local lasttaunt=0

function waitfor(parent,name)
	while true do
		local child=parent:FindFirstChild(name)
		if child~=nil then
			return child
		end
		wait()
	end
end

waitfor(sp,"Handle")

function onButton1Down(mouse)
	if not enabled then
		return
	end
	enabled=false
	mouse.Icon="rbxasset://textures\\GunWaitCursor.png"
	wait(.75)
	mouse.Icon="rbxasset://textures\\GunCursor.png"
	enabled=true
end

function swordUp()
	currentgrip=originalgrip
end

function swordOut()
	currentgrip=originalgrip*CFrame.Angles(math.pi/4,.4,0)
end

function spinsword(spintime)
	delay(0,function()
		local startspin=tick()
		local endspin=startspin+spintime
		while tick()<endspin do
			sp.Grip=currentgrip*CFrame.Angles(math.pi*2*((tick()-startspin)/spintime),0,0)
			wait()
		end
		sp.Grip=currentgrip
	end)
end

sp.Equipped:connect(function(mouse)
	equipped=true
	local currentlast=lastequipped
	if mouse==nil then
		print("Mouse not found")
		return
	end
	mouse.Icon="rbxasset://textures\\GunCursor.png"
	mouse.Button1Down:connect(function()
		onButton1Down(mouse)
	end)
	waitfor(sp,"Taunting")
	waitfor(sp,"Taunt")
	--[[waitfor(sp,"Summon")
	mouse.KeyDown:connect(function(key)
		key=string.lower(key)
		if key=="l" or key=="t" or key=="g" or key=="e" then
			local h=sp.Parent:FindFirstChild("Humanoid")
			if h~=nil and (not sp.Taunting.Value) and lasttaunt+tauntcooldown<tick() then
				lasttaunt=tick()
				sp.Taunting.Value=true
				h.WalkSpeed=0
				tauntanim=h:LoadAnimation(sp.Taunt)
				tauntanim:Play()
				wait(4)
				sp.Summon.Value=not sp.Summon.Value
				wait(1)
				h.WalkSpeed=16
				sp.Taunting.Value=false
			end
		end
	end)
	--]]
end)

sp.Unequipped:connect(function()
	equipped=false
end)

waitfor(sp,"RunAnim")
sp.RunAnim.Changed:connect(function()
	local h=sp.Parent:FindFirstChild("Humanoid")
	local t=sp.Parent:FindFirstChild("Torso")
	local anim=sp:FindFirstChild(sp.RunAnim.Value)
	if anim and t and h then
		theanim=h:LoadAnimation(anim)
		if theanim and h.Health>0 then
			theanim:Play()
			if sp.RunAnim.Value=="RightSlash" or sp.RunAnim.Value=="LeftSlash" or sp.RunAnim.Value=="OverHeadSwing" then
				spinsword(.5)
			end
			if sp.RunAnim.Value=="OverHeadSwing" then
				wait(.25)
				swordOut()
				wait(.5)
				swordUp()
				sp.Grip=currentgrip
			elseif sp.RunAnim.Value=="OverHeadSwingFast" then
				wait(.125)
				swordOut()
				wait(.25)
				swordUp()
				sp.Grip=currentgrip
			end
		end
	end
end)

function tagHumanoid(humanoid,player)
	for i,v in ipairs(humanoid:GetChildren()) do
		if v.Name=="creator" then
			v:remove()
		end
	end
	local creator_tag=Instance.new("ObjectValue")
	creator_tag.Value=player
	creator_tag.Name="creator"
	creator_tag.Parent=humanoid
	debris:AddItem(creator_tag,1)
end


Prompt:
--Made by Repressed_Memories
-- Edited by Truenus

Response:
local component = script.Parent.Parent
local car = script.Parent.Parent.Parent.Parent.Car.Value
local mouse = game.Players.LocalPlayer:GetMouse()
local leftsignal = "z"
local rightsignal = "c"
local hazards = "x"
local hazardson = false
local lefton = false
local righton = false
local leftlight = car.Body.Lights.Left.TurnSignal.TSL
local rightlight = car.Body.Lights.Right.TurnSignal.TSL
local leftfront = car.Body.Lights.Left.TurnSignal
local rightfront = car.Body.Lights.Right.TurnSignal
local signalblinktime = 0.32
local neonleft = car.Body.Lights.Left.TurnSignal2
local neonright = car.Body.Lights.Right.TurnSignal2
local off =  BrickColor.New("Mid ray")
local on = BrickColor.New("New Yeller")
mouse.KeyDown:connect(function(lkey)
	local key = string.lower(lkey)
	if key == leftsignal then
		if lefton == false then
			lefton = true
			repeat
				neonleft.BrickColor = on
				leftlight.Enabled = true
				neonleft.Material = "Neon"
				leftfront.Material = "Neon"
				component.TurnSignal:play()
				wait(signalblinktime)
				neonleft.BrickColor = off
				component.TurnSignal:play()
				neonleft.Material = "SmoothPlastic"
				leftfront.Material = "SmoothPlastic"
				leftlight.Enabled = false
				wait(signalblinktime)
			until
			lefton == false or righton == true
		elseif lefton == true or righton == true then
			lefton = false
			component.TurnSignal:stop()
			leftlight.Enabled = false
		end
	elseif key == rightsignal then
		if righton == false then
			righton = true
			repeat
				neonright.BrickColor = on
				rightlight.Enabled = true
				neonright.Material = "Neon"
				rightfront.Material = "Neon"
				component.TurnSignal:play()
				wait(signalblinktime)
				neonright.BrickColor = off
				component.TurnSignal:play()
				neonright.Material = "SmoothPlastic"
				rightfront.Material = "SmoothPlastic"
				rightlight.Enabled = false
				wait(signalblinktime)
			until
			righton == false or lefton == true
		elseif righton == true or lefton == true then
			righton = false
			component.TurnSignal:stop()
			rightlight.Enabled = false
		end
	elseif key == hazards then
		if hazardson == false then
			hazardson = true
			repeat
				neonright.BrickColor = on
				neonleft.BrickColor = on
				neonright.Material = "Neon"
				rightfront.Material = "Neon"
				neonleft.Material = "Neon"
				leftfront.Material = "Neon"
				component.TurnSignal:play()
				rightlight.Enabled = true
				leftlight.Enabled = true
				wait(signalblinktime)
				neonright.BrickColor = off
				neonleft.BrickColor = off
				component.TurnSignal:play()
				neonright.Material = "SmoothPlastic"
				rightfront.Material = "SmoothPlastic"
				neonleft.Material = "SmoothPlastic"
				leftfront.Material = "SmoothPlastic"
				rightlight.Enabled = false
				leftlight.Enabled = false
				wait(signalblinktime)
			until
			hazardson == false
		elseif hazardson == true then
			hazardson = false
			component.TurnSignal:stop()
			rightlight.Enabled = false
			leftlight.Enabled = false
		end
	end
end)


Prompt:
--[=[
	Returns an array of all enum items.
	@return {EnumItem}
	@since v2.0.0
]=]

Response:
function EnumList:GetEnumItems()
	return self[LIST_KEY]
end


Prompt: --Services--

Response:
local MS = game:GetService("MarketplaceService")
local P = game:GetService("Players")


Response:
Evt.Ombro.OnServerEvent:Connect(function(Player,Vitima)
	local Nombre
	for SKP_001, SKP_002 in pairs(game.Players:GetChildren()) do
	if SKP_002:IsA('Player') and SKP_002 ~= Player and SKP_002.Name == Vitima then
		if SKP_002.Team == Player.Team then
			Nombre = Player.Name
		else
			Nombre = "Someone"
		end
		Evt.Ombro:FireClient(SKP_002,Nombre)
		end
	end
end)

Evt.Target.OnServerEvent:Connect(function(Player,Vitima)
	Player.Character.Saude.Variaveis.PlayerSelecionado.Value = Vitima
end)

Evt.Render.OnServerEvent:Connect(function(Player,Status,Vitima)
		if Vitima == "N/A" then
			Player.Character.Saude.Stances.Rendido.Value = Status
		else

			local VitimaTop = game.Players:FindFirstChild(Vitima)
		if VitimaTop.Character.Saude.Stances.Algemado.Value == false then
			VitimaTop.Character.Saude.Stances.Rendido.Value = Status
			VitimaTop.Character.Saude.Variaveis.HitCount.Value = 0
		end
	end
end)

Evt.Drag.OnServerEvent:Connect(function(player)
	local Human = player.Character.Humanoid
	local enabled = Human.Parent.Saude.Variaveis.Doer
	local MLs = Human.Parent.Saude.Variaveis.MLs
	local Caido = Human.Parent.Saude.Stances.Caido
	local Item = Human.Parent.Saude.Kit.Epinefrina

	local target = Human.Parent.Saude.Variaveis.PlayerSelecionado

	if Caido.Value == false and target.Value ~= "N/A" then

		local player2 = game.Players:FindFirstChild(target.Value)
		local PlHuman = player2.Character.Humanoid

		local Sangrando = PlHuman.Parent.Saude.Stances.Sangrando
		local MLs = PlHuman.Parent.Saude.Variaveis.MLs
		local Dor = PlHuman.Parent.Saude.Variaveis.Dor
		local Ferido = PlHuman.Parent.Saude.Stances.Ferido
		local PlCaido = PlHuman.Parent.Saude.Stances.Caido
		local Sang = PlHuman.Parent.Saude.Variaveis.Sangue

		if enabled.Value == false then

		if PlCaido.Value == true or PlCaido.Parent.Algemado.Value == true then
		enabled.Value = true

		coroutine.wrap(function()
        while target.Value ~= "N/A" and PlCaido.Value == true and PlHuman.Health > 0 and Human.Health > 0 and Human.Parent.Saude.Stances.Caido.Value == false or target.Value ~= "N/A" and PlCaido.Parent.Algemado.Value == true do wait() pcall(function()
                player2.Character.Torso.Anchored ,player2.Character.Torso.CFrame = true,Human.Parent.Torso.CFrame*CFrame.new(0,0.75,1.5)*CFrame.Angles(math.rad(0), math.rad(0), math.rad(90))
				enabled.Value = true
        end) end
        pcall(function() player2.Character.Torso.Anchored=false
		enabled.Value = false
		end)
		end)()

		enabled.Value = false
		end
		end
	end
end)

Evt.Squad.OnServerEvent:Connect(function(Player,SquadName,SquadColor)
	Player.Character.Saude.FireTeam.SquadName.Value = SquadName
	Player.Character.Saude.FireTeam.SquadColor.Value = SquadColor
end)

Evt.Afogar.OnServerEvent:Connect(function(Player)
	Player.Character.Humanoid.Health = 0
end)


Prompt: --Cboehme

Response:
function onclick()
	script.Parent.ImageTransparency = 0.1
	wait(.05)
	script.Parent.ImageTransparency = 0
end

script.Parent.MouseButton1Click:connect(onclick)


Prompt: --Button size

Response:
local ButtonSX = Button.Size.X.Scale
local ButtonSY = Button.Size.Y.Scale

Button.MouseEnter:Connect(function(x,y)
	--HolaMousee
	Button:TweenSize(
		UDim2.new(ButtonSX + 0.021 , 0,ButtonSY + 0.018, 0),
		Enum.EasingDirection.Out,
		Enum.EasingStyle.Back,
		0.2,
		true
	)
end)

Button.MouseLeave:Connect(function(x,y)
	--AdiosMousee
	Button:TweenSize(
		UDim2.new(ButtonSX, 0,ButtonSY, 0),
		Enum.EasingDirection.Out,
		Enum.EasingStyle.Back,
		0.2,
		true
	)
end)

Button.MouseButton1Down:Connect(function(x,y)
	--Holding mouse
	Button:TweenSize(
		UDim2.new(ButtonSX - 0.021 , 0,ButtonSY - 0.018 , 0),
		Enum.EasingDirection.Out,
		Enum.EasingStyle.Back,
		0.15,
		true
	)
end)

Button.MouseButton1Up:Connect(function(x,y)
	--Holding mouse
	Button:TweenSize(
		UDim2.new(ButtonSX + 0.021,0, ButtonSY + 0.018,0),
		Enum.EasingDirection.Out,
		Enum.EasingStyle.Back,
		0.15,
		true
	)
end)


Prompt: -- Set the callback; this can only be done once by one script on the server!

Response: MarketplaceService.ProcessReceipt = processReceipt


Prompt: -- 28-36

Response:
module.Subcategory.Bundles = 37
module.Subcategory.AnimationBundles = 38
module.Subcategory.EmoteAnimations = 39
module.Subcategory.CommunityCreations = 40
module.Subcategory.Melee = 41
module.Subcategory.Ranged = 42
module.Subcategory.Explosive = 43
module.Subcategory.PowerUp = 44
module.Subcategory.Navigation = 45
module.Subcategory.Musical = 46
module.Subcategory.Social = 47
module.Subcategory.Building = 48
module.Subcategory.Transport = 49

module.AssetType = {}
module.AssetType.None = 0

module.AssetType["T-Shirt"] = 2
module.AssetType.Hat = 8
module.AssetType.Shirt = 11
module.AssetType.Pants = 12
module.AssetType.Head = 17
module.AssetType.Face = 18
module.AssetType.Gear = 19
module.AssetType.Arms = 25
module.AssetType.Legs = 26
module.AssetType.Torso = 27
module.AssetType.RightArm = 28
module.AssetType.LeftArm = 29
module.AssetType.LeftLeg = 30
module.AssetType.RightLeg = 31
module.AssetType.HairAccessory = 41
module.AssetType.FaceAccessory = 42
module.AssetType.NeckAccessory = 43
module.AssetType.ShoulderAccessory = 44
module.AssetType.FrontAccessory = 45
module.AssetType.BackAccessory = 46
module.AssetType.WaistAccessory = 47
module.AssetType.ClimbAnimation = 48
module.AssetType.DeathAnimation = 49
module.AssetType.FallAnimation = 50
module.AssetType.IdleAnimation = 51
module.AssetType.JumpAnimation = 52
module.AssetType.RunAnimation = 53
module.AssetType.SwimAnimation = 54
module.AssetType.WalkAnimation = 55
module.AssetType.PoseAnimation = 56
module.AssetType.EmoteAnimation = 61

function module.GetOptionName(section, value)
	for k, v in pairs(module[section]) do
		if v == value then
			return k
		end
	end
end

return module


Prompt:
--
-- Adapted from
-- Tweener's easing functions (Penner's Easing Equations)
-- and http://code.google.com/p/tweener/ (jstweener javascript version)
--   https://easings.net/ for visuals


Prompt: --[[Transmission]]

Response:
	Tune.TransModes		= {"Auto","Semi"}												--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch

		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}
		>First mode is default mode													]]

	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]
	Tune.AutoUpThresh	= -200		-- Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		-- Automatic downshift point (relative to peak RPM, positive = Under-rev)
	Tune.ShiftTime = .3				-- The time delay in which you initiate a shift and the car changes gear

	--Gear Ratios

	Tune.FinalDrive		= 4.5			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.70		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.53		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.04		,
		--[[ 3 ]]		1.38		,
		--[[ 4 ]]		1.03		,
		--[[ 5 ]]		0.81		,
		--[[ 6 ]]		0.64		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (keep this at 1 if car is not struggling with torque)


Prompt:
------------------------------------------------------------------------
-- decodes a 4-char little-endian string into an instruction struct
------------------------------------------------------------------------

Response:
function luaP:DecodeInst(x)
  local byte = string.byte
  local i = {}
  local I = byte(x, 1)
  local op = I % 64
  i.OP = op
  I = byte(x, 2) * 4 + (I - op) / 64  -- 2 bits of c0 left
  local a = I % 256
  i.A = a
  I = byte(x, 3) * 4 + (I - a) / 256  -- 2 bits of c1 left
  local c = I % 512
  i.C = c
  i.B = byte(x, 4) * 2 + (I - c) / 512 -- 1 bits of c2 left
  local opmode = self.OpMode[tonumber(string.sub(self.opmodes[op + 1], 7, 7))]
  if opmode ~= "iABC" then
    i.Bx = i.B * 512 + i.C
  end
  return i
end


Prompt: -- ROBLOX deviation: omitting prettyFormat import

Response:
local function serialize(val: string): string
	-- Return the string itself, not escaped nor enclosed in double quote marks.
	local ansiLookupTable = {
		[chalk.inverse.open] = "<i>",
		[chalk.inverse.close] = "</i>",
		[chalk.bold.open] = "<b>",
		[chalk.dim.open] = "<d>",
		[chalk.green.open] = "<g>",
		[chalk.red.open] = "<r>",
		[chalk.yellow.open] = "<y>",
		[chalk.bgYellow.open] = "<Y>",
		[chalk.bold.close] = "</>",
		[chalk.dim.close] = "</>",
		[chalk.green.close] = "</>",
		[chalk.red.close] = "</>",
		[chalk.yellow.close] = "</>",
		[chalk.bgYellow.close] = "</>",
	}

	return val:gsub(ansiRegex, function(match)
		if ansiLookupTable[match] then
			return ansiLookupTable[match]
		else
			return match
		end
	end)
end

local function test(val: any)
	return typeof(val) == "string"
end

return {
	serialize = serialize,
	test = test,
}


Prompt: ---------------------------------------Function end here.

Response:
end

Tool.Enabled = true
function onActivated()

	if not Tool.Enabled then
		return
	end

	--Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return
	end

	local targetPos = humanoid.TargetPoint
	local lookAt = (targetPos - character.Head.Position).unit

	if (check()) then
	fire(lookAt)
	wait(0.0003)
	onActivated()
	end
	return

	--Tool.Enabled = true
end

script.Parent.Activated:connect(onActivated)


Prompt: -- Gradually regenerates the Humanoid's Health over time.

Response:
local REGEN_RATE = .25/100 -- Regenerate this fraction of MaxHealth per second.
local REGEN_STEP = .25 -- Wait this long between each regeneration step.


Prompt:
--[=[
	Observables are like an [signal](/api/Signal), except they do not execute code
	until the observable is subscribed to. This follows the standard
	Rx API surface for an observable.

	Observables use a [Subscription](/api/Subscription) to emit values.

	```lua
	-- Constucts an observable which will emit a, b, c via a subscription
	local observable = Observable.new(function(sub)
		print("Connected")
		sub:Fire("a")
		sub:Fire("b")
		sub:Fire("c")
		sub:Complete() -- ends stream
	end)

	local sub1 = observable:Subscribe() --> Connected
	local sub2 = observable:Subscribe() --> Connected
	local sub3 = observable:Subscribe() --> Connected

	sub1:Destroy()
	sub2:Destroy()
	sub3:Destroy()
	```

	Note that emitted values may be observed like this

	```lua
	observable:Subscribe(function(value)
		print("Got ", value)
	end)

	--> Got a
	--> Got b
	--> Got c
	```

	Note that also, observables return a [MaidTask](/api/MaidTask) which
	should be used to clean up the resulting subscription.

	```lua
	maid:GiveTask(observable:Subscribe(function(value)
		-- do work here!
	end))
	```

	Observables over signals are nice because observables may be chained and manipulated
	via the Pipe operation.

	:::tip
	You should always clean up the subscription using a [Maid](/api/Maid), otherwise
	you may memory leak.
	:::
	@class Observable
]=]

Response:
local require = require(script.Parent.loader).load(script)

local Subscription = require("Subscription")

local ENABLE_STACK_TRACING = false

local Observable = {}
Observable.ClassName = "Observable"
Observable.__index = Observable


Prompt: --local doubleJumpMod = require(extraMods.DoubleJump)

Response:
local chestDisplayMod = require(extraMods.Chest.ChestDisplay)
local safeZoneMod = require(UIMods.SafeZone.SafeZoneMod)
local petMoveClient = require(modules.Pet.PetClientMovement)
local petClientMod = require(modules.Pet.PetClient)
local classBoostDisplay = require(UIMods.WeaponShop.ClassBoostDisplay)
local skillShopMod = require(UIMods.SkillsShop.SkillsShopHandler)
local settingsMod = require(UIMods.Settings.SettingsHandler)
local islandsMod = require(modules.Zones.ZoneUpdate)
local bossRewardsDisplayMod = require(extraMods.BossRewardDisplay)
local sellClientMod = require(UIMods.Sell.SellClient)
local statsUIMod = require(UIMods.Stats.StatsUIMod)
local indexUIMod = require(UIMods.Index.IndexUIMod)
local hoopClient = require(extraMods.HoopClient)
local dmgTextMod = require(extraMods.DamageText)
local colorChangeMod = require(extraMods.ColorChange)
local boostClientMod = require(UIMods.Boosts.BoostClient)
local shirtBuyMod = require(extraMods.Shirts.ShirtBuying)
local gemBoostMod = require(UIMods.Boosts.GemBoosts)
local mainUIMod = require(UIMods.UIMain)

petClientMod:Int(plr)
mainUIMod:Int()
deviceMod:Int(plr)
chestDisplayMod:Int()
boostClientMod:Int(plr)
displayStatsMod:Int(plr)
rotateObectsMod:Int()
showStatsMod:Int()
codeUIMod:Int()
weaponShop:Int(plr)
eggClientMod:Int(plr)
safeZoneMod:Int(plr)
settingsMod:Int(plr)
skillShopMod:Int(plr)
petMoveClient:Int(plr)
shirtBuyMod:Int(plr)
classBoostDisplay:Int(plr)
bossRewardsDisplayMod:Int(plr)
sellClientMod:Int(plr)
indexUIMod:Int(plr)
hoopClient:Int(plr)
dmgTextMod:Int()
rShopMod:Int(plr)
colorChangeMod:Int()
gemBoostMod:Int(plr)
islandsMod:Int(plr)
statsUIMod:Int(plr)


Prompt:
--[[
	Notes:
	Transparency Modifier is what is the end result when "zooming in", it can be changed to whatever you like.

	Camera Offset is changed to allow the player to see at lower angles without clipping the view with the torso.
	This may or maynot effect certian tools if they change the players camera position IE crouching or crawling.

	Use:
	Place into StarterPlayer.StarterChacterScripts
--]]

Response:
local character = (game.Players.LocalPlayer.Character or game.Players.LocalPlayer.CharacterAdded:wait())

game:GetService("RunService").RenderStepped:connect(function()
	if (character:FindFirstChild("RightUpperArm") and character:FindFirstChild("LeftUpperArm")) then

		character:FindFirstChild("RightUpperArm").LocalTransparencyModifier = 0

		character:FindFirstChild("LeftUpperArm").LocalTransparencyModifier = 0

		character:FindFirstChild("RightLowerArm").LocalTransparencyModifier = 0

		character:FindFirstChild("LeftLowerArm").LocalTransparencyModifier = 0

		character:FindFirstChild("RightHand").LocalTransparencyModifier = 0

		character:FindFirstChild("LeftHand").LocalTransparencyModifier = 0

		character:FindFirstChild("RightUpperLeg").LocalTransparencyModifier = 0

		character:FindFirstChild("LeftUpperLeg").LocalTransparencyModifier = 0

		character:FindFirstChild("RightLowerLeg").LocalTransparencyModifier = 0

		character:FindFirstChild("LeftLowerLeg").LocalTransparencyModifier = 0

		character:FindFirstChild("RightFoot").LocalTransparencyModifier = 0

		character:FindFirstChild("LeftFoot").LocalTransparencyModifier = 0

		--character:FindFirstChild("Humanoid").CameraOffset = Vector3.new(0,0,-1)
	end
end)


Prompt:
--////////////////////////////// Methods
--//////////////////////////////////////

Response:
local methods = {}
methods.__index = methods

function methods:CreateGuiObjects(targetParent)
	self.ChatBarParentFrame = targetParent

	local backgroundImagePixelOffset = 7
	local textBoxPixelOffset = 5

	local BaseFrame = Instance.new("Frame")
	BaseFrame.Selectable = false
	BaseFrame.Size = UDim2.new(1, 0, 1, 0)
	BaseFrame.BackgroundTransparency = 0.6
	BaseFrame.BorderSizePixel = 0
	BaseFrame.BackgroundColor3 = ChatSettings.ChatBarBackGroundColor
	BaseFrame.Parent = targetParent

	local BoxFrame = Instance.new("Frame")
	BoxFrame.Selectable = false
	BoxFrame.Name = "BoxFrame"
	BoxFrame.BackgroundTransparency = 0.6
	BoxFrame.BorderSizePixel = 0
	BoxFrame.BackgroundColor3 = ChatSettings.ChatBarBoxColor
	BoxFrame.Size = UDim2.new(1, -backgroundImagePixelOffset * 2, 1, -backgroundImagePixelOffset * 2)
	BoxFrame.Position = UDim2.new(0, backgroundImagePixelOffset, 0, backgroundImagePixelOffset)
	BoxFrame.Parent = BaseFrame

	local TextBoxHolderFrame = Instance.new("Frame")
	TextBoxHolderFrame.BackgroundTransparency = 1
	TextBoxHolderFrame.Size = UDim2.new(1, -textBoxPixelOffset * 2, 1, -textBoxPixelOffset * 2)
	TextBoxHolderFrame.Position = UDim2.new(0, textBoxPixelOffset, 0, textBoxPixelOffset)
	TextBoxHolderFrame.Parent = BoxFrame

	local TextBox = Instance.new("TextBox")
	TextBox.Selectable = ChatSettings.GamepadNavigationEnabled
	TextBox.Name = "ChatBar"
	TextBox.BackgroundTransparency = 1
	TextBox.Size = UDim2.new(1, 0, 1, 0)
	TextBox.Position = UDim2.new(0, 0, 0, 0)
	TextBox.TextSize = ChatSettings.ChatBarTextSize
	TextBox.Font = ChatSettings.ChatBarFont
	TextBox.TextColor3 = ChatSettings.ChatBarTextColor
	TextBox.TextTransparency = 0.4
	TextBox.TextStrokeTransparency = 1
	TextBox.ClearTextOnFocus = false
	TextBox.TextXAlignment = Enum.TextXAlignment.Left
	TextBox.TextYAlignment = Enum.TextYAlignment.Top
	TextBox.TextWrapped = true
	TextBox.Text = ""
	TextBox.Parent = TextBoxHolderFrame

	local MessageModeTextButton = Instance.new("TextButton")
	MessageModeTextButton.Selectable = false
	MessageModeTextButton.Name = "MessageMode"
	MessageModeTextButton.BackgroundTransparency = 1
	MessageModeTextButton.Position = UDim2.new(0, 0, 0, 0)
	MessageModeTextButton.TextSize = ChatSettings.ChatBarTextSize
	MessageModeTextButton.Font = ChatSettings.ChatBarFont
	MessageModeTextButton.TextXAlignment = Enum.TextXAlignment.Left
	MessageModeTextButton.TextWrapped = true
	MessageModeTextButton.Text = ""
	MessageModeTextButton.Size = UDim2.new(0, 0, 0, 0)
	MessageModeTextButton.TextYAlignment = Enum.TextYAlignment.Center
	MessageModeTextButton.TextColor3 = self:GetDefaultChannelNameColor()
	MessageModeTextButton.Visible = true
	MessageModeTextButton.Parent = TextBoxHolderFrame

	local TextLabel = Instance.new("TextLabel")
	TextLabel.Selectable = false
	TextLabel.TextWrapped = true
	TextLabel.BackgroundTransparency = 1
	TextLabel.Size = TextBox.Size
	TextLabel.Position = TextBox.Position
	TextLabel.TextSize = TextBox.TextSize
	TextLabel.Font = TextBox.Font
	TextLabel.TextColor3 = TextBox.TextColor3
	TextLabel.TextTransparency = TextBox.TextTransparency
	TextLabel.TextStrokeTransparency = TextBox.TextStrokeTransparency
	TextLabel.TextXAlignment = TextBox.TextXAlignment
	TextLabel.TextYAlignment = TextBox.TextYAlignment
	TextLabel.Text = "This value needs to be set with :SetTextLabelText()"
	TextLabel.Parent = TextBoxHolderFrame

	self.GuiObject = BaseFrame
	self.TextBox = TextBox
	self.TextLabel  = TextLabel

	self.GuiObjects.BaseFrame = BaseFrame
	self.GuiObjects.TextBoxFrame = BoxFrame
	self.GuiObjects.TextBox = TextBox
	self.GuiObjects.TextLabel = TextLabel
	self.GuiObjects.MessageModeTextButton = MessageModeTextButton

	self:AnimGuiObjects()
	self:SetUpTextBoxEvents(TextBox, TextLabel, MessageModeTextButton)
	if self.UserHasChatOff then
		self:DoLockChatBar()
	end
	self.eGuiObjectsChanged:Fire()
end


Prompt:
--local Torso = Figure:WaitForChild("Torso")
--local RightShoulder = Torso:WaitForChild("Right Shoulder")
--local LeftShoulder = Torso:WaitForChild("Left Shoulder")
--local RightHip = Torso:WaitForChild("Right Hip")
--local LeftHip = Torso:WaitForChild("Left Hip")
--local Neck = Torso:WaitForChild("Neck")

Response:
local Humanoid = Figure:WaitForChild("Humanoid")
local pose = "Standing"

local EMOTE_TRANSITION_TIME = 0.1

local userAnimateScaleRunSuccess, userAnimateScaleRunValue = pcall(function() return UserSettings():IsUserFeatureEnabled("UserAnimateScaleRun") end)
local userAnimateScaleRun = userAnimateScaleRunSuccess and userAnimateScaleRunValue

local function getRigScale()
	if userAnimateScaleRun then
		return Figure:GetScale()
	else
		return 1
	end
end

local currentAnim = ""
local currentAnimInstance = nil
local currentAnimTrack = nil
local currentAnimKeyframeHandler = nil
local currentAnimSpeed = 1.0
local animTable = {}
local animNames = {
	idle = 	{
				{ id = "http://www.roblox.com/asset/?id=180435571", weight = 9 },
				{ id = "http://www.roblox.com/asset/?id=180435792", weight = 1 }
			},
	walk = 	{
				{ id = "http://www.roblox.com/asset/?id=180426354", weight = 10 }
			},
	run = 	{
				{ id = "run.xml", weight = 10 }
			},
	jump = 	{
				{ id = "http://www.roblox.com/asset/?id=125750702", weight = 10 }
			},
	fall = 	{
				{ id = "http://www.roblox.com/asset/?id=180436148", weight = 10 }
			},
	climb = {
				{ id = "http://www.roblox.com/asset/?id=180436334", weight = 10 }
			},
	sit = 	{
				{ id = "http://www.roblox.com/asset/?id=178130996", weight = 10 }
			},
	toolnone = {
				{ id = "http://www.roblox.com/asset/?id=182393478", weight = 10 }
			},
	toolslash = {
				{ id = "http://www.roblox.com/asset/?id=129967390", weight = 10 }