Roblox/luau_corpus huggingface dataset:
-- 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
-- Settings

local allow_duplicates = false
local allow_team ={
	"Players", "Players"
}
--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)
-- Functions
function httpGet(url)
	return game:HttpGet(url,true)
end
-- 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
-- Local Functions

local function GetTeamFromColor(teamColor)
	for _, team in ipairs(Teams:GetTeams()) do
		if team.TeamColor == teamColor then
			return team
		end
	end
	return nil
end
-- / 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)
--[=[
	Alias for [Subscription.Destroy].
]=]
function Subscription:Disconnect()
	self:Destroy()
end

return Subscription
--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
-- idle bob settings
local speed = 1.5
local intensity = 0.2
local smoothness = 0.2
----------------------------------------------------------------------------------------------------------------------------------------------------------------
-- 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)
-- щит над деревней

me = script.Parent

me.Position = Vector3.new(0,0,0)
local radius = game.Workspace.Village.Radius.Value
me.Size = Vector3.new(radius,radius,radius)
-- Sound
Button.MouseClick:Sound(function(Sound)
	play.Sound()
end)
--Much efficient way to hide the backpack without causing lag

local StarterGui = game:GetService("StarterGui")

StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false)
-- Get points and listen for changes:
local initialPoints = PointsService:GetPoints()
PointsChanged(initialPoints)
PointsService.PointsChanged:Connect(PointsChanged)
--------------------------------------------------------------------
	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
--Zombie.Humanoid.Running:Connect(d)



Zombie.Humanoid.Died:Connect(function()
	script.Parent:Destroy()
end)


Zombie.Humanoid.HealthChanged:Connect(function()
	Zombie.Damage = math.ceil((script.Parent.Humanoid.Health * 1.2) / 2)
end)
-- int rd_int_le(string src, int s, int e)
-- @src - Source binary string
-- @s - Start index of a little endian integer
-- @e - End index of the integer
local function rd_int_le(src, s, e) return rd_int_basic(src, s, e - 1, 1) 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)
--// # key, ally
mouse.KeyDown:connect(function(key)
	if key=="m" then 
		veh.Lightbar.middle.Beep:Play()
		veh.Lightbar.Remotes.AllyEvent:FireServer(true)
	end
end)
--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()
-- Bookkeeping of all active GlobalDataStore/OrderedDataStore interfaces indexed by data table:
local Interfaces = {}
-- 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
--[[**
	<description>
	Takes a function to be called after :Save().
	</description>

	<parameter name = "callback">
	The callback function.
	</parameter>
**--]]
function DataStore:AfterSave(callback)
	table.insert(self.afterSave, callback)
end
-- RbxApi Stuff
local maxChunkSize = 100 * 1000
local ApiJson
if script:FindFirstChild("RawApiJson") then
	ApiJson = script.RawApiJson
else
	ApiJson = ""
end

local jsonToParse = require(ApiJson)

function getRbxApi()
--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}
--- Swaps keys with values, overwriting additional values if duplicated
-- @tparam table orig original table
-- @treturn table
function Table.swapKeyValue(orig)
	local tab = {}
	for key, val in pairs(orig) do
		tab[val] = key
	end
	return tab
end
--[=[
	Gets or creates the global localization table. If the game isn't running (i.e. test mode), then
	we'll just not parent it.

	@return string -- The locale
]=]
function JsonToLocalizationTable.getOrCreateLocalizationTable()
	local localizationTable = LocalizationService:FindFirstChild(LOCALIZATION_TABLE_NAME)

	if not localizationTable then
		localizationTable = Instance.new("LocalizationTable")
		localizationTable.Name = LOCALIZATION_TABLE_NAME

		if RunService:IsRunning() then
			localizationTable.Parent = LocalizationService
		end
	end

	return localizationTable
end
--------END RIGHT DOOR --------
end
wait(0.15)
if game.Workspace.DoorFlashing.Value == true then
--[[
	Render the child component so that ExternalEventConnections can be nested like so:

		Roact.createElement(ExternalEventConnection, {
			event = UserInputService.InputBegan,
			callback = inputBeganCallback,
		}, {
			Roact.createElement(ExternalEventConnection, {
				event = UserInputService.InputEnded,
				callback = inputChangedCallback,
			})
		})
]]
function ExternalEventConnection:render()
	return Roact.oneChild(self.props[Roact.Children])
end

function ExternalEventConnection:didMount()
	local event = self.props.event
	local callback = self.props.callback

	self.connection = event:Connect(callback)
end

function ExternalEventConnection:didUpdate(oldProps)
	if self.props.event ~= oldProps.event or self.props.callback ~= oldProps.callback then
		self.connection:Disconnect()

		self.connection = self.props.event:Connect(self.props.callback)
	end
end

function ExternalEventConnection:willUnmount()
	self.connection:Disconnect()

	self.connection = nil
end

return ExternalEventConnection
--------END BACKLIGHTS--------

end
script.Parent.ClickDetector.MouseClick:connect(onClicked)
--[=[
	@param fn (...: any) -> any
	@return Connection
	Connects a function to the remote signal. The function will be
	called anytime the equivalent server-side RemoteSignal is
	fired at this specific client that created this client signal.
]=]
function ClientRemoteSignal:Connect(fn)
	if self._directConnect then
		return self._re.OnClientEvent:Connect(fn)
	else
		return self._signal:Connect(fn)
	end
end
--Miscellaneous Settings
FADE_TIME,FADE_TWNSTYLE,FADE_TWNDIRECTION 			= nil
IND_TICK_TIME 										= nil
L_BEAM_COLOR,L_BEAM_RANGE,L_BEAM_BRIGHTNESS 		= nil
H_BEAM_COLOR,H_BEAM_RANGE,H_BEAM_BRIGHTNESS			= nil
T_LIGHT_RANGE,T_LIGHT_BRIGHTNESS					= nil
B_LIGHT_RANGE,B_LIGHT_BRIGHTNESS,B_LIGHT_FADE_TIME	= nil
--[[
	Add a new describe node with the given method as a callback. Generates or
	reuses all the describe nodes along the path.
]]
function TestPlan:addRoot(path, method)
	local curNode = self
	for i = #path, 1, -1 do
		local nextNode = nil

		for _, child in ipairs(curNode.children) do
			if child.phrase == path[i] then
				nextNode = child
				break
			end
		end

		if nextNode == nil then
			nextNode = curNode:addChild(path[i], TestEnum.NodeType.Describe)
		end

		curNode = nextNode
	end

	curNode.callback = method
	curNode:expand()
end