Pinkstack/roblox-luau-corpus-text huggingface dataset:
------------------------------------------------------------------------------
--------------------[ MAIN PROGRAM ]------------------------------------------
------------------------------------------------------------------------------



function DetonateExplosive()
	local GrenadePos = Main.Position
	
	CreateShockwave(Main.Position, S.GrenadeBlastRadius)
	
	Sound:Play()
	
	local E = Instance.new("Explosion")
	E.BlastPressure = S.GrenadeBlastPressure
	E.BlastRadius = S.GrenadeBlastRadius
	E.DestroyJointRadiusPercent = (S.GrenadeRangeBasedDamage and 0 or 1)
	E.ExplosionType = S.GrenadeExplosionType
	E.Position = GrenadePos
	E.Hit:connect(function(HObj, HDist)
		if (not IsIgnored(HObj)) and HObj.Name == "Torso" then
			if S.GrenadeRangeBasedDamage then
				local ClosestPart = nil
				local ClosestDist = math.huge
				
				for _, P in pairs(HObj.Parent:GetChildren()) do
					if P:IsA("BasePart") then
						local Dist = (GrenadePos - P.Position).magnitude
						if Dist < ClosestDist then
							ClosestPart = P
							ClosestDist = Dist
						end
					end
				end
				
				local Dir = (ClosestPart.Position - GrenadePos).unit
				local H, P = AdvRayCast(GrenadePos, Dir, 999)
				local RayHitHuman = H:IsDescendantOf(HObj.Parent)
				if (S.GrenadeRayCastExplosions and RayHitHuman) or (not S.GrenadeRayCastExplosions) then
					local HitHumanoid = FindFirstClass(HObj.Parent, "Humanoid")
					if HitHumanoid and HitHumanoid.Health > 0 and IsEnemy(HitHumanoid) then
						local DistFactor = ClosestDist / S.GrenadeBlastRadius
						local DistInvert = math.max(1 - DistFactor, 0)
						local NewDamage = DistInvert * S.LethalGrenadeDamage
						
						local CreatorTag = Instance.new("ObjectValue")
						CreatorTag.Value = Plyr
						CreatorTag.Name = "creator"
						CreatorTag.Parent = HitHumanoid
						HitHumanoid:TakeDamage(NewDamage)
						MarkHit()
					end
				end
			else
				local HitHumanoid = FindFirstClass(HObj.Parent, "Humanoid")
				if HitHumanoid and HitHumanoid.Health > 0 and IsEnemy(HitHumanoid) then
					local CreatorTag = Instance.new("ObjectValue")
					CreatorTag.Value = Plyr
					CreatorTag.Name = "creator"
					CreatorTag.Parent = HitHumanoid
					MarkHit()
				end
			end
		end
	end)
	E.Parent = game.Workspace
	
	Main.Transparency = 1
	Main.Anchored = true
	Main.CanCollide = false
	
	wait(1)
	
	Main:Destroy()
end

if S.TimerStartOnHit then
	local Detonated = false
	Main.Touched:connect(function(Obj)
		if IsIgnored(Obj) or Detonated then return end
		Main.Velocity = Main.Velocity / 4
		Detonated = true
		
		wait(S.DetonationTime)
		
		DetonateExplosive()
	end)
else
	spawn(function()
		local Touched = false
		Main.Touched:connect(function(Obj)
			if IsIgnored(Obj) or Touched then return end
			Touched = true
			Main.Velocity = Main.Velocity / 4
		end)
	end)
	wait(S.DetonationTime)
	DetonateExplosive()
end
--[[ss1.Touched:connect(function()
	if IsOpen.Value == false then
		OtherDir.Value = false
		opendoor()
		wait(TimeDelay)
		closedoor()
	end
end)]]



handle.ClickDetector.MouseClick:connect(function()
	if IsOpen.Value == false then
		OtherDir.Value = false
		opendoor()
		wait(TimeDelay)
		closedoor()
	end
end)
-- A state object which follows another state object using tweens.


export type Tween<T> = PubTypes.Tween<T> & {
	_goalState: State<T>,
	_tweenInfo: TweenInfo,
	_prevValue: T,
	_nextValue: T,
	_currentValue: T,
	_currentTweenInfo: TweenInfo,
	_currentTweenDuration: number,
	_currentTweenStartTime: number,
	_currentlyAnimating: boolean
}
--[[
	Contains deprecated methods from Reconciler. Broken out so that removing
	this shim is easy -- just delete this file and remove it from init.
]]



local Logging = require(script.Parent.Logging)

local reifyMessage = [[
Roact.reify has been renamed to Roact.mount and will be removed in a future release.
Check the call to Roact.reify at:
]]

local teardownMessage = [[
Roact.teardown has been renamed to Roact.unmount and will be removed in a future release.
Check the call to Roact.teardown at:
]]

local reconcileMessage = [[
Roact.reconcile has been renamed to Roact.update and will be removed in a future release.
Check the call to Roact.reconcile at:
]]

local function createReconcilerCompat(reconciler)
	local compat = {}

	function compat.reify(...)
		Logging.warnOnce(reifyMessage)

		return reconciler.mountVirtualTree(...)
	end

	function compat.teardown(...)
		Logging.warnOnce(teardownMessage)

		return reconciler.unmountVirtualTree(...)
	end

	function compat.reconcile(...)
		Logging.warnOnce(reconcileMessage)

		return reconciler.updateVirtualTree(...)
	end

	return compat
end

return createReconcilerCompat
--Interface


function draw_invincibility:Enable()
	--Enable trails
	for _,v in pairs(self.particles) do
		v.Enabled = true
	end
	self.en_time = self.part_time
	self.enabled = true
end

function draw_invincibility:Disable()
	--Disable trails
	for _,v in pairs(self.particles) do
		v.Enabled = false
	end
	self.enabled = false
end

function draw_invincibility:Draw(dt, hrp_cf)
	if not self.enabled then
		self.en_time -= dt
	end
	if self.en_time > 0 and hrp_cf ~= self.hrp_cf then
		--Set invincibility CFrame
		self.invincibility:SetPrimaryPartCFrame(hrp_cf)
		self.hrp_cf = hrp_cf
	end
end

function draw_invincibility:LazyDraw(dt, hrp_cf)
	if not self.enabled then
		self.en_time -= dt
	end
	if self.en_time > 0 and hrp_cf ~= self.hrp_cf then
		--Set invincibility CFrame
		self.invincibility:SetPrimaryPartCFrame(hrp_cf)
		self.hrp_cf = hrp_cf
	end
end

return draw_invincibility
--player.CharacterAdded:Wait()
--player.Character:WaitForChild("Humanoid")
--player.Character:WaitForChild("HumanoidRootPart")
--camera.CameraSubject = player.Character.HumanoidRootPart



local function onCharacterAdded(character)
	character:WaitForChild("HumanoidRootPart")
	camera.CameraSubject = player.Character.HumanoidRootPart
end

game.Players.LocalPlayer.CharacterAdded:Connect(onCharacterAdded)

game:GetService("RunService").Stepped:connect(function(currTime,dt)
	if(isPlayerRevive and player.Character ~= nil) then
		local character = player.Character
		if(character:FindFirstChild("HumanoidRootPart") == nil) then
			return
		end
		local torso = character.HumanoidRootPart
		local newFrame  = 	CFrame.new(Vector3.new(torso.Position.X , torso.Position.Y + 10, torso.Position.Z - 10) + currentPosition,
			Vector3.new(torso.Position.X,  torso.Position.Y, torso.Position.Z - 10) + currentTarget)
		camera.CFrame = camera.CFrame:Lerp(newFrame, cameraSpeed * dt)
	end
	
end)
--[[Engine]]


	--Torque Curve
	Tune.Horsepower		= 600		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 7000		--		Use sliders to manipulate values
	Tune.Redline		= 7500		--		Copy and paste slider values into the respective tune values
	Tune.ComfortShift   = 3500
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16
	
	--Incline Compensation
	Tune.InclineComp	= 1.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)
--function ClassZombie:FindWay(Goal)
--	local Humanoid = self.Humanoid
--	local PathFindingService = game:GetService('PathfindingService')
--	local Path = PathFindingService:CreatePath()
--	Path:ComputeAsync(self.Character.PrimaryPart.Position, Goal)
--	local WaypointsArray = Path:GetWaypoints()
--	return WaypointsArray
--end
--[[
	Flush all pending actions since the last change event was dispatched.
]]


function Store:flush()
	if not self._mutatedSinceFlush then
		return
	end

	self._mutatedSinceFlush = false

	-- On self.changed:fire(), further actions may be immediately dispatched, in
	-- which case self._lastState will be set to the most recent self._state,
	-- unless we cache this value first
	local state = self._state

	local ok, errorResult = xpcall(function()
		-- If a changed listener yields, *very* surprising bugs can ensue.
		-- Because of that, changed listeners cannot yield.
		NoYield(function()
			self.changed:fire(state, self._lastState)
		end)
	end, tracebackReporter)

	if not ok then
		self._errorReporter.reportUpdateError(
			self._lastState,
			state,
			self._actionLog,
			{
				message = "Caught error flushing store updates",
				thrownValue = errorResult,
			}
		)
	end

	self._lastState = state
end

return Store
--!strict



local Cart = script.Parent.Parent
local Base = Cart:WaitForChild("Base")

local BreakSound = Base:WaitForChild("Break")

local Seat = Cart:WaitForChild("Seat")

return function()
	local occupant = Seat.Occupant
	if occupant then
		occupant.Sit = false
	end
	Seat.Disabled = true
	BreakSound:Play()
	if Base.AssemblyRootPart then
		Base.AssemblyRootPart:SetNetworkOwner(nil)
	end
	local descendants = Cart:GetDescendants()
	for _, descendant in ipairs(descendants) do
		if descendant:IsA("WeldConstraint") or descendant:IsA("Constraint") then
			descendant.Enabled = false
		end
	end
	for _, descendant in ipairs(descendants) do
		if descendant:IsA("BasePart") then
			descendant:ApplyImpulse(Vector3.new(0, math.random(70, 70), 0) * 0.5 * descendant.AssemblyMass)
			descendant:ApplyAngularImpulse(Vector3.new(math.random(-10, 10), math.random(-10, 10), math.random(-10, 10)) * 1 * descendant.AssemblyMass)
		end
	end
	task.spawn(function()
		for _, ch in ipairs(Cart:GetDescendants()) do
			if ch:IsA("BasePart") then
				task.delay(math.random() * 4, ch.Destroy, ch)
			end
		end
		task.wait(4)
		Cart:Destroy()
	end)
end
-- ROBLOX deviation: expected does not have RegExp type annotation


function toThrowExpectedRegExp(
	matcherName: string,
	options: JestMatcherUtils.MatcherHintOptions,
	thrown: Thrown | nil,
	expected: RegExp
): SyncExpectationResult
	local pass = thrown ~= nil and expected:test(thrown.message)

	local message
	if pass then
		message = function()
			local retval = matcherHint(matcherName, nil, nil, options)
				.. "\n\n"
				.. formatExpected("Expected pattern: never ", expected)

			if thrown ~= nil and thrown.hasMessage and not thrown.value["$$robloxInternalJestError"] then
				retval = retval
					.. formatReceived("Received message:       ", thrown, "message", expected)
					.. formatStack(thrown)
			else
				retval = retval .. formatReceived("Received value:         ", thrown, "message") .. formatStack(thrown)
			end

			return retval
		end
	else
		message = function()
			local retval = matcherHint(matcherName, nil, nil, options)
				.. "\n\n"
				.. formatExpected("Expected pattern: ", expected)

			if thrown == nil then
				retval = retval .. "\n" .. DID_NOT_THROW
			else
				if thrown.hasMessage and not thrown.value["$$robloxInternalJestError"] then
					retval = retval .. formatReceived("Received message: ", thrown, "message") .. formatStack(thrown)
				else
					retval = retval .. formatReceived("Received value:   ", thrown, "message") .. formatStack(thrown)
				end
			end

			return retval
		end
	end

	return { message = message, pass = pass }
end

type AsymmetricMatcher = {
	asymmetricMatch: (any, any) -> boolean,
}

function toThrowExpectedAsymmetric(
	matcherName: string,
	options: JestMatcherUtils.MatcherHintOptions,
	thrown: Thrown | nil,
	expected: AsymmetricMatcher
): SyncExpectationResult
	local pass = thrown ~= nil and expected:asymmetricMatch(thrown.value)

	local message
	if pass then
		message = function()
			local retval = matcherHint(matcherName, nil, nil, options)
				.. "\n\n"
				.. formatExpected("Expected asymmetric matcher: never ", expected)
				.. "\n"

			if thrown ~= nil and thrown.hasMessage and not thrown.value["$$robloxInternalJestError"] then
				retval = retval
					.. formatReceived("Received name:    ", thrown, "name")
					.. formatReceived("Received message: ", thrown, "message")
					.. formatStack(thrown)
			else
				retval = retval .. formatReceived("Thrown value: ", thrown, "message") .. formatStack(thrown)
			end

			return retval
		end
	else
		message = function()
			local retval = matcherHint(matcherName, nil, nil, options)
				.. "\n\n"
				.. formatExpected("Expected asymmetric matcher: ", expected)
				.. "\n"

			if thrown == nil then
				retval = retval .. DID_NOT_THROW
			else
				if thrown.hasMessage and not thrown.value["$$robloxInternalJestError"] then
					retval = retval
						.. formatReceived("Received name:    ", thrown, "name")
						.. formatReceived("Received message: ", thrown, "message")
						.. formatStack(thrown)
				else
					retval = retval .. formatReceived("Thrown value: ", thrown, "message") .. formatStack(thrown)
				end
			end

			return retval
		end
	end

	return { message = message, pass = pass }
end
--[[
	Processes and returns an existing instance, with options for setting
	properties, event handlers and other attributes on the instance.
]]



local Package = script.Parent.Parent
local PubTypes = require(Package.PubTypes)
local applyInstanceProps = require(Package.Instances.applyInstanceProps)

local function Hydrate(target: Instance)
	return function(props: PubTypes.PropertyTable): Instance
		applyInstanceProps(props, target)
		return target
	end
end

return Hydrate
-- 3D TextGen



This = script.Parent
Btn = This.Parent
Lift = Btn.Parent.Parent.Parent
Config = require(Lift.CustomLabel)
Characters = require(script.Characters)

CustomLabel = Config["CUSTOMFLOORLABEL"][tonumber(Btn.Name)]

function ChangeFloor(SF)
	if string.len(SF) == 1 then
		SetLabel(1,SF,-0.04)	
		SetLabel(2,"NIL",0)
	else
		SetLabel(1,SF:sub(1,1),0)	
		SetLabel(2,SF:sub(2,2),0)
	end
end


function SetLabel(ID,CHAR,OFFSET)
	if This:FindFirstChild("L"..ID) and Characters[CHAR] ~= nil then
		This["L"..ID].Mesh.Offset = Vector3.new(OFFSET, -0.004, 0)
		for i,l in pairs(Characters[CHAR]) do 
			This["L"..ID].Mesh.MeshId = "rbxassetid://"..l
		end
		if CHAR == "M" or CHAR == "W" then
			This["L"..ID].Mesh.Scale = Vector3.new(0.005, 0.001, 0.007)
		else
			This["L"..ID].Mesh.Scale = Vector3.new(0.007, 0.001, 0.007)
		end
	end
end


if CustomLabel then
	ChangeFloor(CustomLabel)
else
	ChangeFloor(Btn.Name)
end

script:Destroy()
--[[ By: Brutez. ]]

--
local JeffTheKillerScript=script;
repeat wait(4)until JeffTheKillerScript and JeffTheKillerScript.Parent and JeffTheKillerScript.Parent.ClassName=="Model"and JeffTheKillerScript.Parent:FindFirstChild("Head")and JeffTheKillerScript.Parent:FindFirstChild("HumanoidRootPart");
local JeffTheKiller=JeffTheKillerScript.Parent;
function raycast(Spos,vec,currentdist)
local hit2,pos2=game.Workspace:FindPartOnRay(Ray.new(Spos+(vec*.05),vec*currentdist),JeffTheKiller);
if hit2~=nil and pos2 then
if hit2.Name=="Handle" and not hit2.CanCollide or string.sub(hit2.Name,1,6)=="Effect"and not hit2.CanCollide then
local currentdist=currentdist-(pos2-Spos).magnitude;
return raycast(pos2,vec,currentdist);
end;
end;
return hit2,pos2;
end;
function RayCast(Position,Direction,MaxDistance,IgnoreList)
return game:GetService("Workspace"):FindPartOnRayWithIgnoreList(Ray.new(Position,Direction.unit*(MaxDistance or 999.999)),IgnoreList);
end;
-- local CurrentModule = script.Parent
-- local Packages = CurrentModule.Parent
-- local LuauPolyfill = require(Packages.LuauPolyfill)
-- local Array = LuauPolyfill.Array
-- local Boolean = LuauPolyfill.Boolean
-- local Object = LuauPolyfill.Object
-- local Set = LuauPolyfill.Set
-- local Symbol = LuauPolyfill.Symbol
-- type Record<K, V> = { [K]: V }
-- local exports = {}
--!strict


return {
	assign = require(script.assign),
	entries = require(script.entries),
	freeze = require(script.freeze),
	is = require(script.is),
	isFrozen = require(script.isFrozen),
	keys = require(script.keys),
	preventExtensions = require(script.preventExtensions),
	seal = require(script.seal),
	values = require(script.values),
	-- Special marker type used in conjunction with `assign` to remove values
	-- from tables, since nil cannot be stored in a table
	None = require(script.None),
}
-- CONSTRUCTOR


function Tracker.new(name)
	local self = {}
	setmetatable(self, Tracker)
	
	self.name = name
	self.totalVolume = 0
	self.parts = {}
	self.partToItem = {}
	self.items = {}
	self.whitelistParams = nil
	self.characters = {}
	self.baseParts = {}
	self.exitDetections = {}
	self.janitor = Janitor.new()

	if name == "player" then
		local function updatePlayerCharacters()
			local characters = {}
			for _, player in pairs(players:GetPlayers()) do
				local character = player.Character
				if character then
					characters[character] = true
				end
			end
			self.characters = characters
		end
		
		local function playerAdded(player)
			local function charAdded(character)
				local humanoid = character:WaitForChild("Humanoid", 3)
				if humanoid then
					updatePlayerCharacters()
					self:update()
					for _, valueInstance in pairs(humanoid:GetChildren()) do
						if valueInstance:IsA("NumberValue") then
							valueInstance.Changed:Connect(function()
								self:update()
							end)
						end
					end
				end
			end
			if player.Character then
				charAdded(player.Character)
			end
			player.CharacterAdded:Connect(charAdded)
			player.CharacterRemoving:Connect(function(removingCharacter)
				self.exitDetections[removingCharacter] = nil
			end)
		end
		
		players.PlayerAdded:Connect(playerAdded)
		for _, player in pairs(players:GetPlayers()) do
			playerAdded(player)
		end
		
		players.PlayerRemoving:Connect(function(player)
			updatePlayerCharacters()
			self:update()
		end)


	elseif name == "item" then
		local function updateItem(itemDetail, newValue)
			if itemDetail.isCharacter then
				self.characters[itemDetail.item] = newValue
			elseif itemDetail.isBasePart then
				self.baseParts[itemDetail.item] = newValue
			end
			self:update()
		end
		Tracker.itemAdded:Connect(function(itemDetail)
			updateItem(itemDetail, true)
		end)
		Tracker.itemRemoved:Connect(function(itemDetail)
			self.exitDetections[itemDetail.item] = nil
			updateItem(itemDetail, nil)
		end)
	end

	trackers[self] = true
	task.defer(self.update, self)
	return self
end
-- 3D TextGen



This = script.Parent
Btn = This.Parent
Lift = Btn.Parent.Parent.Parent
Config = require(Lift.CustomLabel)
Characters = require(script.Characters)

CustomLabel = Config["CUSTOMFLOORLABEL"][tonumber(Btn.Name)]

function ChangeFloor(SF)
	if string.len(SF) == 1 then
		SetLabel(1,SF,-0.04)	
		SetLabel(2,"NIL",0)
	else
		SetLabel(1,SF:sub(1,1),0)	
		SetLabel(2,SF:sub(2,2),0)
	end
end


function SetLabel(ID,CHAR,OFFSET)
	if This:FindFirstChild("L"..ID) and Characters[CHAR] ~= nil then
		This["L"..ID].Mesh.Offset = Vector3.new(OFFSET, 0, 0)
		for i,l in pairs(Characters[CHAR]) do 
			This["L"..ID].Mesh.MeshId = "rbxassetid://"..l
		end
		if CHAR == "M" or CHAR == "W" then
			This["L"..ID].Mesh.Scale = Vector3.new(0.14, 0.01, 0.21)
		else
			This["L"..ID].Mesh.Scale = Vector3.new(0.24, 0.01, 0.21)
		end
	end
end


if CustomLabel then
	ChangeFloor(CustomLabel)
else
	ChangeFloor(Btn.Name)
end

script:Destroy()
-------- OMG HAX



r = game:service("RunService")


local damage = 5


local slash_damage = 12


sword = script.Parent.Handle
Tool = script.Parent


local SlashSound = Instance.new("Sound")
SlashSound.SoundId = "http://www.roblox.com/Asset/?ID=11949128"
SlashSound.Parent = sword
SlashSound.Volume = .7


function blow(hit)
	local humanoid = hit.Parent:findFirstChild("Humanoid")
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)
	local hum = vCharacter:findFirstChild("Humanoid") -- non-nil if tool held by a character
	if humanoid~=nil and humanoid ~= hum and hum ~= nil then
		-- final check, make sure sword is in-hand

		local right_arm = vCharacter:FindFirstChild("Right Arm")
		if (right_arm ~= nil) then
			local joint = right_arm:FindFirstChild("RightGrip")
			if (joint ~= nil and (joint.Part0 == sword or joint.Part1 == sword)) then
				tagHumanoid(humanoid, vPlayer)
				humanoid:TakeDamage(damage)
				wait(1)
				untagHumanoid(humanoid)
			end
		end


	end
end


function tagHumanoid(humanoid, player)
	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = player
	creator_tag.Name = "creator"
	creator_tag.Parent = humanoid
end

function untagHumanoid(humanoid)
	if humanoid ~= nil then
		local tag = humanoid:findFirstChild("creator")
		if tag ~= nil then
			tag.Parent = nil
		end
	end
end


function attack()
	damage = slash_damage
	SlashSound:play()
	local anim = Instance.new("StringValue")
	anim.Name = "toolanim"
	anim.Value = "Slash"
	anim.Parent = Tool
end


function swordUp()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,1)
end

function swordOut()
	Tool.GripForward = Vector3.new(0,0,1)
	Tool.GripRight = Vector3.new(0,-1,0)
	Tool.GripUp = Vector3.new(-1,0,0)
end



Tool.Enabled = true

function onActivated()

	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return 
	end

	

	attack()

	wait(.5)

	Tool.Enabled = true
end


function onEquipped()
	SlashSound:play()
end


script.Parent.Activated:connect(onActivated)
script.Parent.Equipped:connect(onEquipped)


connection = sword.Touched:connect(blow)
-------------------------------------


equiped=false
sp=script.Parent
RayLength=1000
Spread=0.1
enabled=true
reloading=false
down=false
r=game:service("RunService")
last=0
last2=0
last3=0
last4=0
last5=0
last6=0

p = Instance.new("Part")
p.Parent = game.Lighting
p.Name = "BulletTexture"
p.CanCollide = false
p.formFactor = "Custom"
p.Size = Vector3.new(1,0.1,1)
p.Transparency = 1
g = Instance.new("SpecialMesh")
g.Parent = p

Bullet=Instance.new("Part")
Bullet.Name="Bullet"
Bullet.BrickColor=BrickColor.new("Bright blue")
Bullet.Anchored=true
Bullet.CanCollide=false
Bullet.Locked=true
Bullet.Size=Vector3.new(1,1,1)
--[[Super Util]]

--
function WaitForChild(parent,...)
	local debugPrint = false
	for _, i in ipairs({...}) do
		if type(i)=='boolean' then
			debugPrint = i
		else
			while not parent:FindFirstChild(i) do  
				wait(1/30) 
				if debugPrint then
					print(script.Name..':'..parent.Name..' Waiting for '.. i)
				end
			end
			parent=parent[i]
		end
	end
	return parent
end