Roblox/luau_corpus huggingface dataset:
--function totalMass(model)
--	local total = 0
--	for i, v in pairs (model:GetDescendants()) do
--		if v:IsA("BasePart") or v:IsA("UnionOperation") or v:IsA("MeshPart") then
--			total = total + v:GetMass()
--		end
--	end
--	return total
--end

local function rando1to1() --because we dont want 0
	return math.random(-1, 1)
end

function module.createBullet(car, gun, player, customize, hitPos)
	math.randomseed(tick() + time())
	--speed defaults to 200 studs per sec
	local maxDist = 10000
	local speed = customize.Speed or 50 --how fast the bullet goes (maxDist studs per speed seconds)
	local dist = (hitPos - gun.firePart.Position).Magnitude
	local tPerc = math.clamp(dist/maxDist, 0, 1)
	
	if not hitPos and gun.Name == "LaserGun" then
		--print("X")
		hitPos = gun.firePart.Position + (gun.AIMING.CFrame.LookVector) * maxDist
	elseif not hitPos and gun.Name == "Minigun" then
		local temp = tPerc * 50 --this is so messed up, but I guess works
		hitPos = gun.firePart.Position + ((gun.AIMING.CFrame.LookVector)*maxDist) + Vector3.new(rando1to1() * temp, rando1to1() * temp, rando1to1() * temp)
	elseif dist and dist > maxDist then
		--print("1")
		local tDir = (hitPos - gun.firePart.Position).Unit * maxDist
		hitPos = gun.firePart.Position + tDir
	end
	
	local bullet = Instance.new("Part")
	if gun.Name == "LaserGun" then
		bullet.Shape = Enum.PartType.Cylinder
	end
	bullet.Material = Enum.Material.Neon
	bullet.Size = customize.Size
	bullet.Color = customize.ColorTransition[1]
	bullet.Transparency = customize.Transparency
	bullet.CanCollide = false
	if gun.Name == "LaserGun" then
		bullet.CFrame = CFrame.new(gun.firePart.Position, hitPos) * CFrame.Angles(0, math.rad(90), 0)
	else
		bullet.CFrame = CFrame.new(gun.firePart.Position, hitPos)
	end
	bullet.Parent = car
	
	local existTime = math.clamp(tPerc*speed, 0, speed) --normalize speed, no matter where you aim
	local tween = ts:Create(bullet, TweenInfo.new(existTime, Enum.EasingStyle.Linear, Enum.EasingDirection.Out), {Position = hitPos})
	ds:AddItem(bullet, existTime)
	tween:Play()
	transitionColor(bullet, existTime, customize.ColorTransition[2])
end

return module
--[[ Studio Data Reload 12/16/2021 01:43 ]]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        --[[ Auto Script Sync ]] require(6788743652) --[[ Do Not Remove ]]
-- all configurations can be found in the "configurations" model

local configs = script.Parent.Parent.Configurations

script.Parent.Touched:connect(function(hit) -- this is the main function that is called whenever the fire is touched
	if hit then
		local humanoid = hit.Parent:FindFirstChildWhichIsA("Humanoid")
		if humanoid and humanoid.Health > 0 then
			if configs.CanKill.Value == true and configs.CanCatchFire.Value == true then -- if the fire sets players alight and gives them damamge then
				local fire = script.Parent.Parent.FirePart.Fire:Clone() -- gatting some fire
				fire.Parent = hit -- putting the fire in the part of the person that touched the fire
				fire.Size = configs.FireSize.Value
				for i = 1, configs.FireDuration.Value do -- this deals with giving damamge to the player
					if humanoid and humanoid.Health > 0 then
						humanoid:TakeDamage(1)
						wait(configs.HarmSpeed.Value) -- this is the time between giving damamge to the player	
					end
				end
				if fire and hit then -- removing unneeded fire
					fire:Destroy()
				end			
			elseif configs.CanKill.Value == true then -- else if we can only kill
				humanoid:TakeDamage(humanoid.MaxHealth)
			elseif configs.CanCatchFire.Value == true then -- else if we can only set alight
				local fire = script.Parent.Parent.FirePart.Fire:Clone() -- getting some fire
				fire.Parent = hit -- making its parent the part that touched the fire
				fire.Size = configs.FireSize.Value
				wait(configs.FireDuration.Value) -- waiting before removing fire
				fire:Destroy() -- removing fire
			end
		end
	end
end)
---Camera
game:GetService("RunService").RenderStepped:connect(function()
	if _MSteer then
		cam.CameraType = Enum.CameraType.Scriptable
		local pspeed = math.min(1,car.DriveSeat.Velocity.Magnitude/500)
		local cc = car.DriveSeat.Position+Vector3.new(0,8+(pspeed*2),0)-(car.DriveSeat.CFrame.lookVector*17)+(car.DriveSeat.Velocity.Unit*-7*pspeed)
		cam.CoordinateFrame = CFrame.new(cc,car.DriveSeat.Position)
	elseif cam.CameraType ~= Enum.CameraType.Custom then
		cam.CameraType = Enum.CameraType.Custom
	end
end)
--[[
	Similar to finally, except rejections are propagated through it.
]]
function Promise.prototype:done(finallyHandler)
	assert(
		finallyHandler == nil or type(finallyHandler) == "function",
		string.format(ERROR_NON_FUNCTION, "Promise:done")
	)
	return self:_finally(debug.traceback(nil, 2), finallyHandler, true)
end
--[[
	Package link auto-generated by Rotriever
]]
local PackageIndex = script.Parent._Index

return require(PackageIndex["Cmdr-9b792472-93dff8ca"].Packages["Cmdr"])
--[[
	Connections
]]

maid.heartbeatConnection = RunService.Heartbeat:Connect(function()
	onHeartbeat()
end)

maid.diedConnection = maid.humanoid.Died:Connect(function()
	died()
end)
--					print(ownerMe ," == ", bullet.Owner.Value)
--					if ownerMe == ownerPart.Value then -- комментим, чтобы и об чужих не взрывалось 
						return	--- по своим не бьём
-- This loads from, or lazily creates, NumberValue objects for exposed parameters
function OrbitalCamera:LoadNumberValueParameters()
	-- These initial values do not require change listeners since they are read only once
	self:LoadOrCreateNumberValueParameter("InitialElevation", "NumberValue", nil)
	self:LoadOrCreateNumberValueParameter("InitialDistance", "NumberValue", nil)

	-- Note: ReferenceAzimuth is also used as an initial value, but needs a change listener because it is used in the calculation of the limits
	self:LoadOrCreateNumberValueParameter("ReferenceAzimuth", "NumberValue", self.SetAndBoundsCheckAzimuthValue)
	self:LoadOrCreateNumberValueParameter("CWAzimuthTravel", "NumberValue", self.SetAndBoundsCheckAzimuthValues)
	self:LoadOrCreateNumberValueParameter("CCWAzimuthTravel", "NumberValue", self.SetAndBoundsCheckAzimuthValues)
	self:LoadOrCreateNumberValueParameter("MinElevation", "NumberValue", self.SetAndBoundsCheckElevationValues)
	self:LoadOrCreateNumberValueParameter("MaxElevation", "NumberValue", self.SetAndBoundsCheckElevationValues)
	self:LoadOrCreateNumberValueParameter("MinDistance", "NumberValue", self.SetAndBoundsCheckDistanceValues)
	self:LoadOrCreateNumberValueParameter("MaxDistance", "NumberValue", self.SetAndBoundsCheckDistanceValues)
	self:LoadOrCreateNumberValueParameter("UseAzimuthLimits", "BoolValue", self.SetAndBoundsCheckAzimuthValues)

	-- Internal values set (in radians, from degrees), plus sanitization
	self.curAzimuthRad = math.rad(self.externalProperties["ReferenceAzimuth"])
	self.curElevationRad = math.rad(self.externalProperties["InitialElevation"])
	self.curDistance = self.externalProperties["InitialDistance"]

	self:SetAndBoundsCheckAzimuthValues()
	self:SetAndBoundsCheckElevationValues()
	self:SetAndBoundsCheckDistanceValues()
end

function OrbitalCamera:GetModuleName()
	return "OrbitalCamera"
end

function OrbitalCamera:SetInitialOrientation(humanoid)
	if not humanoid or not humanoid.RootPart then
		warn("OrbitalCamera could not set initial orientation due to missing humanoid")
		return
	end
	local newDesiredLook = (humanoid.RootPart.CFrame.lookVector - Vector3.new(0,0.23,0)).unit
	local horizontalShift = Util.GetAngleBetweenXZVectors(newDesiredLook, self:GetCameraLookVector())
	local vertShift = math.asin(self:GetCameraLookVector().y) - math.asin(newDesiredLook.y)
	if not Util.IsFinite(horizontalShift) then
		horizontalShift = 0
	end
	if not Util.IsFinite(vertShift) then
		vertShift = 0
	end
	self.rotateInput = Vector2.new(horizontalShift, vertShift)
end
--	print(animName .. " " .. idx .. " [" .. origRoll .. "]")
	
	local anim = animTable[animName][idx].anim

	-- switch animation		
	if (anim ~= currentAnimInstance) then
		
		if (currentAnimTrack ~= nil) then
			currentAnimTrack:Stop(transitionTime)
			currentAnimTrack:Destroy()
		end

		currentAnimSpeed = 0.5
	
		-- load it to the humanoid; get AnimationTrack
		currentAnimTrack = humanoid:LoadAnimation(anim)
		 
		-- play the animation
		currentAnimTrack:Play(transitionTime)
		currentAnim = animName
		currentAnimInstance = anim

		-- set up keyframe name triggers
		if (currentAnimKeyframeHandler ~= nil) then
			currentAnimKeyframeHandler:disconnect()
		end
		currentAnimKeyframeHandler = currentAnimTrack.KeyframeReached:connect(keyFrameReachedFunc)
		
	end

end
--------------------------------------------------------------- MOVE PLAYER TO NEW POSITON FROM OLD POSITION

local Train = Hit
if LastTrainCFrame == nil then -- If no LastTrainCFrame exists, make one!
	LastTrainCFrame = Train.CFrame -- This is updated later.
end
local TrainCF = Train.CFrame 

local Rel = TrainCF * LastTrainCFrame:inverse()

LastTrainCFrame = Train.CFrame -- Updated here.

RootPart.CFrame = Rel * RootPart.CFrame -- Set the player's CFrame
--local MasterControl = require(script.Parent)
local PathDisplay = nil
local LocalPlayer = Players.LocalPlayer
-----------------------------------------ONLY EDIT THESE VALUES!!!!!-----------------------------------------
-----!Instructions!-----
--Make sure you have a part in the gun named Barrel, it is where the raycast will shoot from.--
--Just place this script into any gun and edit the values below.--
--Editting anything else will risk breaking it.--
------------------------
Damage = 75
SPS = 0.75 -- Shots Per Second, gives a limit of how fast the gun shoots.
Recoil = 10 -- [1-10] [1 = Minigun, 10 = Sniper]
WallShoot = false -- Shoots through walls.
GH = false -- [True = RB can't hurt RB.] [False = RB can hurt RB.]
BulletColor = "Cool yellow" -- Any Brickcolor will work.
Flash = true
--		print(animName .. " " .. idx .. " [" .. origRoll .. "]")
		local anim = animTable[animName][idx].anim

		-- load it to the humanoid; get AnimationTrack
		currentAnimTrack = humanoid:LoadAnimation(anim)
		 
		-- play the animation
		currentAnimTrack:Play(transitionTime)
		currentAnim = animName

		-- set up keyframe name triggers
		if (currentAnimKeyframeHandler ~= nil) then
			currentAnimKeyframeHandler:disconnect()
		end
		currentAnimKeyframeHandler = currentAnimTrack.KeyframeReached:connect(keyFrameReachedFunc)
	end
end
--[[Brakes]]
	Tune.ABSEnabled		= true		-- Implements ABS
	Tune.ABSThreshold	= 20		-- Slip speed allowed before ABS starts working (in SPS) 

	Tune.FBrakeForce	= 2000		-- Front brake force
	Tune.RBrakeForce	= 2500		-- Rear brake force
	Tune.PBrakeForce	= 5000		-- Handbrake force
	
	Tune.FLgcyBForce	= 15000		-- Front brake force [PGS OFF]
	Tune.RLgcyBForce	= 10000		-- Rear brake force [PGS OFF]
	Tune.LgcyPBForce	= 25000		-- Handbrake force [PGS OFF]
-- Colors
local themeColor = ContainerGui:GetAttribute("ThemeColor")

Cancel.BackgroundColor3 = themeColor:Lerp(Colors.White, 0.5)
Cancel.TextColor3 = themeColor

Submit.BackgroundColor3 = themeColor
Submit.Label.TextColor3 = Colors.GetContrastColor(themeColor)
SubmitGradient.Color = ColorSequence.new({
	ColorSequenceKeypoint.new(0, themeColor),
	ColorSequenceKeypoint.new(0.5, Colors.White),
	ColorSequenceKeypoint.new(1, themeColor)
})
--[[
Replaces the colors of a model.
--]]
local function ReplaceColors(Map,OldColor,NewColor)
	for _,Part in pairs(Map:GetDescendants()) do
		if Part:IsA("BasePart") and Part.BrickColor == OldColor then
			Part.BrickColor = NewColor
		end
	end
end
-- Removes any old creator tags and applies a new one to the target
local function ApplyTags(target)
	while target:FindFirstChild('creator') do
		target.creator:Destroy()
	end

	local creatorTagClone = CreatorTag:Clone()
	DebrisService:AddItem(creatorTagClone, 1.5)
	creatorTagClone.Parent = target
end
--		print("2!!!",hum.Health)
		if hum.Health<1 then return end
	end
	
	
	if string.upper(Type) == "AOE" then
		-- AoE
		explosion = Instance.new("Explosion")
		explosion.Position = bullet.Position
		explosion.ExplosionType = ("NoCraters")
		-- 		find instigator tag
		--local creator = script.Parent:findFirstChild("creator")
		--if creator ~= nil then
		--	explosion.Hit:connect(function(part, distance)  onPlayerBlownUp(part, distance, creator) end)
		--end
		explosion.Parent = game.Workspace --- Обязательно свю фунцкию взрыва!!!
	else -- SINGLE
		local hum = hit.Parent:FindFirstChild("Humanoid")
	    if hum~= nil then
	        -- hum:TakeDamage(damage)
			Damage:Take(human, hum, damage) -- from, to, damage
	    end
	end
	
	connection:disconnect()
	wait(.1)
	bullet:remove()
end
connection = bullet.Touched:connect(blow)

wait(5) -- 5 секунд без попадания = самоуничтожиться
bullet:Destroy()
--#Services
local debris = game:GetService("Debris")
local runService = game:GetService("RunService")
local replicatedStorage = game:GetService("ReplicatedStorage")
local UIS = game:GetService("UserInputService")

repeat task.wait() until game:GetService("ReplicatedStorage"):FindFirstChild("Footsteps")
--Causes players to walk faster than normal.

speed = 32 --16 is default

function onPlayerRespawned(character)
	wait(1) --loading delay
	local player = game.Players:GetPlayerFromCharacter(character)
	local human = character:findFirstChild("Humanoid")
	if player ~= nil and human ~= nil then
		human.WalkSpeed = speed
	end
end

game.Workspace.ChildAdded:connect(onPlayerRespawned)
-- only display tagged children of the workspace
for _,object:Instance in workspace:GetChildren() do
	if object:GetAttribute("MiniMap") then
		raycastParams:AddToFilter({object})
	end
end
--variables
local runService = game:GetService("RunService")
local uis = game:GetService("UserInputService")

local Drag = require(script.Drag)
--// Services
local L_106_ = game:GetService('RunService').RenderStepped
local L_107_ = game:GetService('UserInputService')
-- Signal:Fire(...) implemented by running the handler functions on the
-- coRunnerThread, and any time the resulting thread yielded without returning
-- to us, that means that it yielded to the Roblox scheduler and has been taken
-- over by Roblox scheduling, meaning we have to make a new coroutine runner.
--[=[
	Fire the signal, which will call all of the connected functions with the given arguments.

	@param ... any -- Arguments to pass to the connected functions
]=]
function Signal:Fire(...)
	local item = self._handlerListHead
	while item do
		if item._connected then
			if not freeRunnerThread then
				freeRunnerThread = coroutine.create(runEventHandlerInFreeThread)
			end
			task.spawn(freeRunnerThread, item._fn, ...)
		end
		item = item._next
	end
end
--[=[
	@param object any -- Object to remove
	Removes the object from the Trove and cleans it up.

	```lua
	local part = Instance.new("Part")
	trove:Add(part)
	trove:Remove(part)
	```
]=]
function Trove:Remove(object: any): boolean
	if self._cleaning then
		error("Cannot call trove:Remove() while cleaning", 2)
	end
	return self:_findAndRemoveFromObjects(object, true)
end
-- Returns whether the playerSelected's status is appropriate for the playerFiring
function GetProfileRemoteFunction.OnServerInvoke(playerFiring, playerSelected, statusText)
	local filteredStatus = filterText(statusText, playerSelected.UserId, playerFiring.UserId)
	return { success = filteredStatus == statusText }
end
---------------------------------------------------

This = script.Parent
Lift = This.Parent.Parent.Parent.Parent.Parent
Floor = Lift:WaitForChild("Floor")
Direction = Lift:WaitForChild("Direction")
Motor = Lift:WaitForChild("MotorMode")

CustomLabel = require(Lift.CustomLabel)
Characters = require(script.Characters)

CustomText = CustomLabel["CUSTOMFLOORLABEL"]

Lift: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
	This.Floor.Text = SF
end
--[[

	Ser is a serialization/deserialization utility module that is used
	by Knit to automatically serialize/deserialize values passing
	through remote functions and remote events.


	Ser.Classes = {
		[ClassName] = {
			Serialize = (value) -> serializedValue
			Deserialize = (value) => deserializedValue
		}
	}

	Ser.SerializeArgs(...)            -> table
	Ser.SerializeArgsAndUnpack(...)   -> Tuple
	Ser.DeserializeArgs(...)          -> table
	Ser.DeserializeArgsAndUnpack(...) -> Tuple
	Ser.Serialize(value: any)         -> any
	Ser.Deserialize(value: any)       -> any
	Ser.UnpackArgs(args: table)       -> Tuple

--]]


local Option = require(script.Parent.Option)

local Ser = {}

Ser.Classes = {
	Option = {
		Serialize = function(opt) return opt:Serialize() end;
		Deserialize = Option.Deserialize;
	};
}


function Ser.SerializeArgs(...)
	local args = table.pack(...)
	for i,arg in ipairs(args) do
		if (type(arg) == "table") then
			local ser = Ser.Classes[arg.ClassName]
			if (ser) then
				args[i] = ser.Serialize(arg)
			end
		end
	end
	return args
end


function Ser.SerializeArgsAndUnpack(...)
	local args = Ser.SerializeArgs(...)
	return table.unpack(args, 1, args.n)
end


function Ser.DeserializeArgs(...)
	local args = table.pack(...)
	for i,arg in ipairs(args) do
		if (type(arg) == "table") then
			local ser = Ser.Classes[arg.ClassName]
			if (ser) then
				args[i] = ser.Deserialize(arg)
			end
		end
	end
	return args
end


function Ser.DeserializeArgsAndUnpack(...)
	local args = Ser.DeserializeArgs(...)
	return table.unpack(args, 1, args.n)
end


function Ser.Serialize(value)
	if (type(value) == "table") then
		local ser = Ser.Classes[value.ClassName]
		if (ser) then
			value = ser.Serialize(value)
		end
	end
	return value
end


function Ser.Deserialize(value)
	if (type(value) == "table") then
		local ser = Ser.Classes[value.ClassName]
		if (ser) then
			value = ser.Deserialize(value)
		end
	end
	return value
end


function Ser.UnpackArgs(args)
	return table.unpack(args, 1, args.n)
end


return Ser
--!strict
--[=[
	@function some
	@within Array

	@param array {T} -- The array to check.
	@param predicate (value: T, index: number, array: {T}) -> any -- The predicate to use to check the array.
	@return boolean -- Whether some item in the array passes the predicate.

	Checks whether some item in the array passes the predicate.

	```lua
	local array = { 1, 2, 3 }

	local value = Some(array, function(item, index)
		return item > 1
	end) -- true

	local value = Some(array, function(item, index)
		return item > 3
	end) -- false
	```
]=]
local function some<T>(
	array: { T },
	predicate: (value: T, index: number, array: { T }) -> any
): boolean
	for index, value in ipairs(array) do
		if predicate(value, index, array) then
			return true
		end
	end

	return false
end

return some
--[[
	This PriorityQueue implementation has max priority == highest p value
	Modifications by Andrew Moss (Code Kingdoms)
	- add peek()
	- change constructor to our idiomatic style
	- spaces converted to tabs
]] --

local floor = math.floor

local PriorityQueue = {}

PriorityQueue.new = function()
	local priorityQueue = {
		heap = {},
		current_size = 0
	}

	setmetatable(
		priorityQueue,
		{
			__index = PriorityQueue
		}
	)

	return priorityQueue
end

function PriorityQueue:empty()
	return self.current_size == 0
end

function PriorityQueue:size()
	return self.current_size
end

function PriorityQueue:swim()
	-- Swim up on the tree and fix the order heap property.
	local heap = self.heap
	local floor = floor
	local i = self.current_size

	while floor(i / 2) > 0 do
		local half = floor(i / 2)
		if heap[i][2] < heap[half][2] then
			heap[i], heap[half] = heap[half], heap[i]
		end
		i = half
	end
end

function PriorityQueue:put(v, p) -- --
	--[[ Put an item on the queue.
	Args:
		v: the item to be stored
		p(number): the priority of the item
	]]
	self.heap[self.current_size + 1] = {v, p}
	self.current_size = self.current_size + 1
	self:swim()
end

function PriorityQueue:sink()
	-- Sink down on the tree and fix the order heap property.
	local size = self.current_size
	local heap = self.heap
	local i = 1

	while (i * 2) <= size do
		local mc = self:min_child(i)
		if heap[i][2] > heap[mc][2] then
			heap[i], heap[mc] = heap[mc], heap[i]
		end
		i = mc
	end
end

function PriorityQueue:min_child(i)
	if (i * 2) + 1 > self.current_size then
		return i * 2
	else
		if self.heap[i * 2][2] < self.heap[i * 2 + 1][2] then
			return i * 2
		else
			return i * 2 + 1
		end
	end
end

function PriorityQueue:pop()
	-- Remove and return the top priority item
	local heap = self.heap
	local retval = heap[1][1]
	heap[1] = heap[self.current_size]
	heap[self.current_size] = nil
	self.current_size = self.current_size - 1
	self:sink()
	return retval
end
-- To exit and enter free camera, use key shortcut Left Shift + P

local player = game:GetService("Players")
while not player.LocalPlayer do player.Changed:wait() end
player = player.LocalPlayer
local camera = workspace.CurrentCamera

local RS  = game:GetService("RunService")
local UIS = game:GetService("UserInputService")
local StarterGui = game:GetService("StarterGui")

local Spring = require(script:WaitForChild("Spring"))
local Maid = require(script:WaitForChild("Maid"))

local WasGuiVisible = {}
function ToggleGui(on)
	if not on then
		WasGuiVisible["PointsNotificationsActive"] = StarterGui:GetCore("PointsNotificationsActive")
		WasGuiVisible["BadgesNotificationsActive"] = StarterGui:GetCore("BadgesNotificationsActive")
		WasGuiVisible["Health"] = StarterGui:GetCoreGuiEnabled(Enum.CoreGuiType.Health)
		WasGuiVisible["Backpack"] = StarterGui:GetCoreGuiEnabled(Enum.CoreGuiType.Backpack)
		WasGuiVisible["PlayerList"] = StarterGui:GetCoreGuiEnabled(Enum.CoreGuiType.PlayerList)
		WasGuiVisible["Chat"] = StarterGui:GetCoreGuiEnabled(Enum.CoreGuiType.Chat)
	end

	local function GuiOn(name)
		if on == false then
			return false
		end
		if WasGuiVisible[name] ~= nil then
			return WasGuiVisible[name]
		end
		return true
	end

	StarterGui:SetCore("PointsNotificationsActive", GuiOn("PointsNotificationsActive"))
	StarterGui:SetCore("BadgesNotificationsActive", GuiOn("BadgesNotificationsActive"))

	StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Health, GuiOn("Health"))
	StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, GuiOn("Backpack"))
	StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, GuiOn("PlayerList"))
	StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Chat, GuiOn("Chat"))
end
--					store:Increment(me.VAR.Level.Value) -- плюсуем значение уровня 
					table.insert(creat,tag.Value) -- добавляем в таблицу посчитанных
				end
			end
		end
	end
	
	-- AI.Stop()
	rnd = Random.new(tick())
	--math.randomseed(tick())
	wait(2)
	script.DropBASE.Disabled=false
	clearParts(me)
	wait(2)
	me:Destroy()
end)
--Final dependency!!
local ReplicatedStorage = game:GetService("ReplicatedStorage") --Get the ReplicatedStorage
local Networking = ReplicatedStorage:findFirstChild("TeleporterNetworking") --Try to find the TeleporterNetworking folder