Roblox/luau_corpus huggingface dataset:
--Connect Mouse1Down/Up events to the button to register touch input
--Use MouseButton1Down instead of input start to ensure it only registers touches that originate on the button
EnterImageButton.MouseButton1Down:Connect(function()
	if UserInputService:GetLastInputType() == Enum.UserInputType.Touch then
		--Only register it when in touch mode so that PC users dont click on it by accident
		EnterImageButton.ImageTransparency = 1
		EnterImageButton.Pressed.ImageTransparency = 0

		EnterKeyDown = true
		enterStart()
	end
end)

EnterImageButton.MouseButton1Up:Connect(function()
	if UserInputService:GetLastInputType() == Enum.UserInputType.Touch then
		EnterKeyDown = false
		--Return button image to unpressed
		EnterImageButton.ImageTransparency = 0
		EnterImageButton.Pressed.ImageTransparency = 1
	end
end)

EnterImageButton.InputEnded:Connect(function(Input)
	--Use a third connection to prevent the button getting stuck in pressed mode
	if Input.UserInputType == Enum.UserInputType.Touch then
		--Return button image to unpressed, user has stopped touching the button
		EnterImageButton.ImageTransparency = 0
		EnterImageButton.Pressed.ImageTransparency = 1
	end
end)

FlipImageButton.MouseButton1Down:Connect(function()
	if UserInputService:GetLastInputType() == Enum.UserInputType.Touch then
		FlipImageButton.ImageTransparency = 1
		FlipImageButton.Pressed.ImageTransparency = 0
	end
end)

FlipImageButton.MouseButton1Up:Connect(function()
	if UserInputService:GetLastInputType() == Enum.UserInputType.Touch then
		FlipImageButton.ImageTransparency = 0
		FlipImageButton.Pressed.ImageTransparency = 1
		if AdornedSeat then
			if isFlipped(AdornedSeat) then
				flipSeat()
			end
		end
	end
end)

EnterImageButton.InputEnded:Connect(function(Input)
	if Input.UserInputType == Enum.UserInputType.Touch then
		FlipImageButton.ImageTransparency = 0
		FlipImageButton.Pressed.ImageTransparency = 1
	end
end)
----[INITIALIZE VARIABLES]----
function Initialize()
	for i = 1, #ColorPickers do
		table.insert(PreviewColor, ColorPickers[i].PreviewColor)
		table.insert(RGBHolders, ColorPickers[i].RGBValues)
		table.insert(Errors, ColorPickers[i].Parent.Parent.Error)
		local Inputs = { 
			RGBHolders[i].Red.Value, 
			RGBHolders[i].Green.Value, 
			RGBHolders[i].Blue.Value 
		}
	 	local Hitboxes = { 
			RGBHolders[i].Red.Slider.Hitbox, 
			RGBHolders[i].Green.Slider.Hitbox, 
			RGBHolders[i].Blue.Slider.Hitbox 
		}
		local Sliders = { 
			RGBHolders[i].Red.Slider.Hitbox.Slider, 
			RGBHolders[i].Green.Slider.Hitbox.Slider, 
			RGBHolders[i].Blue.Slider.Hitbox.Slider 
		}
		table.insert(RGBInputs, Inputs)
		table.insert(RGBSliderHitboxes, Hitboxes)
		table.insert(RGBSliders, Sliders)
		UpdatePreviewColor(i)
		UpdateRGBSliders(i)
	end
end
Initialize()
------------------------------------------------------------------------
-- stuff
do
	script.Parent.Equipped:Connect(function()
		if player == nil then
			player = game:GetService("Players"):GetPlayerFromCharacter(script.Parent.Parent)
		end
		if character == nil or character.Parent == nil then
			character = script.Parent.Parent
			humanoid = character.Humanoid
				isR15 = humanoid.RigType == Enum.HumanoidRigType.R15
			rightHand = isR15 and character:WaitForChild("RightHand") or character:WaitForChild("Right Arm")
		end
		local getWeld = rightHand:WaitForChild("RightGrip")		
		motor = Instance.new("Motor6D")
		motor.Name = motorName
		motor.Part0 = getWeld.Part0
		motor.Part1 = getWeld.Part1
		--motor.C0 = getWeld.C0
		--motor.C1 = getWeld.C1
		
		getWeld:Destroy()
		motor.Parent = rightHand
	end)
	script.Parent.Unequipped:Connect(function()
		motor:Destroy()
	end)
end
-- Teleport failure handling
function Queue._onTeleportFailure(player, status, message)
	Log.Error.Queue("Teleport Failed: %s (%s)", player.Name, message)

	-- Add this player to the latest queue given that they failed out of the previous one
	Queue._addToQueue(player)
end

function Queue._sendStatus(forcePlayer)
	local waitTime = tick() - _lastTeleport
	local playerCount = Queue._currentQueueCount()

	local status = {
		enabled = Queue._timeoutEnabled,
		waiting_for = Conf.min_queue_players - playerCount,
		max_players = Conf.max_queue_players,
		current_players = playerCount,
		time_remaining = math.max(0, Conf.queue_time_limit - (tick() - _lastTeleport)),
	}

	if forcePlayer then
		Broadcast.fireRemoteClient(forcePlayer, "QUEUE_STATUS", status)
	else
		for player, time in pairs(_currentQueue) do
			Broadcast.fireRemoteClient(player, "QUEUE_STATUS", status)
		end
	end
end

function Queue.new(gameStageHandler)
	local self = setmetatable({
		gameStageHandler = gameStageHandler,
	}, Queue)

	for _, weaponInstance in pairs(WeaponsFolder:GetChildren()) do
		weaponInstance:Clone().Parent = StarterPack
	end

	return self
end

function Queue:playerAdded(player)
	Log.Debug.Queue("Added player %s", player.Name)
	Queue._addToQueue(player)

	----
	-- find the humanoid, and detect when it dies
	player.CharacterAdded:Connect(function(character)
		local humanoid = character:FindFirstChild("Humanoid")

		if humanoid then
			local loading = nil

			humanoid.Died:Connect(function()
				if not loading then
					loading = true
					wait(3)
					Util.loadCharacter(player)
				end
			end)
		end
	end)

	--
	Util.loadCharacter(player)
end

function Queue:playerRemoving(player)
	Log.Debug.Queue("Removed player %s", player.Name)
	Queue._removeFromQueue(player)
end

function Queue:initialize()
	Log.Warn.Queue("STARTING")

	self.requestConn = Broadcast.registerHandler("QUEUE_STATUS_REQUEST", function(player)
		Queue._sendStatus(player)
	end)

	if not WeaponsSystem.doingSetup and not WeaponsSystem.didSetup then
		WeaponsSystem.setup()
	end

	DamageHandler.setup()

	for _, player in ipairs(Players:GetPlayers()) do
		self:playerAdded(player)
	end

	TeleportService.TeleportInitFailed:Connect(Queue._onTeleportFailure)

	if not Conf.disable_queue then
		spawn(function()
			while true do
				local waitTime = tick() - _lastTeleport
				local currentCount = Queue._currentQueueCount()

				if not Queue._timeoutEnabled or waitTime < Conf.queue_time_limit or currentCount < Conf.min_queue_players then
					wait(1)

				else
					Log.Debug.Queue("Queue is progressing.  Buckle up for fun.  *MAXIMUM* fun...")

					Queue._teleportQueue()
				end
			end
		end)
	end

	Log.Warn.Queue("STARTED")
end

function Queue:destroy()
	Broadcast.unregisterHandler(self.requestConn)
end
-- Services
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
local ReplicatedFirst = game:GetService("ReplicatedFirst")
--[[**
	Gets a dictionary of the given group's information.
	@param [Integer] GroupID The group you are checking.
	@returns [Dictionary] The group's information.
**--]]
function GroupService:GetGroupInfoAsync(GroupID)
	local Success, GroupInfo = pcall(RbxGroupService.GetGroupInfoAsync, RbxGroupService, GroupID)
	return Success and GroupInfo or {}
end

return GroupService
--[=[
	Utility methods for promise
	@class PromiseUtils
]=]

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

local Promise = require("Promise")

local PromiseUtils = {}
-- Factor of torque applied to change the wheel direction
-- Larger number generally means faster braking
local BRAKING_TORQUE = 1000
-- A state object whose value is derived from other objects using a callback.
export type ComputedPairs<K, VI, VO> = PubTypes.ComputedPairs<K, VO> & {
	_oldDependencySet: Set<PubTypes.Dependency>,
	_processor: (K, VI) -> VO,
	_destructor: (VO) -> (),
	_inputIsState: boolean,
	_inputTable: PubTypes.CanBeState<{[K]: VI}>,
	_oldInputTable: {[K]: VI},
	_outputTable: {[K]: VO},
	_oldOutputTable: {[K]: VO},
	_keyData: {[K]: {
		dependencySet: Set<PubTypes.Dependency>,
		oldDependencySet: Set<PubTypes.Dependency>,
		dependencyValues: {[PubTypes.Dependency]: any}
	}}
}
--// Animations
local L_140_

function IdleAnim(L_282_arg1)
	L_23_.IdleAnim(L_3_, L_140_, {
		L_30_,
		L_31_,
		L_32_
	});
end;

function EquipAnim(L_283_arg1)
	L_23_.EquipAnim(L_3_, L_140_, {
		L_30_
	});
end;

function UnequipAnim(L_284_arg1)
	L_23_.UnequipAnim(L_3_, L_140_, {
		L_30_
	});
end;

function FireModeAnim(L_285_arg1)
	L_23_.FireModeAnim(L_3_, L_140_, {
		L_30_,
		L_32_,
		L_31_,
		L_40_
	});
end

function ReloadAnim(L_286_arg1)
	L_23_.ReloadAnim(L_3_, L_140_, {
		L_30_,
		L_31_,
		L_32_,
		L_43_,
		L_3_:WaitForChild('Left Arm'),
		L_40_,
		L_34_,
		L_3_:WaitForChild('Right Arm'),
		L_28_
	});
end;

function BoltingBackAnim(L_287_arg1)
	L_23_.BoltingBackAnim(L_3_, L_140_, {
		L_34_
	});
end

function BoltingForwardAnim(L_288_arg1)
	L_23_.BoltingForwardAnim(L_3_, L_140_, {
		L_34_
	});
end

function BoltingForwardAnim(L_289_arg1)
	L_23_.BoltingForwardAnim(L_3_, L_140_, {
		L_34_
	});
end

function BoltBackAnim(L_290_arg1)
	L_23_.BoltBackAnim(L_3_, L_140_, {
		L_34_,
		L_32_,
		L_31_,
		L_30_,
		L_44_
	});
end

function BoltForwardAnim(L_291_arg1)
	L_23_.BoltForwardAnim(L_3_, L_140_, {
		L_34_,
		L_32_,
		L_31_,
		L_30_,
		L_44_
	});
end

function InspectAnim(L_292_arg1)
	L_23_.InspectAnim(L_3_, L_140_, {
		L_32_,
		L_31_
	});
end

function nadeReload(L_293_arg1)
	L_23_.nadeReload(L_3_, L_140_, {
		L_31_,
		L_32_
	});
end
--[[
	Creates a function that invokes a callback with correct error handling and
	resolution mechanisms.
]]
local function createAdvancer(callback, resolve, reject)
	return function(...)
		local resultLength, result = wpcallPacked(callback, ...)
		local ok = result[1]

		if ok then
			resolve(unpack(result, 2, resultLength))
		else
			reject(unpack(result, 2, resultLength))
		end
	end
end

local function isEmpty(t)
	return next(t) == nil
end

local function createSymbol(name)
	assert(type(name) == "string", "createSymbol requires `name` to be a string.")

	local symbol = newproxy(true)

	getmetatable(symbol).__tostring = function()
		return ("Symbol(%s)"):format(name)
	end

	return symbol
end

local PromiseMarker = createSymbol("PromiseMarker")

local Promise = {}
Promise.prototype = {}
Promise.__index = Promise.prototype

Promise.Status = {
	Started = createSymbol("Started"),
	Resolved = createSymbol("Resolved"),
	Rejected = createSymbol("Rejected"),
	Cancelled = createSymbol("Cancelled"),
}
---This function sets the position of the Plot
function module.SetCharVisibility(Char,Amount,Car)
	---Getting the player meshparts and decals
	for _,v in pairs(Char:GetDescendants()) do
		
		if v:IsA("MeshPart") or v:IsA("Part") or v:IsA("BasePart") then
			if Amount > 0 then
				v.CollisionGroupId = 3
			else
				v.CollisionGroupId = 0
			end
		end
		---Checking what the model is
		if v:IsA("MeshPart") or v:IsA("Decal") or v:IsA("Part") and v.Name ~= "HumanoidRootPart" then
			v.Transparency = Amount
		end
		
		---Modifying name tag
	--	local Nametag = Char.HumanoidRootPart.NameTag
		local ExtendSize = nil
		
		if Car ~= nil then
			if Car:IsA("Model") then
				ExtendSize = Car:GetExtentsSize()
			elseif Car.Parent:IsA("Model") then
				ExtendSize = Car.Parent:GetExtentsSize()
			end
		end
		
		--if ExtendSize ~= nil then
		--	if ExtendSize.Y > 8 then
		--		Nametag.ExtentsOffsetWorldSpace = Vector3.new(0,4 + ExtendSize.Y - 8, 0)
		--		Nametag.MaxDistance = 40
		--	else
		--		Nametag.ExtentsOffsetWorldSpace = Vector3.new(0,4,0)
		--		Nametag.MaxDistance = 40
		--	end
		--else
		--	Nametag.ExtentsOffsetWorldSpace = Vector3.new(0,4,0)
		--	Nametag.MaxDistance = 85
		--end
		
		---Modifying camera zoom
		if Amount > 0 then
			game.Players:GetPlayerFromCharacter(Char).CameraMinZoomDistance = 10
		else
			game.Players:GetPlayerFromCharacter(Char).CameraMinZoomDistance = 0.5
		end
	end
	
end


return module
--edit the function below to return true when you want this response/prompt to be valid
--player is the player speaking to the dialogue, and dialogueFolder is the object containing the dialogue data
return function(player, dialogueFolder)
	local plrData = require(game.ReplicatedStorage.Source.Modules.Util):GetPlayerData(player)
	if plrData.Money.Gold.Value > 8 then
		return true
	end
	return false
end
--- Color ---

button.MouseEnter:Connect(function()
	local Color = Color3.fromRGB(60, 60, 60)
	TweenService:Create(button, Info, {BackgroundColor3 = Color}):Play()
end)

button.MouseLeave:Connect(function()
	local ColorColor = Color3.fromRGB(43, 43, 43)
	TweenService:Create(button, Info, {BackgroundColor3 = ColorColor}):Play()
end)
--This may seem odd, but it is necessary. If there are any _possible_ WeaponsSystem modules in the datamodel,
--we may have found them before they've been installed in ReplicatedStorage, so CollectionService's added signal
--won't run again for them. This means we should switch to waiting for Heartbeat instead of waiting for another
--weapons system to be added.
local anyPossible = searchForWeaponsSystem()
while not WeaponsSystemFolder do
	if anyPossible then
		RunService.Heartbeat:Wait()
	else
		CollectionService:GetInstanceAddedSignal(WEAPONS_SYSTEM_TAG):Wait()
	end
	anyPossible = searchForWeaponsSystem()
end
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 6000		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 6000		--		Use sliders to manipulate values
	Tune.Redline		= 6700		--		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)
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 500		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 9000		--		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)
--[=[
	@within TableUtil
	@function SwapRemove
	@param tbl table -- Array
	@param i number -- Index

	Removes index `i` in the table by swapping the value at `i` with
	the last value in the array, and then trimming off the last
	value from the array.

	This allows removal of the value at `i` in `O(1)` time, but does
	not preserve array ordering. If a value needs to be removed from
	an array, but ordering of the array does not matter, using
	`SwapRemove` is always preferred over `table.remove`.

	In the following example, we remove "B" at index 2. SwapRemove does
	this by moving the last value "E" over top of "B", and then trimming
	off "E" at the end of the array:
	```lua
	local t = {"A", "B", "C", "D", "E"}
	TableUtil.SwapRemove(t, 2) -- Remove "B"
	print(t) --> {"A", "E", "C", "D"}
	```

	:::note Arrays only
	This function works on arrays, but not dictionaries.
]=]
local function SwapRemove(t: Table, i: number)
	local n = #t
	t[i] = t[n]
	t[n] = nil
end
-- goro7

local plr = game.Players.LocalPlayer

game.ReplicatedStorage.Interactions.Client.WaitForMapLoad.OnClientInvoke = function(map, referenceCount)

	-- Wait until complete
	repeat
		wait(0.25)
	until referenceCount - #map:GetDescendants() <= 10

end
-- The maximum distance the can can shoot, this value should never go above 1000
local Range = 600
------------------------------------------------------------------------
-- subexpr -> (simpleexp | unop subexpr) { binop subexpr }
-- where 'binop' is any binary operator with a priority higher than 'limit'
-- * for priority lookups with self.priority[], 1=left and 2=right
-- * recursively called
-- * used in expr()
------------------------------------------------------------------------
function luaY:subexpr(ls, v, limit)
  self:enterlevel(ls)
  local uop = self:getunopr(ls.t.token)
  if uop ~= "OPR_NOUNOPR" then
    luaX:next(ls)
    self:subexpr(ls, v, self.UNARY_PRIORITY)
    luaK:prefix(ls.fs, uop, v)
  else
    self:simpleexp(ls, v)
  end
  -- expand while operators have priorities higher than 'limit'
  local op = self:getbinopr(ls.t.token)
  while op ~= "OPR_NOBINOPR" and self.priority[luaK.BinOpr[op] + 1][1] > limit do
    local v2 = {}  -- expdesc
    luaX:next(ls)
    luaK:infix(ls.fs, op, v)
    -- read sub-expression with higher priority
    local nextop = self:subexpr(ls, v2, self.priority[luaK.BinOpr[op] + 1][2])
    luaK:posfix(ls.fs, op, v, v2)
    op = nextop
  end
  self:leavelevel(ls)
  return op  -- return first untreated operator
end
-- Local private variables and constants
local ZERO_VECTOR2 = Vector2.new(0,0)
local ZERO_VECTOR3 = Vector3.new(0,0,0)

local tweenAcceleration = math.rad(220) -- Radians/Second^2
local tweenSpeed = math.rad(0)          -- Radians/Second
local tweenMaxSpeed = math.rad(250)     -- Radians/Second
local TIME_BEFORE_AUTO_ROTATE = 2       -- Seconds, used when auto-aligning camera with vehicles

local INITIAL_CAMERA_ANGLE = CFrame.fromOrientation(math.rad(-15), 0, 0)
local ZOOM_SENSITIVITY_CURVATURE = 0.5
local FIRST_PERSON_DISTANCE_MIN = 0.5

local cameraOffset = ZERO_VECTOR3
local CAMERA_OFFSET_SMOOTHNESS = 0.175
--!strict
--[[
	A 'Symbol' is an opaque marker type.

	Symbols have the type 'userdata', but when printed to the console, the name
	of the symbol is shown.
]]

local Symbol = {}
--[[---------------- SERVICES -----------------]]--

local contextActionService = game:GetService("ContextActionService")
local runService = game:GetService("RunService")
local repStoreService = game:GetService("ReplicatedStorage")
--------END CREW--------

game.Workspace.RRProjector.Decal.Texture = "http://www.roblox.com/asset/?id="..(game.Workspace.CustomScreen.Value)..""

end
end

script.Parent.ClickDetector.MouseClick:connect(onClicked)
--// States
local L_64_ = false
local L_65_ = false
local L_66_ = false
local L_67_ = false
local L_68_ = false
local L_69_ = true
local L_70_ = false
local L_71_ = false
local L_72_ = false
local L_73_ = false
local L_74_ = false
local L_75_ = false
local L_76_ = false
local L_77_ = false
local L_78_ = false
local L_79_ = false

local L_80_ = false
local L_81_ = false
local L_82_ = false

local L_83_ = false
local L_84_ = true
local L_85_ = true

local L_86_ = false

local L_87_
local L_88_

local L_89_
local L_90_
local L_91_

local L_92_ = L_24_.FireMode

local L_93_ = 0
local L_94_ = false
local L_95_ = true
local L_96_ = false

local L_97_ = 70

local L_98_ = L_2_.PlayerGui:FindFirstChild('AimSFX') or Instance.new('Sound')
L_98_.Parent = L_2_.PlayerGui
--[[Weight and CG]]
	Tune.Weight			= 2600		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		6		,
	 --[[Height]]		3.5		,
	 --[[Length]]		14		}
	Tune.WeightDist		= 50		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible
	
	--Unsprung Weight
	Tune.FWheelDensity	= .1		-- Front Wheel Density
	Tune.RWheelDensity	= .1		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]
	
	Tune.AxleSize		= 2			-- Size of structural members (larger = more stable/carry more weight)
	Tune.AxleDensity	= .1		-- Density of structural members
---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- 

input.InputBegan:connect(function(inputObject)
	
	if inputObject.UserInputType == Enum.UserInputType.Keyboard then
		if inputObject.KeyCode == CanToggleMouse.activationkey then
			if CanToggleMouse.allowed and freemouse == false then
				freemouse = true
			else
				freemouse = false
			end
		end
	end
	
end)
--- Cleans up all tasks.
-- @alias Destroy
function Maid:DoCleaning()
	local tasks = self._tasks

	-- Disconnect all events first as we know this is safe
	for index, job in pairs(tasks) do
		if typeof(job) == "RBXScriptConnection" then
			tasks[index] = nil
			job:Disconnect()
		end
	end

	-- Clear out tasks table completely, even if clean up tasks add more tasks to the maid
	local index, job = next(tasks)
	while job ~= nil do
		tasks[index] = nil
		if type(job) == "function" then
			job()
		elseif type(job) == "thread" then
			local cancelled
			if coroutine.running() ~= job then
				cancelled = pcall(function()
					task.cancel(job)
				end)
			end

			if not cancelled then
				local toCancel = job
				task.defer(function()
					task.cancel(toCancel)
				end)
			end
		elseif typeof(job) == "RBXScriptConnection" then
			job:Disconnect()
		elseif job.Destroy then
			job:Destroy()
		end
		index, job = next(tasks)
	end
end
-- Basic settings
local ROTATION_SPEED = 0.1
local tweenService = game:GetService("TweenService")

while true do
	
	-- Wait
	local waitTime = wait()
	
	-- Tween to rotate
	local goal = {
		CFrame = script.Parent.CFrame * CFrame.fromEulerAnglesXYZ(0, 0, ROTATION_SPEED)
	}
	tweenService:Create(script.Parent, TweenInfo.new(waitTime, Enum.EasingStyle.Linear, Enum.EasingDirection.Out), goal):Play()
	
end
-- update bruv
wait(1)
RunService.RenderStepped:Connect(function()

	for i,v in pairs(workspace.Map:GetChildren()) do

		local CamPos = workspace.CurrentCamera.CFrame.Position
		local vPos = v:GetPivot().Position

		CamPos = Vector3.new(CamPos.X, 0, CamPos.Z)
		vPos = Vector3.new(vPos.X, 0, vPos.Z)
		local dist = (CamPos - vPos).Magnitude

		dist = dist - 3000
		if dist < 0 then
			dist = 0
		end
		dist = dist*dist/3000
		local currentPos = CFrame.new(v:GetAttribute("OriginalPosition") - Vector3.new(0, dist/50, 0)).Position
	--[[
	local refinedPosHeight
	if v:isA("BasePart") then
		refinedPosHeight = Vector3.new(0, currentPos.Y + v.Size.Y/2, 0)
	else
		local cframe, size = v:GetBoundingBox()
		refinedPosHeight = Vector3.new(0, currentPos.Y + size.Y/2, 0)
	end

	if refinedPosHeight.Y < CamPos.Y - 200 then
		dist = 1000000
	end
	]]
		if not isPositionOnScreen(v:GetAttribute("OriginalPosition") - Vector3.new(0, dist/50, 0)) then
			dist = 100000000

			v:PivotTo(CFrame.new(v:GetAttribute("OriginalPosition") - Vector3.new(0, dist/50, 0)) * v:GetPivot().Rotation)
		elseif isPositionOnScreen(v:GetAttribute("OriginalPosition") - Vector3.new(0, dist/50, 0)) then
			v:PivotTo(CFrame.new(v:GetAttribute("OriginalPosition") - Vector3.new(0, dist/50, 0)) * v:GetPivot().Rotation)
		end


	end
end)
-- Public Constructors

function DropdownClass.new(button, listFrame)
	local self = setmetatable({}, DropdownClass)
	
	self._Maid = Lazy.Utilities.Maid.new()
	self._ChangedBind = Instance.new("BindableEvent")
	self._Options = {}
	self._Selected = nil
	
	self.Button = button
	self.ListFrame = listFrame
	self.Changed = self._ChangedBind.Event
	
	init(self)
	self:Set(self._Options[1])
	
	return self
end

function DropdownClass.Create(list, max)
	max = max or #list
	
	local button = DROP_BUTTON:Clone()
	local listFrame = Lazy.Constructors.List.Create(list, max)
	
	listFrame.Position = UDim2.new(0, 0, 1, 0)
	listFrame.Size = UDim2.new(1, 0, max, 0)
	listFrame.Visible = false
	listFrame.Parent = button
	
	return DropdownClass.new(button, listFrame)
end