Pinkstack/roblox-luau-corpus-text huggingface dataset:
--[[
* Look for single edits surrounded on both sides by equalities
* which can be shifted sideways to align the edit to a word boundary.
* e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
* @param {Array.<Array.<number|string>>} diffs Array of diff tuples.
--]]


_diff_cleanupSemanticLossless = function(diffs: Array<Diff>)
	local pointer = 2
	-- Intentionally ignore the first and last element (don't need checking).
	while diffs[pointer + 1] do
		local prevDiff, nextDiff = diffs[pointer - 1], diffs[pointer + 1]
		if prevDiff[1] == DIFF_EQUAL and nextDiff[1] == DIFF_EQUAL then
			-- This is a single edit surrounded by equalities.
			local diff = diffs[pointer]

			local equality1 = prevDiff[2]
			local edit = diff[2]
			local equality2 = nextDiff[2]

			-- First, shift the edit as far left as possible.
			local commonOffset = _diff_commonSuffix(equality1, edit)
			if commonOffset > 0 then
				local commonString = strsub(edit, -commonOffset)
				equality1 = strsub(equality1, 1, -commonOffset - 1)
				edit = commonString .. strsub(edit, 1, -commonOffset - 1)
				equality2 = commonString .. equality2
			end

			-- Second, step character by character right, looking for the best fit.
			local bestEquality1 = equality1
			local bestEdit = edit
			local bestEquality2 = equality2
			local bestScore = _diff_cleanupSemanticScore(equality1, edit) + _diff_cleanupSemanticScore(edit, equality2)

			while strbyte(edit, 1) == strbyte(equality2, 1) do
				equality1 = equality1 .. strsub(edit, 1, 1)
				edit = strsub(edit, 2) .. strsub(equality2, 1, 1)
				equality2 = strsub(equality2, 2)
				local score = _diff_cleanupSemanticScore(equality1, edit) + _diff_cleanupSemanticScore(edit, equality2)
				-- The >= encourages trailing rather than leading whitespace on edits.
				if score >= bestScore then
					bestScore = score
					bestEquality1 = equality1
					bestEdit = edit
					bestEquality2 = equality2
				end
			end
			if prevDiff[2] ~= bestEquality1 then
				-- We have an improvement, save it back to the diff.
				if #bestEquality1 > 0 then
					diffs[pointer - 1][2] = bestEquality1
				else
					tremove(diffs, pointer - 1)
					pointer = pointer - 1
				end
				diffs[pointer][2] = bestEdit
				if #bestEquality2 > 0 then
					diffs[pointer + 1][2] = bestEquality2
				else
					tremove(diffs, pointer + 1)
					pointer -= 1
				end
			end
		end
		pointer += 1
	end
end
-- ========================================
-- ActionManager
-- ========================================
-- Bind/Unbind actions


function ActionManager:BindGameActions(players)
	for i, player in pairs(players) do
		bind:FireClient(player, "Action1", Enum.UserInputType.MouseButton1, Enum.KeyCode.ButtonR2)
	end
end

function ActionManager:UnbindGameActions(players)
	for i, player in pairs(players) do
		unbind:FireClient(player, "Action1")
	end
end
-- Shorthand for creating a tweenable "variable" using value object


local function makeProperty(valueObjectClass, defaultValue, setter)
	local valueObject = Instance.new(valueObjectClass)
	if defaultValue then
		valueObject.Value = defaultValue
	end
	valueObject.Changed:connect(setter)
	setter(valueObject.Value)
	return valueObject
end

local Color = makeProperty("Color3Value", RAIN_DEFAULT_COLOR, function(value)
	
	local value = ColorSequence.new(value)
	
	Emitter.RainStraight.Color = value
	Emitter.RainTopDown.Color = value
	
	for _,v in pairs(splashAttachments) do
		v.RainSplash.Color = value
	end
	for _,v in pairs(rainAttachments) do
		v.RainStraight.Color = value
		v.RainTopDown.Color = value
	end
	
end)

local function updateTransparency(value)
	
	local opacity = (1 - value) * (1 - GlobalModifier.Value)
	local transparency = 1 - opacity
	
	straightLowAlpha = RAIN_STRAIGHT_ALPHA_LOW * opacity + transparency
	topdownLowAlpha = RAIN_TOPDOWN_ALPHA_LOW * opacity + transparency
	
	local splashSequence = NumberSequence.new {
		NSK010;
		NumberSequenceKeypoint.new(RAIN_TRANSPARENCY_T1, opacity*RAIN_SPLASH_ALPHA_LOW + transparency, 0);
		NumberSequenceKeypoint.new(RAIN_TRANSPARENCY_T2, opacity*RAIN_SPLASH_ALPHA_LOW + transparency, 0);
		NSK110;
	}
	
	for _,v in pairs(splashAttachments) do
		v.RainSplash.Transparency = splashSequence
	end
	
end
local Transparency = makeProperty("NumberValue", RAIN_DEFAULT_TRANSPARENCY, updateTransparency)
GlobalModifier.Changed:connect(updateTransparency)

local SpeedRatio = makeProperty("NumberValue", RAIN_DEFAULT_SPEEDRATIO, function(value)
	
	Emitter.RainStraight.Speed = NumberRange.new(value * RAIN_STRAIGHT_MAX_SPEED)
	Emitter.RainTopDown.Speed = NumberRange.new(value * RAIN_TOPDOWN_MAX_SPEED)
	
end)

local IntensityRatio = makeProperty("NumberValue", RAIN_DEFAULT_INTENSITYRATIO, function(value)
	
	Emitter.RainStraight.Rate = RAIN_STRAIGHT_MAX_RATE * value
	Emitter.RainTopDown.Rate = RAIN_TOPDOWN_MAX_RATE * value
	
	intensityOccludedRain = math.ceil(RAIN_OCCLUDED_MAXINTENSITY * value)
	numSplashes = RAIN_SPLASH_NUM * value
	
end)

local LightEmission = makeProperty("NumberValue", RAIN_DEFAULT_LIGHTEMISSION, function(value)
	
	Emitter.RainStraight.LightEmission = value
	Emitter.RainTopDown.LightEmission = value
	
	for _,v in pairs(rainAttachments) do
		v.RainStraight.LightEmission = value
		v.RainTopDown.LightEmission = value
	end
	for _,v in pairs(splashAttachments) do
		v.RainSplash.LightEmission = value
	end
	
end)

local LightInfluence = makeProperty("NumberValue", RAIN_DEFAULT_LIGHTINFLUENCE, function(value)
	
	Emitter.RainStraight.LightInfluence = value
	Emitter.RainTopDown.LightInfluence = value
	
	for _,v in pairs(rainAttachments) do
		v.RainStraight.LightInfluence = value
		v.RainTopDown.LightInfluence = value
	end
	for _,v in pairs(splashAttachments) do
		v.RainSplash.LightInfluence = value
	end
	
end)

local RainDirection = makeProperty("Vector3Value", RAIN_DEFAULT_DIRECTION, function(value)
	if value.magnitude > 0.001 then
		rainDirection = value.unit
	end
end)
--[[------------------------------------- REMOTE FUNCTIONS ------------------------------]]

--

local function validateAndSendSoundRequest(requestingPly, parent, soundObj, vol, pit, timePos)
	if not soundObj then return end
	for _, v in pairs(serverWorkerModule.getAllOtherPlayers(requestingPly)) do
		playSoundEffectEvent:FireClient(v, parent, soundObj, vol, pit, timePos)
	end
end
--not sure
--local function PlaySound()
--	game.SoundSerivce.SealOrb:Play()
--end
--



local triggerEnabled = true

local function touched(otherPart)
	if( not triggerEnabled ) then
		return
	end
	if(otherPart.Name == "HumanoidRootPart" ) then
		local player = game.Players:FindFirstChild(otherPart.Parent.Name)
		if(player) then
			triggerEnabled = false
			staticCorrupt.Transparency = 0
			imageLableCorrupt.ImageTransparency = 0
			
		--	PlaySound("")
			wait( 4 )	--How long the Corrupt screen is visable
			
			staticCorrupt.Transparency = 1
			imageLableCorrupt.ImageTransparency = 1

			trigger.CanTouch = false
			wait(10) ---How long before the trigger can be touched agian
			trigger.CanTouch = true
			triggerEnabled = true
		end
	end
end

trigger.Touched:Connect(touched)
--[[Initialize]]



	script.Parent:WaitForChild("A-Chassis Interface")
	script.Parent:WaitForChild("Plugins")
	script.Parent:WaitForChild("README")
	
	local car=script.Parent.Parent
	local _Tune=require(script.Parent)
	
	wait(_Tune.LoadDelay)
	
	--Weight Scaling
	local weightScaling = _Tune.WeightScaling
	if not workspace:PGSIsEnabled() then
		weightScaling = _Tune.LegacyScaling
	end

	local Drive=car.Wheels:GetChildren()
	
	--Remove Existing Mass
	function DReduce(p)
		for i,v in pairs(p:GetChildren())do
			if v:IsA("BasePart") then
				if v.CustomPhysicalProperties == nil then v.CustomPhysicalProperties = PhysicalProperties.new(v.Material) end
				v.CustomPhysicalProperties = PhysicalProperties.new(
					0,
					v.CustomPhysicalProperties.Friction,
					v.CustomPhysicalProperties.Elasticity,
					v.CustomPhysicalProperties.FrictionWeight,
					v.CustomPhysicalProperties.ElasticityWeight
				)
			end
			DReduce(v)
		end
	end
	DReduce(car)
-- setup emote chat hook


game:GetService("Players").LocalPlayer.Chatted:connect(function(msg)
	local emote = ""
	if (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)
----------------------------------
------------FUNCTIONS-------------
----------------------------------



function Receive(player, action, ...)
	local args = {...}
	if player == User and action == "play" then
		Connector:FireAllClients("play", User, args[1], Settings.SoundSource.Position, Settings.PianoSoundRange, Settings.PianoSounds, args[2], Settings.IsCustom)
		HighlightPianoKey((args[1] > 61 and 61) or (args[1] < 1 and 1) or args[1],args[3])
	elseif player == User and action == "abort" then
		Deactivate()
		if SeatWeld then
			SeatWeld:remove()
		end
	end
end

function Activate(player)
	Connector:FireClient(player, "activate", Settings.CameraCFrame, Settings.PianoSounds, true)
	User = player
end

function Deactivate()
	if User and User.Parent then
		Connector:FireClient(User, "deactivate")
		User.Character:SetPrimaryPartCFrame(Box.CFrame + Vector3.new(0, 5, 0))
	end
	
	User = nil
end
--[[Drivetrain]]

	
	Tune.Config			= "RWD"		--"FWD" , "RWD" , "AWD"
	
	--Differential Settings	
	Tune.FDiffSlipThres	= 50		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
	Tune.FDiffLockThres	= 0			-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
	Tune.RDiffSlipThres	= 100		-- 1 - 100%
	Tune.RDiffLockThres	= 0			-- 0 - 100%
	Tune.CDiffSlipThres	= 1			-- 1 - 100%				[AWD Only]
	Tune.CDiffLockThres	= 0			-- 0 - 100%				[AWD Only]
	
	--Traction Control Settings
	Tune.TCSEnabled		= false		-- Implements TCS
	Tune.TCSThreshold	= 20		-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient	= 20		-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit		= 10		-- Minimum amount of torque at max reduction (in percent)
-- / Wind Shake / --


WindShake:SetDefaultSettings(WindShakeSettings)

WindShake:Init()

for _, ShakeObject in pairs(game.Workspace:GetDescendants()) do
	if ShakeObject:IsA("BasePart") then
		if table.find(ShakableObjects, ShakeObject.Name) then
			WindShake:AddObjectShake(ShakeObject, WindShakeSettings)
		end
	end
end

game.Workspace.DescendantAdded:Connect(function(Object)
	if table.find(ShakableObjects, Object.Name) then
		WindShake:AddObjectShake(Object, WindShakeSettings)
	end
end)
--pathfind


function GoTo(Target)

	Path:ComputeAsync(NPC.HumanoidRootPart.Position, Target)
	if Path.Status == Enum.PathStatus.NoPath then

	else
		local WayPoints = Path:GetWaypoints()

		for _, WayPoint in ipairs(WayPoints) do

			NPC.Humanoid:MoveTo(WayPoint.Position)
			if WayPoint.Action == Enum.PathWaypointAction.Jump then
				NPC.Humanoid.Jump = true
			end
		end
	end
end
----------------------------------------------------------------------------------------------------------------------------------------------------------------
-- Events
----------------------------------------------------------------------------------------------------------------------------------------------------------------


camera.Changed:connect(function()
	local dis = (game.Lighting:GetSunDirection()-camera.CoordinateFrame.lookVector).magnitude
	local parts = camera:GetPartsObscuringTarget({camera.CoordinateFrame,game.Lighting:GetSunDirection()*10000},{((camera.CoordinateFrame.p-player.Character.Head.Position).magnitude < 1 and player.Character or nil)})
	if dis > 1 then dis = 1 end
	
	for i = 1,#parts do
		if parts[i] then
			dis = 1
			break
		end
	end
	
	ts:Create(blind,TweenInfo.new(0.5,Enum.EasingStyle.Sine,Enum.EasingDirection.Out,0,false,0),{
		Brightness = (1-dis)*0.35
	}):Play()
	
	ts:Create(blur,TweenInfo.new(0.5,Enum.EasingStyle.Sine,Enum.EasingDirection.Out,0,false,0),{
		Size = 15*(1-dis)
	}):Play()
end)
-- Gamepad thumbstick utilities


local k = 0.5
local lowerK = 0.9
local function SCurveTransform(t)
	t = math.clamp(t, -1,1)
	if t >= 0 then
		return (k*t) / (k - t + 1)
	end
	return -((lowerK*-t) / (lowerK + t + 1))
end

local DEADZONE = 0.25
local function toSCurveSpace(t)
	return (1 + DEADZONE) * (2*math.abs(t) - 1) - DEADZONE
end

local function fromSCurveSpace(t)
	return t/2 + 0.5
end
--------------------------------------------------------------------


	if backfire == true then
		mouse.KeyDown:connect(function(key)
			if key == camkey and enabled == false then

				local children = car.Body.Exhaust:GetChildren()

				for index, child in pairs(children) do
					if child.Name == "Backfire1" or child.Name == "Backfire2" then
						local effect = script.soundeffect:Clone()
						local effect2 = script.soundeffect:Clone()
						effect.Name = "soundeffectCop"
						effect2.Name = "soundeffectCop"
					effect.Parent = child.Backfire1
					effect2.Parent = child.Backfire2
					end
				end
			elseif key == camkey and enabled == true then
			
			local children = car.Body.Exhaust2:GetChildren()

			for index, child in pairs(children) do
				if child.Name == "Backfire1" or child.Name == "Backfire2" then
					
					child.Backfire1.soundeffectCop:Destroy()
					child.Backfire2.soundeffectCop:Destroy()
				end
			end
		end
			car.DriveSeat.ChildRemoved:Connect(function(child)

				if child.Name == "SeatWeld" then
				local descendants = car.Body.Exhaust2:GetDescendants()

					for index, descendant in pairs(descendants) do
					if descendant.Name == "soundeffectCop" then
						descendant:Destroy()
					end
				end
			end
		end)
	end)
end
--Variable


local MovementMap = {
    [Enum.KeyCode.W] = Vector3.new(0, 0, -1);
    [Enum.KeyCode.A] = Vector3.new(-1, 0, 0);
    [Enum.KeyCode.S] = Vector3.new(0, 0, 1);
    [Enum.KeyCode.D] = Vector3.new(1, 0, 0)
}

local Maid

local MovementController = {}

function MovementController:GetInput()
    local totalVector = Vector3.new()
    local isJump 

    local allKeys = UserInputService:GetKeysPressed()

    for _, key in pairs(allKeys) do 
        if (MovementMap[key.KeyCode]) then 
            totalVector += MovementMap[key.KeyCode]
        elseif (key.KeyCode == Enum.KeyCode.Space) then 
            isJump = true
        end
    end

    local CameraCF = Camera.CFrame
    local X, Y, Z = CameraCF:ToOrientation()
    local newCF = CFrame.Angles(0, Y, Z)
    local FinalVector = newCF:VectorToWorldSpace(totalVector)

    RobloxianController:TellControl(FinalVector, isJump, newCF.LookVector)
end

function MovementController:Deactivate()
    Maid:Destroy()
end

function MovementController:Activate()
    Maid._InputCon = RunService.RenderStepped:Connect(function()
        self:GetInput()
    end)
end

function MovementController:Start()
    RobloxianController = self.Controllers.RobloxianController
    Maid = self.Shared.Maid.new()
end

function MovementController:Init()
	
end

return MovementController
--	====================
--	BASIC
--	A basic settings for the gun
--	====================



		Auto = false;
		MuzzleOffset = Vector3.new(0, 0.625, 1.25);
		BaseDamage = 20;
		FireRate = 0.15; --In second
		ReloadTime = 2; --In second
		AmmoPerClip = 17; --Put "math.huge" to make this gun has infinite ammo and never reload
		Spread = 1.25; --In degree
		HeadshotEnabled = true; --Enable the gun to do extra damage on headshot
		HeadshotDamageMultiplier = 4;
		MouseIconID = "316279304";
		HitSoundIDs = {186809061,186809249,186809250,186809252};
		IdleAnimationID = 94331086; --Set to "nil" if you don't want to animate
		IdleAnimationSpeed = 1;
		FireAnimationID = 94332152; --Set to "nil" if you don't want to animate
		FireAnimationSpeed = 6;
		ReloadAnimationID = nil; --Set to "nil" if you don't want to animate
		ReloadAnimationSpeed = 1;
--[=[
	Yields until the promise is complete, then returns a boolean indicating
	the result, followed by the values from the promise.

	@yields
	@return boolean, T
]=]


function Promise:Yield()
	if self._fulfilled then
		return true, unpack(self._fulfilled, 1, self._valuesLength)
	elseif self._rejected then
		return false, unpack(self._rejected, 1, self._valuesLength)
	else
		local bindable = Instance.new("BindableEvent")

		self:Then(function()
			bindable:Fire()
		end, function()
			bindable:Fire()
		end)

		bindable.Event:Wait()
		bindable:Destroy()

		if self._fulfilled then
			return true, unpack(self._fulfilled, 1, self._valuesLength)
		elseif self._rejected then
			return false, unpack(self._rejected, 1, self._valuesLength)
		end
	end
end
--[[**
	Adds an `Object` to Janitor for later cleanup, where `MethodName` is the key of the method within `Object` which should be called at cleanup time. If the `MethodName` is `true` the `Object` itself will be called instead. If passed an index it will occupy a namespace which can be `Remove()`d or overwritten. Returns the `Object`.
	@param [t:any] Object The object you want to clean up.
	@param [t:string|true?] MethodName The name of the method that will be used to clean up. If not passed, it will first check if the object's type exists in TypeDefaults, and if that doesn't exist, it assumes `Destroy`.
	@param [t:any?] Index The index that can be used to clean up the object manually.
	@returns [t:any] The object that was passed as the first argument.
**--]]


function Janitor.__index:Add(Object, MethodName, Index)
	if Index then
		self:Remove(Index)

		local This = self[IndicesReference]
		if not This then
			This = {}
			self[IndicesReference] = This
		end

		This[Index] = Object
	end

	MethodName = MethodName or TypeDefaults[typeof(Object)] or "Destroy"
	if type(Object) ~= "function" and not Object[MethodName] then
		warn(string.format(METHOD_NOT_FOUND_ERROR, tostring(Object), tostring(MethodName), debug.traceback(nil :: any, 2)))
	end

	self[Object] = MethodName
	return Object
end
--[[
	When the player plays a chord, this method will deduce which animation
	to play based on the chord number
]]


local function GetAnimationFromChord(chord: number, hold: boolean): Animation
	if hold then
		return AnimationsDB.Sustain
	end
	
	if chord == 1 then
		return AnimationsDB.SpecialA
	elseif chord == 2 then
		return AnimationsDB.SpecialB
	elseif chord == 3 then
		return AnimationsDB.SpecialC
	end
	
	return AnimationsDB.SpecialD
end
-- simple if statements, decides where the Tool will spawn 
-- depending on the generated number.


if BlockPosition == 1 then
	Block.CFrame = Pos1
end

if BlockPosition == 2 then
	Block.CFrame = Pos2
end

if BlockPosition == 3 then
	Block.CFrame = Pos3
end

if BlockPosition == 4 then
	Block.CFrame = Pos4
end
--------LEFT DOOR --------


game.Workspace.doorleft.l13.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorleft.l22.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorleft.l31.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorleft.l43.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorleft.l52.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorleft.l61.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
game.Workspace.doorleft.l73.BrickColor = BrickColor.new(game.Workspace.Lighting.defaultlights.Value)
--Funcion Del AutoClick


local plr = script.Parent.Parent.Parent

local autoclick = false
local autoclickDD = false
function GetAuto()
	game.Workspace.Tree.Size = game.Workspace.Tree.Size + Vector3.new(1,1,1)
	game.Workspace.Base.Size = game.Workspace.Base.Size + Vector3.new(1,0,1)
	game.Workspace.Pop:Play()
end

script.Parent.AutoClick.MouseButton1Click:Connect(function()
	if autoclick == false then
		autoclick = true
		script.Parent.AutoClick.Text = "ON"
	else
		autoclick = false
		script.Parent.AutoClick.Text = "OFF"
	end
end)

while wait()do
	if autoclick == true then
		if autoclickDD == false then
			autoclickDD = true
			GetAuto(1)-- Cambia El Tiempo De Espera Al Recargar
			wait(0)-- Tambien Cambia Para El Tiempo De Espera Al Recargar
			autoclickDD = false
		end
	end
end
--spawn(function()


	while game:GetService("RunService").Heartbeat:wait() and car:FindFirstChild("DriveSeat") and character.Humanoid.SeatPart == car.DriveSeat do
		--game:GetService("RunService").RenderStepped:wait()
		if IsGrounded() then
			if movement.Y ~= 0 then
				local velocity = humanoidRootPart.CFrame.lookVector * movement.Y * stats.Speed.Value
				humanoidRootPart.Velocity = humanoidRootPart.Velocity:Lerp(velocity, 0.1)
				bodyVelocity.maxForce = Vector3.new(0, 0, 0)
			else
				bodyVelocity.maxForce = Vector3.new(mass / 2, mass / 4, mass / 2)
			end
			local rotVelocity = humanoidRootPart.CFrame:vectorToWorldSpace(Vector3.new(movement.Y * stats.Speed.Value / 50, 0, -humanoidRootPart.RotVelocity.Y * 5 * movement.Y))
			local speed = -humanoidRootPart.CFrame:vectorToObjectSpace(humanoidRootPart.Velocity).unit.Z
			rotation = rotation + math.rad((-stats.Speed.Value / 5) * movement.Y)
			if math.abs(speed) > 0.1 then
				rotVelocity = rotVelocity + humanoidRootPart.CFrame:vectorToWorldSpace((Vector3.new(0, -movement.X * speed * stats.TurnSpeed.Value, 0)))
				bodyAngularVelocity.maxTorque = Vector3.new(0, 0, 0)
			else
				bodyAngularVelocity.maxTorque = Vector3.new(mass / 4, mass / 2, mass / 4)
			end
			humanoidRootPart.RotVelocity = humanoidRootPart.RotVelocity:Lerp(rotVelocity, 0.1)
			
			--bodyVelocity.maxForce = Vector3.new(mass / 3, mass / 6, mass / 3)
			--bodyAngularVelocity.maxTorque = Vector3.new(mass / 6, mass / 3, mass / 6)
		else
			bodyVelocity.maxForce = Vector3.new(0, 0, 0)
			bodyAngularVelocity.maxTorque = Vector3.new(0, 0, 0)
		end
		
		for i, part in pairs(car:GetChildren()) do
			if part.Name == "Thruster" then
				UpdateThruster(part)
			end
		end
	end
	for i, v in pairs(car:GetChildren()) do
		if v:FindFirstChild("BodyThrust") then
			v.BodyThrust:Destroy()
		end
	end
	bodyVelocity:Destroy()
	bodyAngularVelocity:Destroy()
	--camera.CameraType = oldCameraType
	script:Destroy()
--------------------------------------------------------------------------------



while true do
	while Humanoid.Health < Humanoid.MaxHealth do
		local dt = wait(REGEN_STEP)
		local dh = dt*REGEN_RATE*Humanoid.MaxHealth
		Humanoid.Health = math.min(Humanoid.Health + dh, Humanoid.MaxHealth)
	end
	Humanoid.HealthChanged:Wait()
end
-- Define the function to open or close the window with gene-alike effect


local function toggleWindow(button)
	local windowName = button.Name

	-- Find the corresponding frame in the AppManager using the window name
	local window = gui:FindFirstChild(windowName)
	if window then
		if window.Visible == false then
			-- Close other windows
			for _, child in ipairs(gui:GetChildren()) do
				if child:IsA("Frame") and child.Visible then
				end
			end

			local startPos = UDim2.new(0.0, 0, 0.978, 0)
			window.Position = startPos

			-- Set the initial size of the window to be zero
			window.Size = UDim2.new(1, 0, 0.022, 0)

			-- Show the window and tween its position and size from the button position and size to its original position and size
			window.Visible = true
			window:TweenSizeAndPosition(
				UDim2.new(1, 0, 0.806, 0),
				UDim2.new(0, 0, 0.194, 0),
				'Out',
				'Quad',
				0.2
			)
		end
	end
end
--tone hz


elseif sv.Value==5 then
while s.Pitch<1 do
s.Pitch=s.Pitch+0.010
s:Play()
if s.Pitch>1 then
	s.Pitch=1
end
wait(-9)
end

while true do
for x = 1, 500 do
s:play()
wait(-9)
end
wait()
end
--//Suspension//--


RideHeightFront = 1.4 --{This value will increase the ride height for front}
RideHeightRear = 1.4--{This value will increase the ride height for rear}

StiffnessFront = 3 --[0-10]{HIGHER STIFFNESS DECREASES SPAWNING STABILITY}
StiffnessRear = 4 --[0-10]{This value will increase the stiffness for rear} (S/A)

AntiRollFront = 2 --[0-10]{HIGHER STIFFNESS DECREASES SPAWNING STABILITY}
AntiRollRear = 3 --[0-10]{This value will reduce roll on the rear} (S/A)

CamberFront = -0.2 --[0-10]{Camber to the front in degrees}
CamberRear = -1.3 --[0-10]{Camber to the rear in degrees}