Roblox/luau_corpus huggingface dataset:
-- Reparents an instance and outputs helpful logging information so we can see
-- where instances are going at runtime.
local function move(instance: Instance, newParent: Instance)
    instance.Parent = newParent
    log("move", ("%s -> %s"):format(instance.Name, instance:GetFullName()))
end
-- << VARIABLES >>
local topBar = main.gui.CustomTopBar
local coreToHide = {"Chat", "PlayerList"}
local originalCoreStates = {};
local cmdBar = main.gui.CmdBar
local currentProps = {}
local originalTopBarTransparency = 0.5
local originalTopBarVisibility = true
local mainProps
mainProps = {
	maxSuggestions = 5;
	mainParent = cmdBar;
	textBox = cmdBar.SearchFrame.TextBox;
	rframe = cmdBar.ResultsFrame;
	suggestionPos = 1;
	suggestionDisplayed = 0;
	forceExecute = false;
	highlightColor = Color3.fromRGB(50,50,50);
	otherColor = Color3.fromRGB(80,80,80);
	suggestionLabels = {};
	currentBarCommand = nil;
}
--Set up equipping and unequipping the tool.
Tool.Equipped:Connect(function()
	if not Equipped then
		Equipped = true
		
		CurrentCharacter = Tool.Parent
		CurrentPlayer = game.Players:GetPlayerFromCharacter(CurrentCharacter)
		EquipSound:Play()
		
		--Create the left hand rocket.
		local LeftGripAttachment = CurrentCharacter:FindFirstChild("LeftGripAttachment",true)
		if LeftGripAttachment then
			CurrentHandRocket = RocketCreator:CreateRocket(false)
			CurrentHandRocket.Name = "HandRocket"
			CurrentHandRocket.Transparency  = 1
			CurrentHandRocket.Parent = Tool
			
			local Weld = Instance.new("Weld")
			Weld.Part0 = LeftGripAttachment.Parent
			Weld.Part1 = CurrentHandRocket
			Weld.C0 = LeftGripAttachment.CFrame
			Weld.C1 = CFrame.Angles(0,math.pi,0)
			Weld.Parent = CurrentHandRocket
		end
		
		RocketBuffer:SetCurrentPlayer(CurrentPlayer)
	end
end)

Tool.Unequipped:Connect(function()
	if Equipped then
		Equipped = false
		
		CurrentCharacter = nil
		CurrentPlayer = nil
		EquipSound:Stop()
		if CurrentHandRocket then CurrentHandRocket:Destroy() end
		RocketBuffer:SetCurrentPlayer()
	end
end)
---
local  Paint = false
	
script.Parent.MouseButton1Click:connect(function()
	Paint = not Paint
	handler:FireServer("Khaki",Paint)
end)
--	script.Parent.Menu.Visible=false
else
	-- старый
	script.Parent.History.Visible=false
-- http://www.ryanjuckett.com/programming/damped-springs/

local EPSILON = 0.0001;

local exp = math.exp;
local cos = math.cos;
local sin = math.sin;
local sqrt = math.sqrt;

local spring = {};
local spring_mt = {__index = spring};

function spring.new(p0, v0, target, angularFrequency, dampingRatio)
	local self = {};
	self.p = p0;
	self.v = v0;
	self.target = target;
	self.angularFrequency = angularFrequency or 10;
	self.dampingRatio = dampingRatio or 1;
	return setmetatable(self, spring_mt);
end

function spring:update(dt)
	local aF = self.angularFrequency;
	local dR =  self.dampingRatio;
	
	if (aF < EPSILON) then return; end;
	if (dR < 0) then dR = 0; end;
	
	local epos = self.target;
	local dpos = self.p - epos;
	local dvel = self.v;
	
	if (dR > 1 + EPSILON) then
		local za = -aF * dR;
		local zb = aF * sqrt(dR*dR - 1);
		local z1 = za - zb;
		local z2 = za + zb;
		local expTerm1 = exp(z1 * dt);
		local expTerm2 = exp(z2 * dt);
		
		local c1 = (dvel - dpos*z2)/(-2*zb);
		local c2 = dpos - c1;
		self.p = epos + c1*expTerm1 + c2*expTerm2;
		self.v = c1*z1*expTerm1 + c2*z2*expTerm2;
	elseif (dR > 1 - EPSILON) then
		local expTerm = exp(-aF * dt);
		
		local c1 = dvel + aF*dpos;
		local c2 = dpos;
		local c3 = (c1*dt + c2)*expTerm;
		
		self.p = epos + c3;
		self.v = (c1*expTerm) - (c3*aF);
	else
		local omegaZeta = aF*dR;
		local alpha = aF*sqrt(1 - dR*dR);
		local expTerm = exp(-omegaZeta*dt);
		local cosTerm = cos(alpha*dt);
		local sinTerm = sin(alpha*dt);
		
		local c1 = dpos;
		local c2 = (dvel + omegaZeta*dpos) / alpha;
		self.p = epos + expTerm*(c1*cosTerm + c2*sinTerm);
		self.v = -expTerm*((c1*omegaZeta - c2*alpha)*cosTerm + (c1*alpha + c2*omegaZeta)*sinTerm);
	end
end

return spring;
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------
-- STATE CHANGE HANDLERS

function onRunning(speed)
	local heightScale = if userAnimateScaleRun then getHeightScale() else 1
	
	local movedDuringEmote = currentlyPlayingEmote and Humanoid.MoveDirection == Vector3.new(0, 0, 0)
	local speedThreshold = movedDuringEmote and (Humanoid.WalkSpeed / heightScale) or 0.75
	if speed > speedThreshold * heightScale then
		local scale = 16.0
		playAnimation("walk", 0.2, Humanoid)
		setAnimationSpeed(speed / scale)
		pose = "Running"
	else
		if emoteNames[currentAnim] == nil and not currentlyPlayingEmote 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)
	if userAnimateScaleRun then
		speed /= getHeightScale()
	end
	local scale = 5.0
	playAnimation("climb", 0.1, Humanoid)
	setAnimationSpeed(speed / scale)
	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
--[[
	Add a new child under the test plan's root node.
]]
function TestPlan:addChild(phrase, nodeType, nodeModifier)
	nodeModifier = getModifier(phrase, self.testNamePattern, nodeModifier)
	local child = TestNode.new(self, phrase, nodeType, nodeModifier)
	table.insert(self.children, child)
	return child
end
--[[
    Returns a HumanoidDescription representing the outfit that "player" is
    currently wearing, with the addition of one extra item given by "assetId".

    The "assetType" parameter represents which kind of accessories the new one
    belongs to. It must be the name of a property under HumanoidDescription. If
    the user is already wearing items of that type, those are removed first.

    In case of a failure to retrieve "player"'s current outfit, a generic
    character look is generated.
]]

local MerchBooth = script:FindFirstAncestor("MerchBooth")

local Cryo = require(MerchBooth.Packages.Cryo)
local matchAssetTypeToAccessoryType = require(MerchBooth.Modules.matchAssetTypeToAccessoryType)
local isAccessory = require(MerchBooth.Modules.isAccessory)
local isClassicClothing = require(MerchBooth.Modules.isClassicClothing)

local DEFAULT_BODY_COLOR = Color3.fromRGB(122, 122, 122)

local function generateDescriptionWithItem(player: Player, assetId: number, assetType: Enum.AssetType)
	local character = player and player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	local description = humanoid and humanoid:GetAppliedDescription()

	-- We could run into the "no description" case if, for instance, the game
	-- has characters disabled. In which case, we want a new description with
	-- character colors set to grey (default is black and isn't very visible in
	-- the default dark theme).
	if not description then
		description = Instance.new("HumanoidDescription")
		description.HeadColor = DEFAULT_BODY_COLOR
		description.TorsoColor = DEFAULT_BODY_COLOR
		description.LeftArmColor = DEFAULT_BODY_COLOR
		description.RightArmColor = DEFAULT_BODY_COLOR
		description.LeftLegColor = DEFAULT_BODY_COLOR
		description.RightLegColor = DEFAULT_BODY_COLOR
	end

	if isAccessory(assetType) then
		local accessoryTypeEnum = matchAssetTypeToAccessoryType(assetType)
		local accessories = Cryo.List.filter(description:GetAccessories(true), function(accessory)
			return accessory.AccessoryType ~= accessoryTypeEnum
		end)
		table.insert(accessories, {
			Order = 1,
			AssetId = assetId,
			AccessoryType = accessoryTypeEnum,
		})
		description:SetAccessories(accessories, true)
	elseif isClassicClothing(assetType) then
		if assetType == Enum.AssetType.TShirt then
			description.GraphicTShirt = assetId
		elseif assetType == Enum.AssetType.Shirt then
			description.Shirt = assetId
		elseif assetType == Enum.AssetType.Pants then
			description.Pants = assetId
		end
	end

	return description
end

return generateDescriptionWithItem
--[[Rear]]--
	Tune.RSusDamping	= 120 		-- Dampening
	Tune.RSusStiffness	= 4000		-- Stiffness
	
	Tune.RSusLength		= 1.85 		-- Suspension length (in studs)
	Tune.RPreComp		= -0.1 		-- Vehicle height, relative to your suspension settings
	Tune.RExtLimit		= .2 		-- Max Extension Travel (in studs)
	Tune.RCompLimit		= .8 		-- Max Compression Travel (in studs)
	
	Tune.RBaseOffset	= {				-- Suspension base point
		 --[[Lateral]]		0		,	-- positive = outward
		 --[[Vertical]]		1.7		,	-- positive = upward
		 --[[Forward]]		-.5		}	-- positive = forward
	
	Tune.RBricksVisible	= false 	-- Makes the front suspension bricks visible (Debug)
	Tune.RConstsVisible	= false 	-- Makes the front suspension constraints visible (Debug)
--!strict
local BloxbizSDK = script.Parent.Parent.Parent.Parent

local UtilsStorage = BloxbizSDK:FindFirstChild("Utils")
local Fusion = require(UtilsStorage:WaitForChild("Fusion"))

export type States = {
	Enabled: Fusion.Value<boolean>,
	Hovering: Fusion.Value<boolean>,
	HeldDown: Fusion.Value<boolean>,
	Selected: Fusion.Value<boolean>,
}

export type Values<T> = {
	MouseDown: T?,
	Selected: T?,
	Hover: T?,
	Disabled: T?,
	Default: T,
}

return function(states: States, values: Values<any>, speed: number?, damping: number?): Fusion.Spring<any>
	return Fusion.Spring(
		Fusion.Computed(function()
			if states.Enabled:get() then
				if states.Selected:get() then
					return values.Selected or values.Default
				elseif states.HeldDown:get() then
					return values.MouseDown or values.Default
				elseif states.Hovering:get() then
					return values.Hover or values.Default
				else
					return values.Default
				end
			else
				return values.Disabled or values.Default
			end
		end),
		speed or 20,
		damping or 1
	)
end
-- NOTE: To hide this from the games folder structure use the command bar and type >hide
-- To Show it again type >show

local SETTINGS = {
	--The thing you need to use before typing the macro 
	PREFIX = "!",
	--The splitter character for between the (). Note: This has to be 1 character	
	ARGUMENT_SPLITTER = ",",
	--The default is tab, and this is the key you must press after typing out the macro
	ACTIVATION_KEY = "	",
	--Used for >MS(). If this is on and it requires a service to be added to the file it will also add that chunk of code. (Note: With this off it wont work as intended if it doesnt have the service already in file declared as a varable)
	AUTO_IMPORT = true,
	--turn this off to allow any sort of casing like: >gS(Players), 
	CASE_SENSATIVE_COMMANDS = false,
	--Used for >MS() so it knows what paths its allowed to look into (Note: this has to be a top level path)
	SEARCH_LOCATIONS = {"Workspace", "Players", "MaterialService", "ReplicatedFirst", "ReplicatedStorage", "ServerScriptService", "ServerStorage", "StarterGui", "StarterPack", "StarterPlayer", "Teams", "Chat", "TextChatService", "LocalizationService", "TestService"},
	--NOT WORKING RIGHT, ONLY TURN ON IF YOU WANT TO SEE WHAT IT DOES. 
	--What its supposed to do is if it sees that a required service is lower than the line you are adding it to then it will move the service up to the current line
	REORGANISE_IMPORTS = false,
}

return SETTINGS
--------------------------------------------------------------------
	if smoke == true then
		mouse.KeyDown:connect(function(key)
		if key == camkey and enabled == false then
		
		local children = car.Wheels:GetChildren()

		for index, child in pairs(children) do
				if child:IsA("Part") then
						local effect = script.soundeffect:Clone()
						effect.Name = "soundeffectCop"
				effect.Parent = child.SQ
			end
		end
		elseif key == camkey and enabled == true then
			local children = car.Wheels:GetChildren()

			for index, child in pairs(children) do
				if child:IsA("Part") then
					child.SQ.soundeffectCop:Destroy()
				end
			end
		end
		car.DriveSeat.ChildRemoved:Connect(function(child)

			if child.Name == "SeatWeld" then
				local children = car.Wheels:GetChildren()

				for index, child in pairs(children) do
					if child:IsA("Part") then
						child.SQ.soundeffectCop:Destroy()
					end
				end
			end
		end)
	end)
end
--[=[
	Gets the service by name. Throws an error if the service is not found.
]=]
function KnitServer.GetService(serviceName: string): Service
	assert(started, "Cannot call GetService until Knit has been started")
	assert(type(serviceName) == "string", `ServiceName must be a string; got {type(serviceName)}`)
	return assert(services[serviceName], `Could not find service "{serviceName}"`) :: Service
end
--[=[
	Creates a new controller.

	:::caution
	Controllers must be created _before_ calling `Knit.Start()`.
	:::
	```lua
	-- Create a controller
	local MyController = Knit.CreateController {
		Name = "MyController",
	}

	function MyController:KnitStart()
		print("MyController started")
	end

	function MyController:KnitInit()
		print("MyController initialized")
	end
	```
]=]
function KnitClient.CreateController(controllerDef: ControllerDef): Controller
	assert(type(controllerDef) == "table", "Controller must be a table; got " .. type(controllerDef))
	assert(type(controllerDef.Name) == "string", "Controller.Name must be a string; got " .. type(controllerDef.Name))
	assert(#controllerDef.Name > 0, "Controller.Name must be a non-empty string")
	assert(not DoesControllerExist(controllerDef.Name), "Controller \"" .. controllerDef.Name .. "\" already exists")
	local controller = controllerDef :: Controller
	controllers[controller.Name] = controller
	return controller
end
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]
local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local handler = car:WaitForChild("AC6_FE_Sounds")
local _Tune = require(car["A-Chassis Tune"])
local on = 0
local throt=0
local redline=0


for i,v in pairs(car.DriveSeat:GetChildren()) do
	for _,a in pairs(script:GetChildren()) do
		if v.Name==a.Name then v:Stop() wait() v:Destroy() end
	end
end

while wait() do
	local _RPM = script.Parent.Values.RPM.Value
	
	if script.Parent.Values.Throttle.Value <= _Tune.IdleThrottle/100 then
		throt = math.max(.3,throt-.2)	
	else
		throt = math.min(1,throt+.1)	
	end	
	if script.Parent.Values.RPM.Value > _Tune.Redline-_Tune.RevBounce/4 and script.Parent.Values.Throttle.Value > _Tune.IdleThrottle/100 then
		redline=.5
	else
		redline=1
	end
	if not script.Parent.IsOn.Value then on=math.max(on-.015,0) else on=1 end
	local Pitch = math.max((((script.SetPitch.Value + script.SetRev.Value*_RPM/_Tune.Redline))*on^2),script.SetPitch.Value)
	if FE then
		handler:FireServer("updateSound",Pitch)
	else
		car.DriveSeat.Rev.Pitch = Pitch
	end
end
-- Services
local ContextActionService = game:GetService 'ContextActionService'
local Workspace = game:GetService 'Workspace'
--[=[
	Returns true is the brio is dead.

	```lua
	local brio = Brio.new("a", "b")
	print(brio:IsDead()) --> false

	brio:Kill()

	print(brio:IsDead()) --> true
	```

	@return boolean
]=]
function Brio:IsDead()
	return self._values == nil
end
--DO NOT CHANGE ANYTHING INSIDE OF THIS SCRIPT BESIDES WHAT YOU ARE TOLD TO UNLESS YOU KNOW WHAT YOU'RE DOING OR THE SCRIPT WILL NOT WORK!!
local hitPart = script.Parent
local debounce = true
local tool = game.ServerStorage.Egg
-- Footsteps
local stepEvent = Evt.Step
stepEvent.OnServerEvent:Connect(function(player,soundId,volume,timeStamp)
	stepEvent:FireAllClients(player,soundId,volume,timeStamp)
end)
--[=[
	Takes a result and converts it to a brio if it is not one.

	@return (source: Observable<Brio<T> | T>) -> Observable<Brio<T>>
]=]
function RxBrioUtils.toBrio()
	return Rx.map(function(result)
		if Brio.isBrio(result) then
			return result
		end

		return Brio.new(result)
	end)
end
-- This is not ideal in a server script.
-- CFraming should be done on the client for a less choppy experience.

local base = script.Parent:WaitForChild('Base')

local startCF = base.CFrame
local startTime = os.clock()
local tau = math.pi*2


local VERTICAL_SWING_AMOUNT = 90
local VERTICAL_SWING_TIME = 19

local HORIZONTAL_SWING_AMOUNT = 0
local HORIZONTAL_SWING_TIME = 6

while base and base.Parent do
	wait()
	local d = os.clock() - startTime
	base.CFrame = startCF * CFrame.Angles(0, math.sin(d*tau/HORIZONTAL_SWING_TIME)*math.rad(HORIZONTAL_SWING_AMOUNT)*.5, math.sin(d*tau/VERTICAL_SWING_TIME)*math.rad(VERTICAL_SWING_AMOUNT)*.5)
end
--		print("Keyframe : ".. frameName)	
		playToolAnimation(toolAnimName, 0.0, Humanoid)
	end
end


function playToolAnimation(animName, transitionTime, humanoid, priority)	 
		
		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
--// Player Events

game:GetService("RunService").RenderStepped:connect(function()

	for L_32_forvar1, L_33_forvar2 in pairs(game.Players:GetChildren()) do
		if L_33_forvar2:IsA('Player') and L_33_forvar2.TeamColor ~= L_1_.TeamColor and L_33_forvar2 ~= L_1_ and L_33_forvar2.Character and L_13_ then
			if L_33_forvar2.Character.Head:FindFirstChild('TeamTag') then
				L_33_forvar2.Character.Head.TeamTag:Destroy()				
			end
		end

	for L_18_forvar1, L_19_forvar2 in pairs(game.Players:GetChildren()) do
	if L_19_forvar2:IsA('Player') and L_19_forvar2.Character and L_19_forvar2.Character.Head then
		if L_19_forvar2.TeamColor == L_1_.TeamColor then
			if L_19_forvar2.Character.Saude.FireTeam.SquadName.Value ~= '' then
				spawnTag(L_19_forvar2.Character, L_19_forvar2.Character.Saude.FireTeam.SquadColor.Value)
			else
				spawnTag(L_19_forvar2.Character, Color3.fromRGB(255,255,255))
			end
		end;
	end;
end
		end
		
end)
-- Local player
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:wait()
local humanoid = character:WaitForChild("Humanoid")
--------RIGHT DOOR --------

game.Workspace.doorright.l32.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l41.BrickColor = BrickColor.new(1023)
game.Workspace.doorright.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
-- Model Position Tweening --
function Functions.CreateModelTween(Model, TweenInformation, Goal)
	local CFrameValue = Instance.new("CFrameValue")
	CFrameValue.Value = Model.PrimaryPart.CFrame
	
	CFrameValue.Changed:Connect(function(Value)
		Model:SetPrimaryPartCFrame(Value)
	end)
	
	local Tween = TweenService:Create(CFrameValue, TweenInformation, Goal)
	Tween:Play()
	Tween.Completed:Wait()
end
--[[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	= "RPM"												--[[
	[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		= 1.6		 --	[TRANSMISSION CALCULATIONS FOR NERDS]
	Tune.Ratios			= {			 --		SPEED [SPS]	 = (Wheel diameter(studs) * pi(3.14) * RPM) / (60 * Gear Ratio * Final Drive * Multiplier)
		--[[Reverse]]	3.40		,--		WHEEL TORQUE = Engine Torque * Gear Ratio * Final Drive * Multiplier
		--[[Neutral]]	0			,
		--[[ 1 ]]		3.77      	,
		--[[ 2 ]]		2.34		,
		--[[ 3 ]]		1.52		,
		--[[ 4 ]]		1.14		,
		--[[ 5 ]]		0.86		,
		--[[ 6 ]]		0.69   	,
	}
	Tune.FDMult			= 5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
--End of Editable Values

local car = script.Parent.Car.Value
local hb = game:GetService('RunService').Heartbeat
local sound = car.Body.Drag.Wind
local sound2 = car.Body.Drag.Body
sound:Play()
sound2:Play()

local function update()
	sound.Volume=Vol*(car.DriveSeat.Velocity.Magnitude/500)
	sound2.Volume=Vol*(car.DriveSeat.Velocity.Magnitude/500)
	car.Body.DownforceF.T.Force = Vector3.new(0,(car.DriveSeat.Velocity.Magnitude/-300)*F,0)
	car.Body.DownforceR.T.Force = Vector3.new(0,(car.DriveSeat.Velocity.Magnitude/-300)*R,0)
	car.Body.Drag.T.Force = Vector3.new(0,0,(car.DriveSeat.Velocity.magnitude^2*(Drag/30)))
end

hb:Connect(update)
--------------------------------------------------------------------------------
-- Popper.lua
-- Prevents your camera from clipping through walls.
--------------------------------------------------------------------------------

local Players = game:GetService('Players')

local FFlagUserPoppercamLooseOpacityThreshold do
	local success, enabled = pcall(function()
		return UserSettings():IsUserFeatureEnabled("UserPoppercamLooseOpacityThreshold")
	end)
	FFlagUserPoppercamLooseOpacityThreshold = success and enabled
end

local camera = game.Workspace.CurrentCamera

local min = math.min
local tan = math.tan
local rad = math.rad
local inf = math.huge
local ray = Ray.new

local function eraseFromEnd(t, toSize)
	for i = #t, toSize + 1, -1 do
		t[i] = nil
	end
end

local nearPlaneZ, projX, projY do
	local function updateProjection()
		local fov = rad(camera.FieldOfView)
		local view = camera.ViewportSize
		local ar = view.X/view.Y

		projY = 2*tan(fov/2)
		projX = ar*projY
	end

	camera:GetPropertyChangedSignal('FieldOfView'):Connect(updateProjection)
	camera:GetPropertyChangedSignal('ViewportSize'):Connect(updateProjection)

	updateProjection()

	nearPlaneZ = camera.NearPlaneZ
	camera:GetPropertyChangedSignal('NearPlaneZ'):Connect(function()
		nearPlaneZ = camera.NearPlaneZ
	end)
end

local blacklist = {} do
	local charMap = {}

	local function refreshIgnoreList()
		local n = 1
		blacklist = {}
		for _, character in pairs(charMap) do
			blacklist[n] = character
			n = n + 1
		end
	end

	local function playerAdded(player)
		local function characterAdded(character)
			charMap[player] = character
			refreshIgnoreList()
		end
		local function characterRemoving()
			charMap[player] = nil
			refreshIgnoreList()
		end

		player.CharacterAdded:Connect(characterAdded)
		player.CharacterRemoving:Connect(characterRemoving)
		if player.Character then
			characterAdded(player.Character)
		end
	end

	local function playerRemoving(player)
		charMap[player] = nil
		refreshIgnoreList()
	end

	Players.PlayerAdded:Connect(playerAdded)
	Players.PlayerRemoving:Connect(playerRemoving)

	for _, player in ipairs(Players:GetPlayers()) do
		playerAdded(player)
	end
	refreshIgnoreList()
end
-- Render the map at 0FPS (static since we know it doesn't change)

	for i,d in pairs(workspace.Map:GetDescendants()) do
		if d:IsA("BasePart") then
			local mapObj_Handler = VF_Handler:RenderObject(d)
		end
	end
--create tables:
for i,part in pairs(model:GetChildren()) do
	if string.sub(part.Name, 1,1) == "e" then
		table.insert(e, 1, part)
	end
end
for i,part in pairs(model:GetChildren()) do
	if string.sub(part.Name, 1,1) == "f" then
		table.insert(f, 1, part)
	end
end

function lightOn(T)
	for i, part in pairs (T) do
		if part:FindFirstChild("On") then
			part.On.Value  = true
		end
	end
end

function lightOff(T)
	for i, part in pairs (T) do
		if part:FindFirstChild("On") then
			part.On.Value = false
		end
	end
end

while true do

	lightOn(e)
	wait(0.25)

	lightOff(e)
	wait(0.25)

	lightOn(f)
	wait(0.25)

	lightOff(f)
	wait(0.25)
	
end
--If you want to get teleported to a specific Model, enter the name of the model you want to go to here.
------------------------------------
modelname="tele2"