Pinkstack/roblox-luau-corpus-text huggingface dataset:
-- Remove this after you've become acquainted with EventSequencer


if RunService:IsStudio() then
	-- Best practice is to configure this ahead of time and don't use this
	-- This is for demo purposes so that it works out of the box
	Players.PlayerAdded:Connect(function(player)
		table.insert(playerIDs, player.UserId)
		EventSequencer.setSeekingPermissions({
			-- Replace this with non-production PlaceIds 
			placeIDs = {game.PlaceId},
			groups = {
				-- Replace this if you want certain groups allowed
				-- The following is an example of one group permissions
				{GroupID = 7384468, MinimumRankID = 5}
			},
			-- Replace this with known player IDs in a table
			playerIDs = playerIDs
		})
	end)
	
	local playersService = game:GetService("Players")
	local playerAdded = function(player)
		if not table.find(playerIDs, player.UserId) then
			table.insert(playerIDs, player.UserId)
		end
	end
	playersService.PlayerAdded:connect(playerAdded)
	for _, player in ipairs(playersService:GetPlayers()) do
		playerAdded(player)
	end
	
	EventSequencer.setSeekingPermissions({
		-- Replace this with non production PlaceIds 
		placeIDs = {game.PlaceId},
		groups = {
			-- Replace this if you want certain groups allowed
			-- The following is an example of one group permission
			{GroupID = 7384468, MinimumRankID = 5}
		},
		-- Replace this with known player IDs in a table
		playerIDs = playerIDs
	})
end
-- Implements Javascript's `Array.prototype.filter` as defined below
-- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter


return function<T, U>(t: Array<T>, callback: callbackFn<T> | callbackFnWithThisArg<T, U>, thisArg: U?): Array<T>
	if _G.__DEV__ then
		if typeof(t) ~= "table" then
			error(string.format("Array.filter called on %s", typeof(t)))
		end
		if typeof(callback) ~= "function" then
			error("callback is not a function")
		end
	end

	local len = #t
	local res = {}
	local index = 1

	if thisArg == nil then
		for i = 1, len do
			local kValue = t[i]
			if kValue ~= nil then
				if (callback :: callbackFn<T>)(kValue, i, t) then
					res[index] = kValue
					index += 1
				end
			end
		end
	else
		for i = 1, len do
			local kValue = t[i]
			if kValue ~= nil then
				if (callback :: callbackFnWithThisArg<T, U>)(thisArg, kValue, i, t) then
					res[index] = kValue
					index += 1
				end
			end
		end
	end

	return res
end
--game:GetService("UserInputService").InputBegan:Connect(function(input)
--	local c = 0
--	if input.KeyCode == Enum.KeyCode.One then
--		c = Start(1)
--	elseif input.KeyCode == Enum.KeyCode.Two then
--		c = Start(2)
--	elseif input.KeyCode == Enum.KeyCode.Three then
--		c = Start(3)
--	elseif input.KeyCode == Enum.KeyCode.Four then
--		c = Start(4)
--	elseif input.KeyCode == Enum.KeyCode.Five then
--		c = Start(5)
--	elseif input.KeyCode == Enum.KeyCode.Six then
--		c = Start(6)
--	elseif input.KeyCode == Enum.KeyCode.Seven then
--		c = Start(7)
--	elseif input.KeyCode == Enum.KeyCode.Eight then
--		c = Start(8)
--	elseif input.KeyCode == Enum.KeyCode.Nine then
--		c = Start(9)
--	elseif input.KeyCode == Enum.KeyCode.Zero then
--		c = Start(0)
--	end
--end)




while wait(.01) do
	local b = 360/#nodes
	c = script.Parent.HumanoidRootPart.Position
	a=a+3
	for i,n in pairs(nodes) do
		local b = a + i*(360/#nodes)
		x = math.cos(math.rad(b)+math.rad(a))
		z = math.sin(math.rad(b)+math.rad(a))
		n.BodyPosition.Position = (c+Vector3.new(x,0,z)*dist)+Vector3.new(0,math.sin(b*.05)*height,0)
		n.CFrame = CFrame.new(n.Position,c)
	end
end
--Funcion Del AutoClick


local plr = script.Parent.Parent.Parent

local lea = plr:WaitForChild("leaderstats")-- Nombre De La Carpeta De Su Sistema De Dinero
local gold = lea:WaitForChild("TimesClicked")-- Nombre De Su Sistema De Dinero
local coin = lea:WaitForChild("Coins")-- Nombre De Su Sistema De Dinero
local boost = plr:WaitForChild("CoinBoost")-- Nombre De Su Sistema De Dinero
local world = plr:WaitForChild("WorldBoost")-- Nombre De Su Sistema De Dinero
local autoclick = false
local autoclickDD = false
function GetAuto()
	gold.Value = gold.Value +1 --Cambiar Por Cuanto Dinero Quieres Que Obtenga
	coin.Value = coin.Value + 1 + 1*boost.Value*world.Value
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(.1)-- Tambien Cambia Para El Tiempo De Espera Al Recargar
			autoclickDD = false
		end
	end
end
--[[Susupension]]


	Tune.SusEnabled		= true		-- works only in with PGSPhysicsSolverEnabled, defaults to false when PGS is disabled
	
	--Front Suspension
	Tune.FSusDamping	= 100		-- Spring Dampening
	Tune.FSusStiffness	= 9000		-- Spring Force
	Tune.FSusLength		= 8			-- Suspension length (in studs)
	Tune.FSusMaxExt		= .4		-- Max Extension Travel (in studs)
	Tune.FSusMaxComp	= .4		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 50		-- Suspension Angle (degrees from horizontal)
		
	Tune.FWsBoneLen		= 5			-- Wishbone Length
	Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward
	
	--Rear Suspension
	Tune.RSusDamping	= 100		-- Spring Dampening
	Tune.RSusStiffness	= 9000		-- Spring Force
	Tune.RSusLength		= 8			-- Suspension length (in studs)
	Tune.RSusMaxExt		= .4		-- Max Extension Travel (in studs)
	Tune.RSusMaxComp	= .4		-- Max Compression Travel (in studs)
	Tune.RSusAngle		= 50		-- Suspension Angle (degrees from horizontal)
		
	Tune.RWsBoneLen		= 5			-- Wishbone Length
	Tune.RWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Aesthetics	
	Tune.SusVisible		= true			-- Spring Visible
	Tune.WsBVisible		= true			-- Wishbone Visible
	Tune.SusRadius		= .2			-- Suspension Coil Radius
	Tune.SusThickness	= .5			-- Suspension Coil Thickness
	Tune.SusColor		= "Really black"	-- Suspension Color [BrickColor]
	Tune.SusCoilCount	= 8				-- Suspension Coil Count
	Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
	Tune.WsThickness	= .5			-- Wishbone Rod Thickness
--[[Transmission]]


	Tune.TransModes		= {"Auto"}								--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch
		
		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}								
		>First mode is default mode													]]
	
	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]	
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)
	
	--Gear Ratios
	Tune.FinalDrive		= 3.31			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.70		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.53		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.04		,
		--[[ 3 ]]		1.38		,
		--[[ 4 ]]		1.03		,
		--[[ 5 ]]		0.81		,
		--[[ 6 ]]		0.64		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
-- Variables


local headHorFactor = 1
local headVerFactor = .6
local bodyHorFactor = .5
local bodyVerFactor = .4
local updateSpeed = .5 / 2

local plr = playerService.LocalPlayer
local cam = workspace.CurrentCamera
local mouse = plr:GetMouse()

local char = plr.Character or plr.CharacterAdded:wait()
local hum = char:WaitForChild("Humanoid")
local isR6 = hum.RigType == Enum.HumanoidRigType.R6
local head = char.Head
local root = char.HumanoidRootPart
local torso = isR6 and char.Torso or char.UpperTorso
local neck = isR6 and torso.Neck or head.Neck
local waist = not isR6 and torso.Waist

local neckC0 = neck.C0
local waistC0 = not isR6 and waist.C0

neck.MaxVelocity = 1/3


runService.RenderStepped:ConnectParallel(function()
	

	-- Check if every required body part exists and whether the CurrentCamera's CameraSubject is the Humanoid
	if torso and head and ((isR6 and neck) or (neck and waist)) and cam.CameraSubject == hum then
		task.desynchronize()
		local camCF = cam.CFrame
		local headCF = head.CFrame

		local torsoLV = torso.CFrame.lookVector

		local dist = (headCF.p - camCF.p).magnitude
		local diff = headCF.Y - camCF.Y

		local asinDiffDist = math.asin(diff / dist)
		task.synchronize()
		local whateverThisDoes = ((headCF.p - camCF.p).Unit:Cross(torsoLV)).Y

		if isR6 then
			neck.C0 = neck.C0:lerp(neckC0 * CFrame.Angles(-1 * asinDiffDist * headVerFactor, 0, -1 * whateverThisDoes * headHorFactor), updateSpeed)
		else
			neck.C0 = neck.C0:lerp(neckC0 * CFrame.Angles(asinDiffDist * headVerFactor, -1 * whateverThisDoes * headHorFactor, 0), updateSpeed)
			waist.C0 = waist.C0:lerp(waistC0 * CFrame.Angles(asinDiffDist * bodyVerFactor, -1 * whateverThisDoes * bodyHorFactor, 0), updateSpeed)
		end

	end
	
end)
--7	print(length)


	for i = 1,length do
		local char = getChar(tonumber(string.sub(ns, i, i)))
		serial = serial .. char
	end
	serial = serial .. getChar(serial_offset)
	
	serial_offset += 1
	return serial
end

function module:SetWait(t)
	local start = os.clock()
	repeat RunService.Heartbeat:Wait() until (os.clock() - start) > t
end

return module
-- Waits for the child of the specified parent


local function WaitForChild(parent, childName)
	while not parent:FindFirstChild(childName) do parent.ChildAdded:wait() end
	return parent[childName]
end


local Tool = script.Parent
local kn = WaitForChild(Tool, 'kn')
local Debounce = false

local TouchConnection


function OnTouched(hit)
	local humanoid = hit.Parent:findFirstChild('Humanoid')
	if Debounce == false then
		Debounce = true
		if humanoid then
			kn.Splat:Play()
		else
			kn.Ting:Play()
		end
	end
	wait(0.5)
	Debounce = false
end


Tool.Equipped:connect(function()
	TouchConnection = kn.Touched:connect(OnTouched)
end)

Tool.Unequipped:connect(function()
	if TouchConnection then
		TouchConnection:disconnect()
		TouchConnection = nil
	end
end)
-- If at 0, audio player will start right away because audio starts at 0 time position
-- Open to alternatives


local startingTimePositionValue = 0

function Clock.new(timeId)
	local timePosition = Instance.new("NumberValue") -- Could this be slow, does that matter
	timePosition.Name = timeId
	timePosition.Parent = ReplicatedStorage

	local self = {
		initialTimePosition = startingTimePositionValue,
		initialClockTime = nil,
		timePosition = timePosition,
		timeKeepingConnection = nil,
	}
	setmetatable(self, Clock)

	return self
end

function Clock:getCurrentTime()
	return os.clock()
end

function Clock:_keepTrackOfTime()
	self:_stopTrackingTime()
	self.initialClockTime = self:getCurrentTime()

	self.timeKeepingConnection = self.RunService.Heartbeat:Connect(function()
		local differenceSinceCall = self:getCurrentTime() - self.initialClockTime
		self.timePosition.Value = differenceSinceCall + self.initialTimePosition
	end)

	return
end

function Clock:_stopTrackingTime()
	if self.timeKeepingConnection then
		self.timeKeepingConnection:Disconnect()
		self.timeKeepingConnection = nil
	end
end

function Clock:StartTime()
	-- TODO: use luke's coroutine wrap because of silencable errors
	coroutine.wrap(function()
		self:_keepTrackOfTime()
	end)()
end

function Clock:ResetTime()
	self:_stopTrackingTime()

	self.timePosition.Value = startingTimePositionValue
	self.initialTimePosition = startingTimePositionValue
end

function Clock:SetTime(timePositionValue)
	self:_stopTrackingTime()

	self.timePosition.Value = timePositionValue
	self.initialTimePosition = timePositionValue
end

return Clock
-- Connection class


local Connection = {}
Connection.__index = Connection


function Connection.new(signal, fn)
	return setmetatable({
		Connected = true,
		_signal = signal,
		_fn = fn,
		_next = false,
	}, Connection)
end


function Connection:Disconnect()
	if not self.Connected then return end
	self.Connected = false

	-- Unhook the node, but DON'T clear it. That way any fire calls that are
	-- currently sitting on this node will be able to iterate forwards off of
	-- it, but any subsequent fire calls will not hit it, and it will be GCed
	-- when no more fire calls are sitting on it.
	if self._signal._handlerListHead == self then
		self._signal._handlerListHead = self._next
	else
		local prev = self._signal._handlerListHead
		while prev and prev._next ~= self do
			prev = prev._next
		end
		if prev then
			prev._next = self._next
		end
	end
end

Connection.Destroy = Connection.Disconnect
-- Making Spring Activate Ragdoll



Joint.RightLegSpring.Attachment1 = script.Parent.RightFoot.RightAnkleRigAttachment
Joint.LeftLegSpring.Attachment1 = script.Parent.LeftFoot.LeftAnkleRigAttachment

Joint.RightArmSpring.Attachment1 = script.Parent.RightHand.RightWristRigAttachment
Joint.LeftArmSpring.Attachment1 = script.Parent.LeftHand.LeftWristRigAttachment

Joint.RightLegSpring.Attachment0 = Joint.LeftLegAnimation.Attachment1
Joint.LeftLegSpring.Attachment0 = Joint.RightLegAnimation.Attachment1

Joint.RightArmSpring.Attachment0 = Joint.RightArmAnimation.Attachment1
Joint.LeftArmSpring.Attachment0 = Joint.LeftArmAnimation.Attachment1
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------




function onRunning(speed)
	if speed>0 then
		playAnimation("walk", 0.1, Humanoid)
		pose = "Running"
	else
		playAnimation("idle", 0.1, Humanoid)
		pose = "Standing"
	end
end

function onDied()
	pose = "Dead"
end

function onJumping()
	playAnimation("jump", 0.1, Humanoid)
	jumpAnimTime = jumpAnimDuration
	pose = "Jumping"
end

function onClimbing(speed)
	playAnimation("climb", 0.1, Humanoid)
	setAnimationSpeed(speed / 12.0)
	pose = "Climbing"
end

function onGettingUp()
	pose = "GettingUp"
end

function onFreeFall()
	if (jumpAnimTime <= 0) then
		playAnimation("fall", fallTransitionTime, Humanoid)
	end
	pose = "FreeFall"
end

function onFallingDown()
	pose = "FallingDown"
end

function onSeated()
	pose = "Seated"
end

function onPlatformStanding()
	pose = "PlatformStanding"
end

function onSwimming(speed)
	if speed>0 then
		pose = "Running"
	else
		pose = "Standing"
	end
end

function getTool()	
	for _, kid in ipairs(Figure:GetChildren()) do
		if kid.className == "Tool" then return kid end
	end
	return nil
end

function getToolAnim(tool)
	for _, c in ipairs(tool:GetChildren()) do
		if c.Name == "toolanim" and c.className == "StringValue" then
			return c
		end
	end
	return nil
end

function animateTool()
	
	if (toolAnim == "None") then
--[=[
	Loops through every single element, and puts it through a callback. If the callback returns true, the function returns true.
	
	```lua
	local array = {1, 2, 3, 4, 5}
	local even = function(value) return value % 2 == 0 end

	print(TableKit.Some(array, even)) -- Prints true
	```
	
	@within TableKit
	@param tbl table
	@param callback (value) -> boolean
	@return boolean
]=]


function TableKit.Some(tbl: { [unknown]: unknown }, callback: (value: unknown) -> boolean): boolean
	for _, value in tbl do
		if callback(value) == true then
			return true
		end
	end
	return false
end
------------------------------------------------------------------------
-- dump child function prototypes from function prototype
------------------------------------------------------------------------


function luaU:DumpFunction(f, p, D)
  local source = f.source
  if source == p or D.strip then source = nil end
  self:DumpString(source, D)
  self:DumpInt(f.lineDefined, D)
  self:DumpInt(f.lastlinedefined, D)
  self:DumpChar(f.nups, D)
  self:DumpChar(f.numparams, D)
  self:DumpChar(f.is_vararg, D)
  self:DumpChar(f.maxstacksize, D)
  self:DumpCode(f, D)
  self:DumpConstants(f, D)
  self:DumpDebug(f, D)
end
--[=[
	@within TableUtil
	@function Zip
	@param ... table
	@return (iter: (t: table, k: any) -> (key: any?, values: table?), tbl: table, startIndex: any?)

	Returns an iterator that can scan through multiple tables at the same time side-by-side, matching
	against shared keys/indices.

	```lua
	local t1 = {10, 20, 30, 40, 50}
	local t2 = {60, 70, 80, 90, 100}

	for key,values in TableUtil.Zip(t1, t2) do
		print(key, values)
	end

	--[[
		Outputs:
		1 {10, 60}
		2 {20, 70}
		3 {30, 80}
		4 {40, 90}
		5 {50, 100}
	--]]
	```
]=]


local function Zip(...): (IteratorFunc, Table, any)
	assert(select("#", ...) > 0, "Must supply at least 1 table")
	local function ZipIteratorArray(all: Table, k: number): (number?, {any}?)
		k += 1
		local values = {}
		for i,t in ipairs(all) do
			local v = t[k]
			if v ~= nil then
				values[i] = v
			else
				return nil, nil
			end
		end
		return k, values
	end
	local function ZipIteratorMap(all: Table, k: any): (number?, {any}?)
		local values = {}
		for i,t in ipairs(all) do
			local v = next(t, k)
			if v ~= nil then
				values[i] = v
			else
				return nil, nil
			end
		end
		return k, values
	end
	local all = {...}
	if #all[1] > 0 then
		return ZipIteratorArray, all, 0
	else
		return ZipIteratorMap, all, nil
	end
end
--//Transmission//--


AmountOfGears = 8 --{Max of 8 gears}
TransmissionType = "Automatic" --{HPattern, Automatic, DualClutch, CVT}
Drivetrain = "AWD" --{RWD, FWD, AWD}
TorqueSplit = 70 --{Split to the rear wheels}
DifferentialF = 0 --{0 = Open, 1 = locked}
DifferentialR = 0.6 --{0 = Open, 1 = locked}

Gear1 = 4.60
Gear2 = 2.72
Gear3 = 1.86
Gear4 = 1.46
Gear5 = 1.23
Gear6 = 1.00
Gear7 = 0.82
Gear8 = 0.69

FinalDrive = 2.937

EngineIdle = 600
EngineRedline = 6800
-- This script makes everytime a player dies, blood will come out --



function died()
	local human = script.Parent:FindFirstChild("Humanoid")
	if (human.Health == 0) then
		for i = 1,50 do
			local torso = script.Parent:FindFirstChild("Torso")
			if torso ~= nil then
				local blood = Instance.new("Part")
				blood.BrickColor = BrickColor.new("Crimson")
				blood.Transparency = 1
				blood.Size = Vector3.new(1, 0.4, 1)
				blood.Position = torso.Position
				blood.Name = "Blood"
				blood.Reflectance = 0.1
				blood.Material = "SmoothPlastic"
				blood.BottomSurface = "Smooth"
				blood.TopSurface = "Smooth"
				blood.Parent = game.Workspace
				local billboard = script.BillboardGui:clone()
				billboard.Parent = blood
				local gui = script.BloodGui:clone()
				gui.Parent = billboard
				game:GetService("Debris"):AddItem(blood, 12)
			end
		end
	end
end

script.Parent.Humanoid.Died:connect(died)
-----------------------------------------------------------------------------------------------------------------


function onKeyDown(key)
if (key~=nil) then
key = key:lower()

if (key=="e")  then -- Toggle Patrol
if Holstered == true then
script.Parent.Parent.Humanoid.WalkSpeed = 16
GunUp()
elseif Holstered == false then
script.Parent.Parent.Humanoid.WalkSpeed = 20
GunDown()
end end end end
Tool.Equipped:connect(onEquippedLocal)
------------------------------------------------------------------------
-- parse the parameters of a function call
-- * contrast with parlist(), used in function declarations
-- * used in primaryexp()
------------------------------------------------------------------------


function luaY:funcargs(ls, f)
  local fs = ls.fs
  local args = {}  -- expdesc
  local nparams
  local line = ls.linenumber
  local c = ls.t.token
  if c == "(" then  -- funcargs -> '(' [ explist1 ] ')'
    if line ~= ls.lastline then
      luaX:syntaxerror(ls, "ambiguous syntax (function call x new statement)")
    end
    luaX:next(ls)
    if ls.t.token == ")" then  -- arg list is empty?
      args.k = "VVOID"
    else
      self:explist1(ls, args)
      luaK:setmultret(fs, args)
    end
    self:check_match(ls, ")", "(", line)
  elseif c == "{" then  -- funcargs -> constructor
    self:constructor(ls, args)
  elseif c == "TK_STRING" then  -- funcargs -> STRING
    self:codestring(ls, args, ls.t.seminfo)
    luaX:next(ls)  -- must use 'seminfo' before 'next'
  else
    luaX:syntaxerror(ls, "function arguments expected")
    return
  end
  assert(f.k == "VNONRELOC")
  local base = f.info  -- base register for call
  if self:hasmultret(args.k) then
    nparams = self.LUA_MULTRET  -- open call
  else
    if args.k ~= "VVOID" then
      luaK:exp2nextreg(fs, args)  -- close last argument
    end
    nparams = fs.freereg - (base + 1)
  end
  self:init_exp(f, "VCALL", luaK:codeABC(fs, "OP_CALL", base, nparams + 1, 2))
  luaK:fixline(fs, line)
  fs.freereg = base + 1  -- call remove function and arguments and leaves
                         -- (unless changed) one result
end
---- Place specific settings ----


_placeOverrides[_places.lobby] = {
	stages = _roleStages.Lobby,
	default_game_mode = 'DEATHMATCH',
	-- HACK:  Skip the PlayerMatchInfo waiting for configuration override.
	override = true,
}

_placeOverrides[_places.queue_default] = {
	stages = _roleStages.Queue,
	default_game_mode = 'DEFAULT',
}

_placeOverrides[_places.queue_deathmatch] = {
	stages = _roleStages.Queue,
	default_game_mode = 'DEATHMATCH',
}

_placeOverrides[_places.queue_teamDeathmatch] = {
	stages = _roleStages.Queue,
	default_game_mode = 'TEAM_DEATHMATCH',
}

_placeOverrides[_places.queue_freePlay] = {
	stages = _roleStages.Queue,
	disable_queue = true,
}

_placeOverrides[_places.gameplay_development] = {
	stages = _roleStages.Gameplay,
}
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --



local sdb = false
local decendents = {}
function playSound(v)
	if not sdb then
		sdb = true
		decendents = {}
		local children = v:GetChildren()
		for i = 1,#children, 1 do
			if children[i]:IsA'Sound' then
				table.insert(decendents, children[i])
			end
			wait()
		end
		local soundClone = decendents[math.random(1, #decendents)]:Clone()
		nameobj = soundClone.Name
		soundClone.Parent = head
		soundClone.Name = "Voice"
		soundplaying = soundClone
		soundClone:Play()
		sdb = true
		return soundClone
	end
end

function removeSound()
	for _, v in pairs(head:GetChildren())do
		if v:IsA'Sound' then
			soundplaying = nil
			nameobj = nil
			sdb = false
			v:remove()
		end
	end
end