Roblox/luau_corpus huggingface dataset:
--- Registers the default commands, with an optional filter function or array of groups.
function Registry:RegisterDefaultCommands (arrayOrFunc)
	local isArray = type(arrayOrFunc) == "table"

	if isArray then
		arrayOrFunc = Util.MakeDictionary(arrayOrFunc)
	end

	self:RegisterCommandsIn(self.Cmdr.DefaultCommandsFolder, isArray and function (command)
		return arrayOrFunc[command.Group] or false
	end or arrayOrFunc)
end
-------- OMG HAX

r = game:service("RunService")


local damage = 5


local slash_damage = 12


sword = script.Parent.Handle
Tool = script.Parent


local SlashSound = Instance.new("Sound")
SlashSound.SoundId = "rbxasset://sounds\\swordslash.wav"
SlashSound.Parent = sword
SlashSound.Volume = .7


local UnsheathSound = Instance.new("Sound")
UnsheathSound.SoundId = "rbxasset://sounds\\unsheath.wav"
UnsheathSound.Parent = sword
UnsheathSound.Volume = 1


function blow(hit)
	local humanoid = hit.Parent:findFirstChild("Humanoid")
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)
	local hum = vCharacter:findFirstChild("Humanoid") -- non-nil if tool held by a character
	if humanoid~=nil and humanoid ~= hum and hum ~= nil then
		-- final check, make sure sword is in-hand

		local right_arm = vCharacter:FindFirstChild("Right Arm")
		if (right_arm ~= nil) then
			local joint = right_arm:FindFirstChild("RightGrip")
			if (joint ~= nil and (joint.Part0 == sword or joint.Part1 == sword)) then
				tagHumanoid(humanoid, vPlayer)
				humanoid:TakeDamage(damage)
				wait(1)
				untagHumanoid(humanoid)
			end
		end


	end
end


function tagHumanoid(humanoid, player)
	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = player
	creator_tag.Name = "creator"
	creator_tag.Parent = humanoid
end

function untagHumanoid(humanoid)
	if humanoid ~= nil then
		local tag = humanoid:findFirstChild("creator")
		if tag ~= nil then
			tag.Parent = nil
		end
	end
end


function attack()
	damage = slash_damage
	SlashSound:play()
	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Slash"
	anim.Parent = Tool
end


function swordUp()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,1)
end

function swordOut()
	Tool.GripForward = Vector3.new(0,0,1)
	Tool.GripRight = Vector3.new(0,-1,0)
	Tool.GripUp = Vector3.new(-1,0,0)
end



Tool.Enabled = true

function onActivated()

	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return 
	end

	

	attack()

	wait(.5)

	Tool.Enabled = true
end


function onEquipped()
	UnsheathSound:play()
end


script.Parent.Activated:connect(onActivated)
script.Parent.Equipped:connect(onEquipped)


connection = sword.Touched:connect(blow)
--when verifying friendships, we just check both the caller and the target's friend lists to see if the IDs are found in both lists

local friendlists = {} --Key: person's username. Value: table of online friends' user IDs

function CheckFriendship(caller,target)
	if caller == nil or target == nil or friendlists[caller.Name] == nil or friendlists[target.Name] == nil then return false end
	local f1 = false
	local f2 = false
	for _,v in pairs(friendlists[caller.Name]) do
		if v == target.userId then
			f1 = true
			break
		end
	end
	for _,v in pairs(friendlists[target.Name]) do
		if v == caller.userId then
			f2 = true
			break
		end
	end
	if f1 == true and f2 == true then
		return true
	else
		return false
	end
end

game.ReplicatedStorage.RemoteFunctions.SendFriendsOnlineData.OnServerEvent:connect(function(plr,tbl) --client should send a table of all friend userIDs
	if type(tbl) == "table" and #tbl <= 200 then
		for _,v in pairs(tbl) do
			if type(v) ~= "number" then return end
		end
		friendlists[plr.Name] = tbl
	end
end)

game.ServerStorage.RemoteFunctions.PlayersAreFriends.OnInvoke = function(caller,target)
	return CheckFriendship(caller,target)
end


game.Players.PlayerRemoving:connect(function(plr)
	friendlists[plr.Name] = nil
end)
--[=[
	@param optionB Option
	@return Option
	Returns `optionB` if the calling option has a value,
	otherwise returns None.

	```lua
	local optionA = Option.Some(32)
	local optionB = Option.Some(64)
	local opt = optionA:And(optionB)
	-- opt == optionB

	local optionA = Option.None
	local optionB = Option.Some(64)
	local opt = optionA:And(optionB)
	-- opt == Option.None
	```
]=]
function Option:And(optionB)
	if self:IsSome() then
		return optionB
	else
		return Option.None
	end
end
--[[
	Contains the logic to run a test plan and gather test results from it.

	TestRunner accepts a TestPlan object, executes the planned tests, and
	produces a TestResults object. While the tests are running, the system's
	state is contained inside a TestSession object.
]]

local Expectation = require(script.Parent.Expectation)
local TestEnum = require(script.Parent.TestEnum)
local TestSession = require(script.Parent.TestSession)
local LifecycleHooks = require(script.Parent.LifecycleHooks)

local RUNNING_GLOBAL = "__TESTEZ_RUNNING_TEST__"

local TestRunner = {
	environment = {}
}

function TestRunner.environment.expect(...)
	return Expectation.new(...)
end
------------------------------------------------------------------------
-- parse a break statement
-- * used in statements()
------------------------------------------------------------------------
function luaY:breakstat(ls)
  -- stat -> BREAK
  local fs = ls.fs
  local bl = fs.bl
  local upval = false
  while bl and not bl.isbreakable do
    if bl.upval then upval = true end
    bl = bl.previous
  end
  if not bl then
    luaX:syntaxerror(ls, "no loop to break")
  end
  if upval then
    luaK:codeABC(fs, "OP_CLOSE", bl.nactvar, 0, 0)
  end
  bl.breaklist = luaK:concat(fs, bl.breaklist, luaK:jump(fs))
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%)
	}
	
	--Control Mapping
	Tune.Controls = {
		
	--Keyboard Controls
		--Mode Toggles
		ToggleTCS				= Enum.KeyCode.T					,
		ToggleABS				= Enum.KeyCode.Y					,
		ToggleTransMode			= Enum.KeyCode.M					,
		ToggleMouseDrive		= Enum.KeyCode.R					,
		
		--Primary Controls
		Throttle				= Enum.KeyCode.Up					,
		Brake					= Enum.KeyCode.Down					,
		SteerLeft				= Enum.KeyCode.Left					,
		SteerRight				= Enum.KeyCode.Right				,
		
		--Secondary Controls
		Throttle2				= Enum.KeyCode.W					,
		Brake2					= Enum.KeyCode.S					,
		SteerLeft2				= Enum.KeyCode.A					,
		SteerRight2				= Enum.KeyCode.D					,
		
		--Manual Transmission
		ShiftUp					= Enum.KeyCode.E					,
		ShiftDown				= Enum.KeyCode.Q					,
		Clutch					= Enum.KeyCode.LeftShift			,
		
		--Handbrake
		PBrake					= Enum.KeyCode.P					,
		
	--Mouse Controls
		MouseThrottle			= Enum.UserInputType.MouseButton1	,
		MouseBrake				= Enum.UserInputType.MouseButton2	,
		MouseClutch				= Enum.KeyCode.W					,
		MouseShiftUp			= Enum.KeyCode.E					,
		MouseShiftDown			= Enum.KeyCode.Q					,
		MousePBrake				= Enum.KeyCode.LeftShift			,
		
	--Controller Mapping
		ContlrThrottle			= Enum.KeyCode.ButtonR2				,
		ContlrBrake				= Enum.KeyCode.ButtonL2				,
		ContlrSteer				= Enum.KeyCode.Thumbstick1			,
		ContlrShiftUp			= Enum.KeyCode.ButtonY				,
		ContlrShiftDown			= Enum.KeyCode.ButtonX				,
		ContlrClutch			= Enum.KeyCode.ButtonR1				,
		ContlrPBrake			= Enum.KeyCode.ButtonL1				,
		ContlrToggleTMode		= Enum.KeyCode.DPadUp				,
		ContlrToggleTCS			= Enum.KeyCode.DPadDown				,
		ContlrToggleABS			= Enum.KeyCode.DPadRight			,
	}
	
return Tune
--Main Control------------------------------------------------------------------------
Red = script.Parent.Red.Lamp
Yellow = script.Parent.Yellow.Lamp
Green = script.Parent.Green.Lamp
DRed = script.Parent.Red.DynamicLight
DYellow = script.Parent.Yellow.DynamicLight
DGreen = script.Parent.Green.DynamicLight
function Active()
	if Signal.Value == 0 then
		Green.Enabled = false
		Yellow.Enabled = false
		Red.Enabled = false
		DGreen.Enabled = false
		DYellow.Enabled = false
		DRed.Enabled = false
		GArrow.Enabled = false
		YArrow.Enabled = false
		FYellow.Enabled = false
		DGArrow.Enabled = false
		DYArrow.Enabled = false
		DFYellow.Enabled = false
	elseif Signal.Value == 1 then
		while Signal.Value == 1 do
		Green.Enabled = true
		Yellow.Enabled = false
		Red.Enabled = false
		DGreen.Enabled = true
		DYellow.Enabled = false
		DRed.Enabled = false
			while Signal.Value == 1 do
			YArrow.Enabled = false
			FYellow.Enabled = true
			GArrow.Enabled = false
			DRed.Enabled = false
			DYellow.Enabled = false
			DFYellow.Enabled = true
			DGArrow.Enabled = false
			wait(.5)
			FYellow.Enabled = false
			DFYellow.Enabled = false
			wait(.5)
			if Signal.Value ~= 1 then break end
			if Turn.Value == 1 then break end
		    if Turn.Value == 2 then break end
		    if Turn.Value == 3 then break end
		    if Turn.Value == 0 then break end
			end
		end
	elseif Signal.Value == 2 then
		Green.Enabled = false
		Yellow.Enabled = true
		Red.Enabled = false
		DGreen.Enabled = false
		DYellow.Enabled = true
		DRed.Enabled = false
		GArrow.Enabled = false
		FYellow.Enabled = false
		YArrow.Enabled = true
		FYellow.Enabled = false
		DGArrow.Enabled = false
		DYArrow.Enabled = true
		elseif Signal.Value == 3 then
		Green.Enabled = false
		Yellow.Enabled = false
		Red.Enabled = true
		DGreen.Enabled = false
		DYellow.Enabled = false
		DRed.Enabled = true
		GArrow.Enabled = false
		FYellow.Enabled = false
		YArrow.Enabled = false
		DGArrow.Enabled = false
		DFYellow.Enabled = false
		DYArrow.Enabled = false
	end
end
Signal.Changed:connect(Active)
--[[
	Called when the goal state changes value, or when the speed or damping has
	changed.
]]
function class:update(): boolean
	local goalValue = self._goalState:get(false)

	-- figure out if this was a goal change or a speed/damping change
	if goalValue == self._goalValue then
		-- speed/damping change
		local damping = unwrap(self._damping)
		if typeof(damping) ~= "number" then
			warn("mistypedSpringDamping", typeof(damping))
		elseif damping < 0 then
			warn("invalidSpringDamping", damping)
		else
			self._currentDamping = damping
		end

		local speed = unwrap(self._speed)
		if typeof(speed) ~= "number" then
			warn("mistypedSpringSpeed", nil, typeof(speed))
		elseif speed < 0 then
			warn("invalidSpringSpeed", nil, speed)
		else
			self._currentSpeed = speed
		end

		return false
	else
		-- goal change - reconfigure spring to target new goal
		self._goalValue = goalValue

		local oldType = self._currentType
		local newType = typeof(goalValue)
		self._currentType = newType

		local springGoals = unpackType(goalValue, newType)
		local numSprings = #springGoals
		self._springGoals = springGoals

		if newType ~= oldType then
			-- if the type changed, snap to the new value and rebuild the
			-- position and velocity tables
			self._currentValue = self._goalValue

			local springPositions = table.create(numSprings, 0)
			local springVelocities = table.create(numSprings, 0)
			for index, springGoal in ipairs(springGoals) do
				springPositions[index] = springGoal
			end
			self._springPositions = springPositions
			self._springVelocities = springVelocities

			-- the spring may have been animating before, so stop that
			SpringScheduler.remove(self)
			return true

			-- otherwise, the type hasn't changed, just the goal...
		elseif numSprings == 0 then
			-- if the type isn't animatable, snap to the new value
			self._currentValue = self._goalValue
			return true

		else
			-- if it's animatable, let it animate to the goal
			SpringScheduler.add(self)
			return false
		end
	end
end

local function Spring<T>(
	goalState,
	speed: number?,
	damping: number?
)
	-- apply defaults for speed and damping
	if not speed then
		speed = 10
	end

	if not damping then
		damping = 1
	end

	local dependencySet = {[goalState] = true}

	if xtypeof(speed) == "State" then
		dependencySet[speed] = true
	end

	if xtypeof(damping) == "State" then
		dependencySet[damping] = true
	end

	local self = setmetatable({
		type = "State",
		kind = "Spring",
		dependencySet = dependencySet,
		-- if we held strong references to the dependents, then they wouldn't be
		-- able to get garbage collected when they fall out of scope
		dependentSet = setmetatable({}, WEAK_KEYS_METATABLE),
		_speed = speed,
		_damping = damping,

		_goalState = goalState,
		_goalValue = nil,

		_currentType = nil,
		_currentValue = nil,
		_currentSpeed = unwrap(speed),
		_currentDamping = unwrap(damping),

		_springPositions = nil,
		_springGoals = nil,
		_springVelocities = nil
	}, CLASS_METATABLE)

	-- add this object to the goal state's dependent set
	goalState.dependentSet[self] = true
	self:update()

	return self
end

return Spring
--------
SYNC_RATE:Connect(function()
	for Index, Object in ipairs(ActiveHitboxes) do
		if Object.deleted then
			Handler:remove(Object.object)
		else
			for _, Point in ipairs(Object.points) do
				if not Object.active then
					Point.LastPosition = nil
				else
					local rayStart, rayDir, RelativePointToWorld = Point.solver:solve(Point, Object.debugMode)
					local raycastResult = workspace:Raycast(rayStart, rayDir, Object.raycastParams)
					Point.solver:lastPosition(Point, RelativePointToWorld)

					if raycastResult then
						local hitPart = raycastResult.Instance
						local findModel = not Object.partMode and hitPart:FindFirstAncestorOfClass("Model")
						local humanoid = findModel and findModel:FindFirstChildOfClass("Humanoid")
						local target = humanoid or (Object.partMode and hitPart)

						if target and not Object.targetsHit[target] then
							Object.targetsHit[target] = true
							Object.OnHit:Fire(hitPart, humanoid, raycastResult, Point.group)
						end
					end
					
					Object.OnUpdate:Fire(Point.LastPosition)
				end
			end
		end
	end
end)

return Handler
--[[
	Add a dummy child node to the current node to hold the given error. This
	allows an otherwise empty describe node to report an error in a more natural
	way.
]]
function TestSession:addDummyError(phrase, message)
	self:pushNode({type = TestEnum.NodeType.It, phrase = phrase})
	self:setError(message)
	self:popNode()
	self.nodeStack[#self.nodeStack].status = TestEnum.TestStatus.Failure
end
--Precalculated paths
local t,f,n=true,false,{}
local r={
[58]={{31,32,34,35,39,41,30,56,58},t},
[49]={{31,29,28,44,45,49},t},
[16]={n,f},
[19]={{31,32,34,35,39,41,30,56,58,20,19},t},
[59]={{31,32,34,35,39,41,59},t},
[63]={{31,32,34,35,39,41,30,56,58,23,62,63},t},
[34]={{31,32,34},t},
[21]={{31,32,34,35,39,41,30,56,58,20,21},t},
[48]={{31,29,28,44,45,49,48},t},
[27]={{31,29,28,27},t},
[14]={n,f},
[31]={{31},t},
[56]={{31,32,34,35,39,41,30,56},t},
[29]={{31,29},t},
[13]={n,f},
[47]={{31,29,28,44,45,49,48,47},t},
[12]={n,f},
[45]={{31,29,28,44,45},t},
[57]={{31,32,34,35,39,41,30,56,57},t},
[36]={{31,32,33,36},t},
[25]={{31,29,28,27,26,25},t},
[71]={{31,32,34,35,39,41,59,61,71},t},
[20]={{31,32,34,35,39,41,30,56,58,20},t},
[60]={{31,32,34,35,39,41,60},t},
[8]={n,f},
[4]={n,f},
[75]={{31,32,34,35,39,41,59,61,71,72,76,73,75},t},
[22]={{31,32,34,35,39,41,30,56,58,20,21,22},t},
[74]={{31,32,34,35,39,41,59,61,71,72,76,73,74},t},
[62]={{31,32,34,35,39,41,30,56,58,23,62},t},
[1]={n,f},
[6]={n,f},
[11]={n,f},
[15]={n,f},
[37]={{31,32,33,36,37},t},
[2]={n,f},
[35]={{31,32,34,35},t},
[53]={{31,29,28,44,45,49,48,47,52,53},t},
[73]={{31,32,34,35,39,41,59,61,71,72,76,73},t},
[72]={{31,32,34,35,39,41,59,61,71,72},t},
[33]={{31,32,33},t},
[69]={{31,32,34,35,39,41,60,69},t},
[65]={{31,32,34,35,39,41,30,56,58,20,19,66,64,65},t},
[26]={{31,29,28,27,26},t},
[68]={{31,32,34,35,39,41,30,56,58,20,19,66,64,67,68},t},
[76]={{31,32,34,35,39,41,59,61,71,72,76},t},
[50]={{31,29,28,44,45,49,48,47,50},t},
[66]={{31,32,34,35,39,41,30,56,58,20,19,66},t},
[10]={n,f},
[24]={{31,29,28,27,26,25,24},t},
[23]={{31,32,34,35,39,41,30,56,58,23},t},
[44]={{31,29,28,44},t},
[39]={{31,32,34,35,39},t},
[32]={{31,32},t},
[3]={n,f},
[30]={{31,32,34,35,39,41,30},t},
[51]={{31,29,28,44,45,49,48,47,50,51},t},
[18]={n,f},
[67]={{31,32,34,35,39,41,30,56,58,20,19,66,64,67},t},
[61]={{31,32,34,35,39,41,59,61},t},
[55]={{31,29,28,44,45,49,48,47,52,53,54,55},t},
[46]={{31,29,28,44,45,49,48,47,46},t},
[42]={{31,32,34,35,38,42},t},
[40]={{31,32,34,35,40},t},
[52]={{31,29,28,44,45,49,48,47,52},t},
[54]={{31,29,28,44,45,49,48,47,52,53,54},t},
[43]={n,f},
[7]={n,f},
[9]={n,f},
[41]={{31,32,34,35,39,41},t},
[17]={n,f},
[38]={{31,32,34,35,38},t},
[28]={{31,29,28},t},
[5]={n,f},
[64]={{31,32,34,35,39,41,30,56,58,20,19,66,64},t},
}
return r
-- Preload animations
function playAnimation(animName, transitionTime, humanoid)
	if (animName ~= currentAnim) then		 
		
		if (currentAnimTrack ~= nil) then
			currentAnimTrack:Stop(transitionTime)
			currentAnimTrack:Destroy()
		end

		currentAnimSpeed = 1.0
		local roll = math.random(1, animTable[animName].totalWeight) 
		local origRoll = roll
		local idx = 1
		while (roll > animTable[animName][idx].weight) do
			roll = roll - animTable[animName][idx].weight
			idx = idx + 1
		end
-- emote bindable hook
if FFlagAnimateScriptEmoteHook then
	script:WaitForChild("PlayEmote").OnInvoke = function(emote)
		-- Only play emotes when idling
		if pose ~= "Standing" then
			return
		end

		if emoteNames[emote] ~= nil then
			-- Default emotes
			playAnimation(emote, EMOTE_TRANSITION_TIME, Humanoid)

			if userPlayEmoteByIdAnimTrackReturn then
				return true, currentAnimTrack
			else
				return true
			end
		elseif typeof(emote) == "Instance" and emote:IsA("Animation") then
			-- Non-default emotes
			playEmote(emote, EMOTE_TRANSITION_TIME, Humanoid)

			if userPlayEmoteByIdAnimTrackReturn then
				return true, currentAnimTrack
			else
				return true
			end
		end

		-- Return false to indicate that the emote could not be played
		return false
	end
end

if (not FFlagUserFixLoadAnimationError) or Character.Parent ~= nil then
	-- initialize to idle
	playAnimation("idle", 0.1, Humanoid)
	pose = "Standing"
end
-- Roblox character sound script

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local FootstepsSoundGroup = game:GetService("SoundService"):WaitForChild("Footsteps")
local L_1_ = game.Players.LocalPlayer
local L_2_ = L_1_.Character

local SOUND_DATA = {
	Climbing = {
		SoundId = "rbxasset://sounds/action_footsteps_plastic.mp3",
		Looped = true,
	},
	Died = {
		SoundId = "rbxasset://sounds/uuhhh.mp3",
	},
	FreeFalling = {
		SoundId = "rbxasset://sounds/action_falling.mp3",
		Looped = true,
	},
	GettingUp = {
		SoundId = "rbxasset://sounds/action_get_up.mp3",
	},
	Jumping = {
		SoundId = "rbxasset://sounds/action_jump.mp3",
	},
	Landing = {
		SoundId = "rbxasset://sounds/action_jump_land.mp3",
	},
	Running = {
		SoundId = '' ,
		Looped = true,
		Playing = true,
		Pitch = 1,
	},
	Splash = {
		SoundId = "rbxasset://sounds/impact_water.mp3",
	},
	Swimming = {
		SoundId = "rbxasset://sounds/action_swim.mp3",
		Looped = true,
		Pitch = 1.6,
	},
}

 -- wait for the first of the passed signals to fire
local function waitForFirst(...)
	local shunt = Instance.new("BindableEvent")
	local slots = {...}

	local function fire(...)
		for i = 1, #slots do
			slots[i]:Disconnect()
		end

		return shunt:Fire(...)
	end

	for i = 1, #slots do
		slots[i] = slots[i]:Connect(fire)
	end

	return shunt.Event:Wait()
end
--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)
	return (plrData.Character.NPCSpecifics.GaveGriefToArtie.Value == true)
end
--[[Wheel Alignment]]
--[Don't physically apply alignment to wheels]
--[Values are in degrees]
Tune.FCamber		= -1
Tune.RCamber		= -1
Tune.FToe			= 0
Tune.RToe			= 0
--local obj = --object or gui or wahtever goes here
--local Properties = {}
--Properties.Size = UDim2.new()
--Tween(obj,Properties,2,true,Enum.EasingStyle.Linear,Enum.EasingDirection.Out,0,false)
--Obj,Property,Time,wait,Easingstyle,EasingDirection,RepeatAmt,Reverse

	


function HighlightPianoKey(note1,transpose)
	if not Settings.KeyAesthetics then return end
	local octave = math.ceil(note1/12)
	local note2 = (note1 - 1)%12 + 1
	local original = Piano.Case.Part
	local key = Piano.Case.Part:Clone()
	key.Parent = Piano.Keys
	key.Name = note1
	local part
	local Time = 1
	local Properties = {}
	local part = key
	key.Position = original.Position + Vector3.new((note1 + .1),-3,0)
	key.Transparency = 0
	if IsBlack(note1) then
		local obj = key
		obj.Color = Color3.fromRGB(236, 24, 116)
		Properties = {}
		Properties.Transparency = 1
		Properties.Position = part.Position + Vector3.new(0,20,0)
		Tween(obj,Properties,Time,true,Enum.EasingStyle.Linear)
	else
		local obj = key
		obj.Color = Color3.fromRGB(197, 93, 223)
		Properties = {}
		Properties.Transparency = 1
		Properties.Position = part.Position + Vector3.new(0,20,0)
		Tween(obj,Properties,Time,true,Enum.EasingStyle.Linear)
	end
	key:Destroy()
	return
end
--[[
	Returns an iterator over the children of an element.
	`elementOrElements` may be one of:
	* a boolean
	* nil
	* a single element
	* a fragment
	* a table of elements

	If `elementOrElements` is a boolean or nil, this will return an iterator with
	zero elements.

	If `elementOrElements` is a single element, this will return an iterator with
	one element: a tuple where the first value is ElementUtils.UseParentKey, and
	the second is the value of `elementOrElements`.

	If `elementOrElements` is a fragment or a table, this will return an iterator
	over all the elements of the array.

	If `elementOrElements` is none of the above, this function will throw.
]]
function ElementUtils.iterateElements(elementOrElements)
	local richType = Type.of(elementOrElements)

	-- Single child
	if richType == Type.Element then
		local called = false

		return function()
			if called then
				return nil
			else
				called = true
				return ElementUtils.UseParentKey, elementOrElements
			end
		end
	end

	local regularType = typeof(elementOrElements)

	if elementOrElements == nil or regularType == "boolean" then
		return noop
	end

	if regularType == "table" then
		return pairs(elementOrElements)
	end

	error("Invalid elements")
end
--// Math
local L_131_ = function(L_168_arg1, L_169_arg2, L_170_arg3)
	if L_168_arg1 > L_170_arg3 then
		return L_170_arg3
	elseif L_168_arg1 < L_169_arg2 then
		return L_169_arg2
	end
	return L_168_arg1
end

local L_132_ = L_120_.new(Vector3.new())
L_132_.s = 30
L_132_.d = 0.55
	
local L_133_ = CFrame.Angles(0, 0, 0)
--////////////////////////////// Include
--//////////////////////////////////////
local Chat = game:GetService("Chat")
local clientChatModules = Chat:WaitForChild("ClientChatModules")
local modulesFolder = script.Parent
local ChatSettings = require(clientChatModules:WaitForChild("ChatSettings"))
local CurveUtil = require(modulesFolder:WaitForChild("CurveUtil"))

local commandModules = clientChatModules:WaitForChild("CommandModules")
local WhisperModule = require(commandModules:WaitForChild("Whisper"))

local MessageSender = require(modulesFolder:WaitForChild("MessageSender"))

local ChatLocalization = nil
pcall(function() ChatLocalization = require(game:GetService("Chat").ClientChatModules.ChatLocalization) end)
if ChatLocalization == nil then ChatLocalization = {} function ChatLocalization:Get(key,default) return default end end