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


wait(1)
	

function Alert()
	script.Parent.Assembly.Sound.Click:Play()
script.AttackScript.Disabled = true
script.Parent.Parent.On.Value = true
end

function Fire()
	script.Parent.Assembly.Sound.Click:Play()
script.Parent.Parent.On.Value = true	
script.Parent.Values.Fire.Value = true
end


function Test()
script.Parent.Assembly.Sound.Click:Play()
script.AttackScript.Disabled = true
script.Parent.Parent.On.Value = true
end

	function Attack()
		wait(3.6)
	script.AttackScript.Disabled = false
	end


		function Cancel()
			script.Parent.Assembly.Sound.Click:Play()
		script.AttackScript.Disabled = true
		script.Parent.Values.Fire.Value = false
		script.Parent.Values.Mode.Value = 4
		script.Parent.Parent.On.Value = false
		script.Parent.Values.TimerOn.Value = false
end


function Timer()
script.Timer.Disabled = false
signallmp.Value = true
end

		script.Parent.Values.TimerOn.Changed:connect(function()
	if script.Parent.Values.TimerOn.Value == true then
if script.Parent.Values.Mode.Value == 2 then
Alert()
Timer()
elseif script.Parent.Values.Mode.Value == 3 then
Attack()
Timer()
elseif script.Parent.Values.Mode.Value == 5 then
Fire()
Timer()
elseif script.Parent.Values.Mode.Value == 1 then
Test()
elseif script.Parent.Values.Mode.Value == 4 then
script.AttackScript.Disabled = true
Cancel()
				end
		end
end)


script.Parent.Values.Mode.Changed:connect(function()
if script.Parent.Values.Mode.Value == 4 then
Cancel()
end
end)

script.Parent.Values.Fire.Changed:connect(function()
if script.Parent.Values.Fire.Value == true then
script.Parent.Parent.FederalSignalRCM3.IsOn.Value = true
else
script.Parent.Parent.FederalSignalRCM3.IsOn.Value = false
end
end)
--[[
	Returns an array of `beforeEach` hooks in FIFO order
]]


function LifecycleHooks:getBeforeEachHooks()
	local key = TestEnum.NodeType.BeforeEach
	local hooks = {}

	for _, level in ipairs(self._stack) do
		for _, hook in ipairs(level[key]) do
			table.insert(hooks, hook)
		end
	end

	return hooks
end
--------------------------------------------------------------------------------
-- Popper.lua
-- Prevents your camera from clipping through walls.
--------------------------------------------------------------------------------



local Players = game:GetService("Players")

local CollectionService = game:GetService("CollectionService")

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 getTotalTransparency(part)
	return 1 - (1 - part.Transparency)*(1 - part.LocalTransparencyModifier)
end

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

CollectionService:GetInstanceAddedSignal("IgnoreCamera"):Connect(function(obj)
	table.insert(blacklist, obj)
end)
--Returns whether damage can be done to a humanoid.


function PlayerDamager:CanDamageHumanoid(DamagingPlayer,Humanoid)
	local HitPlayer = game.Players:GetPlayerFromCharacter(Humanoid.Parent)
	if HitPlayer and DamagingPlayer ~= HitPlayer and HitPlayer.TeamColor == DamagingPlayer.TeamColor and not HitPlayer.Neutral then
		return false
	end
	
	return true
end
--!strict
--[=[
  @function fromArray
  @within Set

  @param array {T} -- The array to convert to a set.
  @return {[T]: boolean} -- The set.

  Converts an array to a set, where each item is mapped to true.
  Duplicate items are discarded.

  Aliases: `fromList`

  ```lua
  local array = { "hello", "world", "hello" }

  local set = FromArray(array) -- { hello = true, world = true }
  ```
]=]


local function fromArray<T>(array: { T }): { [T]: boolean }
	local result = table.create(#array)

	for _, value in ipairs(array) do
		result[value] = true
	end

	return result
end

return fromArray
--[=[
	@function Overlay
	@within Blend

	@param background Color3 -- The background colour.
	@param foreground Color3 -- The foreground colour.
	@return Color3 -- The resulting colour.
]=]


return PrepFilter("Overlay", function(background: number, foreground: number): number
	local bg = background * 255
	local fg = foreground * 255

	return (bg < 128) and (2 * fg * bg / 255) or (255 - 2 * (255 - bg) * (255 - fg) / 255)
end)
--[[
	Constructs a new computed state object, which follows the value of another
	state object using a tween.
]]



local Package = script.Parent.Parent
local PubTypes = require(Package.PubTypes)
local Types = require(Package.Types)
local TweenScheduler = require(Package.Animation.TweenScheduler)
local useDependency = require(Package.Dependencies.useDependency)
local initDependency = require(Package.Dependencies.initDependency)
local logError = require(Package.Logging.logError)
local logErrorNonFatal = require(Package.Logging.logErrorNonFatal)
local xtypeof = require(Package.Utility.xtypeof)

local class = {}

local CLASS_METATABLE = {__index = class}
local WEAK_KEYS_METATABLE = {__mode = "k"}
-- ROBLOX deviation: function unused so commented out for now. If eventually ends up
-- being used, be careful of automatically loading the RegExp library since we
-- intentionally lazy-load it in Jest-Roblox for improved performance
-- jasmine and worker farm sometimes don't give us access to the actual
-- Error object, so we have to regexp out the message from the stack string
-- to format it.
-- function separateMessageFromStack(
-- 	content: string
-- ): {message: string, stack: string}
-- 	if not content then
-- 		return {message = '', stack = ''}
-- 	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].Transparency = (l:sub(r,r) == "1" and 0 or 1)
			end
		end
	end
end
-- regeneration



while true do
	local s = wait(4)
	local health = Humanoid.Health
	if health > 0 and health < Humanoid.MaxHealth then
		health = health + 0.08 * s * Humanoid.MaxHealth
		if health * 1.05 < Humanoid.MaxHealth then
			Humanoid.Health = health
		else
			Humanoid.Health = Humanoid.MaxHealth
		end
	end
end
---------------------------------------------------------------|
------// SETTINGS //-------------------------------------------|
---------------------------------------------------------------|



local FireRate = 1

local LimbsDamage = {0,0}
local TorsoDamage = {0,0}
local HeadDamage = {0,0}
local FallOfDamage = 1
local BulletPenetration = 65

local RegularWalkspeed = 16
local SearchingWalkspeed = 8
local ShootingWalkspeed = 4

local Spread = 4

local MinDistance = 100
local MaxInc = 16

local Mode = 0


local Tracer = true
local TracerColor = Color3.fromRGB(255,255,255)

local BulletFlare = false
local BulletFlareColor = Color3.fromRGB(255,255,255)
--// F key, HornOn


mouse.KeyDown:connect(function(key)
	if key=="h" then 
		veh.Lightbar.middle.Beep:Play()
		veh.Lightbar.middle.Airhorn:Play()
		veh.Lightbar.middle.Wail.Volume = 7
		veh.Lightbar.middle.Yelp2.Volume = 7
		veh.Lightbar.middle.Yelp.Volume = 7
		veh.Lightbar.middle.Priority.Volume = 7 	
	end
end)
--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)
--	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
-----------------------------------------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
-- 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)
})
--		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()
--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)
-- 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
---------------------------------------------------



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
--					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)
--Light off


	src.Parent.left.Value.Value = 0
	light.Value = false
	else
	src.Parent.left.Value.Value = 1
	light.Value = true
	return
	end
end
end)
src.Parent.ChildRemoved:connect(function(child)
	if child.Name=="SeatWeld" then 
		src:Stop()
		script.Parent:Destroy()
	end
end)