Pinkstack/roblox-luau-corpus-text huggingface dataset:
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------



function onSwimming(speed)
	if userAnimateScaleRun then
		speed /= getHeightScale()
	end
	if speed > 1.00 then
		local scale = 10.0
		playAnimation("swim", 0.4, Humanoid)
		setAnimationSpeed(speed / scale)
		pose = "Swimming"
	else
		playAnimation("swimidle", 0.4, Humanoid)
		pose = "Standing"
	end
end

function animateTool()
	if (toolAnim == "None") then
		playToolAnimation("toolnone", toolTransitionTime, Humanoid, Enum.AnimationPriority.Idle)
		return
	end

	if (toolAnim == "Slash") then
		playToolAnimation("toolslash", 0, Humanoid, Enum.AnimationPriority.Action)
		return
	end

	if (toolAnim == "Lunge") then
		playToolAnimation("toollunge", 0, Humanoid, Enum.AnimationPriority.Action)
		return
	end
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

local lastTick = 0

function stepAnimate(currentTime)
	local amplitude = 1
	local frequency = 1
	local deltaTime = currentTime - lastTick
	lastTick = currentTime

	local climbFudge = 0
	local setAngles = false

	if (jumpAnimTime > 0) then
		jumpAnimTime = jumpAnimTime - deltaTime
	end

	if (pose == "FreeFall" and jumpAnimTime <= 0) then
		playAnimation("fall", fallTransitionTime, Humanoid)
	elseif (pose == "Seated") then
		playAnimation("sit", 0.5, Humanoid)
		return
	elseif (pose == "Running") then
		playAnimation("walk", 0.2, Humanoid)
	elseif (pose == "Dead" or pose == "GettingUp" or pose == "FallingDown" or pose == "Seated" or pose == "PlatformStanding") then
		stopAllAnimations()
		amplitude = 0.1
		frequency = 1
		setAngles = true
	end

	-- Tool Animation handling
	local tool = Character:FindFirstChildOfClass("Tool")
	if tool and tool:FindFirstChild("Handle") then
		local animStringValueObject = getToolAnim(tool)

		if animStringValueObject then
			toolAnim = animStringValueObject.Value
			-- message recieved, delete StringValue
			animStringValueObject.Parent = nil
			toolAnimTime = currentTime + .3
		end

		if currentTime > toolAnimTime then
			toolAnimTime = 0
			toolAnim = "None"
		end

		animateTool()		
	else
		stopToolAnimations()
		toolAnim = "None"
		toolAnimInstance = nil
		toolAnimTime = 0
	end
end
-- Create a new ray info object.
-- This is just a utility alias with some extra type checking.


function FastCast.newBehavior(): FastCastBehavior
	-- raycastParams, maxDistance, acceleration, canPenetrateFunction, canHitFunction, cosmeticBulletTemplate, cosmeticBulletContainer, autoIgnoreBulletContainer
	return {
		RaycastParams = nil,
		Acceleration = Vector3.new(),
		TravelType = "Distance",
		MaxDistance = 1000,
		Lifetime = 5,
		CanPenetrateFunction = nil,
		CanHitFunction = nil,
		HighFidelityBehavior = FastCast.HighFidelityBehavior.Default,
		HighFidelitySegmentSize = 0.5,
		CosmeticBulletTemplate = nil,
		CosmeticBulletProvider = nil,
		CosmeticBulletContainer = nil,
		RaycastHitbox = nil,
		CurrentCFrame = CFrame.new(),
		ModifiedDirection = Vector3.new(),
		AutoIgnoreContainer = true,
		HitEventOnTermination = false,
		Hitscan = false
	}
end

local DEFAULT_DATA_PACKET = FastCast.newBehavior()
function FastCast:Fire(origin: Vector3, direction: Vector3, velocity: Vector3 | number, castDataPacket: FastCastBehavior?): ActiveCast
	if castDataPacket == nil then castDataPacket = DEFAULT_DATA_PACKET end
	
	local cast = ActiveCastStatic.new(self, origin, direction, velocity, castDataPacket)
	cast.RayInfo.WorldRoot = self.WorldRoot
	return cast
end
--Settings--


local mySettings = marine.Settings

local stabAnimation = myHuman:LoadAnimation(marine.Stab)
stabAnimation.Priority = Enum.AnimationPriority.Action
local stabPunchAnimation = myHuman:LoadAnimation(marine.StabPunch)
stabPunchAnimation.Priority = Enum.AnimationPriority.Action
local throwAnimation = myHuman:LoadAnimation(marine.ThrowAnimation)
throwAnimation.Priority = Enum.AnimationPriority.Action
throwAnimation.Looped = false
-- Read the current body orientation angle as an attribute from the server, and use it to orient the character


function OrientableBody:orientFromAttribute()
	local value: Vector2 = self.character:GetAttribute(ATTRIBUTE)
	if value then
		self.motor:setGoal({
			horizontalAngle = Otter.spring(value.X),
			verticalAngle = Otter.spring(value.Y),
		})
	end
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.LeftShift		,
		
	--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			,
	}
----------------------------------------------------------------------
--------------------[ TRAIL HANDLING ]--------------------------------
----------------------------------------------------------------------



local createTrail = script:WaitForChild("createTrail")
createTrail.OnServerEvent:connect(function(_, Origin, P, gunIgnore, S)
	local Trail = Instance.new("Part")
	Trail.BrickColor = S.trailSettings.Color
	Trail.Transparency = S.trailSettings.Transparency
	Trail.Anchored = true
	Trail.CanCollide = false
	Trail.Size = V3(1, 1, 1)
	local Mesh = Instance.new("CylinderMesh")
	Mesh.Offset = V3(0, -(P - Origin).magnitude / 2, 0)
	Mesh.Scale = V3(S.trailSettings.Thickness, (P - Origin).magnitude, S.trailSettings.Thickness)
	Mesh.Parent = Trail
	Trail.Parent = gunIgnore
	Trail.CFrame = CF(Origin, P) * CFANG(RAD(90), 0, 0)
	delay(S.trailSettings.visibleTime, function()
		if S.trailSettings.disappearTime > 0 then
			local t0 = tick()
			while true do
				local Alpha = math.min((tick() - t0) / S.trailSettings.disappearTime, 1)
				Trail.Transparency = numLerp(S.trailSettings.Transparency, 1, Alpha)
				if Alpha == 1 then break end
				wait()
			end
			Trail:Destroy()
		else
			Trail:Destroy()
		end
	end)
end)
--// F key, HornOff


mouse.KeyUp:connect(function(key)
	if key=="f" then 
		veh.Lightbar.middle.Airhorn:Stop()
		veh.Lightbar.middle.Wail.Volume = 3
		veh.Lightbar.middle.Yelp.Volume = 3
		veh.Lightbar.middle.Priority.Volume = 3
		veh.Lightbar.HORN.Transparency = 1
	end
end)
--Values--


local car = script.Parent.Parent.Car.Value
local FE = workspace.FilteringEnabled
local _Tune = require(car["A-Chassis Tune"])
local Redline = _Tune.Redline
local maxPSI = WasteGatePressure
local totalPSI = 0
local actualPSI = 0
local CR = CompressionRatio
local TC = TurboCount
local handler = car:WaitForChild("UpdateAndMake")
local Values = script.Parent.Parent.Values
local Throttle = script.Parent.Parent.Values.Throttle.Value
local BOVFix = (1 - Throttle)
local tester = 1
local BOVact = 0
local BOVact2 = 0
local Whistle = car.DriveSeat:WaitForChild("Whistle")
local BOV = car.DriveSeat:WaitForChild("BOV")
Whistle:Play()
--track serverside attention target table to give newly joined players


local targets = {}

broadcastAttention.OnServerEvent:Connect(function (player, target)
	if player then
		broadcastAttention:FireAllClients(player, target)
		targets[player] = target
	end
end)

getAttentionOnJoin.OnServerEvent:Connect(function (player)
	if player then
		getAttentionOnJoin:FireClient(player, targets)
	end
end)
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------
-- STATE CHANGE HANDLERS



function onRunning(speed)
	if speed > 0.5 then
		playAnimation("run", 0.2, Humanoid)
		pose = "Running"
	else
		if emoteNames[currentAnim] == nil then
			playAnimation("idle", 0.2, Humanoid)
			pose = "Standing"
		end
	end
end

function onDied()
	pose = "Dead"
end

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

function onClimbing(speed)
	local scale = 5.0
	playAnimation("climb", 0.1, Humanoid)
	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
--				if ZombieTarget.Torso.Position.Y > model.Torso.Position.Y + 2 then
--					model.Humanoid.Jump = true
--				end


			end
			
		end
	end
	PursueState.Init = function()
	end
	
	-- AttackState: Keep moving towards target and play attack animation.
	local AttackState = StateMachine.NewState()
	AttackState.Name = "Attack"
	local lastAttack = os.time()
	local attackTrack = model.Humanoid:LoadAnimation(model.Animations.Attack)
	AttackState.Action = function()
		model.Humanoid:MoveTo(ZombieTarget.Torso.Position)
		local now = os.time()
		if now - lastAttack > 3 then
			lastAttack = now
			attackTrack:Play()
		end
	end
	
	-- HuntState: Can't see target but NPC will move to target's last known location.
	-- Will eventually get bored and switch state.
	local HuntState = StateMachine.NewState()
	HuntState.Name = "Hunt"
	HuntState.Action = function()
		if ZombieTargetLastLocation then
			PathLib:MoveToTarget(model, ZombieTargetLastLocation)
		end
	end
	HuntState.Init = function()
		lastBored = os.time() + configs["BoredomDuration"] / 2
	end
	
	-- CONDITION DEFINITIONS	
	
	-- CanSeeTarget: Determines if a target is visible. Returns true if target is visible and
	-- sets current target. A target is valid if it is nearby, visible, has a Torso and WalkSpeed
	-- greater than 0 (this is to ignore inanimate objects that happen to use humanoids)
	local CanSeeTarget = StateMachine.NewCondition()
	CanSeeTarget.Name = "CanSeeTarget"
	CanSeeTarget.Evaluate = function()
		if model then
			-- Get list of all nearby Zombies and non-Zombie humanoids
			-- Zombie list is used to ignore zombies during later raycast
			local humanoids = HumanoidList:GetCurrent()	
			local zombies = {}
			local characters = {}
			for _, object in pairs(humanoids) do
				if object and object.Parent and object.Parent:FindFirstChild("Torso") and object.Health > 0 and object.WalkSpeed > 0 then				
					local torso = object.Parent:FindFirstChild("Torso")
					if torso then
						local distance = (model.Torso.Position - torso.Position).magnitude
						if distance <= configs["AggroRange"] then
							if object.Parent.Name == "Zombie" then
								table.insert(zombies, object.Parent)
							else
								table.insert(characters, object.Parent)
							end
						end	
					end	
				end
			end	
			
			local target = AIUtilities:GetClosestVisibleTarget(model, characters, zombies, configs["FieldOfView"])
			if target then
				ZombieTarget = target
				return true
			end
-- Takes an instance and overlays it on top of a parent. This is used for
-- overlaying a DevModule's DataModel-based layout on top of existing services.


local function overlay(instance: Instance, parent: Instance)
	for _, child in ipairs(instance:GetChildren()) do
		local existingChild = parent:FindFirstChild(child.Name)

		if existingChild and child.ClassName == "Folder" then
			overlay(child, existingChild)
		else
			move(child, parent)
		end
	end
end
-- Actual measured distance to the camera Focus point, which may be needed in special circumstances, but should
-- never be used as the starting point for updating the nominal camera-to-subject distance (self.currentSubjectDistance)
-- since that is a desired target value set only by mouse wheel (or equivalent) input, PopperCam, and clamped to min max camera distance


function BaseCamera:GetMeasuredDistanceToFocus()
	local camera = game.Workspace.CurrentCamera
	if camera then
		return (camera.CoordinateFrame.p - camera.Focus.p).magnitude
	end
	return nil
end

function BaseCamera:GetCameraLookVector()
	return game.Workspace.CurrentCamera and game.Workspace.CurrentCamera.CFrame.lookVector or UNIT_Z
end

function BaseCamera:CalculateNewLookCFrameFromArg(suppliedLookVector, rotateInput)
	local currLookVector = suppliedLookVector or self:GetCameraLookVector()
	local currPitchAngle = math.asin(currLookVector.y)
	local yTheta = math.clamp(rotateInput.y, -MAX_Y + currPitchAngle, -MIN_Y + currPitchAngle)
	local constrainedRotateInput = Vector2.new(rotateInput.x, yTheta)
	local startCFrame = CFrame.new(ZERO_VECTOR3, currLookVector)
	local newLookCFrame = CFrame.Angles(0, -constrainedRotateInput.x, 0) * startCFrame * CFrame.Angles(-constrainedRotateInput.y,0,0)
	return newLookCFrame
end

function BaseCamera:CalculateNewLookVectorFromArg(suppliedLookVector, rotateInput)
	local newLookCFrame = self:CalculateNewLookCFrameFromArg(suppliedLookVector, rotateInput)
	return newLookCFrame.lookVector
end

function BaseCamera:CalculateNewLookVectorVRFromArg(rotateInput)
	local subjectPosition = self:GetSubjectPosition()
	local vecToSubject = (subjectPosition - game.Workspace.CurrentCamera.CFrame.p)
	local currLookVector = (vecToSubject * X1_Y0_Z1).unit
	local vrRotateInput = Vector2.new(rotateInput.x, 0)
	local startCFrame = CFrame.new(ZERO_VECTOR3, currLookVector)
	local yawRotatedVector = (CFrame.Angles(0, -vrRotateInput.x, 0) * startCFrame * CFrame.Angles(-vrRotateInput.y,0,0)).lookVector
	return (yawRotatedVector * X1_Y0_Z1).unit
end

function BaseCamera:GetHumanoid()
	local character = player and player.Character
	if character then
		local resultHumanoid = self.humanoidCache[player]
		if resultHumanoid and resultHumanoid.Parent == character then
			return resultHumanoid
		else
			self.humanoidCache[player] = nil -- Bust Old Cache
			local humanoid = character:FindFirstChildOfClass("Humanoid")
			if humanoid then
				self.humanoidCache[player] = humanoid
			end
			return humanoid
		end
	end
	return nil
end

function BaseCamera:GetHumanoidPartToFollow(humanoid, humanoidStateType)
	if humanoidStateType == Enum.HumanoidStateType.Dead then
		local character = humanoid.Parent
		if character then
			return character:FindFirstChild("Head") or humanoid.Torso
		else
			return humanoid.Torso
		end
	else
		return humanoid.Torso
	end
end
-- ROBLOX note: this flowtype built-in is derived from the object shape returned by forwardRef


export type React_AbstractComponent<Config, Instance> = {
	["$$typeof"]: number,
	render: ((props: Config, ref: React_Ref<Instance>) -> React_Node)?,
	displayName: string?,
	defaultProps: Config?,
	-- not in React flowtype, but is in definitelytyped and is used in ReactElement
	name: string?,
	-- allows methods to be hung on a component, used in forwardRef.spec regression test we added
	[string]: any,
}
--// ------------------------------- //--
--// Don't edit anything below here! //--
--// ------------------------------- //--



local camera = game.Workspace.CurrentCamera
local character = game.Players.LocalPlayer.Character or game.Players.LocalPlayer.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")

local Z = 0
local damping = (character.Humanoid.WalkSpeed / 2) * GENERAL_DAMPING
local PI = 3.1415926
local tick = PI / 2
local running = false
local strafing = false

humanoid.Strafing:Connect(function(bool)
	strafing = bool
end)

humanoid.Jumping:Connect(function()
	running = false
end)

humanoid.Swimming:Connect(function()
	running = false
end)

humanoid.Running:Connect(function(speed)
	if speed > 0.1 then
		running = true
	else
		running = false
	end
end)

local function mix(par1, par2, factor)
	return par2 + (par1 - par2) * factor
end

while true do
	game:GetService("RunService").RenderStepped:Wait()
	
	fps = (camera.CFrame.p - character.Head.Position).Magnitude
	
	if fps < 0.52 then
		Z = 1
	else
		Z = 0
	end
	
	if running == true and strafing == false then
		tick = tick + humanoid.WalkSpeed / 92
	else
		if tick > 0 and tick < PI / 2 then
			tick = mix(tick, PI / 2, 0.9)
		end
		if tick > PI / 2 and tick < PI then
			tick = mix(tick, PI / 2, 0.9)
		end
		if tick > PI and tick < PI * 1.5 then
			tick = mix(tick, PI * 1.5, 0.9)
		end
		if tick > PI * 1.5 and tick < PI * 2 then
			tick = mix(tick, PI * 1.5, 0.9)
		end
	end
	
	if tick >= PI * 2 then
		tick = 0
	end	
	
	camera.CFrame = camera.CFrame * 
		CFrame.new(math.cos(tick) / damping * OFFSET_DAMPING, math.sin(tick * 2) / (damping * 2 * OFFSET_DAMPING), Z) * 
		CFrame.Angles(0, 0, math.sin(tick - PI * 1.5) / (damping * 15 * TILT_DAMPING)) --Set camera CFrame
end
-------------------------



function tween(prop,object,val,tm)
	local tweenInfo = TweenInfo.new(tm, Enum.EasingStyle.Quad, Enum.EasingDirection.Out, 0, false)
	local goal = {}
	goal[prop] = val
	local a = ts:Create(object, tweenInfo, goal)
	a:Play()
end

function rad(x)
	local open = x and 0 or 0.5
	HUB:TweenPosition(UDim2.new(open-0.5, 0, 1, 0),Enum.EasingDirection.Out,Enum.EasingStyle.Quad,.25,true)
	radio:TweenPosition(UDim2.new(0-open, 0, 1, 0),Enum.EasingDirection.Out,Enum.EasingStyle.Quad,.25,true)
end

function swap()
	if mode == 2 then
		mode = 0
		rad(true)
	else mode = mode + 1
		rad(false)
	end
	HUB.Windows:TweenPosition(UDim2.new(0, 0, mode-2,3),Enum.EasingDirection.Out,Enum.EasingStyle.Quad,.4,true)
	HUB.Misc:TweenPosition(UDim2.new(0, 0, mode-1,3),Enum.EasingDirection.Out,Enum.EasingStyle.Quad,.4,true)
-- Initialization


Storage = Instance.new('Folder', game.Workspace)
local StorageFolder = Instance.new('ObjectValue', Tool.Configuration)
StorageFolder.Value = Storage
StorageFolder.Name = 'StorageFolder'
RocketTemplate = script.Rocket
RocketTemplate.Parent = nil
RocketTemplate.PrimaryPart.BodyForce.force = Vector3.new(0,196.2,0) * (RocketTemplate.PrimaryPart:GetMass() + RocketTemplate.Part:GetMass())
--[[ Local Functions ]]

--
local function getHumanoid()
	local character = LocalPlayer and LocalPlayer.Character
	if character and character.Parent then
		if CachedHumanoid and CachedHumanoid.Parent == character then
			return CachedHumanoid
		else
			CachedHumanoid = nil
			for _,child in pairs(character:GetChildren()) do
				if child:IsA('Humanoid') then
					CachedHumanoid = child
					return CachedHumanoid
				end
			end
		end
	end
end
-- Objects


local displayMap = 	  { {1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1},	-- 0
						{0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1},	-- 1
						{1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1},	-- 2
						{1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1},	-- 3
						{1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1},	-- 4
						{1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1},	-- 5
						{1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1},	-- 6
						{1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1},	-- 7
						{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},	-- 8
						{1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1} }	-- 9

local blankPattern =	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
local error_E = 		{1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1}
local error_R =			{0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0}
local noon_A =			{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1}
local noon_P =			{1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0}

local lightingService = game:GetService("Lighting")
local minsAfterMidnightVar = script.Parent.MinutesAfterMidnight
local msPerUpdateVar = script.MillisecondsPerUpdate
local isOnVar = script.Parent.isOn
local prevIsOn = true

local screen = script.Parent.Display.SurfaceGui.Screen
local hrsTens = script.Parent.Display.SurfaceGui.Screen.Hours10
local hrsOnes = script.Parent.Display.SurfaceGui.Screen.Hours1
local minsTens = script.Parent.Display.SurfaceGui.Screen.Minutes10
local minsOnes = script.Parent.Display.SurfaceGui.Screen.Minutes1
local noon = script.Parent.Display.SurfaceGui.Screen.Noon
--// This section of code waits until all of the necessary RemoteEvents are found in EventFolder.
--// I have to do some weird stuff since people could potentially already have pre-existing
--// things in a folder with the same name, and they may have different class types.
--// I do the useEvents thing and set EventFolder to useEvents so I can have a pseudo folder that
--// the rest of the code can interface with and have the guarantee that the RemoteEvents they want
--// exist with their desired names.



local FFlagUserHandleChatHotKeyWithContextActionService = false do
	local ok, value = pcall(function()
		return UserSettings():IsUserFeatureEnabled("UserHandleChatHotKeyWithContextActionService")
	end)
	if ok then
		FFlagUserHandleChatHotKeyWithContextActionService = value
	end
end

local FFlagUserHandleFriendJoinNotifierOnClient = false
do
	local success, value = pcall(function()
		return UserSettings():IsUserFeatureEnabled("UserHandleFriendJoinNotifierOnClient")
	end)
	if success then
		FFlagUserHandleFriendJoinNotifierOnClient = value
	end
end

local FILTER_MESSAGE_TIMEOUT = 60

local RunService = game:GetService("RunService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Chat = game:GetService("Chat")
local StarterGui = game:GetService("StarterGui")
local ContextActionService = game:GetService("ContextActionService")

local DefaultChatSystemChatEvents = ReplicatedStorage:WaitForChild("DefaultChatSystemChatEvents")
local EventFolder = ReplicatedStorage:WaitForChild("DefaultChatSystemChatEvents")
local clientChatModules = Chat:WaitForChild("ClientChatModules")
local ChatConstants = require(clientChatModules:WaitForChild("ChatConstants"))
local ChatSettings = require(clientChatModules:WaitForChild("ChatSettings"))
local messageCreatorModules = clientChatModules:WaitForChild("MessageCreatorModules")
local MessageCreatorUtil = require(messageCreatorModules:WaitForChild("Util"))

local ChatLocalization = nil
-- This file was @generated by Tarmac. It is not intended for manual editing.


return {
	Calendar = "rbxassetid://8915045287",
	Caret = "rbxassetid://8915045496",
	Close = "rbxassetid://8915045615",
	Clothing = "rbxassetid://8915045766",
	Eye = "rbxassetid://8915045943",
	Gamepad = {
		ButtonA = "rbxassetid://8712691282",
		ButtonB = "rbxassetid://8712691429",
		ButtonL1 = "rbxassetid://8712691596",
		ButtonL2 = "rbxassetid://8712691753",
		ButtonR1 = "rbxassetid://8712691861",
		ButtonR2 = "rbxassetid://8712691936",
		ButtonX = "rbxassetid://8712692030",
		ButtonY = "rbxassetid://8712692150",
		DPadDown = "rbxassetid://8712692266",
		DPadLeft = "rbxassetid://8712692372",
		DPadRight = "rbxassetid://8712692480",
		DPadUp = "rbxassetid://8712692563",
	},
	Info = "rbxassetid://8915046089",
	KeyBacking = "rbxassetid://9589929509",
	RadioButtonInner = "rbxassetid://9589830458",
	RadioButtonOuter = "rbxassetid://9589830610",
	Robux = "rbxassetid://8915046254",
	Rotation = "rbxassetid://8915046440",
	ShoppingCart = "rbxassetid://8915046573",
	Sparkle = "rbxassetid://8915046721",
	Timer = "rbxassetid://8915046889",
}