Prompt:
-- The pierce function can also be used for things like bouncing.
-- In reality, it's more of a function that the module uses to ask "Do I end the cast now, or do I keep going?"
-- Because of this, you can use it for logic such as ray reflection or other redirection methods.
-- A great example might be to pierce or bounce based on something like velocity or angle.
-- You can see this implementation further down in the OnRayPierced function.

Response:
function CanRayPierce(cast, rayResult, segmentVelocity)

	-- Let's keep track of how many times we've hit something.
	local hits = cast.UserData.Hits
	if (hits == nil) then
		-- If the hit data isn't registered, set it to 1 (because this is our first hit)
		cast.UserData.Hits = 1
	else
		-- If the hit data is registered, add 1.
		return false
		--cast.UserData.Hits += 1
	end

	-- And if the hit count is over 3, don't allow piercing and instead stop the ray.
	if (cast.UserData.Hits > 1) then
		return false
	end

	-- Now if we make it here, we want our ray to continue.
	-- This is extra important! If a bullet bounces off of something, maybe we want it to do damage too!
	-- So let's implement that.
	local hitPart = rayResult.Instance
	if hitPart ~= nil and hitPart.Parent ~= nil then
		local humanoid = hitPart.Parent:FindFirstChildOfClass("Humanoid")
		if humanoid then
			humanoid:TakeDamage(25) -- Damage.
		end
	end

	-- And then lastly, return true to tell FC to continue simulating.
	return true

	--[[
	-- This function shows off the piercing feature literally. Pass this function as the last argument (after bulletAcceleration) and it will run this every time the ray runs into an object.

	-- Do note that if you want this to work properly, you will need to edit the OnRayPierced event handler below so that it doesn't bounce.

	if material == Enum.Material.Ice or material == Enum.Material.Glass then
		-- Hit glass, plastic, or ice...
		if hitPart.Transparency >= 0.5 then
			-- And it's >= half transparent...
			return true -- Yes! We can pierce.
		end
	end
	return false
	--]]
end

function Fire(direction)
	-- Called when we want to fire the gun.
	if Tool.Parent:IsA("Backpack") then return end -- Can't fire if it's not equipped.
	-- Note: Above isn't in the event as it will prevent the CanFire value from being set as needed.

	-- UPD. 11 JUNE 2019 - Add support for random angles.
	local directionalCF = CFrame.new(Vector3.new(), direction)
	-- Now, we can use CFrame orientation to our advantage.
	-- Overwrite the existing Direction value.
	local direction = (directionalCF * CFrame.fromOrientation(0, 0, RNG:NextNumber(0, TAU)) * CFrame.fromOrientation(math.rad(RNG:NextNumber(MIN_BULLET_SPREAD_ANGLE, MAX_BULLET_SPREAD_ANGLE)), 0, 0)).LookVector

	-- UPDATE V6: Proper bullet velocity!
	-- IF YOU DON'T WANT YOUR BULLETS MOVING WITH YOUR CHARACTER, REMOVE THE THREE LINES OF CODE BELOW THIS COMMENT.
	-- Requested by https://www.roblox.com/users/898618/profile/
	-- We need to make sure the bullet inherits the velocity of the gun as it fires, just like in real life.
	local humanoidRootPart = Tool.Parent:WaitForChild("HumanoidRootPart", 1)	-- Add a timeout to this.
	local myMovementSpeed = humanoidRootPart.Velocity							-- To do: It may be better to get this value on the clientside since the server will see this value differently due to ping and such.
	local modifiedBulletSpeed = (direction * BULLET_SPEED)-- + myMovementSpeed	-- We multiply our direction unit by the bullet speed. This creates a Vector3 version of the bullet's velocity at the given speed. We then add MyMovementSpeed to add our body's motion to the velocity.

	if PIERCE_DEMO then
		CastBehavior.CanPierceFunction = CanRayPierce
	end

	local simBullet = Caster:Fire(FirePointObject.WorldPosition, direction, modifiedBulletSpeed, CastBehavior)
	-- Optionally use some methods on simBullet here if applicable.

	-- Play the sound
	PlayFireSound()
end


Prompt:
--[[
	    ___      _______                _       _______
	   / _ |____/ ___/ /  ___ ____ ___ (_)__   /__  __/
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<     / /
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/	/_/
						SecondLogic @ Inspare
						Avxnturador @ Novena
]]

Response:
local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local handler = car:WaitForChild("AC6_FE_Sounds")
local _Tune = require(car["A-Chassis Tune"])
local BOVact = 0
local BOVact2 = 0

local BOV_Loudness = 1	--volume of the BOV (not exact volume so you kinda have to experiment with it)
local BOV_Pitch = 0.9	--max pitch of the BOV (not exact so might have to mess with it)
local TurboLoudness = .25 --volume of the Turbo (not exact volume so you kinda have to experiment with it also)

script:WaitForChild("Whistle")
script:WaitForChild("BOV")

for i,v in pairs(car.DriveSeat:GetChildren()) do
	for _,a in pairs(script:GetChildren()) do
		if v.Name==a.Name then v:Stop() wait() v:Destroy() end
	end
end

car.DriveSeat.ChildRemoved:connect(function(child)
	if child.Name=="SeatWeld" then
		for i,v in pairs(car.DriveSeat:GetChildren()) do
			for _,a in pairs(script:GetChildren()) do
				if v.Name==a.Name then v:Stop() wait() v:Destroy() end
			end
		end
	end
end)

handler:FireServer("newSound","Whistle",car.DriveSeat,script.Whistle.SoundId,0,script.Whistle.Volume,true)
handler:FireServer("newSound","BOV",car.DriveSeat,script.BOV.SoundId,0,script.BOV.Volume,true)
handler:FireServer("playSound","Whistle")
car.DriveSeat:WaitForChild("Whistle")
car.DriveSeat:WaitForChild("BOV")
local ticc = tick()
local _TCount = 0
if _Tune.Aspiration == "Single" then _TCount = 1 elseif _Tune.Aspiration == "Double" then _TCount = 2 end

while wait() do
	local psi = (((script.Parent.Values.Boost.Value)/(_Tune.Boost*_TCount))*2)

	BOVact = math.floor(psi*20)
	WP = (psi)
	WV = (psi/4)*TurboLoudness

	BP = (1-(-psi/20))*BOV_Pitch
	BV = (((-0.5+((psi/2)*BOV_Loudness)))*(1 - script.Parent.Values.Throttle.Value))

	if BOVact < BOVact2 then if car.DriveSeat.BOV.IsPaused then if FE then handler:FireServer("playSound","BOV") else car.DriveSeat.BOV:Play() end end end
	if BOVact >= BOVact2 then if FE then handler:FireServer("stopSound","BOV") else car.DriveSeat.BOV:Stop() end end

	if FE then
		handler:FireServer("updateSound","Whistle",script.Whistle.SoundId,WP,WV)
		handler:FireServer("updateSound","BOV",script.BOV.SoundId,BP,BV)
	else
		car.DriveSeat.Whistle.Pitch = WP
		car.DriveSeat.Whistle.Volume = WV
		car.DriveSeat.BOV.Pitch = BP
		car.DriveSeat.BOV.Volume = BV
	end
	if (tick()-ticc) >= 0.1 then
		BOVact2 = math.floor(psi*20)
		ticc = tick()
	end
end


Prompt:
--[[

	Returns true if a table/dictionary contains userdata (somewhat deep)

	Functions.HasUserdata(
		table, 					<-- |REQ|	Table/dictionary
	)

--]]

Response:
return function(tbl)
	--- Variables
	local found = false

	--- Scan local function
	local function Scan(v)
		--- Already found userdata
		if found then
			return
		end

		--- Iterate
		for key, value in pairs(v) do
			--- Already found userdata
			if found then
				return
			end

			--- Main check
			if type(value) == "userdata" or type(key) == "userdata" then
				--- Userdata located
				found = true
				return

			elseif type(value) == "table" then
				--- Re-iterate
				Scan(value)
			end
		end
	end

	--- Scan
	Scan(tbl)

	--
	return found
end


Prompt: -- Create class

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

function FreeDragging.new(Tool)
    local self = {
		Tool = Tool;

        -- Dragging state
        IsDragging = false;
        StartScreenPoint = nil;
        StartTarget = nil;
        CrossthroughCorrection = nil;
        LastSelection = nil;
        LastBasePartOffset = nil;
        Target = nil;
        TargetPoint = nil;
        TargetNormal = nil;
        LastTargetNormal = nil;
        CornerOffsets = nil;

        -- Surface alignment state
        TriggerAlignment = nil;
        SurfaceAlignment = nil;
        LastSurfaceAlignment = nil;
    }

    setmetatable(self, FreeDragging)

    -- Listen for free dragging ending
    self:InstallDragEndListener()

    -- Return initialized module
    return self
end

function FreeDragging:EnableDragging()
	-- Enables part dragging

	local function HandleDragStart(Action, State, Input)
		if State.Name ~= 'Begin' then
			return Enum.ContextActionResult.Pass
		end

		-- Get mouse target
		local TargetPart = Core.Mouse.Target
		if (not TargetPart) or Selection.Multiselecting then
			return Enum.ContextActionResult.Pass
		end

		-- Make sure target is draggable, unless snapping
		local IsSnapping = UserInputService:IsKeyDown(Enum.KeyCode.R) and #Selection.Items > 0
		if not Core.IsSelectable({ TargetPart }) and not IsSnapping then
			return Enum.ContextActionResult.Pass
		end

		-- Initialize dragging detection data
		self.StartTarget = TargetPart
		self.StartScreenPoint = Vector2.new(Core.Mouse.X, Core.Mouse.Y)

		-- Select unselected target, if not snapping
		local _, ScopeTarget = Core.Targeting:UpdateTarget()
		if not Selection.IsSelected(ScopeTarget) and not IsSnapping then
			Core.Targeting.SelectTarget(true)
			Core.Targeting.CancelSelecting()
		end

		local function HandlePotentialDragStart(Action, State, Input)
			if State.Name ~= 'Change' then
				return Enum.ContextActionResult.Pass
			end

			-- Trigger dragging if the mouse is moved over 2 pixels
			local DragScreenDistance = self.StartScreenPoint and
				(Vector2.new(Core.Mouse.X, Core.Mouse.Y) - self.StartScreenPoint).Magnitude
			if DragScreenDistance >= 2 then

				-- Prepare for dragging
				BoundingBox.ClearBoundingBox()
				self:SetUpDragging(self.StartTarget, SnapTracking.Enabled and self.Tool.SnappedPoint or nil)

				-- Stop watching for potential dragging
				ContextActionService:UnbindAction 'BT: Watch for dragging'

			end

			-- Pass input if not a touch interaction
			if Input.UserInputType.Name ~= 'Touch' then
				return Enum.ContextActionResult.Pass
			end
		end

		-- Watch for potential dragging
		ContextActionService:BindAction('BT: Watch for dragging', HandlePotentialDragStart, false,
			Enum.UserInputType.MouseMovement,
			Enum.UserInputType.Touch
		)
	end

	-- Pay attention to when the user intends to start dragging
	ContextActionService:BindAction('BT: Start dragging', HandleDragStart, false,
		Enum.UserInputType.MouseButton1,
		Enum.UserInputType.Touch
	)

end

function FreeDragging:SetUpDragging(BasePart, BasePoint)
	-- Sets up and initiates dragging based on the given base part

	-- Prevent selection while dragging
	Core.Targeting.CancelSelecting()

	-- Prepare parts, and start dragging
	self.InitialState = self.Tool:PreparePartsForDragging()
	self:StartDragging(BasePart, self.InitialState, BasePoint)

end

function FreeDragging:StartDragging(BasePart, InitialState, BasePoint)
	-- Begins dragging the selection

	-- Ensure dragging is not already ongoing
	if self.IsDragging then
		return
	end

	-- Indicate that we're dragging
	self.IsDragging = true

	-- Track changes
	self.Tool:TrackChange()

	-- Disable bounding box calculation
	BoundingBox.ClearBoundingBox()

	-- Cache area permissions information
	local AreaPermissions
	if Core.Mode == 'Tool' then
		AreaPermissions = Security.GetPermissions(Security.GetSelectionAreas(Selection.Parts), Core.Player)
	end

	-- Ensure a base part is provided
	if not InitialState[BasePart] then
		BasePart = next(InitialState)
		if not BasePart then
			return
		end
	end

	-- Determine the base point for dragging
	local BasePartOffset = -BasePart.CFrame:pointToObjectSpace(Core.Mouse.Hit.p)

	-- Improve base point alignment for the given increment
	BasePartOffset = Vector3.new(
		math.clamp(MoveUtil.GetIncrementMultiple(BasePartOffset.X, self.Tool.Increment), -BasePart.Size.X / 2, BasePart.Size.X / 2),
		math.clamp(MoveUtil.GetIncrementMultiple(BasePartOffset.Y, self.Tool.Increment), -BasePart.Size.Y / 2, BasePart.Size.Y / 2),
		math.clamp(MoveUtil.GetIncrementMultiple(BasePartOffset.Z, self.Tool.Increment), -BasePart.Size.Z / 2, BasePart.Size.Z / 2)
	)

	-- Use the given base point instead if any
	if BasePoint then
		BasePartOffset = -BasePart.CFrame:pointToObjectSpace(BasePoint)
	end

	-- Prepare snapping in case it is enabled, and make sure to override its default target selection
	SnapTracking.TargetBlacklist = Selection.Items
	self.Tool.Maid.DragSnapping = self.Tool.PointSnapped:Connect(function (SnappedPoint)

		-- Align the selection's base point to the snapped point
		local Rotation = self.SurfaceAlignment or (InitialState[BasePart].CFrame - InitialState[BasePart].CFrame.p)
		BasePart.CFrame = CFrame.new(SnappedPoint) * Rotation * CFrame.new(BasePartOffset)
		MoveUtil.TranslatePartsRelativeToPart(BasePart, InitialState)

		-- Make sure we're not entering any unauthorized private areas
		if Core.Mode == 'Tool' and Security.ArePartsViolatingAreas(Selection.Parts, Core.Player, false, AreaPermissions) then
			BasePart.CFrame = InitialState[BasePart].CFrame
			MoveUtil.TranslatePartsRelativeToPart(BasePart, InitialState)
		end

	end)

	-- Update cache of corner offsets for later crossthrough calculations
	self.CornerOffsets = GetCornerOffsets(InitialState[BasePart].CFrame, InitialState)

	-- Provide a callback to trigger alignment
	self.TriggerAlignment = function ()

		-- Trigger drag recalculation
		self:DragToMouse(BasePart, BasePartOffset, InitialState, AreaPermissions)

		-- Trigger snapping recalculation
		if SnapTracking.Enabled then
			self.Tool.PointSnapped:Fire(self.Tool.SnappedPoint)
		end

	end

	local function HandleDragChange(Action, State, Input)
		if State.Name == 'Change' then
			self:DragToMouse(BasePart, BasePartOffset, InitialState, AreaPermissions)
		end
		return Enum.ContextActionResult.Pass
	end

	-- Start up the dragging
	ContextActionService:BindAction('BT: Dragging', HandleDragChange, false,
		Enum.UserInputType.MouseMovement,
		Enum.UserInputType.Touch
	)

end

function FreeDragging:DragToMouse(BasePart, BasePartOffset, InitialState, AreaPermissions)
	-- Drags the selection by `BasePart`, judging area authorization from `AreaPermissions`

	----------------------------------------------
	-- Check what and where the mouse is aiming at
	----------------------------------------------

	-- Don't consider other selected parts possible targets
	local IgnoreList = Support.CloneTable(Selection.Items)
	table.insert(IgnoreList, Core.Player and Core.Player.Character)

	-- Perform the mouse target search
	local Target, TargetPoint, TargetNormal = Workspace:FindPartOnRayWithIgnoreList(
		Ray.new(Core.Mouse.UnitRay.Origin, Core.Mouse.UnitRay.Direction * 5000),
		IgnoreList
	)
	self.Target = Target
	self.TargetPoint = TargetPoint
	self.TargetNormal = TargetNormal

	-- Reset any surface alignment and calculated crossthrough if target surface changes
	if self.LastTargetNormal ~= self.TargetNormal then
		self.SurfaceAlignment = nil
		self.CrossthroughCorrection = nil
	end

	-- Reset any calculated crossthrough if selection, drag offset, or surface alignment change
	if (self.LastSelection ~= Selection.Items) or
			(self.LastBasePartOffset ~= BasePartOffset) or
			(self.LastSurfaceAlignment ~= self.SurfaceAlignment) then
		self.CrossthroughCorrection = nil
	end

	-- Save last dragging options for change detection
	self.LastSelection = Selection.Items
	self.LastBasePartOffset = BasePartOffset
	self.LastSurfaceAlignment = self.SurfaceAlignment
	self.LastTargetNormal = self.TargetNormal

	------------------------------------------------
	-- Move the selection towards any snapped points
	------------------------------------------------

	-- If snapping is enabled, skip regular dragging
	if SnapTracking.Enabled then
		return
	end

	------------------------------------------------------
	-- Move the selection towards the right mouse location
	------------------------------------------------------

	-- Get the increment-aligned target point
	self.TargetPoint = self:GetAlignedTargetPoint(
		self.Target,
		self.TargetPoint,
		self.TargetNormal,
		self.Tool.Increment
	)

	-- Move the parts towards their target destination
	local Rotation = self.SurfaceAlignment or (InitialState[BasePart].CFrame - InitialState[BasePart].CFrame.p)
	local TargetCFrame = CFrame.new(self.TargetPoint) * Rotation * CFrame.new(BasePartOffset)

	-- Calculate crossthrough against target plane if necessary
	if not self.CrossthroughCorrection then
		self.CrossthroughCorrection = 0

		-- Calculate each corner's tentative position
		for _, CornerOffset in pairs(self.CornerOffsets) do
			local Corner = TargetCFrame * CornerOffset

			-- Calculate the corner's target plane crossthrough
			local CornerCrossthrough = -(self.TargetPoint - Corner):Dot(self.TargetNormal)

			-- Check if this corner crosses through the most
			if CornerCrossthrough < self.CrossthroughCorrection then
				self.CrossthroughCorrection = CornerCrossthrough
			end
		end
	end

	-- Move the selection, retracted by the max. crossthrough amount
	BasePart.CFrame = TargetCFrame - (self.TargetNormal * self.CrossthroughCorrection)
	MoveUtil.TranslatePartsRelativeToPart(BasePart, InitialState)

	----------------------------------------
	-- Check for relevant area authorization
	----------------------------------------

	-- Make sure we're not entering any unauthorized private areas
	if Core.Mode == 'Tool' and Security.ArePartsViolatingAreas(Selection.Parts, Core.Player, false, AreaPermissions) then
		BasePart.CFrame = InitialState[BasePart].CFrame
		MoveUtil.TranslatePartsRelativeToPart(BasePart, InitialState)
	end

end

function FreeDragging:AlignSelectionToTarget()
	-- Aligns the selection to the current target surface while dragging

	-- Ensure dragging is ongoing
	if not self.IsDragging or not self.TargetNormal then
		return
	end

	-- Get target surface normal as arbitrarily oriented CFrame
	local TargetNormalCF = CFrame.new(Vector3.new(), self.TargetNormal)

	-- Use detected surface normal directly if not targeting a part
	if not self.Target then
		self.SurfaceAlignment = TargetNormalCF * CFrame.Angles(-math.pi / 2, 0, 0)

	-- For parts, calculate orientation based on the target surface, and the target part's orientation
	else

		-- Set upward direction to match the target surface normal
		local UpVector, LookVector, RightVector = self.TargetNormal

		-- Use target's rightward orientation for calculating orientation (when targeting forward or backward directions)
		local Target, TargetNormal = self.Target, self.TargetNormal
		if TargetNormal:isClose(Target.CFrame.lookVector, 0.000001) or TargetNormal:isClose(-Target.CFrame.lookVector, 0.000001) then
			LookVector = TargetNormal:Cross(Target.CFrame.rightVector).unit
			RightVector = LookVector:Cross(TargetNormal).unit

		-- Use target's forward orientation for calculating orientation (when targeting any other direction)
		else
			RightVector = Target.CFrame.lookVector:Cross(TargetNormal).unit
			LookVector = TargetNormal:Cross(RightVector).unit
		end

		-- Generate rotation matrix based on direction vectors
		self.SurfaceAlignment = CFrame.new(
			0, 0, 0,
			RightVector.X, UpVector.X, -LookVector.X,
			RightVector.Y, UpVector.Y, -LookVector.Y,
			RightVector.Z, UpVector.Z, -LookVector.Z
		)

	end

	-- Trigger alignment
	self:TriggerAlignment()

end

function FreeDragging:GetAlignedTargetPoint(Target, TargetPoint, TargetNormal, Increment)
	-- Returns the target point aligned to the nearest increment multiple

	-- By default, use the center of the universe for alignment on all axes
	local ReferencePoint = CFrame.new()
	local PlaneAxes = Vector3.new(1, 1, 1)

	-----------------------------------------------------------------------------
	-- Detect appropriate reference points and plane axes for recognized surfaces
	-----------------------------------------------------------------------------

	-- Make sure the target is a part
	if Target and Target:IsA 'BasePart' and Target.ClassName ~= 'Terrain' then
		local Size = Target.Size / 2

		-- Calculate the direction of a wedge surface
		local WedgeDirection = (Target.CFrame - Target.CFrame.p) *
			CFrame.fromAxisAngle(Vector3.FromAxis(Enum.Axis.X), math.atan(Target.Size.Z / Target.Size.Y))

		-- Calculate the direction of a corner part's Z-axis surface
		local CornerDirectionZ = (Target.CFrame - Target.CFrame.p) *
			CFrame.fromAxisAngle(Vector3.FromAxis(Enum.Axis.X), math.pi - math.atan(Target.Size.Z / Target.Size.Y))

		-- Calculate the direction of a corner part's X-axis surface
		local CornerDirectionX = (Target.CFrame - Target.CFrame.p) *
			CFrame.fromAxisAngle(Vector3.FromAxis(Enum.Axis.Z), math.atan(Target.Size.Y / Target.Size.X)) *
			CFrame.fromAxisAngle(Vector3.FromAxis(Enum.Axis.X), math.pi / 2) *
			CFrame.fromAxisAngle(Vector3.FromAxis(Enum.Axis.Z), -math.pi / 2)

		-- Get the right alignment reference point on a part's front surface
		if TargetNormal:isClose(Target.CFrame.lookVector, 0.000001) then
			ReferencePoint = Target.CFrame * CFrame.new(Size.X, Size.Y, -Size.Z)
			PlaneAxes = Vector3.new(1, 1, 0)

		-- Get the right alignment reference point on a part's back surface
		elseif TargetNormal:isClose(-Target.CFrame.lookVector, 0.000001) then
			ReferencePoint = Target.CFrame * CFrame.new(-Size.X, Size.Y, Size.Z)
			PlaneAxes = Vector3.new(1, 1, 0)

		-- Get the right alignment reference point on a part's left surface
		elseif TargetNormal:isClose(-Target.CFrame.rightVector, 0.000001) then
			ReferencePoint = Target.CFrame * CFrame.new(-Size.X, Size.Y, -Size.Z)
			PlaneAxes = Vector3.new(0, 1, 1)

		-- Get the right alignment reference point on a part's right surface
		elseif TargetNormal:isClose(Target.CFrame.rightVector, 0.000001) then
			ReferencePoint = Target.CFrame * CFrame.new(Size.X, Size.Y, Size.Z)
			PlaneAxes = Vector3.new(0, 1, 1)

		-- Get the right alignment reference point on a part's upper surface
		elseif TargetNormal:isClose(Target.CFrame.upVector, 0.000001) then
			ReferencePoint = Target.CFrame * CFrame.new(Size.X, Size.Y, Size.Z)
			PlaneAxes = Vector3.new(1, 0, 1)

		-- Get the right alignment reference point on a part's bottom surface
		elseif TargetNormal:isClose(-Target.CFrame.upVector, 0.000001) then
			ReferencePoint = Target.CFrame * CFrame.new(Size.X, -Size.Y, -Size.Z)
			PlaneAxes = Vector3.new(1, 0, 1)

		-- Get the right alignment reference point on wedged part surfaces
		elseif TargetNormal:isClose(WedgeDirection.lookVector, 0.000001) then

			-- Get reference point oriented to wedge plane
			ReferencePoint = WedgeDirection *
				CFrame.fromAxisAngle(Vector3.FromAxis(Enum.Axis.X), -math.pi / 2) +
				(Target.CFrame * Vector3.new(Size.X, Size.Y, Size.Z))

			-- Set plane offset axes
			PlaneAxes = Vector3.new(1, 0, 1)

		-- Get the right alignment reference point on the Z-axis surface of a corner part
		elseif TargetNormal:isClose(CornerDirectionZ.lookVector, 0.000001) then

			-- Get reference point oriented to wedged plane
			ReferencePoint = CornerDirectionZ *
				CFrame.fromAxisAngle(Vector3.FromAxis(Enum.Axis.X), -math.pi / 2) +
				(Target.CFrame * Vector3.new(-Size.X, Size.Y, -Size.Z))

			-- Set plane offset axes
			PlaneAxes = Vector3.new(1, 0, 1)

		-- Get the right alignment reference point on the X-axis surface of a corner part
		elseif TargetNormal:isClose(CornerDirectionX.lookVector, 0.000001) then

			-- Get reference point oriented to wedged plane
			ReferencePoint = CornerDirectionX *
				CFrame.fromAxisAngle(Vector3.FromAxis(Enum.Axis.X), -math.pi / 2) +
				(Target.CFrame * Vector3.new(Size.X, Size.Y, -Size.Z))

			-- Set plane offset axes
			PlaneAxes = Vector3.new(1, 0, 1)

		-- Return an unaligned point for unrecognized surfaces
		else
			return TargetPoint
		end

	end

	-------------------------------------
	-- Calculate the aligned target point
	-------------------------------------

	-- Get target point offset from reference point
	local ReferencePointOffset = ReferencePoint:inverse() * CFrame.new(TargetPoint)

	-- Align target point on increment grid from reference point along the plane axes
	local AlignedTargetPoint = ReferencePoint * (Vector3.new(
		MoveUtil.GetIncrementMultiple(ReferencePointOffset.X, Increment),
		MoveUtil.GetIncrementMultiple(ReferencePointOffset.Y, Increment),
		MoveUtil.GetIncrementMultiple(ReferencePointOffset.Z, Increment)
	) * PlaneAxes)

	-- Return the aligned target point
	return AlignedTargetPoint

end

function FreeDragging:FinishDragging()
	-- Releases parts and registers position changes from dragging

	-- Make sure dragging is active
	if not self.IsDragging then
		return
	end

	-- Indicate that we're no longer dragging
	self.IsDragging = false

	-- Clear any surface alignment
	self.SurfaceAlignment = nil

	-- Stop the dragging action
	ContextActionService:UnbindAction 'BT: Dragging'

	-- Stop, clean up snapping point tracking
	SnapTracking.StopTracking()
	self.Tool.Maid.DragSnapping = nil

	-- Restore the original state of each part
	for Part, State in pairs(self.InitialState) do
		Part:MakeJoints()
		Core.RestoreJoints(State.Joints)
		Part.CanCollide = State.CanCollide
		Part.Anchored = State.Anchored
	end

	-- Register changes
	self.Tool:RegisterChange()

end


Prompt:
--[[
ExplorerButton.MouseButton1Up:connect(function()
	if CurrentWindow ~= "Explorer" then
		CurrentWindow = "Explorer"

		ExplorerPanel:TweenPosition(UDim2.new(1, -300, 0, 0), "Out", "Quad", 0.5, true)
		PropertiesFrame:TweenPosition(UDim2.new(1, -300, 0.5, 36), "Out", "Quad", 0.5, true)
		SettingsPanel:TweenPosition(UDim2.new(1, 0, 0, 0), "Out", "Quad", 0.5, true)
	end
end)

SettingsButton.MouseButton1Up:connect(function()
	if CurrentWindow ~= "Settings" then
		CurrentWindow = "Settings"

		ExplorerPanel:TweenPosition(UDim2.new(1, 0, 0, 0), "Out", "Quad", 0.5, true)
		PropertiesFrame:TweenPosition(UDim2.new(1, 0, 0.5, 36), "Out", "Quad", 0.5, true)
		SettingsPanel:TweenPosition(UDim2.new(1, -300, 0, 0), "Out", "Quad", 0.5, true)
	end
end)
--]]

Response:
function createSetting(name,interName,defaultOn)
	local newSetting = SettingTemplate:Clone()
	newSetting.Position = UDim2.new(0,0,0,#SettingList:GetChildren() * 60)
	newSetting.SName.Text = name

	local function toggle(on)
		if on then
			newSetting.Change.Bar:TweenPosition(UDim2.new(0,32,0,-2),Enum.EasingDirection.Out,Enum.EasingStyle.Quart,0.25,true)
			newSetting.Change.OnBar:TweenSize(UDim2.new(0,34,0,15),Enum.EasingDirection.Out,Enum.EasingStyle.Quart,0.25,true)
			newSetting.Status.Text = "On"
			Settings[interName] = true
		else
			newSetting.Change.Bar:TweenPosition(UDim2.new(0,-2,0,-2),Enum.EasingDirection.Out,Enum.EasingStyle.Quart,0.25,true)
			newSetting.Change.OnBar:TweenSize(UDim2.new(0,0,0,15),Enum.EasingDirection.Out,Enum.EasingStyle.Quart,0.25,true)
			newSetting.Status.Text = "Off"
			Settings[interName] = false
		end
	end

	newSetting.Change.MouseButton1Click:connect(function()
		toggle(not Settings[interName])
	end)

	newSetting.Visible = true
	newSetting.Parent = SettingList

	if defaultOn then
		toggle(true)
	end
end

createSetting("Click part to select","ClickSelect",false)
createSetting("Selection Box","SelBox",false)
createSetting("Clear property value on focus","ClearProps",false)
createSetting("Select ungrouped models","SelectUngrouped",true)
createSetting("SaveInstance decompiles scripts","SaveInstanceScripts",true)


Prompt:
--[[
	A show of two tracks begins on every hour.
	When there is not a show going on, the PreShowVenue will be active.
]]

Response:
local replicatedStorage = game:GetService("ReplicatedStorage")
local EventSequencer = require(replicatedStorage:WaitForChild("EventSequencer"))
local scenesFolder = replicatedStorage:WaitForChild("SequencerScenes")

local PSV_SCENE = scenesFolder:WaitForChild("PreShowVenue")
local SHOW_SCENES = {
	scenesFolder:WaitForChild("Track1"),
	scenesFolder:WaitForChild("Track2"),
}

local year = 2023
local month = 9
local day = 22
local hour = 12
local minute = 0
local second = 0
local millisecond = 69


Prompt:
-- Coroutine runner that we create coroutines of. The coroutine can be
-- repeatedly resumed with functions to run followed by the argument to run
-- them with.

Response:
local function runEventHandlerInFreeThread(...)
	acquireRunnerThreadAndCallEventHandler(...)
	while true do
		acquireRunnerThreadAndCallEventHandler(coroutine.yield())
	end
end


Prompt: -- If in-game, enable ctrl hotkeys for cloning and deleting

Response:
if Mode == 'Tool' then
	AssignHotkey({ 'LeftControl', 'C' }, CloneSelection);
	AssignHotkey({ 'RightControl', 'C' }, CloneSelection);
	AssignHotkey({ 'LeftControl', 'X' }, DeleteSelection);
	AssignHotkey({ 'RightControl', 'X' }, DeleteSelection);
end;


Prompt: -- functions

Response:
function stopAllAnimations()
	local oldAnim = currentAnim

	-- return to idle if finishing an emote
	if (emoteNames[oldAnim] ~= nil and emoteNames[oldAnim] == false) then
		oldAnim = "idle"
	end

	currentAnim = ""
	currentAnimInstance = nil
	if (currentAnimKeyframeHandler ~= nil) then
		currentAnimKeyframeHandler:disconnect()
	end

	if (currentAnimTrack ~= nil) then
		currentAnimTrack:Stop()
		currentAnimTrack:Destroy()
		currentAnimTrack = nil
	end
	return oldAnim
end

function setAnimationSpeed(speed)
	if speed ~= currentAnimSpeed then
		currentAnimSpeed = speed
		currentAnimTrack:AdjustSpeed(currentAnimSpeed)
	end
end

function keyFrameReachedFunc(frameName)
	if (frameName == "End") then

		local repeatAnim = currentAnim
		-- return to idle if finishing an emote
		if (emoteNames[repeatAnim] ~= nil and emoteNames[repeatAnim] == false) then
			repeatAnim = "idle"
		end

		local animSpeed = currentAnimSpeed
		playAnimation(repeatAnim, 0.0, Humanoid)
		setAnimationSpeed(animSpeed)
	end
end


Prompt:
--- Sets whether the command is in a valid state or not.
-- Cannot submit if in invalid state.

Response:
function Window:SetIsValidInput(isValid, errorText)
	Entry.TextBox.TextColor3 = isValid and Color3.fromRGB(255, 255, 255) or Color3.fromRGB(255, 73, 73)
	self.Valid = isValid
	self._errorText = errorText
end


Prompt:
--[[**
	ensures Roblox Region3 type

	@param value The value to check against

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

Response: t.Region3 = primitive("Region3")


Prompt: -------- OMG HAX

Response:
r = game:service("RunService")

Tool = script.Parent

local equalizingForce = 236 / 1.2 -- amount of force required to levitate a mass
local gravity = .75 -- things float at > 1

local ghostEffect = nil
local massCon1 = nil
local massCon2 = nil

local head = nil
function recursiveGetLift(node)
	local m = 0
	local c = node:GetChildren()
	if (node:FindFirstChild("Head") ~= nil) then head = node:FindFirstChild("Head") end -- nasty hack to detect when your parts get blown off

	for i=1,#c do
		if c[i].className == "Part" then
			if (head ~= nil and (c[i].Position - head.Position).magnitude < 10) then -- GROSS
				if c[i].Name == "Handle" then
					m = m + (c[i]:GetMass() * equalizingForce * 1) -- hack that makes hats weightless, so different hats don't change your jump height
				else
					m = m + (c[i]:GetMass() * equalizingForce * gravity)
				end
			end
		end
		m = m + recursiveGetLift(c[i])
	end
	return m
end

function onMassChanged(child, char)
	print("Mass changed:" .. child.Name .. "    " .. char.Name)
	if (ghostEffect ~= nil) then
		ghostEffect.force = Vector3.new(0, recursiveGetLift(char) ,0)
	end
end

function UpdateGhostState(isUnequipping)

	if isUnequipping == true then
		ghostEffect:Remove()
		ghostEffect = nil
		massCon1:disconnect()
		massCon2:disconnect()
	else
		if ghostEffect == nil then
			local char = Tool.Parent
			if char == nil then return end
			ghostEffect = Instance.new("BodyForce")
			ghostEffect.Name = "GravityCoilEffect"
			ghostEffect.force = Vector3.new(0, recursiveGetLift(char) ,0)
			ghostEffect.Parent = char.Head
			ghostChar = char
			massCon1 = char.ChildAdded:connect(function(child)  onMassChanged(child, char) end)
			massCon2 = char.ChildRemoved:connect(function(child)  onMassChanged(child, char) end)
		end
	end

end

function onEquipped()
	Tool.Handle.CoilSound:Play()
	UpdateGhostState(false)
end

function onUnequipped()
	UpdateGhostState(true)
end

script.Parent.Equipped:connect(onEquipped)
script.Parent.Unequipped:connect(onUnequipped)


Prompt: --Edited by Stickmasterluke

Response:
Tool=script.Parent

enabled = true
function onButton1Down(mouse)
	if not enabled then
		return
	end

	enabled = false
	mouse.Icon = "rbxasset://textures\\GunWaitCursor.png"

	wait(.5)
	mouse.Icon = "rbxasset://textures\\GunCursor.png"
	enabled = true

end

flyen = true
function onEquippedLocal(mouse)
	if mouse == nil then
		print("Mouse not found")
		return
	end

	mouse.KeyDown:connect(function(key)
		if key == "e" and flyen then
			flyen = false
			char = Tool.Parent
			char.Torso.Velocity = char.Torso.Velocity + Vector3.new(0,80,0) + (char.Torso.CFrame.lookVector * 80)
			wait(0.5)
			flyen = true
		end
	end)

	mouse.Icon = "rbxasset://textures\\GunCursor.png"
	mouse.Button1Down:connect(function() onButton1Down(mouse) end)
end

Tool.Equipped:connect(onEquippedLocal)

wait(1)


Prompt:
--[[ << MODIFY COMMANDS >>
This allows you to change the permission type required to use a command
Format:  ["CommandName"] = "PermissionName" ;																																																]]

Response:
ModifiedCommands={
	["fly"] = "Mod" ; -- This changes the command so that Mods (or above) can use it
}																																																											;Version = 1.3;--[[Don't edit this, otherwise the commands may break]]}


Prompt: --// Ammo Settings

Response:
	Ammo = 100;
	StoredAmmo = 30;
	MagCount = 6; --  If you want infinate ammo, set to math.huge EX. MagCount = math.huge;
	ExplosiveAmmo = 3;


Prompt: -- Handle joining general channel first.

Response:
for i, channelData in pairs(initData.Channels) do
	if channelData[1] == ChatSettings.GeneralChannelName then
		HandleChannelJoined(channelData[1], channelData[2], channelData[3], channelData[4], true, false)
	end
end

for i, channelData in pairs(initData.Channels) do
	if channelData[1] ~= ChatSettings.GeneralChannelName then
		HandleChannelJoined(channelData[1], channelData[2], channelData[3], channelData[4], true, false)
	end
end

return moduleApiTable


Prompt: --[[Steering]]

Response:
	Tune.SteerInner		= 56		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 40		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .04		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 320		-- Speed of gradient cutoff (in SPS)
	Tune.MinSteer		= 10		-- Minimum steering at max steer decay (in percent)
	Tune.MSteerExp		= 1			-- Mouse steering exponential degree

	--Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 100000	-- Steering Aggressiveness


Prompt: --[[Transmission]]

Response:
	Tune.TransModes		= {"Auto"}								--[[
	[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)

	--Gear Ratios
	Tune.FinalDrive		= 4.06			-- 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 (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


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

Response:
local v1 = {
	Name = "hover",
	Description = "Returns the name of the player you are hovering over.",
	Group = "DefaultUtil",
	Args = {}
};
local l__Players__1 = game:GetService("Players");
function v1.ClientRun()
	local l__Target__2 = l__Players__1.LocalPlayer:GetMouse().Target;
	if not l__Target__2 then
		return "";
	end;
	local v3 = l__Players__1:GetPlayerFromCharacter(l__Target__2:FindFirstAncestorOfClass("Model"));
	return v3 and v3.Name or "";
end;
return v1;


Prompt: -- Profile object:

Response:
local Profile = {
	--[[
		Data = {}, -- [table] -- Loaded once after ProfileStore:LoadProfileAsync() finishes
		MetaData = {}, -- [table] -- Updated with every auto-save
		GlobalUpdates = GlobalUpdates, -- [GlobalUpdates]

		_profile_store = ProfileStore, -- [ProfileStore]
		_profile_key = "", -- [string]

		_release_listeners = [ScriptSignal] / nil, -- [table / nil]
		_hop_ready_listeners = [ScriptSignal] / nil, -- [table / nil]
		_hop_ready = false,

		_view_mode = true / nil, -- [bool] or nil

		_load_timestamp = os.clock(),

		_is_user_mock = false, -- ProfileStore.Mock
		_mock_key_info = {},
	--]]
}
Profile.__index = Profile

function Profile:IsActive() --> [bool]
	local loaded_profiles = self._is_user_mock == true and self._profile_store._mock_loaded_profiles or self._profile_store._loaded_profiles
	return loaded_profiles[self._profile_key] == self
end

function Profile:GetMetaTag(tag_name) --> value
	local meta_data = self.MetaData
	if meta_data == nil then
		return nil
		-- error("[ProfileService]: This Profile hasn't been loaded before - MetaData not available")
	end
	return self.MetaData.MetaTags[tag_name]
end

function Profile:SetMetaTag(tag_name, value)
	if type(tag_name) ~= "string" then
		error("[ProfileService]: tag_name must be a string")
	elseif string.len(tag_name) == 0 then
		error("[ProfileService]: Invalid tag_name")
	end
	self.MetaData.MetaTags[tag_name] = value
end

function Profile:Reconcile()
	ReconcileTable(self.Data, self._profile_store._profile_template)
end

function Profile:ListenToRelease(listener) --> [ScriptConnection] (place_id / nil, game_job_id / nil)
	if type(listener) ~= "function" then
		error("[ProfileService]: Only a function can be set as listener in Profile:ListenToRelease()")
	end
	if self._view_mode == true then
		return {Disconnect = function() end}
	end
	if self:IsActive() == false then
		-- Call release listener immediately if profile is expired
		local place_id
		local game_job_id
		local active_session = self.MetaData.ActiveSession
		if active_session ~= nil then
			place_id = active_session[1]
			game_job_id = active_session[2]
		end
		listener(place_id, game_job_id)
		return {Disconnect = function() end}
	else
		return self._release_listeners:Connect(listener)
	end
end

function Profile:Save()
	if self._view_mode == true then
		error("[ProfileService]: Can't save Profile in view mode - Should you be calling :OverwriteAsync() instead?")
	end
	if self:IsActive() == false then
		warn("[ProfileService]: Attempted saving an inactive profile "
			.. self:Identify() .. "; Traceback:\n" .. debug.traceback())
		return
	end
	-- Reject save request if a save is already pending in the queue - this will prevent the user from
	--	unecessary API request spam which we could not meaningfully execute anyways!
	if IsCustomWriteQueueEmptyFor(self._profile_store._profile_store_lookup, self._profile_key) == true then
		-- We don't want auto save to trigger too soon after manual saving - this will reset the auto save timer:
		RemoveProfileFromAutoSave(self)
		AddProfileToAutoSave(self)
		-- Call save function in a new thread:
		task.spawn(SaveProfileAsync, self)
	end
end

function Profile:Release()
	if self._view_mode == true then
		return
	end
	if self:IsActive() == true then
		task.spawn(SaveProfileAsync, self, true) -- Call save function in a new thread with release_from_session = true
	end
end

function Profile:ListenToHopReady(listener) --> [ScriptConnection] ()
	if type(listener) ~= "function" then
		error("[ProfileService]: Only a function can be set as listener in Profile:ListenToHopReady()")
	end
	if self._view_mode == true then
		return {Disconnect = function() end}
	end
	if self._hop_ready == true then
		task.spawn(listener)
		return {Disconnect = function() end}
	else
		return self._hop_ready_listeners:Connect(listener)
	end
end

function Profile:AddUserId(user_id) -- Associates user_id with profile (GDPR compliance)

	if type(user_id) ~= "number" or user_id % 1 ~= 0 then
		warn("[ProfileService]: Invalid UserId argument for :AddUserId() ("
			.. tostring(user_id) .. "); Traceback:\n" .. debug.traceback())
		return
	end

	if user_id < 0 and self._is_user_mock ~= true and UseMockDataStore ~= true then
		return -- Avoid giving real Roblox APIs negative UserId's
	end

	if table.find(self.UserIds, user_id) == nil then
		table.insert(self.UserIds, user_id)
	end

end

function Profile:RemoveUserId(user_id) -- Unassociates user_id with profile (safe function)

	if type(user_id) ~= "number" or user_id % 1 ~= 0 then
		warn("[ProfileService]: Invalid UserId argument for :RemoveUserId() ("
			.. tostring(user_id) .. "); Traceback:\n" .. debug.traceback())
		return
	end

	local index = table.find(self.UserIds, user_id)

	if index ~= nil then
		table.remove(self.UserIds, index)
	end

end

function Profile:Identify() --> [string]
	return IdentifyProfile(
		self._profile_store._profile_store_name,
		self._profile_store._profile_store_scope,
		self._profile_key
	)
end

function Profile:ClearGlobalUpdates() -- Clears all global updates data from a profile payload

	if self._view_mode ~= true then
		error("[ProfileService]: :ClearGlobalUpdates() can only be used in view mode")
	end

	local global_updates_object = {
		_updates_latest = {0, {}},
		_profile = self,
	}
	setmetatable(global_updates_object, GlobalUpdates)

	self.GlobalUpdates = global_updates_object

end

function Profile:OverwriteAsync() -- Saves the profile to the DataStore and removes the session lock

	if self._view_mode ~= true then
		error("[ProfileService]: :OverwriteAsync() can only be used in view mode")
	end

	SaveProfileAsync(self, nil, true)

end


Prompt: --These scripts are not mine, I just simply edited them.


Prompt: -- This screenGui exists so that the billboardGui is not deleted when the PlayerGui is reset.

Response:
local BubbleChatScreenGui = Instance.new("ScreenGui")
BubbleChatScreenGui.Name = "BubbleChat"
BubbleChatScreenGui.ResetOnSpawn = false
BubbleChatScreenGui.Parent = PlayerGui


Prompt:
-- a: amplitud
-- p: period

Response:
local function outInElastic(t, b, c, d, a, p)
  if t < d / 2 then
    return outElastic(t * 2, b, c / 2, d, a, p)
  else
    return inElastic((t * 2) - d, b + c / 2, c / 2, d, a, p)
  end
end

local function inBack(t, b, c, d, s)
  if not s then s = 1.70158 end
  t = t / d
  return c * t * t * ((s + 1) * t - s) + b
end

local function outBack(t, b, c, d, s)
  if not s then s = 1.70158 end
  t = t / d - 1
  return c * (t * t * ((s + 1) * t + s) + 1) + b
end

local function inOutBack(t, b, c, d, s)
  if not s then s = 1.70158 end
  s = s * 1.525
  t = t / d * 2
  if t < 1 then
    return c / 2 * (t * t * ((s + 1) * t - s)) + b
  else
    t = t - 2
    return c / 2 * (t * t * ((s + 1) * t + s) + 2) + b
  end
end

local function outInBack(t, b, c, d, s)
  if t < d / 2 then
    return outBack(t * 2, b, c / 2, d, s)
  else
    return inBack((t * 2) - d, b + c / 2, c / 2, d, s)
  end
end

local function outBounce(t, b, c, d)
  t = t / d
  if t < 1 / 2.75 then
    return c * (7.5625 * t * t) + b
  elseif t < 2 / 2.75 then
    t = t - (1.5 / 2.75)
    return c * (7.5625 * t * t + 0.75) + b
  elseif t < 2.5 / 2.75 then
    t = t - (2.25 / 2.75)
    return c * (7.5625 * t * t + 0.9375) + b
  else
    t = t - (2.625 / 2.75)
    return c * (7.5625 * t * t + 0.984375) + b
  end
end

local function inBounce(t, b, c, d)
  return c - outBounce(d - t, 0, c, d) + b
end

local function inOutBounce(t, b, c, d)
  if t < d / 2 then
    return inBounce(t * 2, 0, c, d) * 0.5 + b
  else
    return outBounce(t * 2 - d, 0, c, d) * 0.5 + c * .5 + b
  end
end

local function outInBounce(t, b, c, d)
  if t < d / 2 then
    return outBounce(t * 2, b, c / 2, d)
  else
    return inBounce((t * 2) - d, b + c / 2, c / 2, d)
  end
end

return {
  linear = linear,
  inQuad = inQuad,
  outQuad = outQuad,
  inOutQuad = inOutQuad,
  inCubic  = inCubic ,
  outCubic = outCubic,
  inOutCubic = inOutCubic,
  outInCubic = outInCubic,
  inQuart = inQuart,
  outQuart = outQuart,
  inOutQuart = inOutQuart,
  outInQuart = outInQuart,
  inQuint = inQuint,
  outQuint = outQuint,
  inOutQuint = inOutQuint,
  outInQuint = outInQuint,
  inSine = inSine,
  outSine = outSine,
  inOutSine = inOutSine,
  outInSine = outInSine,
  inExpo = inExpo,
  outExpo = outExpo,
  inOutExpo = inOutExpo,
  outInExpo = outInExpo,
  inCirc = inCirc,
  outCirc = outCirc,
  inOutCirc = inOutCirc,
  outInCirc = outInCirc,
  inElastic = inElastic,
  outElastic = outElastic,
  inOutElastic = inOutElastic,
  outInElastic = outInElastic,
  inBack = inBack,
  outBack = outBack,
  inOutBack = inOutBack,
  outInBack = outInBack,
  inBounce = inBounce,
  outBounce = outBounce,
  inOutBounce = inOutBounce,
  outInBounce = outInBounce,
}


Prompt:
--function configureAnimationSetOld(name, fileList)
--	if (animTable[name] ~= nil) then
--		for _, connection in pairs(animTable[name].connections) do
--			connection:Disconnect()
--		end
--	end
--	animTable[name] = {}
--	animTable[name].count = 0
--	animTable[name].totalWeight = 0
--	animTable[name].connections = {}


Prompt:
--[[
	Saved profile structure:

	DataStoreProfile = {
		Data = {},
		MetaData = {
			ProfileCreateTime = 0,
			SessionLoadCount = 0,
			ActiveSession = {place_id, game_job_id} / nil,
			ForceLoadSession = {place_id, game_job_id} / nil,
			MetaTags = {},
			LastUpdate = 0, -- os.time()
		},
		GlobalUpdates = {
			update_index,
			{
				{update_id, version_id, update_locked, update_data},
				...
			}
		},
	}

	OR

	DataStoreProfile = {
		GlobalUpdates = {
			update_index,
			{
				{update_id, version_id, update_locked, update_data},
				...
			}
		},
	}
--]]


Prompt: --// Aim|Zoom|Sensitivity Customization

Response:
	ZoomSpeed = 0.23; -- The lower the number the slower and smoother the tween
	AimZoom = 60; -- Default zoom
	AimSpeed = 0.23;
	UnaimSpeed = 0.23;
	CycleAimZoom = 55; -- Cycled zoom
	MouseSensitivity = 0.5; -- Number between 0.1 and 1
	SensitivityIncrement = 0.05; -- No touchy


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

Response:
local l__ContextActionService__1 = game:GetService("ContextActionService");
local l__UserInputService__2 = game:GetService("UserInputService");
local l__RunService__3 = game:GetService("RunService");
local l__UserGameSettings__4 = UserSettings():GetService("UserGameSettings");
local l__LocalPlayer__5 = game:GetService("Players").LocalPlayer;
local v6 = math.rad(120);
local v7 = Vector2.new(1, 0.77) * math.rad(0.5);
local v8 = Vector2.new(1, 0.77) * math.rad(7);
local v9 = Vector2.new(1, 0.66) * math.rad(1);
local v10 = Vector2.new(1, 0.77) * math.rad(4);
local v11 = Instance.new("BindableEvent");
local v12 = Instance.new("BindableEvent");
local u1 = v11;
l__UserInputService__2.InputBegan:Connect(function(p1, p2)
	if not p2 and p1.UserInputType == Enum.UserInputType.MouseButton2 then
		u1:Fire();
	end;
end);
local u2 = v12;
l__UserInputService__2.InputEnded:Connect(function(p3, p4)
	if p3.UserInputType == Enum.UserInputType.MouseButton2 then
		u2:Fire();
	end;
end);
u1 = nil;
u1 = function(p5)
	return math.sign(p5) * math.clamp((math.exp(2 * ((math.abs(p5) - 0.1) / 0.9)) - 1) / (math.exp(2) - 1), 0, 1);
end;
u2 = function(p6)
	local l__CurrentCamera__13 = workspace.CurrentCamera;
	if not l__CurrentCamera__13 then
		return p6;
	end;
	local v14 = l__CurrentCamera__13.CFrame:ToEulerAnglesYXZ();
	if p6.Y * v14 >= 0 then
		return p6;
	end;
	return Vector2.new(1, (1 - (2 * math.abs(v14) / math.pi) ^ 0.75) * 0.75 + 0.25) * p6;
end;
local u3 = 0.016666666666666666;
l__RunService__3.Stepped:Connect(function(p7, p8)
	u3 = p8;
end);
local v15 = {};
local u4 = 0;
local v16 = Instance.new("BindableEvent");
v15.gamepadZoomPress = v16.Event;
local u5 = {
	Thumbstick2 = Vector2.new()
};
function v15.getRotationActivated()
	local v17 = true;
	if not (u4 > 0) then
		v17 = u5.Thumbstick2.Magnitude > 0;
	end;
	return v17;
end;
local u6 = {
	Left = 0,
	Right = 0,
	I = 0,
	O = 0
};
local u7 = {
	Movement = Vector2.new(),
	Wheel = 0,
	Pan = Vector2.new(),
	Pinch = 0
};
local u8 = {
	Move = Vector2.new(),
	Pinch = 0
};
function v15.getRotation(p9)
	local v18 = Vector2.new(1, l__UserGameSettings__4:GetCameraYInvertValue());
	local v19 = Vector2.new(u6.Right - u6.Left, 0) * u3;
	if p9 then
		v19 = Vector2.new();
	end;
	return (v19 * v6 + u5.Thumbstick2 * v10 + u7.Movement * v7 + u7.Pan * v8 + u2(u8.Move) * v9) * v18;
end;
function v15.getZoomDelta()
	return (u6.O - u6.I) * 0.1 + (-u7.Wheel + u7.Pinch) * 1 + -u8.Pinch * 0.04;
end;
local u9 = nil;
local function u10(p10)
	local v20 = l__LocalPlayer__5:FindFirstChildOfClass("PlayerGui");
	local v21 = v20 and v20:FindFirstChild("TouchGui");
	local v22 = v21 and v21:FindFirstChild("TouchControlFrame");
	local v23 = v22 and v22:FindFirstChild("DynamicThumbstickFrame");
	if not v23 then
		return false;
	end;
	if not v21.Enabled then
		return false;
	end;
	local l__AbsolutePosition__24 = v23.AbsolutePosition;
	local v25 = l__AbsolutePosition__24 + v23.AbsoluteSize;
	local v26 = false;
	if l__AbsolutePosition__24.X <= p10.X then
		v26 = false;
		if l__AbsolutePosition__24.Y <= p10.Y then
			v26 = false;
			if p10.X <= v25.X then
				v26 = p10.Y <= v25.Y;
			end;
		end;
	end;
	return v26;
end;
local function u11()
	u4 = math.max(0, u4 + 1);
end;
local u12 = {};
local u13 = nil;
local function u14()
	u4 = math.max(0, u4 - 1);
end;
local function u15(p11, p12)
	assert(p11.UserInputType == Enum.UserInputType.Touch);
	assert(p11.UserInputState == Enum.UserInputState.Begin);
	if u9 == nil and u10(p11.Position) and not p12 then
		u9 = p11;
		return;
	end;
	if not p12 then
		u11();
	end;
	u12[p11] = p12;
end;
local function u16(p13, p14)
	assert(p13.UserInputType == Enum.UserInputType.Touch);
	assert(p13.UserInputState == Enum.UserInputState.Change);
	if p13 == u9 then
		return;
	end;
	if u12[p13] == nil then
		u12[p13] = p14;
	end;
	local v27 = {};
	for v28, v29 in pairs(u12) do
		if not v29 then
			table.insert(v27, v28);
		end;
	end;
	if #v27 == 1 and u12[p13] == false then
		local l__Delta__30 = p13.Delta;
		u8.Move = Vector2.new(l__Delta__30.X, l__Delta__30.Y);
	end;
	if #v27 ~= 2 then
		u13 = nil;
		return;
	end;
	local l__Magnitude__31 = (v27[1].Position - v27[2].Position).Magnitude;
	if u13 then
		u8.Pinch = l__Magnitude__31 - u13;
	end;
	u13 = l__Magnitude__31;
end;
local function u17(p15)
	local l__Delta__32 = p15.Delta;
	u7.Movement = Vector2.new(l__Delta__32.X, l__Delta__32.Y);
end;
local function u18(p16, p17)
	assert(p16.UserInputType == Enum.UserInputType.Touch);
	assert(p16.UserInputState == Enum.UserInputState.End);
	if p16 == u9 then
		u9 = nil;
	end;
	if u12[p16] == false then
		u13 = nil;
		u14();
	end;
	u12[p16] = nil;
end;
local u19 = false;
local function u20()
	for v33, v34 in pairs({ u5, u6, u7, u8 }) do
		for v35, v36 in pairs(v34) do
			if type(v36) == "boolean" then
				v34[v35] = false;
			else
				v34[v35] = v34[v35] * 0;
			end;
		end;
	end;
end;
local function u21()
	u12 = {};
	u9 = nil;
	u13 = nil;
end;
local function u22(p18, p19, p20)
	local l__Position__37 = p20.Position;
	u5[p20.KeyCode.Name] = Vector2.new(u1(l__Position__37.X), -u1(l__Position__37.Y));
end;
local l__Value__23 = Enum.ContextActionPriority.Default.Value;
local function u24(p21, p22, p23)
	if p22 == Enum.UserInputState.Begin then
		local v38 = 1;
	else
		v38 = 0;
	end;
	u6[p23.KeyCode.Name] = v38;
end;
local function u25(p24, p25, p26)
	if p25 == Enum.UserInputState.Begin then
		v16:Fire();
	end;
end;
local u26 = {};
local function u27(p27, p28)
	if p27.UserInputType == Enum.UserInputType.Touch then
		u15(p27, p28);
		return;
	end;
	if p27.UserInputType == Enum.UserInputType.MouseButton2 and not p28 then
		u11();
	end;
end;
local function u28(p29, p30)
	if p29.UserInputType == Enum.UserInputType.Touch then
		u16(p29, p30);
		return;
	end;
	if p29.UserInputType == Enum.UserInputType.MouseMovement then
		u17(p29);
	end;
end;
local function u29(p31, p32)
	if p31.UserInputType == Enum.UserInputType.Touch then
		u18(p31, p32);
		return;
	end;
	if p31.UserInputType == Enum.UserInputType.MouseButton2 then
		u14();
	end;
end;
local function u30(p33, p34, p35, p36)
	if not p36 then
		u7.Wheel = p33;
		u7.Pan = p34;
		u7.Pinch = -p35;
	end;
end;
function v15.setInputEnabled(p37)
	if u19 == p37 then
		return;
	end;
	u19 = p37;
	u20();
	u21();
	if not u19 then
		l__ContextActionService__1:UnbindAction("RbxCameraThumbstick");
		l__ContextActionService__1:UnbindAction("RbxCameraMouseMove");
		l__ContextActionService__1:UnbindAction("RbxCameraMouseWheel");
		l__ContextActionService__1:UnbindAction("RbxCameraKeypress");
		for v39, v40 in pairs(u26) do
			v40:Disconnect();
		end;
		u26 = {};
		return;
	end;
	l__ContextActionService__1:BindActionAtPriority("RbxCameraThumbstick", u22, false, l__Value__23, Enum.KeyCode.Thumbstick2);
	l__ContextActionService__1:BindActionAtPriority("RbxCameraKeypress", u24, false, l__Value__23, Enum.KeyCode.Left, Enum.KeyCode.Right, Enum.KeyCode.I, Enum.KeyCode.O);
	l__ContextActionService__1:BindAction("RbxCameraGamepadZoom", u25, false, Enum.KeyCode.ButtonR3);
	table.insert(u26, l__UserInputService__2.InputBegan:Connect(u27));
	table.insert(u26, l__UserInputService__2.InputChanged:Connect(u28));
	table.insert(u26, l__UserInputService__2.InputEnded:Connect(u29));
	table.insert(u26, l__UserInputService__2.PointerAction:Connect(u30));
end;
function v15.getInputEnabled()
	return u19;
end;
function v15.resetInputForFrameEnd()
	u7.Movement = Vector2.new();
	u8.Move = Vector2.new();
	u8.Pinch = 0;
	u7.Wheel = 0;
	u7.Pan = Vector2.new();
	u7.Pinch = 0;
end;
l__UserInputService__2.WindowFocused:Connect(u20);
l__UserInputService__2.WindowFocusReleased:Connect(u20);
local u31 = false;
function v15.getHoldPan()
	return u31;
end;
local u32 = false;
function v15.getTogglePan()
	return u32;
end;
function v15.getPanning()
	return u32 or u31;
end;
function v15.setTogglePan(p38)
	u32 = p38;
end;
local u33 = false;
local u34 = nil;
local u35 = nil;
local l__Event__36 = v11.Event;
local u37 = 0;
local l__Event__38 = v12.Event;
function v15.enableCameraToggleInput()
	if u33 then
		return;
	end;
	u33 = true;
	u31 = false;
	u32 = false;
	if u34 then
		u34:Disconnect();
	end;
	if u35 then
		u35:Disconnect();
	end;
	u34 = l__Event__36:Connect(function()
		u31 = true;
		u37 = tick();
	end);
	u35 = l__Event__38:Connect(function()
		u31 = false;
		if tick() - u37 < 0.3 and (u32 or l__UserInputService__2:GetMouseDelta().Magnitude < 2) then
			u32 = not u32;
		end;
	end);
end;
function v15.disableCameraToggleInput()
	if not u33 then
		return;
	end;
	u33 = false;
	if u34 then
		u34:Disconnect();
		u34 = nil;
	end;
	if u35 then
		u35:Disconnect();
		u35 = nil;
	end;
end;
return v15;


Prompt:
-- In build mode, after every time you change this script, copy the script, delete it, and paste it back into your hat, if you don't,
-- nothing will change, I don't know why, but this is how I make my givers.


Prompt:
--[[
	Removes a Tween from the scheduler.
]]

Response:
function TweenScheduler.remove(tween: Tween)
	allTweens[tween] = nil
end


Prompt: --Change sound id to the id you want to play

Response:
debounce = false

script.Parent.Touched:connect(function(hit)
script.Parent:Destroy()
end)


Prompt:
--[[ << MODIFY COMMANDS >>
This allows you to change the permission type required to use a command
Format:  ["CommandName"] = "PermissionName" ;																																																]]

Response:
ModifiedCommands={
	["fly"] = "Admin" ; -- This changes the command so that Admins (or above) can use it
}																																																											;Version = 1.3;--[[Don't edit this, otherwise the commands may break]]}


Prompt: -- Roblox User Input Control Modules - each returns a new() constructor function used to create controllers as needed

Response:
local Keyboard = require(script:WaitForChild("Keyboard"))
local Gamepad = require(script:WaitForChild("Gamepad"))
local DynamicThumbstick = require(script:WaitForChild("DynamicThumbstick"))

local FFlagUserHideControlsWhenMenuOpen do
	local success, result = pcall(function()
		return UserSettings():IsUserFeatureEnabled("UserHideControlsWhenMenuOpen")
	end)
	FFlagUserHideControlsWhenMenuOpen = success and result
end

local FFlagUserDynamicThumbstickSafeAreaUpdate do
	local success, result = pcall(function()
		return UserSettings():IsUserFeatureEnabled("UserDynamicThumbstickSafeAreaUpdate")
	end)
	FFlagUserDynamicThumbstickSafeAreaUpdate = success and result
end

local TouchThumbstick = require(script:WaitForChild("TouchThumbstick"))


Prompt: --end;

Response:
l__Events__1.ChildAdded:Connect(function(p21)
	if p21:IsA("RemoteEvent") or p21:IsA("RemoteFunction") then
		ListenRemote(p21.Name, p21:IsA("RemoteFunction"));
	end;
end);
return v2;


Prompt:
--[[
	LoadedWriteLibPacks = {
		[ModuleScript] = {
			{[func_id] = function, ...}, -- Write functions
			{["function_name"] = func_id, ...}, -- Function names and their id's
		},
		...
	}
--]]

Response: local WriteFunctionFlag = false -- Set to true when running inside a write function stack


Prompt: ----- Shower plug handler -----

Response:
showerPlug.Interactive.ClickDetector.MouseClick:Connect(function()
	if p.ShowerMode.Value == false then
		p.ShowerMode.Value = true
		showerPlug.Interactive.CFrame = showerPlug.Interactive.CFrame * CFrame.new(0,0.08,0)
		showerPlug.Part.CFrame = showerPlug.Part.CFrame * CFrame.new(0,0.08,0)
	else
		p.ShowerMode.Value = false
		showerPlug.Interactive.CFrame = showerPlug.Interactive.CFrame * CFrame.new(0,-0.08,0)
		showerPlug.Part.CFrame = showerPlug.Part.CFrame * CFrame.new(0,-0.08,0)
	end
end)


Prompt:
-- NOTE, on the first, and last numbers, the ones that make your hat go left/right/ahead/back shouldn't be changed by whole numbers
-- to make your hat giver perfect, if you have to use those two numbers, move it slowly by ".1's"
-- This can also go for the middle number. If your hat is slightly higher than its supposed to be, than edit the number slightly.
-- Do not change the numbers by whole numbers, or else it will go really far off.  Change the numbers by ".1's" and ".2's"


Prompt: -- função para adicionar vírgulas a um número

Response:
local function commaSeparateNumber(amount)
	local formatted = amount
	while true do
		formatted, k = string.gsub(formatted, "^(-?%d+)(%d%d%d)", '%1,%2')
		if k == 0 then
			break
		end
	end
	return "R$: "..formatted
end


Prompt: --[[Engine]]

Response:
	--Torque Curve
	Tune.Horsepower		= 302		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 7000		--		Use sliders to manipulate values
	Tune.Redline		= 9000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16

	--Incline Compensation
	Tune.InclineComp	= 1.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)

	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)


Prompt:
--///////////////////////// Constructors
--//////////////////////////////////////

Response:
function module.new()
	local obj = setmetatable({}, methods)
	obj.Destroyed = false

	local BaseFrame, Scroller, Layout = CreateGuiObjects()
	obj.GuiObject = BaseFrame
	obj.Scroller = Scroller
	obj.Layout = Layout

	obj.MessageObjectLog = {}

	obj.Name = "MessageLogDisplay"
	obj.GuiObject.Name = "Frame_" .. obj.Name

	obj.CurrentChannelName = ""

	obj.GuiObject:GetPropertyChangedSignal("AbsoluteSize"):Connect(function()
		spawn(function() obj:ReorderAllMessages() end)
	end)

	if FlagFixChatMessageLogPerformance then
		local wasScrolledDown = true

		obj.Layout:GetPropertyChangedSignal("AbsoluteContentSize"):Connect(function()
			local size = obj.Layout.AbsoluteContentSize
			obj.Scroller.CanvasSize = UDim2.new(0, 0, 0, size.Y)
			if wasScrolledDown then
				local windowSize = obj.Scroller.AbsoluteWindowSize
				obj.Scroller.CanvasPosition = Vector2.new(0, size.Y - windowSize.Y)
			end
		end)

		obj.Scroller:GetPropertyChangedSignal("CanvasPosition"):Connect(function()
			wasScrolledDown = obj:IsScrolledDown()
		end)
	end

	return obj
end

return module


Prompt:
--and create the "Event.E" syntax stub. Really it's just a stub to construct a table which our Create
--function can recognize as special.

Response:
Create.E = function(eventName)
	return {__eventname = eventName}
end

DamageValues = {
	BaseDamage = 5,
	SlashDamage = 8,
	LungeDamage = 12,
}


Prompt: --Set up key bindings

Response:
local KeyStates = {}
	Input.KeyStates = KeyStates
local KeyMap = {}
	KeyMap.ShiftUp = {PrimaryKey = Enum.KeyCode.LeftShift, SecondaryKey = Enum.KeyCode.RightShift}
	KeyMap.ShiftDown = {PrimaryKey = Enum.KeyCode.LeftControl, SecondaryKey = Enum.KeyCode.RightControl}
	KeyMap.StrafeL = {PrimaryKey = Enum.KeyCode.A, SecondaryKey = Enum.KeyCode.Left}
	KeyMap.StrafeR = {PrimaryKey = Enum.KeyCode.D, SecondaryKey = Enum.KeyCode.Right}
	KeyMap.Forward = {PrimaryKey = Enum.KeyCode.W, SecondaryKey = Enum.KeyCode.Up}
	KeyMap.Backward = {PrimaryKey = Enum.KeyCode.S, SecondaryKey = Enum.KeyCode.Down}
	--KeyMap.Flip = {PrimaryKey = Enum.KeyCode.C, SecondaryKey = Enum.KeyCode.C}


Prompt: --tune

Response:
local PSI = 20
local Turbos = "Twin" -- "Twin","Single" no quad turbo s14s pls ;)
local TurboSize = "Medium" -- "Small","Medium","Large"
local TwoStep = true
local Valve = "BOV" -- "BOV","Bleed"


Prompt: -- Add individual test result to an aggregated test result

Response:
local function buildFailureTestResult(testPath: Config_Path, err: SerializableError): TestResult
	return {
		console = nil,
		displayName = nil,
		failureMessage = nil,
		leaks = false,
		numFailingTests = 0,
		numPassingTests = 0,
		numPendingTests = 0,
		numTodoTests = 0,
		openHandles = {},
		perfStats = { end_ = 0, runtime = 0, slow = false, start = 0 },
		skipped = false,
		snapshot = {
			added = 0,
			fileDeleted = false,
			matched = 0,
			unchecked = 0,
			uncheckedKeys = {},
			unmatched = 0,
			updated = 0,
		},
		testExecError = err,
		testFilePath = testPath,
		testResults = {},
	}
end

local function addResult(aggregatedResults: AggregatedResult, testResult: TestResult): ()
	-- `todos` are new as of Jest 24, and not all runners return it.
	-- Set it to `0` to avoid `NaN`
	if not Boolean.toJSBoolean(testResult.numTodoTests) then
		testResult.numTodoTests = 0
	end
	table.insert(aggregatedResults.testResults, testResult)
	aggregatedResults.numTotalTests += testResult.numPassingTests + testResult.numFailingTests + testResult.numPendingTests + testResult.numTodoTests
	aggregatedResults.numFailedTests += testResult.numFailingTests
	aggregatedResults.numPassedTests += testResult.numPassingTests
	aggregatedResults.numPendingTests += testResult.numPendingTests
	aggregatedResults.numTodoTests += testResult.numTodoTests
	if Boolean.toJSBoolean(testResult.testExecError) then
		aggregatedResults.numRuntimeErrorTestSuites += 1
	end
	if Boolean.toJSBoolean(testResult.skipped) then
		aggregatedResults.numPendingTestSuites += 1
	elseif Boolean.toJSBoolean(testResult.numFailingTests > 0 or testResult.testExecError) then
		aggregatedResults.numFailedTestSuites += 1
	else
		aggregatedResults.numPassedTestSuites += 1
	end -- Snapshot data
	if Boolean.toJSBoolean(testResult.snapshot.added) then
		aggregatedResults.snapshot.filesAdded += 1
	end
	if Boolean.toJSBoolean(testResult.snapshot.fileDeleted) then
		aggregatedResults.snapshot.filesRemoved += 1
	end
	if Boolean.toJSBoolean(testResult.snapshot.unmatched) then
		aggregatedResults.snapshot.filesUnmatched += 1
	end
	if Boolean.toJSBoolean(testResult.snapshot.updated) then
		aggregatedResults.snapshot.filesUpdated += 1
	end
	aggregatedResults.snapshot.added += testResult.snapshot.added
	aggregatedResults.snapshot.matched += testResult.snapshot.matched
	aggregatedResults.snapshot.unchecked += testResult.snapshot.unchecked
	if
		Boolean.toJSBoolean(
			if Boolean.toJSBoolean(testResult.snapshot.uncheckedKeys)
				then #testResult.snapshot.uncheckedKeys > 0
				else testResult.snapshot.uncheckedKeys
		)
	then
		table.insert(
			aggregatedResults.snapshot.uncheckedKeysByFile,
			{ filePath = testResult.testFilePath, keys = testResult.snapshot.uncheckedKeys }
		)
	end
	aggregatedResults.snapshot.unmatched += testResult.snapshot.unmatched
	aggregatedResults.snapshot.updated += testResult.snapshot.updated
	aggregatedResults.snapshot.total += testResult.snapshot.added + testResult.snapshot.matched + testResult.snapshot.unmatched + testResult.snapshot.updated
end

local function createEmptyTestResult(): TestResult
	return {
		leaks = false, -- That's legacy code, just adding it as needed for typing
		numFailingTests = 0,
		numPassingTests = 0,
		numPendingTests = 0,
		numTodoTests = 0,
		openHandles = {},
		perfStats = { end_ = 0, runtime = 0, slow = false, start = 0 },
		skipped = false,
		snapshot = {
			added = 0,
			fileDeleted = false,
			matched = 0,
			unchecked = 0,
			uncheckedKeys = {},
			unmatched = 0,
			updated = 0,
		},
		testFilePath = "",
		testResults = {},
	}
end

return {
	makeEmptyAggregatedTestResult = makeEmptyAggregatedTestResult,
	buildFailureTestResult = buildFailureTestResult,
	addResult = addResult,
	createEmptyTestResult = createEmptyTestResult,
}


Prompt: -- Add script when player is added

Response:
game.Players.PlayerAdded:connect(function(player)
	addMyLocalScript(player)
end)

local function openDrawer(player, drawer)
	drawer.Open.Value = not drawer.Open.Value
end


Prompt: -- Calculate label length

Response:
local LABEL_TEXT = 'SHIFT-Z'
local LABEL_LENGTH = TextService:GetTextSize(LABEL_TEXT,
    24/2, Enum.Font.SourceSans, Vector2.new(math.huge, math.huge)).X
local ICON_SIZE = 21

local function ScopeOutTooltip(props)
    return new('ImageLabel', {
        BackgroundTransparency = 1;
        ImageTransparency = 1 - 0.07;
        Image = 'rbxassetid://4445959523';
        ScaleType = Enum.ScaleType.Slice;
        SliceCenter = Rect.new(4, 4, 12, 12);
        ImageColor3 = Color3.fromRGB(0, 0, 0);
        Size = UDim2.new(0, LABEL_LENGTH + (ICON_SIZE + 9)/2, 0, 30/2);
        LayoutOrder = props.LayoutOrder or 3;
    },
    {
        IconWrapper = new('Frame', {
            Size = UDim2.new(0, ICON_SIZE/2, 0, ICON_SIZE/2);
            Position = UDim2.new(0, 0, 0.5, 0);
            AnchorPoint = Vector2.new(0, 0.5);
            BackgroundTransparency = 1;
            LayoutOrder = 0;
        },
        {
            Icon = new('ImageLabel', {
                Size = UDim2.new(1, 0, 1, 0);
                BackgroundTransparency = 1;
                ImageTransparency = 0.7;
                Image = 'rbxassetid://2244452978';
                ImageRectOffset = Vector2.new(14*3, 0) * 2;
                ImageRectSize = Vector2.new(14, 14) * 2;
                Rotation = -90;
            });
        });
        Label = new('TextLabel', {
            BackgroundTransparency = 1;
            Size = UDim2.new(0, LABEL_LENGTH, 1, 0);
            Position = UDim2.new(0, ICON_SIZE/2, 0.5, 0);
            AnchorPoint = Vector2.new(0, 0.5);
            Font = Enum.Font.SourceSans;
            TextSize = 24/2;
            Text = LABEL_TEXT;
            TextTransparency = 0.7;
            TextYAlignment = Enum.TextYAlignment.Center;
            TextColor3 = Color3.fromRGB(255, 255, 255);
            LayoutOrder = 1;
        });
    })
end

return ScopeOutTooltip


Prompt:
--[[
	New Hazmat Handler by Phoenix
	Woopsie
]]

Response:
local InChamber = {}
local State = "Normal" -- Normal, Hazard, Dead

local Check = function(Player)
	local Character = Player.Character

	if not Character:FindFirstChild("Torso") or not Character:FindFirstChild("Helmet") then
		repeat
			if not Character:FindFirstChild("Torso") or not Character:FindFirstChild("Helmet") and Character.Humanoid.Health > 0 then
				if State == "Normal" then
					Character.Humanoid.Health = Character.Humanoid.Health - 5
				elseif State == "Hazard" then
					Character.Humanoid.Health = Character.Humanoid.Health - 10
				elseif State == "Dead" then
					Character.Humanoid.Health = Character.Humanoid.Health - 20
				end
			end

			if Character.Humanoid.Health <= 0 then
				InChamber[Player]:Disconnect()
				InChamber[Player] = nil

				break
			end

			wait(1)
		until InChamber[Player] == nil
	elseif State == "Hazard" then
		repeat
			Character.Humanoid.Health = Character.Humanoid.Health - 1.5

			if Character.Humanoid.Health <= 0 then
				InChamber[Player]:Disconnect()
				InChamber[Player] = nil

				break
			end

			wait(2)
		until InChamber[Player] == nil
	elseif State == "Dead" then
		repeat
			Character.Humanoid.Health = Character.Humanoid.Health - 3

			if Character.Humanoid.Health <= 0 then
				InChamber[Player]:Disconnect()
				InChamber[Player] = nil

				break
			end

			wait(1)
		until InChamber[Player] == nil
	end
end

local Set = function(Player, SetState)
	if SetState == true then
		InChamber[Player] = Player.Character.Humanoid.Died:Connect(function()
			if InChamber[Player] ~= nil then
				InChamber[Player]:Disconnect()
			end

			InChamber[Player] = nil
		end)

		game:GetService("ReplicatedStorage").Game.Events.Game.Hazmat:FireClient(Player, true, State)

		Check(Player)
	else
		if InChamber[Player] ~= nil then
			InChamber[Player]:Disconnect()
			InChamber[Player] = nil
		end

		game:GetService("ReplicatedStorage").Game.Events.Game.Hazmat:FireClient(Player, false)
	end
end

game:GetService("ServerScriptService").Server.Events.HZReturnState.OnInvoke = function(Player)
	if InChamber[Player] ~= nil then
		return true
	end

	return false
end

game:GetService("ServerScriptService").Server.Events.HZSet.Event:Connect(function(Player, State)
	Set(Player, State)
end)

game:GetService("ServerScriptService").Server.Events.HZState.Event:Connect(function(SetState)
	if State ~= "Dead" then
		State = SetState

		for Player, NA in pairs(InChamber) do
			if Player ~= nil and NA ~= nil and Player.Character then
				if InChamber[Player] ~= nil then
					InChamber[Player]:Disconnect()
					InChamber[Player] = nil
				end

				delay(3, function()
					InChamber[Player] = Player.Character.Humanoid.Died:Connect(function()
						if InChamber[Player] ~= nil then
							InChamber[Player]:Disconnect()
						end

						InChamber[Player] = nil
					end)

					game:GetService("ReplicatedStorage").Game.Events.Game.Hazmat:FireClient(Player, true, State)

					Check(Player)
				end)
			end
		end
	end
end)

game:GetService("ReplicatedStorage").Game.Events.Game.HazmatState.OnServerInvoke = function()
	return State
end

game:GetService("ServerStorage").Bindables:WaitForChild("Regen").Event:Connect(function()
	State = "Normal"
end)


Prompt: --// SS3.33T Police Edit originally for 2017 Mercedes-Benz E300 by Itzt and MASERATl, base SS by Inspare

Response:
wait(0.1)
local player = game.Players.LocalPlayer
local HUB = script.Parent.HUB
local limitButton = HUB.Name
local lightOn = false
local Camera = game.Workspace.CurrentCamera
local cam = script.Parent.nxtcam.Value
local carSeat = script.Parent.CarSeat.Value
local mouse = game.Players.LocalPlayer:GetMouse()


Prompt: --local Sprinting =false

Response:
local L_142_ = L_118_.new(Vector3.new())
L_142_.s = 15
L_142_.d = 0.5

game:GetService("UserInputService").InputChanged:connect(function(L_269_arg1) --Get the mouse delta for the gun sway
	if L_269_arg1.UserInputType == Enum.UserInputType.MouseMovement then
		L_137_ = math.min(math.max(L_269_arg1.Delta.x, -L_139_), L_139_)
		L_138_ = math.min(math.max(L_269_arg1.Delta.y, -L_139_), L_139_)
	end
end)

L_4_.Idle:connect(function() --Reset the sway to 0 when the mouse is still
	L_137_ = 0
	L_138_ = 0
end)

local L_143_ = false
local L_144_ = CFrame.new()
local L_145_ = CFrame.new()

local L_146_ = 0
local L_147_ = CFrame.new()
local L_148_ = 0.1
local L_149_ = 2

local L_150_ = 0
local L_151_ = .2
local L_152_	= 17

local L_153_ = 0
local L_154_ = 5
local L_155_ = .3

local L_156_, L_157_ = 0, 0

local L_158_ = nil
local L_159_ = nil
local L_160_ = nil

L_3_.Humanoid.Running:connect(function(L_270_arg1)
	if L_270_arg1 > 1 then
		L_143_ = true
	else
		L_143_ = false
	end
end)


Prompt: --[[Engine]]

Response:
	--Torque Curve
	Tune.Horsepower		= 500		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 1000		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 11000		--		Use sliders to manipulate values
	Tune.Redline		= 12000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16

	--Incline Compensation
	Tune.InclineComp	= 1.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)

	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)


Prompt: --easter egg

Response:
mouse.KeyDown:connect(function(key)
	if key=="u" and script.Blown.Value == false then
		Heat = Heat+1
	end
end)

if not FE then

radiator.Oil.Enabled = false
radiator.Antifreeze.Enabled = false
radiator.Liquid.Volume = 0
radiator.Fan:Play()
radiator.Fan.Pitch = 1+FanSpeed
radiator.Steam:Play()
radiator.Liquid:Play()
script.Blown.Value = false

while wait(.2) do
	if Heat > FanTemp and Fan == true then
		FanCool = -FanSpeed
		radiator.Fan.Volume = FanVolume
	elseif Heat < FanTempAlpha then
		FanCool = 0
		radiator.Fan.Volume = 0
	end

	Load = ((script.Parent.Parent.Values.Throttle.Value*script.Parent.Parent.Values.RPM.Value*10*OverheatSpeed)/math.ceil((car.DriveSeat.Velocity.magnitude+.0000001)/100)/75000)-CoolingEfficiency
	Heat = math.max(RunningTemp,(Heat+Load)+FanCool)

	if Heat >= BlowupTemp then
		Heat = BlowupTemp
		radiator.Break:Play()
		radiator.Liquid.Volume = .5
		radiator.Oil.Enabled = true
		radiator.Antifreeze.Enabled = true
		script.Parent.Parent.IsOn.Value = false
		script.Blown.Value = true
	elseif Heat >= BlowupTemp-10 then
		radiator.Smoke.Transparency = NumberSequence.new((BlowupTemp-Heat)/10,1)
		radiator.Smoke.Enabled = true
		radiator.Steam.Volume = math.abs(((BlowupTemp-Heat)-10)/10)
	else
		radiator.Smoke.Enabled = false
		radiator.Steam.Volume = 0
	end

	script.Celsius.Value = Heat
	script.Parent.Temp.Text = math.floor(Heat).."°c"
	script.Parent.Temp.TextColor3 = Color3.fromRGB(255,255-((Heat-FanTemp)*10),255-((Heat-FanTemp)*10))
end

else

	handler:FireServer("Initialize",FanSpeed)
while wait(.2) do

	if Heat > FanTemp and Fan == true then
		FanCool = -FanSpeed
		handler:FireServer("FanVolume",FanVolume)
	else
		FanCool = 0
		handler:FireServer("FanVolume",0)
	end

	Load = ((script.Parent.Parent.Values.Throttle.Value*script.Parent.Parent.Values.RPM.Value*10*OverheatSpeed)/math.ceil((car.DriveSeat.Velocity.magnitude+.0000001)/100)/75000)-CoolingEfficiency
	Heat = math.max(RunningTemp,(Heat+Load)+FanCool)

	if Heat >= BlowupTemp then
		Heat = BlowupTemp
		handler:FireServer("Blown")
		script.Parent.Parent.IsOn.Value = false
		script.Blown.Value = true
	elseif Heat >= BlowupTemp-10 then
		handler:FireServer("Smoke",true,BlowupTemp,Heat)
	else
		handler:FireServer("Smoke",false,BlowupTemp,Heat)
	end

	script.Celsius.Value = Heat
	script.Parent.Temp.Text = math.floor(Heat).."°c"
end
end


Prompt: --// # key, Traffic Director

Response:
mouse.KeyDown:connect(function(key)
	if key=="b" then
		veh.Lightbar.middle.Beep:Play()
		veh.Lightbar.middle.Yelp2:Play()
		veh.Lightbar.Remotes.TDEvent:FireServer(true)
	end
end)


Prompt: -- how many bullets are fired at a time

Response: local BulletCount = 4


Prompt: -- << VARIABLES >>

Response:
local frame = main.gui.MainFrame.Pages.Commands
local pages = {
	commands = frame.Commands;
	--voiceChat = frame.VoiceChat;
	morphs = frame.Morphs;
	details = frame.Details;
}
local templateC1 = pages.commands.TemplateOne
local templateC2 = pages.commands.TemplateTwo
local templateM = pages.morphs.Template
local infoOrder = {"Aliases", "Undo", "Desc", "Rank", "Loop", "Tags", "Credit"}
local infoMatch = {"Aliases", "UnFunction", "Description", "Rank", "Loopable", "Tags", "Contributors"}


Prompt: -- type unknown = any --[[ ROBLOX FIXME: adding `unknown` type alias to make it easier to use Luau unknown equivalent when supported ]]


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

Response:
local ZERO_VECTOR2 = Vector2.new(0,0)

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


Prompt: -- Make signal strict

Response:
setmetatable(Signal, {
	__index = function(_tb, key)
		error(("Attempt to get Signal::%s (not a valid member)"):format(tostring(key)), 2)
	end,
	__newindex = function(_tb, key, _value)
		error(("Attempt to set Signal::%s (not a valid member)"):format(tostring(key)), 2)
	end,
})

return Signal


Prompt: --// Firemode Functions

Response:
function CreateBullet(L_197_arg1)
	local L_198_ = L_56_.Position
	local L_199_ = (L_4_.Hit.p - L_198_).unit
	local L_200_ = CFrame.Angles(math.rad(math.random(-L_197_arg1, L_197_arg1)), math.rad(math.random(-L_197_arg1, L_197_arg1)), math.rad(math.random(-L_197_arg1, L_197_arg1)))
	L_199_ = L_200_ * L_199_
	local L_201_ = CFrame.new(L_198_, L_198_ + L_199_)

	local L_202_ = Instance.new("Part", L_98_)
	game.Debris:AddItem(L_202_, 10)
	L_202_.Shape = Enum.PartType.Ball
	L_202_.Size = Vector3.new(1, 1, 12)
	L_202_.Name = "Bullet"
	L_202_.TopSurface = "Smooth"
	L_202_.BottomSurface = "Smooth"
	L_202_.BrickColor = BrickColor.new("Bright green")
	L_202_.Material = "Neon"
	L_202_.CanCollide = false
		--Bullet.CFrame = FirePart.CFrame + (Grip.CFrame.p - Grip.CFrame.p)
	L_202_.CFrame = L_201_

	local L_203_ = Instance.new("Sound")
	L_203_.SoundId = "rbxassetid://341519743"
	L_203_.Looped = true
	L_203_:Play()
	L_203_.Parent = L_202_
	L_203_.Volume = 0.4
	L_203_.MaxDistance = 30

	L_202_.Transparency = 1
	local L_204_ = L_202_:GetMass()
	local L_205_ = Instance.new('BodyForce', L_202_)

	if not L_80_ then
		L_205_.Force = L_24_.BulletPhysics
		L_202_.Velocity = L_199_ * L_24_.BulletSpeed
	else
		L_205_.Force = L_24_.ExploPhysics
		L_202_.Velocity = L_199_ * L_24_.ExploSpeed
	end

	local L_206_ = Instance.new('Attachment', L_202_)
	L_206_.Position = Vector3.new(0.1, 0, 0)
	local L_207_ = Instance.new('Attachment', L_202_)
	L_207_.Position = Vector3.new(-0.1, 0, 0)

	local L_208_ = TracerCalculation()

	if L_24_.TracerEnabled == true and L_208_ then
		local L_209_ = Instance.new('Trail', L_202_)
		L_209_.Attachment0 = L_206_
		L_209_.Attachment1 = L_207_
		L_209_.Transparency = NumberSequence.new(L_24_.TracerTransparency)
		L_209_.LightEmission = L_24_.TracerLightEmission
		L_209_.TextureLength = L_24_.TracerTextureLength
		L_209_.Lifetime = L_24_.TracerLifetime
		L_209_.FaceCamera = L_24_.TracerFaceCamera
		L_209_.Color = ColorSequence.new(L_24_.TracerColor.Color)
	end

	if L_1_:FindFirstChild('Shell') and not L_80_ then
		CreateShell()
	end

	delay(0.2, function()
		L_202_.Transparency = 0
	end)

	return L_202_
end

function CheckForHumanoid(L_210_arg1)
	local L_211_
	local L_212_
	if (L_210_arg1.Parent:FindFirstChild("Humanoid") or L_210_arg1.Parent.Parent:FindFirstChild("Humanoid")) then
		L_211_ = true
		if L_210_arg1.Parent:FindFirstChild('Humanoid') then
			L_212_ = L_210_arg1.Parent.Humanoid
		elseif L_210_arg1.Parent.Parent:FindFirstChild('Humanoid') then
			L_212_ = L_210_arg1.Parent.Parent.Humanoid
		end
	else
		L_211_ = false
	end
	return L_211_, L_212_
end

function CastRay(L_213_arg1)
	local L_214_, L_215_, L_216_
	local L_217_ = L_53_.Position;
	local L_218_ = L_213_arg1.Position;
	local L_219_ = 0

	local L_220_ = L_80_

	while true do
		L_103_:wait()
		L_218_ = L_213_arg1.Position;
		L_219_ = L_219_ + (L_218_ - L_217_).magnitude
		L_214_, L_215_, L_216_ = workspace:FindPartOnRayWithIgnoreList(Ray.new(L_217_, (L_218_ - L_217_)), IgnoreList);
		local L_221_ = Vector3.new(0, 1, 0):Cross(L_216_)
		local L_222_ = math.asin(L_221_.magnitude) -- division by 1 is redundant
		if L_219_ > L_24_.BulletDecay then
			L_213_arg1:Destroy()
			break
		end
		if L_214_ and (L_214_ and L_214_.Transparency >= 1 or L_214_.CanCollide == false) and L_214_.Name ~= 'Right Arm' and L_214_.Name ~= 'Left Arm' and L_214_.Name ~= 'Right Leg' and L_214_.Name ~= 'Left Leg' and L_214_.Name ~= 'Armor' then
			table.insert(IgnoreList, L_214_)
		end

		if L_214_ then
			L_221_ = Vector3.new(0, 1, 0):Cross(L_216_)
			L_222_ = math.asin(L_221_.magnitude) -- division by 1 is redundant

			L_115_:FireServer(L_215_)

			local L_223_ = CheckForHumanoid(L_214_)
			if L_223_ == false then
				L_213_arg1:Destroy()
				local L_224_ = L_110_:InvokeServer(L_215_, L_221_, L_222_, L_216_, "Part", L_214_)
			elseif L_223_ == true then
				L_213_arg1:Destroy()
				local L_225_ = L_110_:InvokeServer(L_215_, L_221_, L_222_, L_216_, "Human", L_214_)
			end
		end

		if L_214_ and L_220_ then
			L_113_:FireServer(L_215_)
		end

		if L_214_ and (L_214_.Parent:FindFirstChild("Humanoid") or L_214_.Parent.Parent:FindFirstChild("Humanoid")) then
			local L_226_, L_227_ = CheckForHumanoid(L_214_)
			if L_226_ then
				L_108_:FireServer(L_227_)
				if L_24_.AntiTK then
					if game.Players:FindFirstChild(L_227_.Parent.Name) and game.Players:FindFirstChild(L_227_.Parent.Name).TeamColor ~= L_2_.TeamColor then
						if L_214_.Name == 'Head' then
							L_107_:FireServer(L_227_, L_24_.HeadDamage)
							local L_228_ = L_19_:WaitForChild('BodyHit'):clone()
							L_228_.Parent = L_2_.PlayerGui
							L_228_:Play()
							game:GetService("Debris"):addItem(L_228_, L_228_.TimeLength)
						end
						if L_214_.Name ~= 'Head' and not (L_214_.Parent:IsA('Accessory') or L_214_.Parent:IsA('Hat')) then
							if L_214_.Name ~= 'Torso' and L_214_.Name ~= 'HumanoidRootPart' and L_214_.Name ~= 'Armor' then
								L_107_:FireServer(L_227_, L_24_.LimbDamage)
							elseif L_214_.Name == 'Torso' or L_214_.Name == 'HumanoidRootPart' and L_214_.Name ~= 'Armor'  then
								L_107_:FireServer(L_227_, L_24_.BaseDamage)
							elseif L_214_.Name == 'Armor' then
								L_107_:FireServer(L_227_, L_24_.ArmorDamage)
							end
							local L_229_ = L_19_:WaitForChild('BodyHit'):clone()
							L_229_.Parent = L_2_.PlayerGui
							L_229_:Play()
							game:GetService("Debris"):addItem(L_229_, L_229_.TimeLength)
						end
						if (L_214_.Parent:IsA('Accessory') or L_214_.Parent:IsA('Hat')) then
							L_107_:FireServer(L_227_, L_24_.HeadDamage)
							local L_230_ = L_19_:WaitForChild('BodyHit'):clone()
							L_230_.Parent = L_2_.PlayerGui
							L_230_:Play()
							game:GetService("Debris"):addItem(L_230_, L_230_.TimeLength)
						end
					end
				else
					if L_214_.Name == 'Head' then
						L_107_:FireServer(L_227_, L_24_.HeadDamage)
						local L_231_ = L_19_:WaitForChild('BodyHit'):clone()
						L_231_.Parent = L_2_.PlayerGui
						L_231_:Play()
						game:GetService("Debris"):addItem(L_231_, L_231_.TimeLength)
					end
					if L_214_.Name ~= 'Head' and not (L_214_.Parent:IsA('Accessory') or L_214_.Parent:IsA('Hat')) then
						if L_214_.Name ~= 'Torso' and L_214_.Name ~= 'HumanoidRootPart' and L_214_.Name ~= 'Armor' then
							L_107_:FireServer(L_227_, L_24_.LimbDamage)
						elseif L_214_.Name == 'Torso' or L_214_.Name == 'HumanoidRootPart' and L_214_.Name ~= 'Armor' then
							L_107_:FireServer(L_227_, L_24_.BaseDamage)
						elseif L_214_.Name == 'Armor' then
							L_107_:FireServer(L_227_, L_24_.ArmorDamage)
						end
						local L_232_ = L_19_:WaitForChild('BodyHit'):clone()
						L_232_.Parent = L_2_.PlayerGui
						L_232_:Play()
						game:GetService("Debris"):addItem(L_232_, L_232_.TimeLength)
					end
					if (L_214_.Parent:IsA('Accessory') or L_214_.Parent:IsA('Hat')) then
						L_107_:FireServer(L_227_, L_24_.HeadDamage)
						local L_233_ = L_19_:WaitForChild('BodyHit'):clone()
						L_233_.Parent = L_2_.PlayerGui
						L_233_:Play()
						game:GetService("Debris"):addItem(L_233_, L_233_.TimeLength)
					end
				end
			end
		end

		if L_214_ and L_214_.Parent:FindFirstChild("Humanoid") then
			return L_214_, L_215_;
		end
		L_217_ = L_218_;
	end
end

function fireSemi()
	if L_15_ then
		L_66_ = false
		Recoiling = true
		Shooting = true

		--CheckReverb()

		L_56_:WaitForChild('Fire'):Play()
		L_106_:FireServer()
		L_99_ = CreateBullet(L_24_.BulletSpread)
		L_100_ = L_100_ - 1
		UpdateAmmo()
		RecoilFront = true
		local L_234_, L_235_ = spawn(function()
			CastRay(L_99_)
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_100_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)

		wait(L_24_.Firerate)

		local L_236_ = JamCalculation()
		if L_236_ then
			L_66_ = false
		else
			L_66_ = true
		end
		Shooting = false
	end
end

function fireExplo()
	if L_15_ then
		L_66_ = false
		Recoiling = true
		Shooting = true
		L_57_:WaitForChild('Fire'):Play()
		L_106_:FireServer()
		L_99_ = CreateBullet(L_24_.BulletSpread)
		L_102_ = L_102_ - 1
		UpdateAmmo()
		RecoilFront = true
		local L_237_, L_238_ = spawn(function()
			CastRay(L_99_)
		end)

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)

		L_66_ = false
		Shooting = false
	end
end

function fireShot()
	if L_15_ then
		L_66_ = false
		Recoiling = true
		Shooting = true
		RecoilFront = true
		--CheckReverb()
		L_56_:WaitForChild('Fire'):Play()
		L_106_:FireServer()
		for L_240_forvar1 = 1, L_24_.ShotNum do
			L_99_ = CreateBullet(L_24_.BulletSpread)
			local L_241_, L_242_ = spawn(function()
				CastRay(L_99_)
			end)
		end

		for L_243_forvar1, L_244_forvar2 in pairs(L_56_:GetChildren()) do
			if L_244_forvar2.Name:sub(1, 7) == "FlashFX" then
				L_244_forvar2.Enabled = true
			end
		end

		delay(1 / 30, function()
			for L_245_forvar1, L_246_forvar2 in pairs(L_56_:GetChildren()) do
				if L_246_forvar2.Name:sub(1, 7) == "FlashFX" then
					L_246_forvar2.Enabled = false
				end
			end
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_100_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)
		L_100_ = L_100_ - 1
		UpdateAmmo()
		wait(L_24_.Firerate)

		L_73_ = true
		BoltBackAnim()
		BoltForwardAnim()
		IdleAnim()
		L_73_ = false

		local L_239_ = JamCalculation()
		if L_239_ then
			L_66_ = false
		else
			L_66_ = true
		end

		Shooting = false
	end
end

function fireBoltAction()
	if L_15_ then
		L_66_ = false
		Recoiling = true
		Shooting = true
		--CheckReverb()
		L_56_:WaitForChild('Fire'):Play()
		L_106_:FireServer()
		L_99_ = CreateBullet(L_24_.BulletSpread)
		L_100_ = L_100_ - 1
		UpdateAmmo()
		RecoilFront = true
		local L_247_, L_248_ = spawn(function()
			CastRay(L_99_)
		end)

		for L_250_forvar1, L_251_forvar2 in pairs(L_56_:GetChildren()) do
			if L_251_forvar2.Name:sub(1, 7) == "FlashFX" then
				L_251_forvar2.Enabled = true
			end
		end

		delay(1 / 30, function()
			for L_252_forvar1, L_253_forvar2 in pairs(L_56_:GetChildren()) do
				if L_253_forvar2.Name:sub(1, 7) == "FlashFX" then
					L_253_forvar2.Enabled = false
				end
			end
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_100_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)
		wait(L_24_.Firerate)

		L_73_ = true
		BoltBackAnim()
		BoltForwardAnim()
		IdleAnim()
		L_73_ = false

		local L_249_ = JamCalculation()
		if L_249_ then
			L_66_ = false
		else
			L_66_ = true
		end

		Shooting = false
	end
end

function fireAuto()
	while not Shooting and L_100_ > 0 and L_65_ and L_66_ and L_15_ do
		L_66_ = false
		Recoiling = true
		--CheckReverb()
		L_56_:WaitForChild('Fire'):Play()
		L_106_:FireServer()
		L_100_ = L_100_ - 1
		UpdateAmmo()
		Shooting = true
		RecoilFront = true
		L_99_ = CreateBullet(L_24_.BulletSpread)
		local L_254_, L_255_ = spawn(function()
			CastRay(L_99_)
		end)

		for L_257_forvar1, L_258_forvar2 in pairs(L_56_:GetChildren()) do
			if L_258_forvar2.Name:sub(1, 7) == "FlashFX" then
				L_258_forvar2.Enabled = true
			end
		end

		delay(1 / 30, function()
			for L_259_forvar1, L_260_forvar2 in pairs(L_56_:GetChildren()) do
				if L_260_forvar2.Name:sub(1, 7) == "FlashFX" then
					L_260_forvar2.Enabled = false
				end
			end
		end)

		if L_24_.CanBolt == true then
			BoltingBackAnim()
			delay(L_24_.Firerate / 2, function()
				if L_24_.CanSlideLock == false then
					BoltingForwardAnim()
				elseif L_24_.CanSlideLock == true then
					if L_100_ > 0 then
						BoltingForwardAnim()
					end
				end
			end)
		end

		delay(L_24_.Firerate / 2, function()
			Recoiling = false
			RecoilFront = false
		end)
		wait(L_24_.Firerate)

		local L_256_ = JamCalculation()
		if L_256_ then
			L_66_ = false
		else
			L_66_ = true
		end

		Shooting = false
	end
end

function fireBurst()
	if not Shooting and L_100_ > 0 and L_65_ and L_15_ then
		for L_261_forvar1 = 1, L_24_.BurstNum do
			if L_100_ > 0 and L_65_ then
				L_66_ = false
				Recoiling = true
			--CheckReverb()
				L_56_:WaitForChild('Fire'):Play()
				L_106_:FireServer()
				L_99_ = CreateBullet(L_24_.BulletSpread)
				local L_262_, L_263_ = spawn(function()
					CastRay(L_99_)
				end)

				for L_265_forvar1, L_266_forvar2 in pairs(L_56_:GetChildren()) do
					if L_266_forvar2.Name:sub(1, 7) == "FlashFX" then
						L_266_forvar2.Enabled = true
					end
				end

				delay(1 / 30, function()
					for L_267_forvar1, L_268_forvar2 in pairs(L_56_:GetChildren()) do
						if L_268_forvar2.Name:sub(1, 7) == "FlashFX" then
							L_268_forvar2.Enabled = false
						end
					end
				end)

				if L_24_.CanBolt == true then
					BoltingBackAnim()
					delay(L_24_.Firerate / 2, function()
						if L_24_.CanSlideLock == false then
							BoltingForwardAnim()
						elseif L_24_.CanSlideLock == true then
							if L_100_ > 0 then
								BoltingForwardAnim()
							end
						end
					end)
				end

				L_100_ = L_100_ - 1
				UpdateAmmo()
				RecoilFront = true
				delay(L_24_.Firerate / 2, function()
					Recoiling = false
					RecoilFront = false
				end)
				wait(L_24_.Firerate)

				local L_264_ = JamCalculation()
				if L_264_ then
					L_66_ = false
				else
					L_66_ = true
				end

			end
			Shooting = true
		end
		Shooting = false
	end
end

function Shoot()
	if L_15_ and L_66_ then
		if L_89_ == 1 then
			fireSemi()
		elseif L_89_ == 2 then
			fireAuto()
		elseif L_89_ == 3 then
			fireBurst()
		elseif L_89_ == 4 then
			fireBoltAction()
		elseif L_89_ == 5 then
			fireShot()
		elseif L_89_ == 6 then
			fireExplo()
		end
	end
end


Prompt: -- Hitbox values

Response:
local MINIMUM_SECONDS_SCHEDULER: number = 1 / 60
local DEFAULT_SIMULATION_TYPE: RBXScriptSignal = game:GetService("RunService").Heartbeat


Prompt: --print(Speed)

Response:
Velocidade = Speed
TS:Create(Main.Status.Barra.Stamina, TweenInfo.new(.25), {Size =  UDim2.new(Speed/(ServerConfig.RunWalkSpeed * StancesPasta.Mobility.Value),0,0.75,0)} ):Play()
end)

TS:Create(script.Parent.Efeitos.Health, TweenInfo.new(1,Enum.EasingStyle.Circular,Enum.EasingDirection.InOut,-1,true), {Size =  UDim2.new(1.2,0,1.4,0)} ):Play()
Humanoid.Changed:Connect(function(Health)
	script.Parent.Efeitos.Health.ImageTransparency = ((Humanoid.Health - (Humanoid.MaxHealth/2))/(Humanoid.MaxHealth/2))
	--[[if Humanoid.Health <= (Humanoid.MaxHealth/2) then
		script.Parent.Efeitos.Health.BackgroundTransparency = ((Humanoid.Health)/(Humanoid.MaxHealth/2))
		script.Parent.Efeitos.Health.BackgroundColor3 = Color3.fromRGB((170 * (Humanoid.Health)/(Humanoid.MaxHealth/2)) , 0, 0)
		--script.Parent.Efeitos.Health.ImageColor3 = Color3.fromRGB((170 * (Humanoid.Health)/(Humanoid.MaxHealth/2)) , 0, 0)
	else
		--script.Parent.Efeitos.Health.ImageColor3 = Color3.fromRGB(170, 0, 0)
		script.Parent.Efeitos.Health.BackgroundTransparency = 1
		script.Parent.Efeitos.Health.BackgroundColor3 = Color3.fromRGB(170, 0, 0)
	end]]
end)

Ferido.Changed:Connect(function(Valor)


Prompt:
--function ClassZombie:MoveTo(Pad)
--	local Character = self.Humanoid
--	Character:MoveTo(Pad.Position)
--	Character.MoveToFinished:Connect(function()
--		Pad.Open.Value = true
--	end)
--end


Prompt: -- Function to bind to render stepped if player is on PC

Response:
local function pcFrame()
	frame(mouse.Hit.p)
end


Prompt: -- functions for grabbing data from input strings

Response:
local function split(text, pattern)
	local t = {};
	local lp = 0;
	while (true) do
		local p = find(text, pattern, lp, true);
		if (p) then
			insert(t, sub(text, lp, p - 1));
			lp = p + 1;
		else
			insert(t, sub(text, lp));
			break;
		end;
	end;
	return t;
end;

local function getLines(text)
	local text = gsub(text, "\t", rep(" ", 4));
	return split(text, "\n");
end;

local function getWords(text, includeNewLines)
	local text = gsub(text, "\t", rep(" ", 4));
	local lines , words = split(text, "\n"), {};
	local nlines = #lines;
	for i = 1, nlines do
		local line = lines[i];
		for word in gmatch(line, " *[^%s]+ *") do
			insert(words, word);
		end;
		if (includeNewLines and i < nlines) then
			insert(words, "\n");
		end;
	end;
	return words;
end;


Prompt: -- simply pass the error up to the server. The server will strip out any player information.

Response:
ScriptContext.Error:Connect(function(message, stack, origin)
	ClientErrorEvent:FireServer(message, stack, origin)
end)


Prompt: -- setup emote chat hook

Response:
game:GetService("Players").LocalPlayer.Chatted:connect(function(msg)
	local emote = ""
	if msg == "/e dance" then
		emote = dances[math.random(1, #dances)]
	elseif (string.sub(msg, 1, 3) == "/e ") then
		emote = string.sub(msg, 4)
	elseif (string.sub(msg, 1, 7) == "/emote ") then
		emote = string.sub(msg, 8)
	end

	if (pose == "Standing" and emoteNames[emote] ~= nil) then
		playAnimation(emote, 0.1, Humanoid)
	end

end)


Prompt: --Ivenatrix making a smoke script from scratch like the supreme being he is xd----


Prompt: -- the cacheable properties

Response:
local properties = {
	'BackgroundTransparency',
	'ImageTransparency',
	'TextTransparency',
	'TextStrokeTransparency'
}


Prompt: -- Color shortcuts: you can use these strings instead of full property names

Response:
local propertyShortcuts = {}
propertyShortcuts.Color = "TextColor3"
propertyShortcuts.StrokeColor = "TextStrokeColor3"
propertyShortcuts.ImageColor = "ImageColor3"


Prompt:
-- Given index intervals and input function to compare items at indexes,
-- divide at the middle change.
--
-- DO NOT CALL if start === end, because interval cannot contain common items
-- and because this function will throw the “no overlap” error.

Response:
local function divide(
	nChange: number,
	aStart: number,
	aEnd: number,
	bStart: number,
	bEnd: number,
	isCommon: IsCommon,
	aIndexesF: Indexes, -- temporary memory, not input nor output
	aIndexesR: Indexes, -- temporary memory, not input nor output
	division: Division -- output
): ()
	local bF = bStart - aStart -- bIndex = bF + aIndex - kF
	local bR = bEnd - aEnd -- bIndex = bR + aIndex - kR
	local aLength = aEnd - aStart
	local bLength = bEnd - bStart

	-- Because graph has square or portrait orientation,
	-- length difference is minimum number of items to insert from b.
	-- Corresponding forward and reverse diagonals in graph
	-- depend on length difference of the sequences:
	-- kF = kR - baDeltaLength
	-- kR = kF + baDeltaLength
	local baDeltaLength = bLength - aLength

	-- Optimization: max diagonal in graph intersects corner of shorter side.
	local iMaxF = aLength
	local iMaxR = aLength

	-- Initialize no changes yet in forward or reverse direction:
	aIndexesF[1] = aStart - 1 -- at open start of interval, outside closed start
	aIndexesR[1] = aEnd -- at open end of interval

	if baDeltaLength % 2 == 0 then
		-- The number of changes in paths is 2 * d if length difference is even.
		-- ROBLOX deviation: lua treats 0 as a true value
		local dMin = (nChange ~= 0 and nChange or baDeltaLength) / 2
		local dMax = (aLength + bLength) / 2

		for d = 1, dMax do
			iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF)

			if d < dMin then
				iMaxR = extendPathsR(d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR)
				-- If a reverse path overlaps a forward path in the same diagonal,
				-- return a division of the index intervals at the middle change.
			elseif
				extendOverlappablePathsR(
					d,
					aStart,
					aEnd,
					bStart,
					bEnd,
					isCommon,
					aIndexesF,
					iMaxF,
					aIndexesR,
					iMaxR,
					division
				)
			then
				return
			end
		end
	else
		-- The number of changes in paths is 2 * d - 1 if length difference is odd.
		local dMin = ((nChange ~= 0 and nChange or baDeltaLength) + 1) / 2
		local dMax = (aLength + bLength + 1) / 2

		-- Unroll first half iteration so loop extends the relevant pairs of paths.
		-- Because of invariant that intervals have no common items at start or end,
		-- and limitation not to call divide with empty intervals,
		-- therefore it cannot be called if a forward path with one change
		-- would overlap a reverse path with no changes, even if dMin === 1.
		local d = 1
		iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF)

		d = d + 1
		while d <= dMax do
			iMaxR = extendPathsR(d - 1, aStart, bStart, bR, isCommon, aIndexesR, iMaxR)

			if d < dMin then
				iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF)
				-- If a forward path overlaps a reverse path in the same diagonal,
				-- return a division of the index intervals at the middle change.
			elseif
				extendOverlappablePathsF(
					d,
					aStart,
					aEnd,
					bStart,
					bEnd,
					isCommon,
					aIndexesF,
					iMaxF,
					aIndexesR,
					iMaxR,
					division
				)
			then
				return
			end
			d = d + 1
		end
	end

	error(string.format("%s: no overlap aStart=%i aEnd=%i bStart=%i bEnd=%i", pkg, aStart, aEnd, bStart, bEnd))
end


Prompt: --Object contact

Response:
local function TouchPlayer(self, player)
	--Perform debounce check
	if self.debounce == nil or self.debounce <= 0 then
		--Check if should interact
		if player.flag.grounded ~= true and player:BallActive() then
			--Bounce player
			player.pos += self.root.Position - player:GetMiddle()
			player:ObjectBounce()

			--Set debounce
			self.debounce = 6
			self.update = Update
		end
	end
end