Roblox/luau_corpus huggingface dataset:
--// Localize
log("Localize");
local Localize = service.Localize
os = Localize(os)
math = Localize(math)
table = Localize(table)
string = Localize(string)
coroutine = Localize(coroutine)
Instance = Localize(Instance)
Vector2 = Localize(Vector2)
Vector3 = Localize(Vector3)
CFrame = Localize(CFrame)
UDim2 = Localize(UDim2)
UDim = Localize(UDim)
Ray = Localize(Ray)
Rect = Localize(Rect)
Faces = Localize(Faces)
Color3 = Localize(Color3)
NumberRange = Localize(NumberRange)
NumberSequence = Localize(NumberSequence)
NumberSequenceKeypoint = Localize(NumberSequenceKeypoint)
ColorSequenceKeypoint = Localize(ColorSequenceKeypoint)
PhysicalProperties = Localize(PhysicalProperties)
ColorSequence = Localize(ColorSequence)
Region3int16 = Localize(Region3int16)
Vector3int16 = Localize(Vector3int16)
BrickColor = Localize(BrickColor)
TweenInfo = Localize(TweenInfo)
Axes = Localize(Axes)
task = Localize(task)
--// F key, Horn
mouse.KeyUp:connect(function(key)
	if key=="h" then 
		script.Parent.Parent.Horn.TextTransparency = 0.15
		veh.Lightbar.middle.Airhorn:Stop()
		veh.Lightbar.middle.Wail.Volume = 3
		veh.Lightbar.middle.Yelp.Volume = 3
		veh.Lightbar.middle.Priority.Volume = 3
		script.Parent.Parent.MBOV.Visible = true
			script.Parent.Parent.MBOV.Text = "Made by OfficerVargas"
	end
end)
-- constants

local PLAYER	= Players.LocalPlayer
local EVENTS	= ReplicatedStorage:WaitForChild("Events")
local REMOTES	= ReplicatedStorage:WaitForChild("Remotes")
local MODULES	= ReplicatedStorage:WaitForChild("Modules")
	local CONFIG	= require(MODULES:WaitForChild("Config"))
	local MOUSE		= require(MODULES:WaitForChild("Mouse"))
	local EFFECTS	= require(MODULES:WaitForChild("Effects"))
	local DAMAGE	= require(MODULES:WaitForChild("Damage"))
	local INPUT		= require(MODULES:WaitForChild("Input"))
	
local EQUIP_COOLDOWN	= 0.2
------------------------------------------------------------------------
--
-- * used in luaK:goiftrue(), luaK:codenot()
------------------------------------------------------------------------
function luaK:invertjump(fs, e)
  local pc = self:getjumpcontrol(fs, e.info)
  assert(luaP:testTMode(luaP:GET_OPCODE(pc)) ~= 0 and
             luaP:GET_OPCODE(pc) ~= "OP_TESTSET" and
             luaP:GET_OPCODE(pc) ~= "OP_TEST")
  luaP:SETARG_A(pc, (luaP:GETARG_A(pc) == 0) and 1 or 0)
end
--[=[
	Pops an entry from the right of the queue
	@return T
]=]
function Queue:PopRight()
	if self._first > self._last then
		error("Queue is empty")
	end

	local value = self[self._last]
	self[self._last] = nil
	self._last = self._last - 1

	return value
end
-- Create a Translate function that uses a fallback translator if the first fails to load or return successfully. You can also set the referenced object to default to the generic game object

function TranslationHelper.translate(text, object)
	if not object then
		object = game
	end
	local translation = ""
	local foundTranslation = false
	if foundPlayerTranslator then
		return playerTranslator:Translate(object, text)
	end
	if foundFallbackTranslator then
		return fallbackTranslator:Translate(object, text)
	end
	return false
end
-- UI --
local main = script.Parent.Parent.Parent.Parent:WaitForChild("main")
local petUI = main.PetUI
local ScrollingFrame = petUI.Pets
local UIGridLayout = ScrollingFrame.UIGridLayout
local shrinkOn = petUI.Shrink.ShrinkOn

local getSizes = function()
	if shrinkOn.Value == true then
		return Vector2.new(0.02, 0.03),Vector2.new(0.225, 0.275),5
	else
		return Vector2.new(0.03, 0.04),Vector2.new(0.3, 0.35),3
	end
end
--[[
	Keeps track of a single spot on a surface canvas. Manages the art item on a single spot, and
	the owner of the art item.
]]
local HttpService = game:GetService("HttpService")

local Spot = {}
Spot.__index = Spot

function Spot.new()
	local self = {
		id = HttpService:GenerateGUID(false),

		-- ID of the applied art
		artId = nil,

		ownerUserId = nil,

		-- Event to fire as a callback whenever the art on this spot changes.
		onArtChanged = nil,
	}

	setmetatable(self, Spot)

	return self
end

function Spot:applyArt(player, artId)
	self.artId = artId
	self.ownerUserId = player.UserId

	if self.onArtChanged then
		self.onArtChanged(self.artId, self.ownerUserId)
	end
end
-- << MAIN >>
while true do	
	sound.SoundId = "rbxassetid://"..music_list[pos]
	pos = pos + 1
	sound:Play()
	sound.Ended:Wait()
	if pos > #music_list then
		pos = 1
	end
end
--[=[
	Fires for the current key the given value
	@param key TKey
	@param ... TEmit
]=]
function ObservableSubscriptionTable:Fire(key, ...)
	assert(key ~= nil, "Bad key")

	local subs = self._subMap[key]
	if not subs then
		return
	end

	-- Make a copy so we don't have to worry about our last changing
	for _, sub in pairs(table.clone(subs)) do
		task.spawn(sub.Fire, sub, ...)
	end
end

function ObservableSubscriptionTable:Complete(key, ...)
	local subs = self._subMap[key]
	if not subs then
		return
	end

	local subsToComplete = table.clone(subs)
	self._subMap[key] = nil

	for _, sub in pairs(subsToComplete) do
		task.spawn(sub.Complete, sub, ...)
	end
end
-- CONFIG
local WHOLE_BODY_DETECTION_LIMIT = 729000 -- This is roughly the volume where Region3 checks begin to exceed 0.5% in Script Performance
-- LOCAL METHODS
local function checkTopbarEnabled()
	local success, bool = xpcall(function()
		return starterGui:GetCore("TopbarEnabled")
	end,function(err)
		--has not been registered yet, but default is that is enabled
		return true	
	end)
	return (success and bool)
end
--[=[
	Yields the thread until a `:Fire` call occurs, returns what the signal was fired with.

	```lua
	task.spawn(function()
		print(
			ScriptSignal:Wait()
		)
	end)

	ScriptSignal:Fire("Arg", nil, 1, 2, 3, nil)
	-- "Arg", nil, 1, 2, 3, nil are printed
	```

	@yields
	@return ...any
	@ignore
]=]
function ScriptSignal:Wait(): (...any)
	local thread do
		thread = coroutine.running()

		local connection
		connection = self:Connect(function(...)
			connection:Disconnect()
			task.spawn(thread, ...)
		end)
	end

	return coroutine.yield()
end
-------------------------------------------------------
--Start HeartBeat--
-------------------------------------------------------
ArtificialHB = Instance.new("BindableEvent", script)
ArtificialHB.Name = "Heartbeat"
script:WaitForChild("Heartbeat")

frame = 1 / 60
tf = 0
allowframeloss = false
tossremainder = false


lastframe = tick()
script.Heartbeat:Fire()


game:GetService("RunService").Heartbeat:connect(function(s, p)
	tf = tf + s
	if tf >= frame then
		if allowframeloss then
			script.Heartbeat:Fire()
			lastframe = tick()
		else
			for i = 1, math.floor(tf / frame) do
				script.Heartbeat:Fire()
			end
			lastframe = tick()
		end
		if tossremainder then
			tf = 0
		else
			tf = tf - frame * math.floor(tf / frame)
		end
	end
end)
-- Watch for newly playing tracks in workspace.Music, change script.Parent.MusicName to the Sound's name
-- When script.Parent.TextBox is changed, change the volume of all children of workspace.Music

MusicUI = script.Parent

MusicUI.TextBox.FocusLost:Connect(function()
	for i,v in pairs(workspace.Music:GetChildren()) do
		v.Volume = MusicUI.TextBox.Text
	end
end)

for _,Sound in pairs(workspace.Music:GetChildren()) do
	Sound:GetPropertyChangedSignal("Playing"):Connect(function()
		if Sound.Playing == true then
			MusicUI.MusicName.Text = Sound.Name
		end
	end)
end
-- This function is called when a player says something in the chat
function onPlayerChatted(player, message)
	 -- Check if the message is the same as the player's secret
	 if message == tostring(secret) then
		 -- If the message is the same as the secret, kick the player with a custom message
		 player:Kick("You couldn't keep a secret")
		 end
end
-- While Falling

while wait(0.1) do
	
if script.Parent.UpperTorso.Velocity.Magnitude > 70 then
	
	script.Parent.Head.ScreamFall:Play()
	
	wait(35)
	
end
	
end
-- functions
script.Parent.Text = "I FINISHED!"
wait(2)
game.ReplicatedStorage.Kicker:FireAllClients()
--Pre-Toggled PBrake
for i,v in pairs(car.Wheels:GetChildren()) do
	if v["#AV"]:IsA("BodyAngularVelocity") then
		if math.abs(v["#AV"].maxTorque.Magnitude-PBrakeForce)<1 then
			_PBrake=true
		end
	else
		if math.abs(v["#AV"].MotorMaxTorque-PBrakeForce)<1 then
			_PBrake=true
		end
	end
end
-- Tags --

local pantsId = script.Parent.Parent.Pants.PantsTemplate
local shirtId = script.Parent.Parent.Shirt.ShirtTemplate
local cPart = script.Parent
local cDetector = script.Parent.ProximityPrompt





local function onClicked(player)
	if player.Team.TeamColor == BrickColor.new("Maroon")then




	local foundShirt = player.Character:FindFirstChild("Shirt") -- Tries to find Shirt
	if not foundShirt then -- if there is no shirt
		print("No shirt found, creating for "..player.Name)
		local newShirt = Instance.new("Shirt",player.Character)
		newShirt.Name = "Shirt"
	else if foundShirt then -- if there is a shirt
			print("Shirt found, reconstructing for "..player.Name)
			player.Character.Shirt:remove()
			local newShirt = Instance.new("Shirt",player.Character)
			newShirt.Name = "Shirt"
		end
	end




	local foundPants = player.Character:FindFirstChild("Pants") -- Tries to find Pants
	if not foundPants then -- if there are no pants
		print("No pants found, creating for "..player.Name)
		local newPants = Instance.new("Pants",player.Character)
		newPants.Name = "Pants"
	else if foundPants then -- if there are pants
			print("Pants found, reconstructing for "..player.Name)
			player.Character.Pants:remove()
			local newPants = Instance.new("Pants",player.Character)
			newPants.Name = "Pants"
		end
	end

	player.Character.Shirt.ShirtTemplate = shirtId
	player.Character.Pants.PantsTemplate = pantsId
	end
end
--[[
	Returns the a count of all items in the local player's inventory that
	are in a given category
--]]

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local PlayerDataClient = require(ReplicatedStorage.Source.PlayerData.Client)
local Sift = require(ReplicatedStorage.Dependencies.Sift)
local PlayerDataKey = require(ReplicatedStorage.Source.SharedConstants.PlayerDataKey)
local ItemCategory = require(ReplicatedStorage.Source.SharedConstants.ItemCategory)

local function countInventoryItemsInCategory(itemCategory: ItemCategory.EnumType)
	local inventory = PlayerDataClient.get(PlayerDataKey.Inventory)
	local itemCounts = Sift.Dictionary.values(inventory[itemCategory] or {})
	local totalItemCount = Sift.Array.reduce(itemCounts, function(a: number, b: number)
		return a + b
	end) or 0

	return totalItemCount
end

return countInventoryItemsInCategory
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]

local mouse = game.Players.LocalPlayer:GetMouse()
local car = script.Parent.Car.Value
local horn = car.DriveSeat:WaitForChild("Horn")
local FE = workspace.FilteringEnabled
local handler = car:WaitForChild("Lights_FE")

mouse.KeyDown:connect(function(key)
	if key=="h" then
		if FE then
			handler:FireServer()
			
		else
			horn:Play()
		end		
	end
end)

game:GetService("UserInputService").InputBegan:connect(function(input,IsRobloxFunction)
	if input.KeyCode ==Enum.KeyCode.ButtonB and input.UserInputState == Enum.UserInputState.Begin then
		if FE then
			handler:FireServer()
		else
			horn:Play()
		end
	end
end)
--// Handling Settings		
	Firerate = 60 / 800; -- 60 = 1 Minute, 800 = Rounds per that 60 seconds. DO NOT TOUCH THE 60!
	
	FireMode = 2; -- 1 = Semi, 2 = Auto, 3 = Burst, 4 = Bolt Action, 5 = Shot, 6 = Explosive
--!nocheck
local Player = game.Players.LocalPlayer
local Character = game.Players.LocalPlayer.Character
local Humanoid = game.Players.LocalPlayer.Character:WaitForChild("Humanoid") :: Humanoid

local ev

local died = false
function death()
	if died then return end
	died = true
	local gs:ModuleScript = game.Players.LocalPlayer.PlayerScripts.Client.ControlScript.Player.GameSettings
	local gs = require(gs) -- ROBLOX SHUT UPI
	gs.lives -= 1
	
	print("death client")
	game.ReplicatedStorage.Remotes.Respawn:FireServer()
	ev:Disconnect()
end

ev = game:GetService("RunService").RenderStepped:Connect(function()
	if Humanoid.Health <= 0 then
		death()
	end
end)
-- How many times per second the gun can fire
local FireRate = 0.12 / 1
--TODO: add a parameter that instead welds the tool to the HumanoidRootPart.
function AnimateLib.Motor6DFromGrip(tool, rightArm)
	local m = Instance.new("Motor6D");
	m.C0 = CFrame.new(0, -1, 0, 1, 0, -0, 0, 0, 1, 0, -1, 0);
	m.C1 = Utils.Math.CFrameFromComponents(tool.GripPos, tool.GripRight, tool.GripUp, -tool.GripForward);
	m.Part0 = rightArm;
	m.Part1 = tool:FindFirstChild('Handle');
	m.Parent = rightArm;
	m.Name = "RightGrip";
	return m;
end
-- local plr=script.Parent.Parent.Parent.Parent.Parent
local plr = Players.LocalPlayer -- or Players:GetPropertyChangedSignal("LocalPlayer"):wait()
-- Adds a service to this provider only
function ServiceBag:_addServiceType(serviceType)
	if not self._serviceTypesToInitializeSet then
		error(("Already finished initializing, cannot add %q"):format(self:_getServiceName(serviceType)))
		return
	end

	-- Already added
	if self._services[serviceType] then
		return
	end

	-- Construct a new version of this service so we're isolated
	local service = setmetatable({}, { __index = serviceType })
	self._services[serviceType] = service

	self:_ensureInitialization(serviceType)
end

function ServiceBag:_ensureInitialization(serviceType)
	if self._initializedServiceTypeSet[serviceType] then
		return
	end

	if self._initializing then
		self._serviceTypesToInitializeSet[serviceType] = nil
		self._initializedServiceTypeSet[serviceType] = true
		self:_initService(serviceType)
	elseif self._serviceTypesToInitializeSet then
		self._serviceTypesToInitializeSet[serviceType] = true
	else
		local serviceName = self:_getServiceName(serviceType)
		error(string.format("Cannot initialize service %q past initializing phase", serviceName))
	end
end

function ServiceBag:_initService(serviceType)
	local service = assert(self._services[serviceType], "No service")
	local serviceName = self:_getServiceName(serviceType)

	if service.Init then
		local current
		task.spawn(function()
			debug.setmemorycategory(serviceName)
			current = coroutine.running()
			service:Init(self)
		end)

		local isDead = coroutine.status(current) == "dead"
		if not isDead then
			error(("Initializing service %q yielded"):format(serviceName))
		end
	end

	table.insert(self._serviceTypesToStart, serviceType)
end
--------END RIGHT DOOR --------

game.Workspace.post1.Light.BrickColor = BrickColor.new(106)
game.Workspace.post2.Light.BrickColor = BrickColor.new(106)
end
wait(0.15)
--Weld stuff here


car.DriveSeat.ChildAdded:connect(function(child)
	if child.Name=="SeatWeld" and child:IsA("Weld") and game.Players:GetPlayerFromCharacter(child.Part1.Parent)~=nil then
		child.C0=CFrame.new(0,-.6,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0)
	end
end)
-- Disable it by default. The PreShowVenue will enable it when it wants.
setFriendsLocatorEnabled(false)
--h.Health = h.Health - 2
if game.Players:FindFirstChild(hit.Parent.Name) ~= nil then
	local player = game.Players:FindFirstChild(hit.Parent.Name)
	local gui = script.Parent.MaceGui:clone() 
	gui.Parent = player.PlayerGui
	gui.Script.Disabled = false
	end
end
end
script.Parent.Touched:connect(onTouched)
--// Return values: bool filterSuccess, bool resultIsFilterObject, variant result
function methods:InternalApplyRobloxFilterNewAPI(speakerName, message) --// USES FFLAG
	local alwaysRunFilter = false
	local runFilter = RunService:IsServer() -- and not RunService:IsStudio()
	if (alwaysRunFilter or runFilter) then
		local fromSpeaker = self:GetSpeaker(speakerName)
		if fromSpeaker == nil then
			return false, nil, nil
		end
		
		local fromPlayerObj = fromSpeaker:GetPlayer()
		if fromPlayerObj == nil then
			return true, false, message
		end

		local success, filterResult = pcall(function()
			local ts = game:GetService("TextService")
			local result = ts:FilterStringAsync(message, fromPlayerObj.UserId)
			return result
		end)
		if (success) then
			return true, true, filterResult
		else
			warn("Error filtering message:", message)
			self:InternalNotifyFilterIssue()
			return false, nil, nil
		end
	else
		--// Simulate filtering latency.
		task.wait(0.2)
		return true, false, message
	end

	return nil
end

function methods:InternalDoMessageFilter(speakerName, messageObj, channel)
	local filtersIterator = self.FilterMessageFunctions:GetIterator()

	for funcId, func, priority in filtersIterator do
		local success, errorMessage = pcall(function()
			func(speakerName, messageObj, channel)
		end)

		if not success then
			warn(string.format("DoMessageFilter Function '%s' failed for reason: %s", funcId, errorMessage))
		end
	end
end

function methods:InternalDoProcessCommands(speakerName, message, channel)
	local commandsIterator = self.ProcessCommandsFunctions:GetIterator()

	for funcId, func, priority in commandsIterator do
		local success, returnValue = pcall(function()
			local ret = func(speakerName, message, channel)
			if type(ret) ~= "boolean" then
				error("Process command functions must return a bool")
			end
			return ret
		end)

		if not success then
			warn(string.format("DoProcessCommands Function '%s' failed for reason: %s", funcId, returnValue))
		elseif returnValue then
			return true
		end
	end

	return false
end

function methods:InternalGetUniqueMessageId()
	local id = self.MessageIdCounter
	self.MessageIdCounter = id + 1
	return id
end

function methods:InternalAddSpeakerWithPlayerObject(speakerName, playerObj, fireSpeakerAdded)
	if (self.Speakers[speakerName:lower()]) then
		error("Speaker \"" .. speakerName .. "\" already exists!")
	end

	local speaker = Speaker.new(self, speakerName)
	speaker:InternalAssignPlayerObject(playerObj)
	self.Speakers[speakerName:lower()] = speaker

	if fireSpeakerAdded then
		local success, err = pcall(function() self.eSpeakerAdded:Fire(speakerName) end)
		if not success and err then
			print("Error adding speaker: " ..err)
		end
	end

	return speaker
end

function methods:InternalFireSpeakerAdded(speakerName)
	local success, err = pcall(function() self.eSpeakerAdded:Fire(speakerName) end)
	if not success and err then
		print("Error firing speaker added: " ..err)
	end
end
-- Place script in workspace.

print("Cash Leaderboard Loaded")


function onPlayerEntered(newPlayer)

	local stats = Instance.new("IntValue")
	stats.Name = "leaderstats"

	local cash = Instance.new("IntValue")
	cash.Name = "Wins"
	cash.Value = 0

	cash.Parent = stats
	stats.Parent = newPlayer
end



game.Players.ChildAdded:connect(onPlayerEntered)
--2--
script.Parent.Parent.ll2.Transparency = 1
script.Parent.Parent.l2.Transparency = 1
script.Parent.Parent.h2.Transparency = 1
script.Parent.Parent.rr2.Transparency = 1
end

function onClicked()
	
	if isOn == true then off() else on() end

end

script.Parent.ClickDetector.MouseClick:connect(onClicked)

on()
------ Locales ------

local CaseData = script.Parent.CaseData
local InformationData = script.Parent.Parent.Parent.CaseInformationFrame.Information
local InformationVariables = script.Parent.Parent.Parent.CaseInformationFrame.Variables
local Button = script.Parent
--[[ Local Functions ]]--
local function setJumpModule(isEnabled)
	if not isEnabled then
		TouchJumpModule:Disable()
	elseif CurrentControlModule == ControlModules.Thumbpad or CurrentControlModule == ControlModules.Thumbstick or
		CurrentControlModule == ControlModules.Default then
		--
		TouchJumpModule:Enable()
	end
end

local function setClickToMove()
	if DevMovementMode == Enum.DevTouchMovementMode.ClickToMove or DevMovementMode == Enum.DevComputerMovementMode.ClickToMove or
		UserMovementMode == Enum.ComputerMovementMode.ClickToMove or UserMovementMode == Enum.TouchMovementMode.ClickToMove then
		--
		if IsTouchDevice then
			ClickToMoveTouchControls = CurrentControlModule or ControlModules.Default
		end
	else
		if IsTouchDevice and ClickToMoveTouchControls then
			ClickToMoveTouchControls:Disable()
			ClickToMoveTouchControls = nil
		end
	end
end
--------------------) Settings
Damage = 0 -- the ammout of health the player or mob will take

Cooldown = 2 -- cooldown for use of the tool again

BoneModelName = "Extreme bone area" -- name the zone model

HumanoidName = "Humanoid"-- the name of player or mob u want to damage
-- local noColor = printSnapshot.noColor
local printExpected = printSnapshot.printExpected
local printPropertiesAndReceived = printSnapshot.printPropertiesAndReceived
local printReceived = printSnapshot.printReceived
local printSnapshotAndReceived = printSnapshot.printSnapshotAndReceived

local types = require(CurrentModule.types)
type MatchSnapshotConfig = types.MatchSnapshotConfig

local utils = require(CurrentModule.utils)

local _toMatchSnapshot, _toThrowErrorMatchingSnapshot

local DID_NOT_THROW = "Received function did not throw"
local NOT_SNAPSHOT_MATCHERS = "Snapshot matchers cannot be used with " .. BOLD_WEIGHT("never")
-- the Tool, reffered to here as "Block." Do not change it!
Block = script.Parent.Parent.Gear -- You CAN change the name in the quotes "Example Tool"
-- Set local variables
local player = players:GetPlayerFromCharacter(script.Parent)
local character = player.Character or player.CharacterAdded:wait()
local humanoid = character.Humanoid

local oldWalkSpeed
--[[
	
	HOW TO USE THIS PLUGIN:
	
	In the body, set all of the lights you want to use as follows:
	
	Li		-indicates the left indicator
	Ri		-indicates the right indicator
	
	HLL		-indicates the low beam headlights
	HLH		-indicates the high beam headlights
	
	BL		-indicates the brake light
	RRL		-indicates the rer running light
	
	RevL	-indicates the reverse light
	
	You can name multiple parts as any of the above.
		
]]--
--!strict
local indexOf = require(script.Parent.indexOf)
type Array<T> = { [number]: T }

return function<T>(array: Array<T>, searchElement: any, fromIndex: number?): boolean
	return indexOf(array, searchElement, fromIndex) ~= -1
end
-- Captions
function Icon:setCaption(text)
	assert(typeof(text) == "string" or text == nil, "Expected string, got "..typeof(text))
	self.captionText = text
	self.instances.captionLabel.Text = text
	self.instances.captionContainer.Parent = (text and activeItems) or self.instances.iconContainer
	self:_updateIconSize(nil, self:getToggleState())
	if self.hovering then
		self:_displayCaption(true)
	end
	return self
end

function Icon:_displayCaption(visibility)
	local newVisibility = visibility
	if self.captionText == nil then
		return
	elseif userInputService.TouchEnabled and not self._draggingFinger then
		return
	end
	local yOffset = 8
	if self._draggingFinger then
		yOffset = yOffset + THUMB_OFFSET
	end
	local iconContainer = self.instances.iconContainer
	local captionContainer = self.instances.captionContainer
	local newPos = UDim2.new(0, iconContainer.AbsolutePosition.X+iconContainer.AbsoluteSize.X/2-captionContainer.AbsoluteSize.X/2, 0, iconContainer.AbsolutePosition.Y+(iconContainer.AbsoluteSize.Y*2)+yOffset)
	captionContainer.Position = newPos
	-- Change transparency of relavent caption instances
	for _, settingName in pairs(self._uniqueSettings.caption) do
		self:_update(settingName)
	end
end
-- this is here to make it possible to avoid huge dependency trees just for types
export type TransformResult = {
	code: string,
	originalCode: string,
	sourceMapPath: string | nil,
}
return {}
-- Get the policy info for the user
local success, result = pcall(PolicyService.GetPolicyInfoForPlayerAsync, PolicyService, player)
if success and result then
	if not result.AreAdsAllowed then
		-- Destroy all Main Portal Template instances on the user's client if ads are not allowed
		mainPortal:Destroy()
	end
else
	print("Failed to get policy for player", player.Name, "Exception:", result)
end
-----------------
--| Variables |--
-----------------

local DebrisService = Game:GetService('Debris')
local PlayersService = Game:GetService('Players')

local MyPlayer = PlayersService.LocalPlayer

local Tool = script.Parent
local ToolHandle = Tool.Handle

local RocketScript = script:WaitForChild('Rocket')
local SwooshSound = script:WaitForChild('Swoosh')
local BoomSound = script:WaitForChild('Boom')
--[[**
	ensures Roblox UDim2 type

	@param value The value to check against

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