Roblox/luau_corpus huggingface dataset:
-- -- -- -- -- -- --
--DIRECTION SCROLL--
-- -- -- -- -- -- --

Lift:WaitForChild("Direction").Changed:connect(function(val)
	if val == 1 then
		This.Display.ARW1.U1.BrickColor = BrickColor.new("Institutional white")
		This.Display.ARW1.U2.BrickColor = BrickColor.new("Institutional white")
		This.Display.ARW1.M1.BrickColor = BrickColor.new("Institutional white")
		This.Display.ARW1.M2.BrickColor = BrickColor.new("Institutional white")
		This.Display.ARW1.D1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.D2.BrickColor = BrickColor.new("Really black")
	elseif val == -1 then
		This.Display.ARW1.U1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.U2.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.M1.BrickColor = BrickColor.new("Institutional white")
		This.Display.ARW1.M2.BrickColor = BrickColor.new("Institutional white")
		This.Display.ARW1.D1.BrickColor = BrickColor.new("Institutional white")
		This.Display.ARW1.D2.BrickColor = BrickColor.new("Institutional white")
	else
		This.Display.ARW1.U1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.U2.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.M1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.M2.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.D1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.D2.BrickColor = BrickColor.new("Really black")
	end
end)
--[[*
 * Test `input` with the given `regex`. This is used by the main
 * `picomatch()` function to test the input string.
 *
 * ```js
 * const picomatch = require('picomatch');
 * // picomatch.test(input, regex[, options]);
 *
 * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
 * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
 * ```
 * @param {String} `input` String to test.
 * @param {RegExp} `regex`
 * @return {Object} Returns an object with matching info.
 * @api public
 ]]

function picomatch.test(input: string, regex: RegExp, options: Object?, ref_: Object?)
	local ref: Object = ref_ or {}
	local glob, posix = ref.glob, ref.posix

	if typeof(input) ~= "string" then
		error(Error.new("TypeError: Expected input to be a string"))
	end

	if input == "" then
		return { isMatch = false, output = "" }
	end

	local opts: Object = options or {}
	local format = if Boolean.toJSBoolean(opts.format)
		then opts.format
		else if Boolean.toJSBoolean(posix) then utils.toPosixSlashes else nil
	local match = input == glob
	local output = if match and Boolean.toJSBoolean(format) then format(input) else input

	if match == false then
		output = if Boolean.toJSBoolean(format) then format(input) else input
		match = output == glob
	end

	if match == false or opts.capture == true then
		if opts.matchBase == true or opts.basename == true then
			match = picomatch.matchBase(input, regex, options, posix)
		else
			-- ROBLOX FIXME: Luau narrows the type to boolean and doesn't allow for result of RegExp:exec to be assigned
			match = regex:exec(output) :: any
		end
	end

	return { isMatch = Boolean.toJSBoolean(match), match = match, output = output }
end
--[[*
 * Use invariant() to assert state which your program assumes to be true.
 *
 * Provide sprintf-style format (only %s is supported) and arguments
 * to provide information about what broke and what you were
 * expecting.
 *
 * The invariant message will be stripped in production, but the invariant
 * will remain to ensure logic does not differ in production.
]]
local Packages = script.Parent.Parent
local LuauPolyfill = require(Packages.LuauPolyfill)
local Error = LuauPolyfill.Error

local function invariant(condition, format, ...)
	-- ROBLOX TODO: we should encapsulate all formatting compatibility here,
	-- rather than spreading workarounds throughout the codebase, eg this
	-- should print an array without the need for a table.concat on the consumer side
	if not condition then
		error(Error(string.format(format, ...)))
	end
end

return invariant
-- -- -- -- -- -- --
--DIRECTION SCROLL--
-- -- -- -- -- -- --

This.Parent.Parent.Parent.Parent:WaitForChild("Direction", 120).Changed:connect(function(val)
	if val == 1 then
		This.Frame.Direction.Text = "▲"
		repeat
			for i = 0.2, -0.8, -0.02 do
				This.Frame.Direction.UIGradient.Offset = Vector2.new(0,i)
				wait()
			end
		until This.Parent.Parent.Parent.Parent.Direction.Value ~= 1
	elseif val == -1 then
		This.Frame.Direction.Text = "▼"
		repeat
			for i = -0.8, 0.2, 0.02 do
				This.Frame.Direction.UIGradient.Offset = Vector2.new(0,i)
				wait()
			end
		until This.Parent.Parent.Parent.Parent.Direction.Value ~= -1
	else
		This.Frame.Direction.Text = ""
	end
end)
--[[
Creates a bridge.
--]]
return function(StartPos,EndPos,InnerSectionCount,Parent)
	local DistanceBetween = (EndPos - StartPos).magnitude
	local BridgeLength = math.ceil(DistanceBetween/8) * 8
	local CenterCF = CFrame.new(StartPos,EndPos) * CFrame.new(0,0,-DistanceBetween/2)
	
	--Create the container.
	local Container = Instance.new("Model")
	Container.Name = "Bridge"
	Container.Parent = Parent
	
	--Create the spines.
	local Spines = {}
	local SpineCount = InnerSectionCount + 1
	for i = 1,SpineCount do
		local Spine = Instance.new("Part")
		Spine.BrickColor = BrickColor.new("Dark stone grey")
		Spine.CFrame = CenterCF * CFrame.new(6 * ((-SpineCount/2) - 0.5 + i),0,0)
		Spine.Size = Vector3.new(2,1,BridgeLength - 2)
		Spine.Anchored = true
		Spine.Parent = Container
		
		table.insert(Spines,Spine)
	end
	
	--Create the path parts.
	local RelativeOffsetStart = CFrame.new(0,1,-(BridgeLength/2) + 4)
	local BridgeSections = BridgeLength/8
	local Floors = {}
	local FloorCount = InnerSectionCount + 2
	for i = 1,FloorCount do
		local RowSections = {}
		table.insert(Floors,RowSections)
		
		for j = 0,BridgeSections - 1 do
			local RelativeOffset = RelativeOffsetStart * CFrame.new(0,0,8 * j)
			local SectionCF = CenterCF * RelativeOffset
		
			local PathPart = Instance.new("Part")
			PathPart.BrickColor = BrickColor.new("Medium stone grey")
			PathPart.CFrame = SectionCF * CFrame.new(6 * ((-SpineCount/2) - 1 + i),0,0)
			PathPart.Size = Vector3.new(6,1,8)
			PathPart.Parent = Container
			if Spines[i - 1] then WeldBetween(Spines[i - 1],PathPart) end
			if Spines[i] then WeldBetween(Spines[i],PathPart) end
			table.insert(RowSections,PathPart)
		end
	end
	
	--Create the sides.
	for i = 0,BridgeSections - 1 do
		local RelativeOffset = RelativeOffsetStart * CFrame.new(0,0,8 * i)
		local SectionCF = CenterCF * RelativeOffset
		
		--Create the left side.
		local LeftSide = Instance.new("Part")
		LeftSide.BrickColor = BrickColor.new("Medium stone grey")
		LeftSide.CFrame = SectionCF * CFrame.new(-(6 * (FloorCount/2)) + 1,1.25,0)
		LeftSide.Size = Vector3.new(2,1.5,8)
		LeftSide.Parent = Container
		WeldBetween(LeftSide,Floors[1][i + 1])
		
		local LeftTop = Instance.new("Part")
		LeftTop.BrickColor = BrickColor.new("Dark stone grey")
		LeftTop.CFrame = SectionCF * CFrame.new(-(6 * (FloorCount/2)) + 1,2.5,0)
		LeftTop.Size = Vector3.new(2,1,8)
		LeftTop.Parent = Container
		WeldBetween(LeftSide,LeftTop)
		
		--Create the right side.
		local RightSide = Instance.new("Part")
		RightSide.BrickColor = BrickColor.new("Medium stone grey")
		RightSide.CFrame = SectionCF * CFrame.new((6 * (FloorCount/2)) - 1,1.25,0)
		RightSide.Size = Vector3.new(2,1.5,8)
		RightSide.Parent = Container
		WeldBetween(RightSide,Floors[#Floors][i + 1])
		
		local RightTop = Instance.new("Part")
		RightTop.BrickColor = BrickColor.new("Dark stone grey")
		RightTop.CFrame = SectionCF * CFrame.new((6 * (FloorCount/2)) - 1,2.5,0)
		RightTop.Size = Vector3.new(2,1,8)
		RightTop.Parent = Container
		WeldBetween(RightSide,RightTop)
	end
end
--fs.Reflectance = 0
--bs.Reflectance = 0
end
if val1.Value > 120 and val1.Value <= 130 then
ch1m.MaxVelocity = 0.6+(val1.Value-120)*0.005
ch2m.MaxVelocity = 0.6+(val1.Value-120)*0.005
ch3m.MaxVelocity = 0.6+(val1.Value-120)*0.005
ch1.Transparency = 1
ch2.Transparency = 1
ch3.Transparency = 1
fs.Transparency = 1-(val1.Value-120)*0.01
bs.Transparency = 1-(val1.Value-120)*0.01
-- Import relevant references
Selection = Core.Selection;
Create = Core.Create;
Support = Core.Support;
Security = Core.Security;
Support.ImportServices();
--Aesthetics	
Tune.SusVisible		= false			-- Spring Visible
Tune.WsBVisible		= false			-- Wishbone Visible
Tune.SusRadius		= .2			-- Suspension Coil Radius
Tune.SusThickness	= .1			-- Suspension Coil Thickness
Tune.SusColor		= "Really black"	-- Suspension Color [BrickColor]
Tune.SusCoilCount	= 8			-- Suspension Coil Count
Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
Tune.WsThickness	= .1			-- Wishbone Rod Thickness
-- Helper function to recursively set the collision group on an object and all of
-- its children
local function setCollisionGroupRecursive(object, group)
	if object:IsA("BasePart") then
		PhysicsService:SetPartCollisionGroup(object, group)
	end
	for _, child in ipairs(object:GetChildren()) do
		setCollisionGroupRecursive(child, group)
	end
end
--[[
	React does a lot of catching, retrying, and rethrowing errors that would
	typically result in loss of meaningful stack information.

	We use xpcall combined with this error function to capture and rethrow in a
	way that retains some stack information.
]]
local function describeError(e: string | Error): Error
	if typeof(e) == "string" then
		local _, endOfStackFrame = string.find(e, ":[%d]+: ")
		local message = if endOfStackFrame then string.sub(e, endOfStackFrame + 1) else e

		local err = LuauPolyfill.Error.new(message)
		err.stack = debug.traceback(nil, 2)
		return err
	end
	return e :: Error
end
--[[[Default Controls]]
--Peripheral Deadzones
Tune.Peripherals = {
	MSteerWidth				= 67		,	-- Mouse steering control width	(0 - 100% of screen width)
	MSteerDZone				= 10		,	-- Mouse steering deadzone (0 - 100%)

	ControlLDZone			= 5			,	-- Controller steering L-deadzone (0 - 100%)
	ControlRDZone			= 5			,	-- Controller steering R-deadzone (0 - 100%)
}
-- Auto saving and issue queue managing:
RunService.Heartbeat:Connect(function()
	-- 1) Auto saving: --
	local auto_save_list_length = #AutoSaveList
	if auto_save_list_length > 0 then
		local auto_save_index_speed = SETTINGS.AutoSaveProfiles / auto_save_list_length
		local os_clock = os.clock()
		while os_clock - LastAutoSave > auto_save_index_speed do
			LastAutoSave = LastAutoSave + auto_save_index_speed
			local profile = AutoSaveList[AutoSaveIndex]
			if os_clock - profile._load_timestamp < SETTINGS.AutoSaveProfiles then
				-- This profile is freshly loaded - auto-saving immediately after loading will cause a warning in the log:
				profile = nil
				for _ = 1, auto_save_list_length - 1 do
					-- Move auto save index to the right:
					AutoSaveIndex = AutoSaveIndex + 1
					if AutoSaveIndex > auto_save_list_length then
						AutoSaveIndex = 1
					end
					profile = AutoSaveList[AutoSaveIndex]
					if os_clock - profile._load_timestamp >= SETTINGS.AutoSaveProfiles then
						break
					else
						profile = nil
					end
				end
			end
			-- Move auto save index to the right:
			AutoSaveIndex = AutoSaveIndex + 1
			if AutoSaveIndex > auto_save_list_length then
				AutoSaveIndex = 1
			end
			-- Perform save call:
			if profile ~= nil then
				task.spawn(SaveProfileAsync, profile) -- Auto save profile in new thread
			end
		end
	end
	-- 2) Issue queue: --
	-- Critical state handling:
	if ProfileService.CriticalState == false then
		if #IssueQueue >= SETTINGS.IssueCountForCriticalState then
			ProfileService.CriticalState = true
			ProfileService.CriticalStateSignal:Fire(true)
			CriticalStateStart = os.clock()
			warn("[ProfileService]: Entered critical state")
		end
	else
		if #IssueQueue >= SETTINGS.IssueCountForCriticalState then
			CriticalStateStart = os.clock()
		elseif os.clock() - CriticalStateStart > SETTINGS.CriticalStateLast then
			ProfileService.CriticalState = false
			ProfileService.CriticalStateSignal:Fire(false)
			warn("[ProfileService]: Critical state ended")
		end
	end
	-- Issue queue:
	while true do
		local issue_time = IssueQueue[1]
		if issue_time == nil then
			break
		elseif os.clock() - issue_time > SETTINGS.IssueLast then
			table.remove(IssueQueue, 1)
		else
			break
		end
	end
end)
--------------------------------------------------------------------------

local _WHEELTUNE = {
																		--[[	
			SS6 Presets
	[Eco]		
		WearSpeed = 1,
		TargetFriction = .7,
		MinFriction = .1,
	[Road]		
		WearSpeed = 2,
		TargetFriction = .7,
		MinFriction = .1,
	[Sport]		
		WearSpeed = 3,
		TargetFriction = .79,
		MinFriction = .1,											]]

	TireWearOn 		= true	,
	
	--Friction and Wear
	FWearSpeed		= 2.0	,
	FTargetFriction	= 1.6	,
	FMinFriction 	= 1	,
	
	RWearSpeed		= 4.0	,
	RTargetFriction	= 2.5	,
	RMinFriction	= 1	,
	
	--Tire Slip
	TCSOffRatio		= 1/3	,
	WheelLockRatio	= 1/2	,	--SS6 Default = 1/4
	WheelspinRatio	= 1/1.1	,	--SS6 Default = 1/1.2
	
	--Wheel Properties
	FFrictionWeight	= 1		,	--SS6 Default = 1
	RFrictionWeight	= 1		,	--SS6 Default = 1
	FLgcyFrWeight	= 10	,
	RLgcyFrWeight	= 10	,
	
	FElasticity		= 0		,	--SS6 Default = .5
	RElasticity		= 0		,	--SS6 Default = .5
	FLgcyElasticity	= 0		,
	RLgcyElasticity	= 0		,
	
	FElastWeight	= 1		,	--SS6 Default = 1
	RElastWeight	= 1		,	--SS6 Default = 1
	FLgcyElWeight	= 10	,
	RLgcyElWeight	= 10	,
	
	--Wear Regen
	RegenSpeed		= 9.8		--SS6 Default = 3.6
}
-------------------------
while true do
Puerta1.BodyVelocity.velocity = Vector3.new(0, 0, 0.5)
Puerta2.BodyVelocity.velocity = Vector3.new(0, 0, -0.5)
script.Parent.Bloqueador.CanCollide = true
wait(6)
Puerta1.BodyVelocity.velocity = Vector3.new(0, 0, 0)
Puerta2.BodyVelocity.velocity = Vector3.new(0, 0, 0)
break
end
-- This value is exposed as a private value so that the test code can stay in
-- sync with what event we listen to for dispatching the Changed event.
-- It may not be Heartbeat in the future.
Store._flushEvent = RunService.Heartbeat

Store.__index = Store
--[[**
	ensures Roblox ColorSequenceKeypoint type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
t.ColorSequenceKeypoint = primitive("ColorSequenceKeypoint")
-- Variables

local gui = script.Parent
local player = game.Players.LocalPlayer
local character = player.Character
local humanoid = character.Humanoid
local bfCreateIndicator = gui.CreateIndicator
--[=[
	@deprecated v1.3.0 -- Use `Signal:Once` instead.
	@param fn ConnectionFn
	@return SignalConnection
]=]
function Signal:ConnectOnce(fn)
	return self:Once(fn)
end
--Set up controller events.
UserInputService.GamepadConnected:Connect(UpdateActiveButton)
UserInputService.GamepadDisconnected:Connect(UpdateActiveButton)
GuiService.Changed:Connect(UpdateActiveButton)

return ControllerGroups
-- Denotes children instances in an instance or component's property table.
export type SpecialKey = {
	type: string, -- replace with "SpecialKey" when Luau supports singleton types
	kind: string,
	stage: string, -- replace with "self" | "descendants" | "ancestor" | "observer" when Luau supports singleton types
	apply: (SpecialKey, value: any, applyTo: Instance, cleanupTasks: {Task}) -> ()
}
--[ Get Items ]--
local HoldKey = script:WaitForChild("HoldKey")

local Humanoid = Avatar:WaitForChild("Humanoid")
local Torso = Avatar:WaitForChild("Torso")
local RH = Torso:WaitForChild("Right Hip")
local LH = Torso:WaitForChild("Left Hip")

local RL = Avatar:WaitForChild("Right Leg")
local LL = Avatar:WaitForChild("Left Leg")

local RJ = Avatar:WaitForChild("HumanoidRootPart"):WaitForChild("RootJoint")
--Input Mode 
if UIS.GamepadEnabled then
	Input.InputMode = "Gamepad"
elseif UIS.TouchEnabled then
	Input.InputMode = "Touch"
	spawn(RunTouchControls)
end
-- Decompiled with the Synapse X Luau decompiler.

return function(p1, p2, ...)
	local v1 = "";

		for v2, v3 in ipairs({ ... }) do
		if not v2 then
			break;
		end;
		if v1 == "" then
			v1 = "+ " .. v3;
		else
			v1 = v1 .. "\n+ " .. v3;
		end;	
	end;
	p1.desc.Text = v1;
end;
------------------------------------------------------------------------------
--------------------[ FUNCTIONS ]---------------------------------------------
------------------------------------------------------------------------------

local CreateShockwave = function(Center, Radius)
	local Shockwave = Instance.new("Part")
	Shockwave.BrickColor = S.ShockwaveColor
	Shockwave.Material = Enum.Material.SmoothPlastic
	Shockwave.Name = "Shockwave"
	Shockwave.Anchored = true
	Shockwave.CanCollide = false
	Shockwave.FormFactor = Enum.FormFactor.Symmetric
	Shockwave.Size = VEC3(1, 1, 1)
	Shockwave.BottomSurface = Enum.SurfaceType.Smooth
	Shockwave.TopSurface = Enum.SurfaceType.Smooth
	local Mesh = Instance.new("SpecialMesh")
	Mesh.MeshType = Enum.MeshType.Sphere
	Mesh.Scale = VEC3()
	Mesh.Parent = Shockwave
	Shockwave.Parent = Main.Parent
	Shockwave.CFrame = CF(Center)
	spawn(function()
		for i = 0, 1, 1 / (30 * S.ShockwaveDuration) do
			local Scale = 2 * Radius * i
			Mesh.Scale = VEC3(Scale, Scale, Scale)
			Shockwave.Transparency = i
			wait()
		end
		Shockwave:Destroy()
	end)
end

local AdvRayCast = function(Origin, Direction, Dist, CustomIgnore)
	local NewIgnore = (CustomIgnore and CustomIgnore or Ignore)
	local NewRay = Ray.new(Origin, Direction * (Dist > 999 and 999 or Dist))
	local HitObj, HitPos = game.Workspace:FindPartOnRayWithIgnoreList(NewRay, NewIgnore)
	local LastPos = HitPos
	local FinalHitObj, FinalHitPos = nil, nil
	local RepTimes = math.floor(Dist / 999)
	if (not HitObj) and (Dist > 999) then
		for i = 0, RepTimes do
			local NewDist = (i == RepTimes and  (Dist - (LastPos - Origin).magnitude) or 999)
			local Ray2 = Ray.new(LastPos, Direction * NewDist)
			local HitObj2, HitPos2 = game.Workspace:FindPartOnRayWithIgnoreList(Ray2, NewIgnore)
			if i ~= RepTimes then
				if HitObj2 then
					FinalHitObj, FinalHitPos = HitObj2, HitPos2
					break
				end
			elseif i == RepTimes then
				FinalHitObj, FinalHitPos = HitObj2, HitPos2
			end
			LastPos = HitPos2
		end
		return FinalHitObj, FinalHitPos
	elseif HitObj or (Dist <= 999) then
		return HitObj, HitPos
	end
end

local FindFirstClass = function(Object, Class)
	local FoundObject = nil
	for _, Obj in pairs(Object:GetChildren()) do
		if Obj.ClassName == Class then
			FoundObject = Obj
			break
		end
	end
	return FoundObject
end

local IsEnemy = function(Human)
	local HitPlyr = game.Players:GetPlayerFromCharacter(Human.Parent)
	if (not HitPlyr) then return S.CanDamageNPCs end
	return S.AllowFriendlyFire or (HitPlyr.TeamColor ~= Plyr.Value.TeamColor or HitPlyr.Neutral)
end

local IsIgnored = function(Obj)
	for _,v in pairs(Ignore) do
		if Obj == v or Obj:IsDescendantOf(v) then
			return true
		end
	end
	return false
end

local MarkHit = function()
	spawn(function()
		local Gui_Clone = Plyr.Value:WaitForChild("PlayerGui"):WaitForChild("Main_Gui")
		local HitMarker = Gui_Clone:WaitForChild("HitMarker")
		
		HitMarker.Visible = true
		local StartMark = tick()
		HitMarker.LastMark.Value = StartMark
		
		wait(0.5)
		
		if HitMarker.LastMark.Value <= StartMark then
			HitMarker.Visible = false
		end
	end)
end
-- you can use this script for a jeff shop or something but rn it just destroys it

local Prox = script.Parent.ProximityPrompt

Prox.Triggered:Connect(function(Player)
	--game.ReplicatedStorage.(ITEM NAME).Parent = Player.Backpack
	script.Parent.Parent:Destroy()
end)
-- Local Functions
local function waitForUpdate(stringLabel)
	if stringLabel._updating then
		repeat wait() until not stringLabel._updating
		
		wait()
	end
end

local function calculateLines(text, font, frameSize)
	local screenGui = Instance.new("ScreenGui", game:GetService("StarterGui"))
	
	local recursivelyCalculate = nil
	recursivelyCalculate = function(str, textSize, lines)
		local label = Instance.new("TextLabel", screenGui)
		label.Size = UDim2.new(0, frameSize.X, 0, frameSize.Y)
		label.Font = font
		label.TextSize = textSize
		label.Text = str
		
		if not label.TextFits then
			local words = {}
			local newStr1 = ""
			local newStr2 = ""
			
			for v in string.gmatch(str, "%S+") do
				table.insert(words, v)
			end
			
			for index, word in ipairs(words) do
				if index <= #words / 2 then
					newStr1 = newStr1 .. word .. " "
				else
					newStr2 = newStr2 .. word .. " "
				end
			end

			recursivelyCalculate(newStr1:sub(1, -2), textSize / 2, lines)
			recursivelyCalculate(newStr2:sub(1, -2), textSize / 2, lines)
		else
			table.insert(lines, str)
		end
		
		label:Destroy()
		
		return textSize / #lines
	end
	
	local lines = {}
	local textSize = recursivelyCalculate(text, frameSize.Y, lines)
	
	screenGui:Destroy(text)
	
	return lines, textSize
end
-- -- -- -- -- -- --
--DIRECTION SCROLL--
-- -- -- -- -- -- --


Lift:WaitForChild("Velocity").Changed:connect(function(vel)
    if vel > 0 then
		This.Display.ARW1.U1.BrickColor = BrickColor.new("Lime green")
		This.Display.ARW1.U2.BrickColor = BrickColor.new("Lime green")
		This.Display.ARW1.U3.BrickColor = BrickColor.new("Lime green")
		This.Display.ARW1.D1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.D2.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.D3.BrickColor = BrickColor.new("Really black")
    elseif vel < 0 then
		This.Display.ARW1.U1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.U2.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.U3.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.D1.BrickColor = BrickColor.new("Lime green")
		This.Display.ARW1.D2.BrickColor = BrickColor.new("Lime green")
		This.Display.ARW1.D3.BrickColor = BrickColor.new("Lime green")
	else
		This.Display.ARW1.U1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.U2.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.U3.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.D1.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.D2.BrickColor = BrickColor.new("Really black")
		This.Display.ARW1.D3.BrickColor = BrickColor.new("Really black")
    end
end)
-- Decompiled with the Synapse X Luau decompiler.

local v1 = require(game.ReplicatedStorage:WaitForChild("Resources"));
while not v1.Loaded do
	game:GetService("RunService").Heartbeat:Wait();
end;
local v4
local v8
local u1 = nil;
local function v2()
	local l__MouseEnabled__3 = v1.UserInputService.MouseEnabled;
	 v4 = false;
	local v5 = false;
	local v6 = false;
	local v7 = false;
	if v1.UserInputService.GamepadEnabled then
		v7 = true;
	elseif v1.GuiService:IsTenFootInterface() then
		if not l__MouseEnabled__3 then
			v7 = true;
		elseif v1.UserInputService.VREnabled then
			v4 = true;
			v6 = v1.Settings.SupportsVR or false;
		elseif v1.UserInputService.TouchEnabled then
			if not l__MouseEnabled__3 then
				v5 = true;
			elseif not v1.UserInputService.GyroscopeEnabled then
				if v1.UserInputService.AccelerometerEnabled then
					v5 = true;
				else
					v6 = true;
				end;
			else
				v5 = true;
			end;
		elseif not v1.UserInputService.GyroscopeEnabled then
			if v1.UserInputService.AccelerometerEnabled then
				v5 = true;
			else
				v6 = true;
			end;
		else
			v5 = true;
		end;
	elseif v1.UserInputService.VREnabled then
		v4 = true;
		v6 = v1.Settings.SupportsVR or false;
	elseif v1.UserInputService.TouchEnabled then
		if not l__MouseEnabled__3 then
			v5 = true;
		elseif not v1.UserInputService.GyroscopeEnabled then
			if v1.UserInputService.AccelerometerEnabled then
				v5 = true;
			else
				v6 = true;
			end;
		else
			v5 = true;
		end;
	elseif not v1.UserInputService.GyroscopeEnabled then
		if v1.UserInputService.AccelerometerEnabled then
			v5 = true;
		else
			v6 = true;
		end;
	else
		v5 = true;
	end;
	if v6 then
		 v8 = "Desktop";
	elseif v5 then
		v8 = "Mobile";
	elseif v7 then
		v8 = "Console";
	else
		v8 = v4 
	end;
	v1.Variables.Desktop = v6;
	v1.Variables.Mobile = v5;
	v1.Variables.Console = v7;
	v1.Variables.VR = v4;
	if v8 ~= u1 then
		u1 = v8;
		v1.Signal.Fire("Changed Platform", v8);
	end;
end;
v1.UserInputService.GamepadConnected:Connect(v2);
v1.UserInputService.GamepadDisconnected:Connect(v2);
task.defer(function()
	while true do
		v2();
		task.wait(3);	
	end;
end);