Roblox/luau_corpus huggingface dataset:
-- Convenience function so that calling code does not have to first get the activeController
-- and then call GetMoveVector on it. When there is no active controller, this function returns the 
-- zero vector
function ControlModule:GetMoveVector(): Vector3
	if self.activeController then
		return self.activeController:GetMoveVector()
	end
	return Vector3.new(0,0,0)
end

function ControlModule:GetActiveController()
	return self.activeController
end

function ControlModule:EnableActiveControlModule()
	if self.activeControlModule == ClickToMove then
		-- For ClickToMove, when it is the player's choice, we also enable the full keyboard controls.
		-- When the developer is forcing click to move, the most keyboard controls (WASD) are not available, only jump.
		self.activeController:Enable(
			true,
			Players.LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.UserChoice,
			self.touchJumpController
		)
	elseif self.touchControlFrame then
		self.activeController:Enable(true, self.touchControlFrame)
	else
		self.activeController:Enable(true)
	end
end

function ControlModule:Enable(enable: boolean?)
	if not self.activeController then
		return
	end

	if enable == nil then
		enable = true
	end
	if enable then
		self:EnableActiveControlModule()
	else
		self:Disable()
	end
end
------------------------------------------------------------------------------------------------------------------------------
--// Classes

local event = {};

function event.new(t)
	local evnts = {};
	local self = setmetatable({},{
		__index = t;
		__newindex = function(tt, k, v)
			if (t[k] ~= v) then
				t[k] = v;
				if (type(evnts[k]) == "function") then
					evnts[k](v);
				end;
			end;
		end;
		__metatable = "The metatable is locked.";
	});
	
	function self:connect(k, f)
		evnts[k] = f;
	end;
	
	return self;
end;

local settings = {};

function settings.new(fontModule, attached, child)
	local self = setmetatable({}, {__index = settings});
	
	settings.child = child;
	settings.attached = attached;
	
	-- place data in new format for easy access
	self.information = fontModule.font.information;
	self.atlases = fontModule.atlases;
	self.styles = fontModule.font.styles;
	
	-- sort from least to greatest
	sort(self.information.sizes, function(a, b) return a > b; end);
	
	-- establish some settings variables
	self.style = self.information.styles[1];
	self.size = child.TextSize;
	
	-- failsafes
	for styleName, style in next, self.styles do
		-- characters that DNE
		for sizeName, size in next, style do
			setmetatable(size.characters, {
				__index = function(t, k)
					local k = tostring(k);
					local v = rawget(t, k)
					if (not v) then
						warn(k, "is not a valid character. Replaced with, \"" .. char(REPLACE) .. "\"");
						return rawget(t, tostring(REPLACE));
					end;
					return v;
				end;
			})
		end;
		-- sizes that DNE
		setmetatable(style, {
			__index = function(t, k)
				local k = tostring(k);
				local v = rawget(t, k);
				if (not v) then
					local closest = getClosestNumber(k, self.information.sizes);
					self.size = closest;
					child.TextSize = closest;
					warn(k, "is not a valid size. Using the closest size,", closest);
					return rawget(t, tostring(closest));
				end;
				return v;
			end;
		});
	end;
	-- styles that DNE
	setmetatable(self.styles, {
		__index = function(t, k)
			local v = rawget(t, k);
			if (not v) then 
				local nstyle = self.information.styles[1];
				self.style = nstyle;
				attached.Style = nstyle;
				warn(k, "is not a valid style. Using first style found", nstyle);
				return rawget(t, nstyle);
			end;
			return v;
		end;
	});
	
	return self;
end;

function settings:preload()
	for _, atlas in next, self.atlases do
		content:Preload(atlas);
	end;
end;
-- Customization
	AntiTK = false; -- Set to false to allow TK and damaging of NPC, true for no TK. (To damage NPC, this needs to be false)
	
	MouseSense = 0.5;

	CanAim = true; -- Allows player to aim
	CanBolt = true; -- When shooting, if this is enabled, the bolt will move (SCAR-L, ACR, AK Series)
	
	LaserAttached = true;
	LightAttached = true;
	TracerEnabled = true;
-- Division of index intervals in sequences a and b at the middle change.
-- Invariant: intervals do not have common items at the start or end.
type Division = {
	-- The end of interval preceding division is open like array slice method.
	nChangePreceding: number, -- number of change items
	aEndPreceding: number,
	bEndPreceding: number,

	nCommonPreceding: number, -- 0 if no common items preceding middle change
	aCommonPreceding: number, -- ignore prop value if nCommonPreceding === 0
	bCommonPreceding: number, -- ignore prop value if nCommonPreceding === 0

	nCommonFollowing: number, -- 0 if no common items following middle change
	aCommonFollowing: number, -- ignore prop value if nCommonFollowing === 0
	bCommonFollowing: number, -- ignore prop value if nCommonFollowing === 0

	-- The start of interval following division is closed like array slice method.
	nChangeFollowing: number, -- number of change items
	aStartFollowing: number,
	bStartFollowing: number,
}

local pkg = "diff-sequences" -- for error messages
local NOT_YET_SET = 0 -- small int instead of undefined to avoid deopt in V8
-- 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 EQUIP_COOLDOWN	= 0.2
--Because with a model we can't be sure that FilteringEnabled is on (it probably isn't ;n;) we'll put the effects in the camera
-- (The camera doesn't replicate to the server, which is exactly what we want)
local camera = workspace.CurrentCamera
--local Sprinting =false
local L_145_ = L_121_.new(Vector3.new())
L_145_.s = 15
L_145_.d = 0.5

game:GetService("UserInputService").InputChanged:connect(function(L_272_arg1) --Get the mouse delta for the gun sway
	if L_272_arg1.UserInputType == Enum.UserInputType.MouseMovement then
		L_140_ = math.min(math.max(L_272_arg1.Delta.x, -L_142_), L_142_)
		L_141_ = math.min(math.max(L_272_arg1.Delta.y, -L_142_), L_142_)
	end
end)

L_4_.Idle:connect(function() --Reset the sway to 0 when the mouse is still
	L_140_ = 0
	L_141_ = 0
end)

local L_146_ = false
local L_147_ = CFrame.new()
local L_148_ = CFrame.new()

local L_149_ 
local L_150_
local L_151_
local L_152_

local L_153_
local L_154_
local L_155_

if not L_24_.TacticalModeEnabled then
	L_149_ = 0
	L_150_ = CFrame.new()
	L_151_ = 0.1
	L_152_ = 2
	
	L_153_ = 0
	L_154_ = .2
	L_155_ = 17
else
	L_149_ = 0
	L_150_ = CFrame.new()
	L_151_ = 0.05
	L_152_ = 2
	
	L_153_ = 0
	L_154_ = 0.09
	L_155_ = 11
end

local L_156_ = 0
local L_157_ = 5
local L_158_ = .3

local L_159_, L_160_ = 0, 0

local L_161_ = nil
local L_162_ = nil
local L_163_ = nil

L_3_.Humanoid.Running:connect(function(L_273_arg1)
	if L_273_arg1 > 1 then
		L_146_ = true
	else
		L_146_ = false
	end
end)
---------------------------------------------------

This = script.Parent
Elevator = This.Parent.Parent.Parent
CustomLabel = require(This.Parent.Parent.Parent.CustomLabel)
Characters = require(script.Characters)

CustomText = CustomLabel["CUSTOMFLOORLABEL"]

Elevator:WaitForChild("Floor").Changed:connect(function(floor)
  --custom indicator code--
  ChangeFloor(tostring(floor))
end)

function ChangeFloor(SF)
	if CustomText[tonumber(SF)] then
		SF = CustomText[tonumber(SF)]
	end
	SetDisplay(1,(string.len(SF) == 2 and SF:sub(1,1) or "NIL"))		
	SetDisplay(2,(string.len(SF) == 2 and SF:sub(2,2) or SF))
end



function SetDisplay(ID,CHAR)
	if This.Display:FindFirstChild("DIG"..ID) and Characters[CHAR] ~= nil then
 		for i,l in pairs(Characters[CHAR]) do 
			for r=1,16 do	
				This.Display["DIG"..ID]["D"..r].BrickColor = (l:sub(r,r) == "1" and BrickColor.new(ActiveColour) or BrickColor.new(InactiveColour))
			end
		end
	end
end
--[[
	[Whether rotation follows the camera or the mouse.]
	[Useful with tools if true, but camera tracking runs smoother.]
--]]
local MseGuide = true
-----------------------------------------------------------------------------------------------------------

local realDataStoreService = game:GetService("DataStoreService")
local allStores = {}

if (game:GetService("Players").LocalPlayer) then
	warn("Mocked DataStoreService is functioning on the client: The real DataStoreService will not work on the client")
end
-- ROBLOX TODO: fix PrettyFormat types imports
type CompareKeys = ((a: string, b: string) -> number) | nil

local Types = require(CurrentModule.types)
type DiffOptions = Types.DiffOptions
type DiffOptionsNormalized = Types.DiffOptionsNormalized

local function noColor(s): string
	return s
end

local DIFF_CONTEXT_DEFAULT = 5

local OPTIONS_DEFAULT = {
	aAnnotation = "Expected",
	aColor = chalk.green,
	aIndicator = "-",
	bAnnotation = "Received",
	bColor = chalk.red,
	bIndicator = "+",
	changeColor = chalk.inverse,
	changeLineTrailingSpaceColor = noColor,
	commonColor = chalk.dim,
	commonIndicator = " ",
	commonLineTrailingSpaceColor = noColor,
	-- ROBLOX deviation: using Object.None instead of nil because assigning nil is no different from not assigning value at all
	compareKeys = Object.None,
	contextLines = DIFF_CONTEXT_DEFAULT,
	emptyFirstOrLastLinePlaceholder = "",
	expand = true,
	includeChangeCounts = false,
	omitAnnotationLines = false,
	patchColor = chalk.yellow,
}

local function getCompareKeys(compareKeys: CompareKeys?): CompareKeys
	return if compareKeys and typeof(compareKeys) == "function" then compareKeys else OPTIONS_DEFAULT.compareKeys
end

local function getContextLines(contextLines: number?): number
	if typeof(contextLines) == "number" and Number.isSafeInteger(contextLines) and contextLines >= 0 then
		return contextLines
	end
	return DIFF_CONTEXT_DEFAULT
end
--[[Transmission]]
	Tune.TransModes		= {"Auto", "Semi"}								--[[
	[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		= 5.06			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	2.70		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		1.53		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.04		,
		--[[ 3 ]]		1.38		,
		--[[ 4 ]]		1.03		,
		--[[ 5 ]]		0.80		,
		--[[ 6 ]]		0.75		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
tagHumanoid(humanoid, creator)

	end

end



function tagHumanoid(humanoid, creator)

	-- tag does not need to expire iff all explosions lethal

	

	if creator ~= nil then

		local new_tag = creator:clone()

		new_tag.Parent = humanoid

		

	end

end



function untagHumanoid(humanoid)

	if humanoid ~= nil then

		local tag = humanoid:findFirstChild("creator")

		if tag ~= nil then

		

			tag.Parent = nil

		end

	end

end



t, s = r.Stepped:wait()



swoosh = script.Parent.Swoosh

swoosh:play()



d = t + 10.0 - s

connection = shaft.Touched:connect(blow)



while t < d do

	fly()

	t = r.Stepped:wait()

end



-- at max range

script.Parent.Explosion.PlayOnRemove = false

swoosh:stop()

shaft:remove()
-- << COMMANDS >>
local module = {
	
	-----------------------------------
	{
	Name = ";give";
	Aliases	= {tool};
	Prefixes = {settings.Prefix};
	Rank = 4;
	RankLock = false;
	Loopable = false;
	Tags = {};
	Description = "";
	Contributors = {};
	--
	Args = {};
	Function = function(speaker, args)
		
	end;
	UnFunction = function(speaker, args)
		
	end;
	--
	};
	
	
	
	
	-----------------------------------
	{
	Name = "music";
	Aliases	= {music};
	Prefixes = {settings.Prefix};
	Rank = 2;
	RankLock = true;
	Loopable = false;
	Tags = {};
	Description = "";
	Contributors = {};
	--
	Args = {};
	--[[
	ClientCommand = true;
	FireAllClients = true;
	BlockWhenPunished = true;
	PreFunction = function(speaker, args)
		
	end;
	Function = function(speaker, args)
		wait(1)
	end;
	--]]
	--
	};
	
	
	
	
	-----------------------------------
		{
	Name = "volume";
	Aliases	= {loudest};
	Prefixes = {settings.Prefix};
	Rank = 2;
	RankLock = true;
	Loopable = false;
	Tags = {};
	Description = "";
	Contributors = {};
	--
	Args = {};
	--[[
	ClientCommand = true;
	FireAllClients = true;
	BlockWhenPunished = true;
	PreFunction = function(speaker, args)
		
	end;
	Function = function(speaker, args)
		wait(1)
	end;
	--]]
	--
	};
	
	
	
	
	-----------------------------------
		{
	Name = "pitch";
	Aliases	= {speed/slow sound};
	Prefixes = {settings.Prefix};
	Rank = 2;
	RankLock = true;
	Loopable = false;
	Tags = {};
	Description = "";
	Contributors = {};
	--
	Args = {};
	--[[
	ClientCommand = true;
	FireAllClients = true;
	BlockWhenPunished = true;
	PreFunction = function(speaker, args)
		
	end;
	Function = function(speaker, args)
		wait(1)
	end;
	--]]
	--
	};
	
	
	
	-----------------------------------
		{
	Name = "cmdbar2";
	Aliases	= {commandbar2};
	Prefixes = {settings.Prefix};
	Rank = 2;
	RankLock = true;
	Loopable = false;
	Tags = {};
	Description = "";
	Contributors = {};
	--
	Args = {};
	--[[
	ClientCommand = true;
	FireAllClients = true;
	BlockWhenPunished = true;
	PreFunction = function(speaker, args)
		
	end;
	Function = function(speaker, args)
		wait(1)
	end;
	--]]
	--
	};
	
	
};



return module
--Listen to seat enter/exit
VehicleSeating.AddSeat(DriverSeat, onEnterSeat, onExitSeat)

for _, seat in ipairs(AdditionalSeats) do
	VehicleSeating.AddSeat(seat, onEnterSeat, onExitSeat)
end
-- context : (string)
-- action : (string)
-- label : (string)
-- value : (number, optional)
function GAReporter:sendEvent(context, action, label, value)
	assert(self.trackingId ~= "UA-00000000-00", "** YOU HAVE NOT YET SET YOUR GOOGLE ANALYTICS TRACKING ID IN CONFIG **")

	-- data validation
	local function validateStringInput(var, name, length)
		if type(var) == "string" then
			if #var > length then
				warn(string.format("%s cannot be longer than %d chars", name, length))
				var = var:sub(1, length - 1)
				warn(string.format("%s  has been truncated to %d chars", name, #var))
			end
		else
			error(string.format("%s must be a string", name))
		end
	end

	validateStringInput(context, "Context", 150)
	validateStringInput(action, "Action", 500)
	validateStringInput(label, "Label", 500)

	if value then
		assert(type(value) == "number", "Value must be a number")
		assert(value < 0, "Value must be greater than 0")
	end

	-- construct some args
	local args = {}
	args["t"] = "event"
	args["ec"] = context
	args["ea"] = action
	if label then
		args["el"] = label
	end
	if value then
		args["ev"] = value
	end

	return sendReport(self._networking, self.trackingId, self.clientId, self.userId, args)
end
-- A state object which follows another state object using spring simulation.
export type Spring<T> = PubTypes.Spring<T> & {
	_speed: PubTypes.CanBeState<number>,
	_speedIsState: boolean,
	_lastSpeed: number,
	_damping: PubTypes.CanBeState<number>,
	_dampingIsState: boolean,
	_lastDamping: number,
	_goalState: State<T>,
	_goalValue: T,
	_currentType: string,
	_currentValue: T,
	_springPositions: {number},
	_springGoals: {number},
	_springVelocities: {number}
}
--[[
	Internal method used by __update to apply new props and state

	Returns true if the update was completed, false if it was cancelled by shouldUpdate
]]
function Component:__resolveUpdate(incomingProps, incomingState)
	if config.internalTypeChecks then
		internalAssert(Type.of(self) == Type.StatefulComponentInstance, "Invalid use of `__resolveUpdate`")
	end

	local internalData = self[InternalData]
	local virtualNode = internalData.virtualNode
	local reconciler = internalData.reconciler

	local oldProps = self.props
	local oldState = self.state

	if incomingProps == nil then
		incomingProps = oldProps
	end
	if incomingState == nil then
		incomingState = oldState
	end

	if self.shouldUpdate ~= nil then
		internalData.lifecyclePhase = ComponentLifecyclePhase.ShouldUpdate
		local continueWithUpdate = self:shouldUpdate(incomingProps, incomingState)

		if not continueWithUpdate then
			internalData.lifecyclePhase = ComponentLifecyclePhase.Idle
			return false
		end
	end

	if self.willUpdate ~= nil then
		internalData.lifecyclePhase = ComponentLifecyclePhase.WillUpdate
		self:willUpdate(incomingProps, incomingState)
	end

	internalData.lifecyclePhase = ComponentLifecyclePhase.Render

	self.props = incomingProps
	self.state = incomingState

	local renderResult = virtualNode.instance:render()

	internalData.lifecyclePhase = ComponentLifecyclePhase.ReconcileChildren
	reconciler.updateVirtualNodeWithRenderResult(virtualNode, virtualNode.hostParent, renderResult)

	if self.didUpdate ~= nil then
		internalData.lifecyclePhase = ComponentLifecyclePhase.DidUpdate
		self:didUpdate(oldProps, oldState)
	end

	internalData.lifecyclePhase = ComponentLifecyclePhase.Idle
	return true
end

return Component
--[[Susupension]]
	Tune.SusEnabled		= true		-- works only in with PGSPhysicsSolverEnabled, defaults to false when PGS is disabled
	
	--Front Suspension
	Tune.FSusDamping	= 500		-- Spring Dampening
	Tune.FSusStiffness	= 8000   	-- Spring Force
	Tune.FAntiRoll 		= 50		-- Anti-Roll (Gyro Dampening)
	
	Tune.FSusLength		= 2			-- Suspension length (in studs)
	Tune.FPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.FExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.FCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 80		-- 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	= 500		-- Spring Dampening
	Tune.RSusStiffness	= 8000		-- Spring Force
	Tune.FAntiRoll 		= 30		-- Anti-Roll (Gyro Dampening)

	Tune.RSusLength		= 2			-- Suspension length (in studs)
	Tune.RPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.RExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.RCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.RSusAngle		= 80		-- 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		= false		-- Spring Visible
	Tune.WsBVisible		= false			-- Wishbone Visible
	Tune.SusRadius		= .2			-- Suspension Coil Radius
	Tune.SusThickness	= .1			-- Suspension Coil Thickness
	Tune.SusColor		= "Bright red"	-- Suspension Color [BrickColor]
	Tune.SusCoilCount	= 6				-- Suspension Coil Count
	Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
	Tune.WsThickness	= .1			-- Wishbone Rod Thickness
-- events

REMOTES.Pin.OnServerEvent:connect(function(player, action, ...)
	local squad	= GetSquad(player)
	
	if squad then
		if action == "Add" then
			for _, p in pairs(squad:GetChildren()) do
				if p.Value ~= player then
					REMOTES.Pin:FireClient(p.Value, action, player, ...)
				end
			end
		elseif action == "Remove" then
			for _, p in pairs(squad:GetChildren()) do
				if p.Value ~= player then
					REMOTES.Pin:FireClient(p.Value, action, player)
				end
			end
		end
	end
end)

Players.PlayerAdded:connect(function(player)
	local info		= player:GetJoinData()
	local squadName	= info.TeleportData
	local squad
	
	if squadName then
		squad = SQUADS:FindFirstChild(squadName)
	end	
	
	if not squad then
		squad	= CreateSquad(squadName)
	end
	
	AddPlayerToSquad(player, squad)
end)

Players.PlayerRemoving:connect(function(player)
	RemovePlayer(player)
end)
--[[
	ROBLOX deviation:
	skipped whole file as it seems unnecessary in Lua environment
]]

return {
	default = function()
		return {}
	end,
}
---------------
--// Functions
---------------
local function toggleBuild()
	if sellMode then
		button.BackgroundColor3 = Color3.new(0.658824, 0.368627, 0.345098)
	else
		button.BackgroundColor3 = Color3.new(0.658824, 0.658824, 0.658824)
	end
end

local function pickupModeVisuals()
	while sellMode do
		task.wait(.01)
		pcall(function()
			local object = Mouse.Target
			local selected = nil


			local P = object.Parent
			local PP = object.Parent.Parent
			local PPP = object.Parent.Parent.Parent
			local TANG = nil

			if P.Name == "Builds" then
				TANG = object
			elseif PP.Name == "Builds" then
				TANG = P
			elseif PPP.Name == "Builds" then
				TANG = PP
			end

			if (object) and (TANG) then
				if TANG ~= selected then
					selected = TANG
					-- Not undo everything if already done
					-- Replace existing

					pcall(function()
						Part:Destroy()
					end)

					Part = Instance.new("Part")
					Part.Size = Vector3.new(5,5,5)
					Part.Color = Color3.new(1,0,0)
					Part.Parent = workspace
					Part.Transparency = 0.8
					Part.Anchored = true
					Part.CanCollide = false
					Part.CanQuery = false
					Part.CanTouch = false

					local SelectionBox = Instance.new("SelectionBox")
					SelectionBox.Color3 = Color3.new(1,0,0)
					SelectionBox.Adornee = Part
					SelectionBox.Parent = Part
					SelectionBox.LineThickness = 0.025
					
					local X,Y,Z
					
					if TANG:IsA("Model") then
						
						X,Y,Z = TANG:GetBoundingBox().X, TANG:GetBoundingBox().Y, TANG:GetBoundingBox().Z

					else
						X,Y,Z = TANG.Position.X, TANG.Position.Z, TANG.Position.Z

					end
					
					Part.Position = Vector3.new(X,2.6,Z)

				end
			else
				pcall(function()
					Part:Destroy()
				end)
			end	
		end)
	end
end
-- References
Tool = script.Parent;
Support = require(Tool:WaitForChild 'SupportLibrary');
RegionModule = require(Tool:WaitForChild 'Region by AxisAngle');
-- Get part
local partDockA1 = workspace.Hologram_Station.dockA1
-- functions

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

function onDied()
	pose = "Dead"
end

function onJumping()
	pose = "Jumping"
end

function onClimbing()
	pose = "Climbing"
end

function onGettingUp()
	pose = "GettingUp"
end

function onFreeFall()
	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 moveJump()
	RightShoulder.MaxVelocity = 0.5
	LeftShoulder.MaxVelocity = 0.5
  RightShoulder:SetDesiredAngle(3.14)
	LeftShoulder:SetDesiredAngle(-3.14)
	RightHip:SetDesiredAngle(0)
	LeftHip:SetDesiredAngle(0)
end
-- Key that user can press to interact with game
local KEY1
if IS_MOBILE then
	KEY1 = nil
elseif IS_CONSOLE then
	KEY1 = Enum.KeyCode.ButtonX
else
	KEY1 = Enum.KeyCode.E
end